roboquant 0.1.6__py3-none-any.whl

roboquant/__init__.py

@@ -0,0 +1,33 @@
+from .account import Account, OptionAccount, Position
+from .roboquant import Roboquant
+
+from .event import Event, PriceItem, Candle, Trade, Quote
+from .order import Order, OrderStatus
+from .timeframe import Timeframe
+from .config import Config
+
+
+from roboquant.brokers import Broker, SimBroker
+from roboquant.traders import Trader, FlexTrader
+from roboquant.trackers import Tracker, StandardTracker, BasicTracker, CAPMTracker, EquityTracker, TensorboardTracker
+from roboquant.strategies import (
+    Strategy,
+    EMACrossover,
+    SMACrossover,
+    CandleStrategy,
+    NOPStrategy,
+    NumpyBuffer,
+    OHLCVBuffer,
+)
+from roboquant.feeds import (
+    Feed,
+    CSVFeed,
+    SQLFeed,
+    RandomWalk,
+    YahooFeed,
+    TiingoLiveFeed,
+    TiingoHistoricFeed,
+    CandleFeed,
+    EventChannel,
+    feedutil
+)

roboquant/account.py

@@ -0,0 +1,127 @@
+from dataclasses import dataclass
+from datetime import datetime
+from decimal import Decimal
+from roboquant.order import Order
+from prettytable import PrettyTable
+
+
+@dataclass(slots=True, frozen=True)
+class Position:
+    """Position of a symbol"""
+
+    size: Decimal
+    """Position size"""
+
+    avg_price: float
+    """Average price paid denoted in the currency of the symbol"""
+
+
+class Account:
+    """The account maintains the following state during a run:
+
+    - Available cash for trading (also sometimes referred to as buying power)
+    - Open positions
+    - Open orders
+    - Total equity value of the account
+    - Last time the account was updated
+
+    Only the broker updates the state of the account and does this only during its `sync` method.
+    """
+
+    def __init__(self):
+        self.buying_power: float = 0.0
+        self.positions: dict[str, Position] = {}
+        self.orders: list[Order] = []
+        self.last_update: datetime = datetime.fromisoformat("1900-01-01T00:00:00+00:00")
+        self.equity = 0.0
+
+    def get_value(self, symbol: str, size: Decimal, price: float) -> float:
+        """Return the total value of the provided contract size denoted in the base currency of the account.
+        The default implementation returns `size * price`.
+
+        The bahavior of this method can be changed for symbols denoted in a different currency and/or contract size by providing
+        a different value_calculator.
+        """
+        return float(size) * price
+
+    def mkt_value(self, prices: dict[str, float]) -> float:
+        """Return the the market value of all the open positions in the account using the provided prices."""
+        return sum([self.get_value(symbol, pos.size, prices[symbol]) for symbol, pos in self.positions.items()], 0.0)
+
+    def unrealized_pnl(self, prices: dict[str, float]) -> float:
+        return sum(
+            [
+                self.get_value(symbol, pos.size, prices[symbol] - pos.avg_price)
+                for symbol, pos in self.positions.items()
+            ],
+            0.0,
+        )
+
+    def has_open_order(self, symbol: str) -> bool:
+        """Return True if there an open order for the symbol, False otherwise"""
+
+        for order in self.orders:
+            if order.symbol == symbol and not order.closed:
+                return True
+        return False
+
+    def get_position_size(self, symbol) -> Decimal:
+        pos = self.positions.get(symbol)
+        return pos.size if pos else Decimal(0)
+
+    def open_orders(self):
+        """Return a list with the open orders"""
+        return [order for order in self.orders if not order.closed]
+
+    def __repr__(self) -> str:
+        p = PrettyTable(["account", "value"], align="r", float_format="12.2")
+        p.add_row(["buying power", self.buying_power])
+        p.add_row(["equity", self.equity])
+        p.add_row(["positions", len(self.positions)])
+        p.add_row(["orders", len(self.orders)])
+        p.add_row(["last update", self.last_update.strftime("%Y-%m-%d %H:%M:%S")])
+        result = p.get_string() + "\n\n"
+
+        p = PrettyTable(["symbol", "position size", "avg price"], align="r", float_format="12.2")
+        for symbol, pos in self.positions.items():
+            p.add_row([symbol, pos.size, pos.avg_price])
+        result += p.get_string() + "\n\n"
+
+        p = PrettyTable(
+            ["symbol", "order size", "order id", "limit", "status", "closed"], align="r", float_format="12.2"
+        )
+        for order in self.orders:
+            p.add_row([order.symbol, order.size, order.id, order.limit, order.status.name, order.closed])
+        result += p.get_string() + "\n"
+
+        return result
+
+
+class OptionAccount(Account):
+    """
+    This account handles common option contracts of size 100 and 10. Serves as an example.
+    If no contract size is registered for a symbol, it creates one based on the symbol name.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._contract_sizes: dict[str, float] = {}
+
+    def register(self, symbol: str, contract_size: float = 100.0):
+        """Register a certain contract-size for a symbol"""
+        self._contract_sizes[symbol] = contract_size
+
+    def get_value(self, symbol: str, size: Decimal, price: float) -> float:
+        contract_size = self._contract_sizes.get(symbol)
+
+        # If nithng registered we try to defer the contract size from the symbol
+        if contract_size is None:
+            if len(symbol) == 21:
+                # OCC compliant option symbol
+                symbol = symbol[0:6].rstrip()
+                contract_size = 10.0 if symbol[-1] == "7" else 100.0
+            else:
+                # not an option symbol
+                contract_size = 1.0
+
+        return contract_size * float(size) * price

roboquant/brokers/__init__.py

@@ -0,0 +1,2 @@
+from .broker import Broker
+from .simbroker import SimBroker

roboquant/brokers/broker.py

@@ -0,0 +1,18 @@
+
+from typing import Protocol
+from roboquant.account import Account
+from roboquant.event import Event
+from roboquant.order import Order
+
+
+
+class Broker(Protocol):
+    """A broker handles the placed orders and communicates its state through the account object"""
+
+    def place_orders(self, *orders: Order):
+        """Place zero or more orders at this broker."""
+        ...
+
+    def sync(self, event: Event | None = None) -> Account:
+        """Sync the state, and return an updated account to reflect the latest state."""
+        ...

roboquant/brokers/ibkrbroker.py

@@ -0,0 +1,211 @@
+from datetime import datetime, timezone, timedelta
+from decimal import Decimal
+import logging
+import time
+import threading
+
+from roboquant.account import Account, Position
+from roboquant.order import Order, OrderStatus
+from roboquant.event import Event
+from .broker import Broker
+
+logger = logging.getLogger(__name__)
+
+try:
+    from ibapi.client import EClient
+    from ibapi.wrapper import EWrapper
+    from ibapi.contract import Contract
+    from ibapi.order import Order as IBKROrder
+    from ibapi.account_summary_tags import AccountSummaryTags
+    from ibapi import VERSION
+    assert VERSION["major"] == 10 and VERSION["minor"] == 19, "Wrong version of the IBAPI found"
+except:
+    logger.fatal("Couldn't import IBAPI package, you need to manually install this")
+    pass
+
+
+class _IBApi(EWrapper, EClient):
+
+    def __init__(self):        
+        EClient.__init__(self, self)
+        self.orders: dict[str, Order] = {}
+        self.positions: dict[str, Position] = {}
+        self.account = {"EquityWithLoanValue": 0.0, "AvailableFunds": 0.0}
+        self.__account_end = threading.Condition()
+        self.__order_id = 0
+
+    def nextValidId(self, orderId: int):
+        self.__order_id = orderId
+        logger.debug("The next valid order id is: %s", orderId)
+
+    def get_next_order_id(self):
+        result = str(self.__order_id)
+        self.__order_id += 1
+        return result
+
+    def position(self, account: str, contract: Contract, position: Decimal, avgCost: float):
+        logger.debug("position=%s symbol=%s  avgCost=%s", position, contract.localSymbol, avgCost)
+        symbol = contract.localSymbol or contract.symbol
+        self.positions[symbol] = Position(position, avgCost)
+
+    def accountSummary(self, reqId: int, account: str, tag: str, value: str, currency: str):
+        logger.debug("account %s=%s", tag, value)
+        self.account[tag] = float(value)
+
+    def accountSummaryEnd(self, reqId: int):
+        with self.__account_end:
+            self.__account_end.notify_all()
+
+    def openOrder(self, orderId: int, contract, order: IBKROrder, orderState):
+        logger.debug(
+            "openOrder orderId=%s status=%s size=%s limit=%s",
+            orderId,
+            orderState.status,
+            order.totalQuantity,
+            order.lmtPrice,
+        )
+        size = order.totalQuantity if order.action == "BUY" else -order.totalQuantity
+        symbol = contract.localSymbol
+        rq_order = Order(symbol, size) if not order.lmtPrice else Order(symbol, size, order.lmtPrice)
+        rq_order.id = str(orderId)
+        self.orders[rq_order.id] = rq_order
+
+    def reqAccountSummary(self):
+        buyingpower_tag = AccountSummaryTags.BuyingPower
+        equity_tag = AccountSummaryTags.NetLiquidation
+        with self.__account_end:
+            super().reqAccountSummary(1, "All", f"{buyingpower_tag},{equity_tag}")
+            self.__account_end.wait()
+
+    def get_buying_power(self):
+        buyingpower_tag = AccountSummaryTags.BuyingPower
+        return self.account[buyingpower_tag] or 0.0
+
+    def get_equity(self):
+        equity_tag = AccountSummaryTags.NetLiquidation
+        return self.account[equity_tag] or 0.0
+
+    def orderStatus(
+        self,
+        orderId,
+        status,
+        filled,
+        remaining,
+        avgFillPrice,
+        permId,
+        parentId,
+        lastFillPrice,
+        clientId,
+        whyHeld,
+        mktCapPrice,
+    ):
+        logger.debug("order status orderId=%s status=%s", orderId, status)
+        id = str(orderId)
+        if id in self.orders:
+            order = self.orders[id]
+            match status:
+                case "Submitted":
+                    order.status = OrderStatus.ACTIVE
+                case "Cancelled":
+                    order.status = OrderStatus.CANCELLED
+                case "Filled":
+                    order.status = OrderStatus.FILLED
+        else:
+            logger.warn(f"recieved status for unknown order id=%s status=%s", orderId, status)
+
+
+class IBKRBroker(Broker):
+    """
+    Atttributes
+    ==========
+    contract_mapping
+        store how symbols map to IBKR contracts. If a symbol is not found, the symbol is assumed to represent a US stock
+
+    """
+
+    def __init__(self, host="127.0.0.1", port=4002, account=None, client_id=123) -> None:
+        self.__account = account or Account()
+        self.contract_mapping: dict[str, Contract] = {}
+        api = _IBApi()
+        api.connect(host, port, client_id)
+        self.__api = api
+        self._has_new_orders_since_sync = False
+
+        # Start the handling in a thread
+        self.__api_thread = threading.Thread(target=api.run, daemon=False)
+        self.__api_thread.start()
+        time.sleep(3.0)
+
+    def _should_sync(self, now):
+        return self._has_new_orders_since_sync or now - self.__account.last_update > timedelta(seconds=30)
+
+    def sync(self, event: Event | None = None) -> Account:
+        logger.debug("start sync")
+        now = datetime.now(timezone.utc)
+
+        if event:
+            # Lets make sure we don't use IBKRBroker by mistake during a back-test.
+            if now - event.time > timedelta(minutes=30):
+                logger.critical("received event from the past, now=%s event-time=%s", now, event.time)
+                raise ValueError(f"received event to far in the past now={now} event-time={event.time}")
+
+        api = self.__api
+        acc = self.__account
+        if self._should_sync(now):
+            acc.last_update = now
+            self._has_new_orders_since_sync = False
+
+            api.reqPositions()
+            api.reqOpenOrders()
+            api.reqAccountSummary()
+
+            acc.positions = {k: v for k, v in api.positions.items() if not v.size.is_zero()}
+            acc.orders = [order for order in api.orders.values()]
+            acc.buying_power = api.get_buying_power()
+            acc.equity = api.get_equity()
+
+        logger.debug("end sync")
+        return acc
+
+    def place_orders(self, *orders: Order):
+
+        self._has_new_orders_since_sync = len(orders) > 0
+
+        for order in orders:
+            assert not order.closed, "cannot place a closed order"
+            if order.size.is_zero():
+                assert order.id is not None
+                self.__api.cancelOrder(int(order.id), "")
+            else:
+                if order.id is None:
+                    order.id = self.__api.get_next_order_id()
+                    self.__api.orders[order.id] = order
+                ibkrorder = self._get_order(order)
+                contract = self.contract_mapping.get(order.symbol) or self._get_default_contract(order.symbol)
+                self.__api.placeOrder(int(order.id), contract, ibkrorder)
+
+    def _get_default_contract(self, symbol: str) -> Contract:
+        """If no contract can be found in the `contract_mapping` dict, this method is called to get a default IBKR contract
+        for the provided symbol.
+
+        The default implementation assumes it is a US stock symbol with SMART exchange routing.
+        """
+
+        c = Contract()
+        c.symbol = symbol
+        c.secType = "STK"
+        c.currency = "USD"
+        c.exchange = "SMART"  # use smart routing by default
+        return c
+
+    def _get_order(self, order: Order):
+        o = IBKROrder()
+        o.action = "BUY" if order.is_buy else "SELL"
+        o.totalQuantity = abs(order.size)
+        o.tif = "GTC"
+        if order.limit:
+            o.orderType = "LMT"
+            o.lmtPrice = order.limit
+        else:
+            o.orderType = "MKT"
+        return o

roboquant/brokers/simbroker.py

@@ -0,0 +1,191 @@
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from decimal import Decimal
+
+from roboquant.order import Order, OrderStatus
+from ..event import Event
+from ..account import Account, Position
+from .broker import Broker
+
+
+@dataclass(slots=True, frozen=True)
+class _Trx:
+    """transaction for an executed trade"""
+
+    symbol: str
+    size: Decimal
+    price: float  # is denoted in the currency of the symbol
+    fee: float = 0.0  # is denoted in base currency of the account
+
+
+@dataclass
+class _OrderState:
+    order: Order
+    accepted: datetime | None = None
+
+
+class SimBroker(Broker):
+    """Implementation of a Broker that simulates order handling and trade execution.
+
+    This class can be extended to support different types of use-cases, like margin trading.
+    """
+
+    __order_id = 0
+
+    def __init__(
+        self, initial_deposit=1000000.0, account=None, price_type="DEFAULT", slippage=0.001, clean_up_orders=True
+    ):
+        super().__init__()
+        self.initial_deposit = initial_deposit
+        self._account = account or Account()
+        self._modify_orders: list[Order] = []
+        self._account.buying_power = initial_deposit
+        self.slippage = slippage
+        self.price_type = price_type
+        self._prices: dict[str, float] = {}
+        self._orders: dict[str, _OrderState] = {}
+        self.clean_up_orders = clean_up_orders
+
+    def _update_account(self, trx: _Trx):
+        """Update a position and cash based on a new transaction"""
+        acc = self._account
+        symbol = trx.symbol
+        acc.buying_power -= acc.get_value(symbol, trx.size, trx.price)
+
+        size = acc.get_position_size(symbol)
+
+        if size.is_zero():
+            # opening of position
+            acc.positions[symbol] = Position(trx.size, trx.price)
+        else:
+            new_size: Decimal = size + trx.size
+            if new_size.is_zero():
+                # closing of position
+                del acc.positions[symbol]
+            elif new_size.is_signed() != size.is_signed():
+                # reverse of position
+                acc.positions[symbol] = Position(new_size, trx.price)
+            else:
+                # increase of position size
+                old_price = acc.positions[symbol].avg_price
+                avg_price = (old_price * float(size) + trx.price * float(trx.size)) / (float(size + trx.size))
+                acc.positions[symbol] = Position(new_size, avg_price)
+
+    def get_execution_price(self, order, item) -> float:
+        """Return the execution price to use for an order based on the price item.
+
+        The default implementation is a fixed slippage percentage based on the configured price_type.
+        """
+
+        price = item.get_price(self.price_type)
+        correction = self.slippage if order.is_buy else -self.slippage
+        return price * (1.0 + correction)
+
+    def get_fee(self, order) -> float:
+        """Return the fee (or rebate) for the execution of an order. The fee is denoted in the base
+        currency of the account.
+
+        The default implementation returns 0.0, so no fee is used.
+        """
+        return 0.0
+
+    def _simulate_market(self, order: Order, item) -> _Trx | None:
+        """Simulate a market for the three order types"""
+
+        price = self.get_execution_price(order, item)
+        if self.is_executable(order, price):
+            fee = self.get_fee(order)
+            return _Trx(order.symbol, order.size, price, fee)
+
+    def next_order_id(self):
+        result = str(SimBroker.__order_id)
+        SimBroker.__order_id += 1
+        return result
+
+    def _has_expired(self, state: _OrderState) -> bool:
+        if state.accepted is None:
+            return False
+        else:
+            return self._account.last_update - state.accepted > timedelta(days=180)
+
+    def is_executable(self, order, price) -> bool:
+        """Is this order executable given the provided price.
+        A market order is always executable, a limit order only when the limit is below the BUY price or
+        above the SELL price"""
+        if order.limit is None:
+            return True
+        if order.is_buy and price <= order.limit:
+            return True
+        if order.is_sell and price >= order.limit:
+            return True
+
+        return False
+
+    def _update_mkt_prices(self, price_items):
+        """track the latest market prices for all open positions"""
+        for symbol in self._account.positions.keys():
+            if (item := price_items.get(symbol)) is not None:
+                self._prices[symbol] = item.get_price(self.price_type)
+
+    def place_orders(self, *orders: Order):
+        """Place new orders at this broker. The order gets assigned a unique id if it hasn't one already.
+
+        There is no trading simulation yet performed or account updated. Orders placed at time `t`, will be
+        processed during time `t+1`. This protects against future bias.
+        """
+        for order in orders:
+            assert not order.closed, "cannot place closed orders"
+            if order.id is None:
+                order.id = self.next_order_id()
+                assert order.id not in self._orders
+                self._orders[order.id] = _OrderState(order)
+            else:
+                assert order.id in self._orders, "existing order id not found"
+                self._modify_orders.append(order)
+
+    def _process_modify_order(self):
+        for order in self._modify_orders:
+            state = self._orders[order.id]  # type: ignore
+            if state.order.closed:
+                continue
+            elif order.is_cancellation:
+                state.order.status = OrderStatus.CANCELLED
+            else:
+                state.order.size = order.size or state.order.size
+                state.order.limit = order.limit or state.order.limit
+        self._modify_orders = []
+
+    def _process_create_orders(self, prices):
+        for state in self._orders.values():
+            order = state.order
+            if order.closed:
+                continue
+            if self._has_expired(state):
+                order.status = OrderStatus.EXPIRED
+            else:
+                if (item := prices.get(order.symbol)) is not None:
+                    state.accepted = state.accepted or self._account.last_update
+                    trx = self._simulate_market(order, item)
+                    if trx is not None:
+                        self._update_account(trx)
+                        order.status = OrderStatus.FILLED
+
+    def sync(self, event: Event | None = None) -> Account:
+        """This will perform the trading simulation for open orders and update the account accordingly."""
+
+        acc = self._account
+        if event:
+            acc.last_update = event.time
+
+        prices = event.price_items if event else {}
+
+        if self.clean_up_orders:
+            self._orders = {id: state for id, state in self._orders.items() if not state.order.closed}
+
+        self._process_modify_order()
+        self._process_create_orders(prices)
+        self._update_mkt_prices(prices)
+
+        acc.equity = acc.mkt_value(self._prices) + acc.buying_power
+        acc.orders = [state.order for state in self._orders.values()]
+        return acc

roboquant/config.py

@@ -0,0 +1,20 @@
+from configparser import ConfigParser
+import os.path
+import os
+
+
+class Config:
+    """Access to roboquant configuration file"""
+
+    def __init__(self, path=None):
+        path = path or os.path.expanduser("~/.roboquant/.env")
+        with open(path, "r") as f:
+            config_string = "[default]\n" + f.read()
+        self.config = ConfigParser()
+        self.config.read_string(config_string)
+
+    def get(self, key):
+        for key2, value in os.environ.items():
+            final_key = key2.lower().replace("_", ".")
+            if final_key == key: return value
+        return self.config.get("default", key)