Backtrader Community

    • Login
    • Search
    • Categories
    • Recent
    • Tags
    • Popular
    • Users
    • Groups
    • Search
    1. Home
    2. filos
    For code/output blocks: Use ``` (aka backtick or grave accent) in a single line before and after the block. See: http://commonmark.org/help/
    F
    • Profile
    • Following 0
    • Followers 0
    • Topics 0
    • Posts 1
    • Best 0
    • Controversial 0
    • Groups 0

    filos

    @filos

    0
    Reputation
    9
    Profile views
    1
    Posts
    0
    Followers
    0
    Following
    Joined Last Online

    filos Unfollow Follow

    Latest posts made by filos

    • RE: Bitcoin trading strategy

      Hey @jeff-lee would love to get some feedback on the trading logic? Would really appreciate your insight.

      def __init__(self):
              self.dataclose = self.datas[0].close
              self.datavolume = self.datas[0].volume
              self.datalow = self.datas[0].low
              self.sma_veryfast = btind.MovingAverageSimple(self.dataclose, period=10)
              self.sma_fast = btind.MovingAverageSimple(self.dataclose, period=20)
              self.sma_mid = btind.MovingAverageSimple(self.dataclose, period=50)
              self.sma_slow = btind.MovingAverageSimple(self.dataclose, period=100)
              self.sma_veryslow = btind.MovingAverageSimple(self.dataclose, period=200)
      
              # BollingerBandsWidth = upperband - lowerband/middleband.
              self.bbw = BollingerBandsW()
              self.boll = btind.BollingerBands(self.dataclose)
              self.std = btind.StdDev(self.bbw.l.bbw, period=100)
              self.lines_bbw = (self.boll.l.top - self.boll.l.bot) / self.boll.l.mid
              
              self.volatility_level = VolatilityLevel()
              self.low_volatility_level = self.volatility_level.l.VLI_fast < self.volatility_level.l.VLI_slow
              self.high_volatility_level = self.volatility_level.l.VLI_fast > self.volatility_level.l.VLI_slow
              self.extreme_volatility_level = self.bbw.l.bbw > self.volatility_level.l.VLI_top
              self.vol_condition = (btind.MovingAverageSimple(self.datavolume, period=10) >
                                    btind.MovingAverageSimple(self.datavolume, period=50))
              self.crossdown_boll_top = bt.ind.CrossDown(self.dataclose, self.boll.top)
              self.crossup_boll_bot = bt.ind.CrossUp(self.dataclose, self.boll.bot)
             
              self.highest_high = btind.Highest(self.dataclose, period=20)
              self.low_of_last_candle = self.datalow[0]
              self.close_of_price = self.dataclose[0]
              self.stop_win = None
              self.stop_loss = None
              self.order = None
      
          @staticmethod
          def get_params():
              return dict()
      
          def notify_order(self, order):
              if order.status in [order.Submitted, order.Accepted]:
                  return
      
              if order.status == order.Completed:
                  if order.isbuy():
                      self.stop_loss = self.stop_loss if self.stop_loss else 0.05 * self.dataclose[-1]
      
                      take_profit = order.executed.price * (1.0 + self.stop_loss)
                      sl_ord = self.sell(exectype=bt.Order.Stop,
                                         price=order.executed.price * (1.0 - self.stop_loss))
                      sl_ord.addinfo(name="Stop")
                      tkp_ord = self.buy(exectype=bt.Order.Limit,
                                         price=take_profit)
                      tkp_ord.addinfo(name="Prof")
      
                      if self.stop_win:
                          self.sell(price=(order.executed.price * (1 + self.stop_win)),
                                    exectype=bt.Order.Limit)
      
              self.order = None
      
          def _next(self):
              if self.order:
                  return
      
              if self.crossdown_boll_top and self.vol_condition:
                  if self.close_of_price > self.sma_fast:
                      if self.bbw.bbw < self.volatility_level.l.VLI_top:
                          if self.low_volatility_level:
                              if self.sma_mid > self.sma_veryslow:
                                  self.buy()
                          else:
                              self.buy()
                  elif self.sma_slow > self.sma_veryslow:
                      self.buy()
                      self.stop_loss = self.low_of_last_candle 
      
              if self.crossup_boll_bot and self.vol_condition:
                  self.close()
                  self.stop_loss = None
                  self.stop_win = None
                  portfolio_value = self.broker.get_value()
                  trade_profit = self.broker.get_value([self.data]) / portfolio_value
      
                  if trade_profit > 0.03:
                      self.stop_win = 0.01
                  elif trade_profit > 0.20:
                      self.stop_win = 0.15
                  elif trade_profit > 0.25:
                      self.stop_win = 0.20
                  elif trade_profit > 0.30:
                      self.stop_win = 0.25
                  elif trade_profit > 0.35:
                      self.stop_win = 0.30
                  elif trade_profit > 0.40:
                      self.stop_win = 0.35
      
              if self.crossup_boll_bot and self.vol_condition:
                  self.sell()
                  self.stop_loss = self.highest_high
      
      posted in Indicators/Strategies/Analyzers
      F
      filos