Qubx 0.0.1__cp311-cp311-manylinux_2_35_x86_64.whl → 0.1.0__cp311-cp311-manylinux_2_35_x86_64.whl

qubx/__init__.py

@@ -1,9 +1,9 @@
-from qubx.utils import set_mpl_theme, runtime_env, install_pyx_recompiler_for_dev
-install_pyx_recompiler_for_dev()
+from qubx.utils import set_mpl_theme, runtime_env
+from qubx.utils.misc import install_pyx_recompiler_for_dev
 
 from loguru import logger
 import os, sys, stackprinter
-from qubx.core.lookups import InstrumentsLookup
+from qubx.core.lookups import FeesLookup, GlobalLookup, InstrumentsLookup
 
 
 def formatter(record):
@@ -36,7 +36,9 @@ logger.remove(None)
 logger.add(sys.stdout, format=formatter, colorize=True)
 logger = logger.opt(colors=True)
 
-lookup = InstrumentsLookup()
+# - global lookup helper
+lookup = GlobalLookup(InstrumentsLookup(), FeesLookup())
+
 
 # registering magic for jupyter notebook
 if runtime_env() in ['notebook', 'shell']:
@@ -50,21 +52,25 @@ if runtime_env() in ['notebook', 'shell']:
 
         @line_magic
         def qubxd(self, line: str):
-            self.qubx_setup('dark')
+            self.qubx_setup('dark' + ' ' + line)
 
         @line_magic
         def qubxl(self, line: str):
-            self.qubx_setup('light')
+            self.qubx_setup('light' + ' ' + line)
 
         @line_magic
         def qubx_setup(self, line: str):
             """
-            QUBE framework initialization
+            QUBX framework initialization
             """
             import os
+            args = [x.strip() for x in line.split(' ')]
+            
+            # setup cython dev hooks - only if 'dev' is passed as argument
+            if line and 'dev' in args: 
+                install_pyx_recompiler_for_dev()
 
             tpl_path = os.path.join(os.path.dirname(__file__), "_nb_magic.py")
-            # print("TPL:", tpl_path)
             with open(tpl_path, 'r', encoding="utf8") as myfile:
                 s = myfile.read()
 

qubx/_nb_magic.py

@@ -5,7 +5,7 @@ import importlib_metadata
 
 import qubx
 from qubx.utils import runtime_env
-from qubx.utils.misc import add_project_to_system_path
+from qubx.utils.misc import add_project_to_system_path, logo
 
 
 def np_fmt_short():
@@ -46,24 +46,8 @@ if runtime_env() in ['notebook', 'shell']:
     # - add project home to system path
     add_project_to_system_path()
 
-    # - check current version
-    try: 
-        version = importlib_metadata.version('qube2')
-    except:
-        version = 'Dev'
-
-    # some new logo
+    # show logo first time
     if not hasattr(qubx.QubxMagics, '__already_initialized__'):
-        from qubx.utils.misc import (green, yellow, cyan, magenta, white, blue, red)
-
-        print(
-        f"""
-                   {red("╻")}
-   {green("┏┓      ╻     ")}  {red("┃")}  {yellow("┏┓")}       {cyan("Quantitative Backtesting Environment")} 
-   {green("┃┃  ┓┏  ┣┓  ┏┓")}  {red("┃")}  {yellow("┏┛")}       
-   {green("┗┻  ┗┻  ┗┛  ┗ ")}  {red("┃")}  {yellow("┗━")}       (c) 2024,  ver. {magenta(version.rstrip())}
-                   {red("╹")}       
-"""
-        )
-        qubx.QubxMagics.__already_initialized__ = True
+        setattr(qubx.QubxMagics, "__already_initialized__", True)
+        logo()
 

qubx/core/account.py

