Flumine Betting Trading Framework

Flumine v3 allows for complex mapping between market data streams and trading strategies. You can implement the following patterns:

One Stream to Multiple Strategies

Create a single stream object and pass it to multiple strategy instances. This is efficient when multiple strategies need to react to the same market data.

Multiple Streams to One Strategy

Pass a list of streams to a single strategy using the streams parameter. This allows a strategy to aggregate data from different market types or filters.

Dynamic Subscription

You can subscribe or unsubscribe a strategy from a stream after the strategy has already been initialized using subscribe_to_stream(stream) and unsubscribe_from_stream(stream).

# One stream to multiple strategies
stream = BetfairMarketStream(market_filter=...) 

strategy_one = ExampleStrategy(name="one", stream=stream)
framework.add_strategy(strategy_one)

strategy_two = ExampleStrategy(name="two", stream=stream)
framework.add_strategy(strategy_two)

# Multiple streams to one strategy
stream_one = BetfairMarketStream(market_filter=...) 
stream_two = BetfairMarketStream(market_filter=...) 

strategy = ExampleStrategy(name="one", streams=[stream_one, stream_two])
framework.add_strategy(strategy)

# Dynamic subscription
strategy.subscribe_to_stream(stream)
strategy.unsubscribe_from_stream(stream)

To create a trading strategy, inherit from BaseStrategy. You must implement the following lifecycle methods:

• check_market_book(self, market, market_book) -> bool: This method is called for every market update. If it returns True, the framework will proceed to call process_market_book. Use this to filter which markets or updates your strategy actually reacts to.
• process_market_book(self, market, market_book): This is where your core trading logic resides. It is only executed if check_market_book returns True.
• start(self, flumine) (Optional): Called when the strategy starts.
• process_orders(self, market, orders) (Optional): Called to handle order updates and lifecycle management (e.g., cancelling, updating, or replacing orders).

from flumine import BaseStrategy

class ExampleStrategy(BaseStrategy):
    def check_market_book(self, market, market_book) -> bool:
        # Return True to trigger process_market_book
        return True

    def process_market_book(self, market, market_book):
        # Your strategy logic here
        pass

To create a trading strategy, inherit from BaseStrategy and implement the following lifecycle methods:

• start(self, flumine): Called when the strategy starts.
• check_market_book(self, market, market_book) -> bool: A filter method. process_market_book will only be executed if this method returns True.
• process_market_book(self, market, market_book): The main logic loop where you inspect market data and decide to place trades.
• process_orders(self, market, orders): Logic for handling order updates, such as cancellations, replacements, or updates to persistence.

from flumine import BaseStrategy
from flumine.markets.market import Market
from betfairlightweight.resources import MarketBook

class ExampleStrategy(BaseStrategy):
    def start(self, flumine) -> None:
        print("starting strategy")

    def check_market_book(self, market: Market, market_book: MarketBook) -> bool:
        # Only process if market is not CLOSED
        return market_book.status != "CLOSED"

    def process_market_book(self, market: Market, market_book: MarketBook) -> None:
        # Your trading logic here
        pass

    def process_orders(self, market: Market, orders: list) -> None:
        # Your order management logic here
        pass