Timeframe
1h
Direction
Long & Short
Stoploss
-100.0%
Trailing Stop
No
ROI
0m: 99.0%
Interface Version
3
Startup Candles
N/A
Indicators
3
freqtrade/freqtrade-strategies
this is an example class, implementing a PSAR based trailing stop loss you are supposed to take the `custom_stoploss()` and `populate_indicators()` parts and adapt it to your own strategy
freqtrade/freqtrade-strategies
freqtrade/freqtrade-strategies
Strategy 003 author@: Gerald Lonlas github@: https://github.com/freqtrade/freqtrade-strategies
# pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement
# flake8: noqa: F401
# isort: skip_file
# --- Do not remove these libs ---
import numpy as np # noqa
import pandas as pd # noqa
from pandas import DataFrame
from freqtrade.strategy import (BooleanParameter, CategoricalParameter, DecimalParameter,
IStrategy, IntParameter)
# --------------------------------
# Add your lib to import here
from datetime import datetime
from typing import Optional
import pandas_ta
import talib.abstract as ta
import freqtrade.vendor.qtpylib.indicators as qtpylib
class TrendLines5x10(IStrategy):
INTERFACE_VERSION = 3
can_short= True
# roi take profit and stop loss points
minimal_roi = {"0": 0.99}
stoploss = -1
use_custom_stoploss = False
trailing_stop = False
use_exit_signal = True
exit_profit_only = False
exit_profit_offset = 0.0
ignore_roi_if_entry_signal = False
timeframe = '1h'
# Strategy Parameters
ATR_Period = 11
LBL = 10
LBR = 10
slope = 17.6
average_price_period = 20
trend_confirmation_period = 50
xlevrage = 10
# Run "populate_indicators()" only for new candle.
process_only_new_candles = True
# Optional order type mapping.
order_types = {
'entry': 'market',
'exit': 'market',
'stoploss': 'market',
'stoploss_on_exchange': False
}
def checkhl(self, data_back, data_forward, hl):
if hl == 'high' or hl == 'High':
ref = data_back[len(data_back)-1]
for i in range(len(data_back)-1):
if ref < data_back[i]:
return 0
for i in range(len(data_forward)):
if ref <= data_forward[i]:
return 0
return 1
if hl == 'low' or hl == 'Low':
ref = data_back[len(data_back)-1]
for i in range(len(data_back)-1):
if ref > data_back[i]:
return 0
for i in range(len(data_forward)):
if ref >= data_forward[i]:
return 0
return 1
def pivot(self, osc, atr, LBL, LBR, highlow):
breakouts = pd.Series(dtype='float64')
pivpoint = 0
atrpoint = 0
counter=0
pivots=[]
atrs=[]
count_list=[]
left = []
right = []
for i in range(len(osc)):
pivots.append(pivpoint)
atrs.append(atrpoint)
count_list.append(counter)
counter +=1
if i < LBL + 1:
left.append(osc[i])
if i > LBL:
right.append(osc[i])
if i > LBL + LBR:
left.append(right[0])
left.pop(0)
right.pop(0)
if self.checkhl(left, right, highlow):
pivots[i - LBR] = osc[i - LBR]
pivpoint = osc[i - LBR]
atrpoint = atr[i - LBR]
counter = 0
slops =list(map(lambda x: x/self.slope,atrs))
if highlow.lower() == 'low':
breakouts = pd.Series(pivots) + (pd.Series(count_list)*pd.Series(slops))
elif highlow.lower() == 'high':
breakouts = pd.Series(pivots) - (pd.Series(count_list)*pd.Series(slops))
return breakouts, pd.Series(pivots)
def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
# average True range for stoploss extention
dataframe['ATR'] = pandas_ta.atr(dataframe['high'],dataframe['low'],dataframe['close'],length= self.ATR_Period)
# main indicators for long and short breakout enteries, and exiting targets
# all are based on pivot points
dataframe['short_breakout'], dataframe['long_target'] = self.pivot(osc=dataframe["high"], atr=dataframe['ATR'],
LBL=self.LBL,LBR=self.LBR,highlow="high")
dataframe['long_breakout'], dataframe['short_target'] = self.pivot(osc=dataframe["low"], atr=dataframe['ATR'],
LBL=self.LBL,LBR=self.LBR,highlow="low")
# moving average for trend confirmation
dataframe['Trend_confirmation'] = ta.SMA(dataframe, timeperiod=self.trend_confirmation_period)
# distance between current (average) price and targets, used for filtering
# low profit trades
dataframe['average_price'] = ta.SMA(dataframe, timeperiod=self.average_price_period)
dataframe['dist_resistance'] = dataframe['long_target']-dataframe['average_price']
dataframe['dist_support'] = dataframe['average_price']-dataframe['short_target']
return dataframe
def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
dataframe.loc[
(
# long position conditions:
# main condition, candle crosses and closes above the long breakout line
(qtpylib.crossed_above(dataframe['close'], dataframe['long_breakout']))
# the whole candle body must be above the moving average for confirming up trend
& (dataframe['open'] > dataframe['Trend_confirmation'])
# the candle must be green
& (dataframe['close'] > dataframe['open'])
# current price must be closer to the resistance
& (dataframe['dist_resistance'] < dataframe['dist_support'])
),
'enter_long'] = 1
dataframe.loc[
(
# short position conditions:
# main condition, candle crosses and closes bellow the short breakout line
(qtpylib.crossed_below(dataframe['close'], dataframe['short_breakout']))
# the whole candle body must be bellow the moving average for confirming up trend
& (dataframe['open'] < dataframe['Trend_confirmation'])
# the candle must be red
& (dataframe['close'] < dataframe['open'])
# current price must be closer to the support
& (dataframe['dist_resistance'] > dataframe['dist_support'])
),
'enter_short'] = 1
return dataframe
def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
dataframe.loc[
(
# exit with profit at long target
(dataframe['close'] >= dataframe['long_target'])
# dynamic stoploss
| (dataframe['close'] <= dataframe['short_target']-dataframe['ATR'])
),
'exit_long'] = 1
dataframe.loc[
(
# exit with profit at short target
(dataframe['close'] <= dataframe['short_target'])
# dynamic stoploss
| (dataframe['close'] >= dataframe['long_target']+dataframe['ATR'])
),
'exit_short'] = 1
return dataframe
def leverage(self, pair: str, current_time: datetime, current_rate: float,
proposed_leverage: float, max_leverage: float, entry_tag: Optional[str],
side: str, **kwargs) -> float:
entry_tag = ''
max_leverage = self.xlevrage
return max_leverage