@@ -0,0 +1,166 @@
+from typing import Any, Optional, List, Dict, Tuple
+from collections import defaultdict
+
+import numpy as np
+
+from qubx import lookup, logger
+from qubx.core.basics import Instrument, Position, TransactionCostsCalculator, dt_64, Deal, Order
+
+
+class AccountProcessor:
+    """
+    Account processor class
+    """
+    account_id: str
+    base_currency: str
+    reserved: Dict[str, float]                         # how much asset is reserved against the trading 
+    _balances: Dict[str, Tuple[float, float]]
+    _active_orders: Dict[str|int, Order]               # active orders
+    _processed_trades: Dict[str|int, List[str|int]] 
+    _positions: Dict[str, Position]
+    _total_capital_in_base: float = 0.0
+    _locked_capital_in_base: float = 0.0
+    _locked_capital_by_order: Dict[str|int, float]
+
+    def __init__(self, 
+                 account_id: str, 
+                 base_currency: str, 
+                 reserves: Dict[str, float] | None, 
+                 total_capital: float=0, 
+                 locked_capital: float=0
+    ) -> None:
+        self.account_id = account_id
+        self.base_currency = base_currency
+        self.reserved = dict() if reserves is None else reserves
+        self._processed_trades = defaultdict(list)
+        self._active_orders = dict()
+        self._positions = {}
+        self._locked_capital_by_order = dict()
+        self._balances = dict()
+        self.update_base_balance(total_capital, locked_capital)
+
+    def update_base_balance(self, total_capital: float, locked_capital: float):
+        """
+        Update base currency balance
+        """
+        self._total_capital_in_base = total_capital
+        self._locked_capital_in_base = locked_capital
+
+    def update_balance(self, symbol: str, total_capital: float, locked_capital: float):
+        self._balances[symbol] = (total_capital, locked_capital)
+
+    def get_balances(self) -> Dict[str, Tuple[float, float]]:
+        return dict(self._balances)
+
+    def attach_positions(self, *position: Position) -> 'AccountProcessor':
+        for p in position:
+            self._positions[p.instrument.symbol] = p 
+        return self
+
+    def update_position_price(self, time: dt_64, symbol: str, price: float):
+        p = self._positions[symbol]
+        p.update_market_price(time, price, 1)
+
+    def get_capital(self) -> float:
+        # TODO: need to take in account leverage and funds currently locked 
+        return self._total_capital_in_base - self._locked_capital_in_base  
+
+    def get_reserved(self, instrument: Instrument) -> float:
+        """
+        Check how much were reserved for this instrument
+        """
+        return self.reserved.get(instrument.symbol, self.reserved.get(instrument.base, 0))
+
+    def process_deals(self, symbol: str, deals: List[Deal]):
+        pos = self._positions.get(symbol)
+
+        if pos is not None:
+            conversion_rate = 1
+            instr = pos.instrument
+            traded_amnt, realized_pnl, deal_cost = 0, 0, 0
+
+            # - check if we need conversion rate for this instrument
+            # - TODO - need test on it !
+            if instr._aux_instrument is not None:
+                aux_pos = self._positions.get(instr._aux_instrument.symbol)
+                if aux_pos:
+                    conversion_rate = aux_pos.last_update_price
+                else:
+                    logger.error(f"Can't find additional instrument {instr._aux_instrument} for estimating {symbol} position value !!!") 
+
+            # - process deals
+            for d in deals:
+                if d.id not in self._processed_trades[d.order_id]: 
+                    self._processed_trades[d.order_id].append(d.id)
+                    realized_pnl += pos.update_position_by_deal(d, conversion_rate) 
+                    deal_cost += d.amount * d.price / conversion_rate
+                    traded_amnt += d.amount
+                    logger.info(f"  ::  traded {d.amount} for {symbol} @ {d.price} -> {realized_pnl:.2f}")
+                    self._total_capital_in_base -= deal_cost
+
+    def _lock_limit_order_value(self, order: Order) -> float:
+        pos = self._positions.get(order.symbol)
+        excess = 0.0
+        # - we handle only instruments it;s subscribed to
+        if pos:
+            sgn = -1 if order.side == 'SELL' else +1
+            pos_change = sgn * order.quantity
+            direction = np.sign(pos_change)
+            prev_direction = np.sign(pos.quantity)
+            # how many shares are closed/open
+            qty_closing = min(abs(pos.quantity), abs(pos_change)) * direction if prev_direction != direction else 0
+            qty_opening = pos_change if prev_direction == direction else pos_change - qty_closing
+            excess = abs(qty_opening) * order.price
+
+            if excess > 0:
+                self._locked_capital_in_base += excess
+                self._locked_capital_by_order[order.id] = excess
+
+        return excess
+
+    def _unlock_limit_order_value(self, order: Order):
+        if order.id in self._locked_capital_by_order:
+            excess = self._locked_capital_by_order.pop(order.id )
+            self._locked_capital_in_base -= excess
+
+    def process_order(self, order: Order):
+        _new = order.status == 'NEW'
+        _open = order.status == 'OPEN'
+        _closed = order.status == 'CLOSED'
+        _cancel = order.status == 'CANCELED'
+
+        if _open or _new:
+            self._active_orders[order.id] = order
+
+            # - calculate amount locked by this order
+            if order.type == 'LIMIT':
+                self._lock_limit_order_value(order)
+
+        if _closed or _cancel:
+            if order.id in self._processed_trades:
+                self._processed_trades.pop(order.id)
+
+            if order.id in self._active_orders:
+                self._active_orders.pop(order.id)
+
+        # - calculate amount to unlock after canceling
+        if _cancel and order.type == 'LIMIT':
+            self._unlock_limit_order_value(order)
+
+        logger.info(f"Order {order.id} {order.type} {order.side} {order.quantity} of {order.symbol} -> {order.status}")
+
+    def add_active_orders(self, orders: Dict[str, Order]):
+        for oid, od in orders.items():
+            self._active_orders[oid] = od
+
+    def get_orders(self, symbol: str | None = None) -> List[Order]:
+        ols = list(self._active_orders.values())
+        if symbol is not None:
+            ols = list(filter(lambda x: x.symbol == symbol, ols))
+        return ols
+
+    def positions_report(self) -> dict:
+        rep = {}
+        for p in self._positions.values():
+            rep[p.instrument.symbol] = {'Qty': p.quantity, 'Price': p.position_avg_price_funds, 'PnL': p.pnl, 'MktValue': p.market_value_funds}
+        return rep

