BotFramework RustyBot(rbot)ご紹介

class SkeltonAgent:      # クラス名は任意です
    def __init__(self):
        """Botの初期化処理です。パラメータなどを設定するといいでしょう。利用しなくても構いません。
        """
        self.tick_count = 0         # on_tickが呼び出された回数をカウントします。
    
    def on_init(self, session):
        """Botの初期化処理。Botの初期化時に一度だけ呼ばれます。
        通常はsession.clock_interval_secを指定しon_clockの呼び出し間隔を設定します。
        Args:
            session: セッション情報（Botの初期化時用に渡されます）
        """
        session.clock_interval_sec = 60 * 60 * 1        # 1時間ごとにon_clockを呼び出す

    
    def on_tick(self, session, side, price, size):
        """取引所からの全ての約定イベント毎に呼び出される処理です（高頻度で呼び出されます）
        Args:
            session: セッション情報（市況情報の取得や注文するために利用します)
            side: 売買区分です。"Buy"または"Sell"が設定されます。
            price: 約定価格です。
            size: 約定数量です。
        """
        
        # on_tickは高頻度によびだされるので、１万回に1回だけ内容をプリントします。
        if self.tick_count % 10_000 == 0:
            print("on_tick: ", side, price, size)

        self.tick_count += 1
    
    def on_clock(self, session, clock):
        """定期的にフレームワークから呼び出される処理です。
        session.clock_interval_secで指定した間隔で呼び出されます。

        Args:
            session: セッション情報（市況情報の取得や注文するために利用します)        
            clock: 現在時刻です。エポック時間からのマイクロ秒で表されます。
        """
        # 現在の時刻をプリントします。
        print("on_clock: ", clock)
    
    def on_update(self, session, updated_order):
        """自分の注文状態が変化した場合に呼び出される処理です。
        Args:
            session: セッション情報（市況情報の取得や注文するために利用します)                
            updated_order: 注文状態が変化した注文情報です。
        """
        # 注文状態が変化した注文情報をプリントします。オーダーを発行しない限り呼び出されません。
        print("on_update", updated_order)    

# Binanceへ接続
market = BinanceMarket(BinanceConfig.BTCUSDT)

# 過去１日分のデータを取得
market.download(ndays=1, verbose=True, archive_only=True)

agent = SkeltonAgent() # テスト対象Agent(Bot)のインスタンス化
runner = Runner() #　実行クラスRunnerのインスタンス化

session = runner.back_test(
                market=market,  # marketを設定
                agent=agent,    # テスト用Agentを指定
                start_time=NOW() - DAYS(1), # 1日前からテスト
                end_time=0,#最新のデータまでテスト
                verbose=True #　進捗を表示
            )

session = runner.dry_run(
                market=market, # marketを設定
                agent=agent, # テスト用Agentを指定
                execute_time = 180, # 60*3=180[sec]　３分間テストします。
                verbose=True #　進捗を表示
            )

runner.real_run(
                market=market,
                agent=agent, 
                # execute_time = 180, # 実行確認時のみ設定。指定しないと永久動作。
                verbose=True,
                log_file="skelton_bot.log" #ログファイルを指定し出力させる。
            )