qubx/core/basics.py

@@ -1,13 +1,21 @@
 from datetime import datetime
 from typing import Callable, Dict, List, Optional, Union
 import numpy as np
+import pandas as pd
 import math
 from dataclasses import dataclass, field
+
+import asyncio
+# from multiprocessing import Queue, Process, Event, Lock
+from threading import Thread, Event, Lock
+from queue import Queue
+
 from qubx.core.series import Quote, Trade, time_as_nsec
 from qubx.core.utils import time_to_str, time_delta_to_str, recognize_timeframe
 
 
 dt_64 = np.datetime64
+td_64 = np.timedelta64
 
 
 @dataclass
@@ -80,9 +88,26 @@ class Signal:
 
 
 class TransactionCostsCalculator:
-    def __init__(self, maker: float, taker: float):
-        self.maker = maker
-        self.taker = taker
+    """
+    A class for calculating transaction costs for a trading strategy.
+    Attributes
+    ----------
+    name : str
+        The name of the transaction costs calculator.
+    maker : float
+        The maker fee, as a percentage of the transaction value.
+    taker : float
+        The taker fee, as a percentage of the transaction value.
+
+    """
+    name: str
+    maker: float
+    taker: float
+
+    def __init__(self, name: str, maker: float, taker: float):
+        self.name = name
+        self.maker = maker / 100.0
+        self.taker = taker / 100.0
 
     def get_execution_fees(self, instrument: Instrument, exec_price: float, amount: float, crossed_market=False, conversion_rate=1.0):
         if crossed_market:
@@ -97,10 +122,45 @@ class TransactionCostsCalculator:
         return 0.0
 
     def __repr__(self):
-        return f'<TCC: {self.maker * 100:.4f} / {self.taker * 100:.4f}>'
+        return f'<{self.name}: {self.maker * 100:.4f} / {self.taker * 100:.4f}>'
 
 
-ZERO_COSTS = TransactionCostsCalculator(0.0, 0.0)
+ZERO_COSTS = TransactionCostsCalculator('Zero', 0.0, 0.0)
+
+
+@dataclass
+class Deal:
+    id: str | int         # trade id
+    order_id: str | int   # order's id
+    time: dt_64           # time of trade
+    amount: float         # signed traded amount: positive for buy and negative for selling
+    price: float
+    aggressive: bool
+    fee_amount: float | None = None
+    fee_currency: str | None = None
+
+
+@dataclass
+class Order:
+    id: str
+    type: str
+    symbol: str
+    time: dt_64
+    quantity: float
+    price: float
+    side: str
+    status: str
+    time_in_force: str
+    client_id: str | None = None
+    cost: float = 0.0
+    
+    def __str__(self) -> str:
+        return f"[{self.id}] {self.type} {self.side} {self.quantity} of {self.symbol} {('@ ' + str(self.price)) if self.price > 0 else ''} ({self.time_in_force}) [{self.status}]"
+
+
+def round_down(x, n):
+    dvz = 10**(-n)
+    return (int(x / dvz)) * dvz
 
 
 class Position:
@@ -115,16 +175,18 @@ class Position:
     position_avg_price_funds: float = 0.0       # average position price
     commissions: float = 0.0                    # cumulative commissions paid for this position
 
-    last_update_time: Optional[int] = None      # when price updated or position changed
-    last_update_price: Optional[float] = None   # last update price (actually instrument's price) in quoted currency
+    last_update_time: int = np.nan              # when price updated or position changed
+    last_update_price: float = np.nan           # last update price (actually instrument's price) in quoted currency
+    last_update_conversion_rate: float = np.nan # last update conversion rate
 
     # - helpers for position processing 
     _formatter: str
     _prc_formatter: str
     _qty_multiplier: float = 1.0
+    __pos_incr_qty: float = 0
 
     def __init__(self, instrument: Instrument, tcc: TransactionCostsCalculator, 
-                 quantity=0.0, average_price=0.0, aux_price=1.0, 
+                 quantity=0.0, pos_average_price=0.0, r_pnl=0.0
                  ) -> None:
         self.instrument = instrument
         self.tcc = tcc
@@ -136,19 +198,41 @@ class Position:
         self._formatter += f'%10.{instrument.price_precision}f %+10.4f | %s  %10.2f'
         self._prc_formatter = f"%.{instrument.price_precision}f"
         if instrument.is_futures:
-            self._qty_multiplier = instrument.futures_info.contract_size
+            self._qty_multiplier = instrument.futures_info.contract_size # type: ignore
 
-        if quantity != 0.0 and average_price > 0.0:
+        self.reset()
+        if quantity != 0.0 and pos_average_price > 0.0:
             self.quantity = quantity
-            raise ValueError("[TODO] Position: restore state by quantity and avg price !!!!")
-
-    def _price(self, update: Union[Quote, Trade]) -> float:
+            self.position_avg_price = pos_average_price
+            self.r_pnl = r_pnl
+
+    def reset(self):
+        """
+        Reset position to zero
+        """
+        self.quantity = 0.0
+        self.pnl = 0.0
+        self.r_pnl = 0.0
+        self.market_value = 0.0
+        self.market_value_funds = 0.0
+        self.position_avg_price = 0.0
+        self.position_avg_price_funds = 0.0
+        self.commissions = 0.0
+        self.last_update_time = np.nan # type: ignore
+        self.last_update_price = np.nan
+        self.last_update_conversion_rate = np.nan
+        self.__pos_incr_qty = 0
+
+    def _price(self, update: Quote | Trade) -> float:
         if isinstance(update, Quote):
             return update.bid if np.sign(self.quantity) > 0 else update.ask
         elif isinstance(update, Trade):
             return update.price
         raise ValueError(f"Unknown update type: {type(update)}")
 
+    def change_position_by(self, timestamp: dt_64, amount: float, exec_price: float, aggressive=True, conversion_rate:float=1) -> float:
+        return self.update_position(timestamp, self.quantity + amount, exec_price, aggressive=aggressive, conversion_rate=conversion_rate)
+
     def update_position(self, timestamp: dt_64, position: float, exec_price: float, aggressive=True, conversion_rate:float=1) -> float:
         # - realized PnL of this fill
         deal_pnl = 0
@@ -171,11 +255,15 @@ class Position:
                 if abs(quantity) < self.instrument.min_size_step:
                     quantity = 0.0
                     self.position_avg_price = 0.0
+                    self.__pos_incr_qty = 0
 
             # - if it has something to add to position let's update price and cost
             if qty_opening != 0:
-                qa_open, qas = abs(qty_opening), abs(quantity)
-                self.position_avg_price = (qa_open * exec_price + qas * self.position_avg_price) / (qas + qa_open)
+                _abs_qty_open = abs(qty_opening)
+                pos_avg_price_raw = (_abs_qty_open * exec_price + self.__pos_incr_qty * self.position_avg_price) / (self.__pos_incr_qty + _abs_qty_open)
+                # - round position average price to be in line with how it's calculated by broker
+                self.position_avg_price = round_down(pos_avg_price_raw, self.instrument.price_precision)
+                self.__pos_incr_qty += _abs_qty_open
 
             # - update position and position's price
             self.position_avg_price_funds = self.position_avg_price / conversion_rate
@@ -185,7 +273,7 @@ class Position:
             self.r_pnl += deal_pnl / conversion_rate
 
             # - update pnl
-            self._update_market_price(time_as_nsec(timestamp), exec_price, conversion_rate)
+            self.update_market_price(time_as_nsec(timestamp), exec_price, conversion_rate)
 
             # - calculate transaction costs
             comms = self.tcc.get_execution_fees(self.instrument, exec_price, pos_change, aggressive, conversion_rate)
@@ -193,12 +281,19 @@ class Position:
 
         return deal_pnl
 
-    def update_market_price(self, price: Union[Quote, Trade], conversion_rate:float=1) -> float:
-        return self._update_market_price(price.time, self._price(price), conversion_rate)
+    def update_market_price_by_tick(self, tick: Quote | Trade, conversion_rate:float=1) -> float:
+        return self.update_market_price(tick.time, self._price(tick), conversion_rate)
 
-    def _update_market_price(self, timestamp: dt_64, price: float, conversion_rate:float) -> float:
-        self.last_update_time = timestamp
+    def update_position_by_deal(self, deal: Deal, conversion_rate:float=1) -> float:
+        time = deal.time.as_unit('ns').asm8 if isinstance(deal.time, pd.Timestamp) else deal.time
+        return self.change_position_by(time, deal.amount, deal.price, deal.aggressive, conversion_rate)
+        # - deal contains cumulative amount
+        # return self.update_position(time, deal.amount, deal.price, deal.aggressive, conversion_rate)
+
+    def update_market_price(self, timestamp: dt_64, price: float, conversion_rate:float) -> float:
+        self.last_update_time = timestamp # type: ignore
         self.last_update_price = price
+        self.last_update_conversion_rate = conversion_rate
 
         if not np.isnan(price):
             self.pnl = self.quantity * (price - self.position_avg_price) / conversion_rate + self.r_pnl
@@ -208,17 +303,53 @@ class Position:
             self.market_value_funds = self.market_value / conversion_rate
         return self.pnl
 
-    def total_pnl(self, conversion_rate:float=1.0) -> float:
+    def total_pnl(self) -> float:
         pnl = self.r_pnl
-        if not np.isnan(self.last_update_price):
-            pnl += self.quantity * (self.last_update_price - self.position_avg_price) / conversion_rate
+        if not np.isnan(self.last_update_price): # type: ignore
+            pnl += self.quantity * (self.last_update_price - self.position_avg_price) / self.last_update_conversion_rate # type: ignore
         return pnl
 
+    def get_amount_released_funds_after_closing(self, to_remain: float = 0.0) -> float:
+        """
+        Estimate how much funds would be released if part of position closed
+        """
+        d = np.sign(self.quantity)
+        funds_release = self.market_value_funds
+        if to_remain != 0 and self.quantity != 0 and np.sign(to_remain) == d:
+            qty_to_release = max(self.quantity - to_remain, 0) if d > 0 else min(self.quantity - to_remain, 0)
+            funds_release = qty_to_release * self.last_update_price / self.last_update_conversion_rate
+        return abs(funds_release)
+
     @staticmethod
     def _t2s(t) -> str:
-        return np.datetime64(t, 'ns').astype('datetime64[ms]').item().strftime('%Y-%m-%d %H:%M:%S') if t else '---'
+        return np.datetime64(t, 'ns').astype('datetime64[ms]').item().strftime('%Y-%m-%d %H:%M:%S') if not np.isnan(t) else '???'
 
     def __str__(self):
         _mkt_price = (self._prc_formatter % self.last_update_price) if self.last_update_price else "---"
         return self._formatter % (Position._t2s(self.last_update_time), self.quantity, self.position_avg_price_funds,self.pnl, _mkt_price,  self.market_value_funds)
     
+
+class CtrlChannel:
+    """
+    Controlled data communication channel
+    """
+    control: Event
+    queue: Queue     # we need something like disruptor here (Queue is temporary)
+    name: str
+    lock: Lock
+
+    def __init__(self, name: str, sent=(None, None)):
+        self.name = name
+        self.control = Event()
+        self.queue = Queue()
+        self.lock = Lock()
+        self.sent = sent
+        self.start()
+
+    def stop(self):
+        if self.control.is_set():
+            self.control.clear()
+            self.queue.put(self.sent) # send sentinel
+
+    def start(self):
+        self.control.set()