class BasilAgent:
    def __init__(self):
        self.OFFSET = 0.00_05
        self.EXPIRE_TIME = 600    # 600[sec] = 10[min]
        self.ORDER_SIZE = 0.01
        self.RANGE = 300

    def on_init(self, session):
        session.clock_interval_sec = 3     # 3秒ごとに on_clock を呼び出す        
    
    def on_clock(self, session, clock):
        if session.expire_order(self.EXPIRE_TIME):         # 期限切れの注文をキャンセルする.
            return                                          # 期限切れがあればリターン

        if session.buy_orders or session.sell_orders:   # 既に注文がある場合はリターン
            return
        
        # 1時間足のレンジを計算してログに出力する。レンジが大きい場合はトレードしない。
        ohlcv1h = session.ohlcv(60*60, 4)
        range = (ohlcv1h['high']-ohlcv1h['low']).mean()
        session.log_indicator("range", range)

        if self.RANGE < range:
            return

        ohlcv = session.ohlcv(3, 1)         # 3秒足を1本分取得。
        if len(ohlcv) < 1:                 # 3秒間に約定データがない場合リターン
            print("NO OHLCV DATA")
            return

        if session.position <= 0.001:    # ポジションが少ない場合は買い注文を出す。
            order_price = ohlcv['close'][-1] * (1 - self.OFFSET)
            print("BUY ORDER: ", order_price, self.ORDER_SIZE)
            session.limit_order('Buy', order_price, self.ORDER_SIZE - session.position)

        else:                       # ポジションがある場合は売り注文を出す。
            order_price = ohlcv['close'][-1] * (1 + self.OFFSET)
            print("SELL ORDER: ", order_price, session.position)
            session.limit_order('Sell', order_price, session.position)

    def on_update(self, session, updated_order):
        # 売りオーダーが期限切れされた場合には、成り行きで売り注文を出す（ロスカット）        
        if updated_order.status == 'Canceled':
            if updated_order.side == 'Sell':
                session.market_order('Sell', updated_order.remaining_size)

bid, ask = session.board

class MMBot:
    def __init__(self):
        """ MMBot クラス初期化（チューニングパラメータ設定）"""
        self.ignore_size = 0.05
        self.order_size = 0.01
        self.price_tick = 0.01
        self.expire_time = 60*10

    def wall_price(self, board):
        """板の壁の値段を返す"""
        wall = board[1:].filter(self.ignore_size < pl.col("size"))
        if len(wall) == 0:
            return None
        
        price = wall.head(1)['price'][0]
        return price


    def main_logic(self, session):
        """ メインロジック """
        if session.expire_order(self.expire_time):  # １０分以上経過した注文をキャンセル
            return                                  # キャンセルしたら終了(次のループで再度注文する)
        
        bid, ask = session.board # 板情報を取得
        if len(bid) < 10 or len(ask) <10:  # 板情報がない場合は終了
            return 
        
        buy_price = self.wall_price(bid)    # 壁が検出できた場合
        if buy_price is None:
            return
        buy_price = buy_price + self.price_tick    # 壁の一つ前の価格を計算
        
        sell_price = self.wall_price(ask)
        if sell_price is None:
            return
        sell_price = sell_price - self.price_tick       # 壁の一つ前の価格を計算
        
        session.log_indicator("buy_price", buy_price)         # ログに壁の一つ前の価格を記録   
        session.log_indicator("sell_price", sell_price)       # ログに壁の一つ前の価格を記録
        session.log_indicator("spread", sell_price - buy_price)   # 買いと売りの壁の差を記録
        
        if not session.buy_orders and session.position <= 0:    # 買い注文がなく、ポジションがマイナス（売り注文が約定済みの場合）
            session.limit_order("Buy", buy_price, self.order_size)  # 壁の一つ前の価格で買い注文を出す
            print("Buy order price", buy_price, "size", self.order_size)
        
        if not session.sell_orders and 0 <= session.position:      # 売り注文がなく、ポジションがプラス（買い注文が約定済みの場合）
            session.limit_order("Sell", sell_price, self.order_size) # 壁の一つ前の価格で売り注文を出す
            print("Sell order price", sell_price, "size", self.order_size)


    def on_init(self, session):
        """ フレームワークから呼び出される初期化 on_clockの呼び出し間隔を設定 """
        session.clock_interval_sec = 60     # 60秒ごとに on_clock を呼び出す

    def on_clock(self, session, timestamp):
        """ フレームワークから呼び出される定期的な処理 """
        self.main_logic(session)
    
    def on_update(self, session, order):
        """ フレームワークから呼び出される注文更新時の処理 """
        # 注文が約定したかキャンセルされたら、次のオーダーを出すためにメインロジックを呼び出す
        if order.status == "Filled" or order.status == "Canceled":
            self.main_logic(session)