Qubx 0.5.7__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/utils/plotting/data.py

@@ -0,0 +1,137 @@
+from dataclasses import dataclass, field
+from typing import Literal, Dict, List, Optional, Union, Any
+from datetime import datetime
+import pandas as pd
+
+PlotType = Literal["candlestick", "line", "scatter", "bar", "area", "signal", "execution", "track", "trend"]
+
+
+@dataclass
+class PlotStyle:
+    """Visual properties of a plot"""
+
+    color: Optional[str] = None
+    width: float = 1.0
+    opacity: float = 1.0
+    dash: Optional[str] = None  # solid, dash, dot
+    marker: Optional[str] = None  # triangle-up, triangle-down etc
+    marker_size: float = 10.0
+    fill_color: Optional[str] = None
+
+
+@dataclass
+class SeriesData:
+    """Single data series"""
+
+    data: Union[pd.Series, pd.DataFrame]
+    type: PlotType
+    name: str
+    style: PlotStyle = field(default_factory=PlotStyle)
+    hover_text: Optional[List[str]] = None
+
+
+@dataclass
+class SubplotData:
+    """Group of series in one subplot"""
+
+    series: List[SeriesData]
+    height_ratio: float = 1.0
+    y_axis_range: Optional[tuple[float, float]] = None
+    show_legend: bool = True
+
+
+@dataclass
+class PlotData:
+    """Complete plot specification"""
+
+    main: SubplotData  # Main chart (usually price)
+    studies: Dict[str, SubplotData] = field(default_factory=dict)  # Additional studies
+    title: str = ""
+
+    def to_looking_glass(self) -> Dict[str, Any]:
+        """Convert to LookingGlass format"""
+        return {
+            "master": self._convert_subplot(self.main),
+            "studies": (
+                {name: self._convert_subplot(study) for name, study in self.studies.items()} if self.studies else None
+            ),
+        }
+
+    def _convert_subplot(self, subplot: SubplotData) -> Union[pd.DataFrame, List[Any]]:
+        """Convert SubplotData to LookingGlass format"""
+        if not subplot.series:
+            return pd.DataFrame()
+
+        # If single OHLCV series, return as main dataframe
+        if len(subplot.series) == 1 and subplot.series[0].type == "candlestick":
+            return (
+                subplot.series[0].data
+                if isinstance(subplot.series[0].data, pd.DataFrame)
+                else subplot.series[0].data.to_frame()
+            )
+
+        # Convert multiple series into list format
+        converted = []
+        for series in subplot.series:
+            if series.type == "candlestick":
+                converted.append(
+                    {
+                        "data": series.data,
+                        "type": "candlestick",
+                        "name": series.name,
+                        "style": {
+                            "increasing_line_color": series.style.color or "green",
+                            "decreasing_line_color": series.style.color or "red",
+                            "opacity": series.style.opacity,
+                        },
+                    }
+                )
+
+            elif series.type in ["line", "area", "step"]:
+                converted.append(
+                    {
+                        "data": series.data,
+                        "type": series.type,
+                        "name": series.name,
+                        "style": {
+                            "color": series.style.color,
+                            "width": series.style.width,
+                            "dash": series.style.dash,
+                            "fill": series.style.fill_color if series.type == "area" else None,
+                            "opacity": series.style.opacity,
+                        },
+                    }
+                )
+
+            elif series.type in ["signal", "execution"]:
+                converted.append(
+                    {
+                        "data": series.data,
+                        "type": "scatter",
+                        "name": series.name,
+                        "style": {
+                            "color": series.style.color,
+                            "marker": series.style.marker or "circle",
+                            "size": series.style.marker_size,
+                            "opacity": series.style.opacity,
+                        },
+                        "hover_text": series.hover_text,
+                    }
+                )
+
+            elif series.type == "trend":
+                converted.append(
+                    {
+                        "data": series.data,
+                        "type": "line",
+                        "name": series.name,
+                        "style": {
+                            "color": series.style.color,
+                            "width": series.style.width,
+                            "dash": series.style.dash or "dash",
+                            "opacity": series.style.opacity,
+                        },
+                    }
+                )
+
+        return converted

qubx/utils/plotting/interfaces.py

@@ -0,0 +1,25 @@
+from typing import List, Tuple
+from dataclasses import dataclass
+
+
+@dataclass
+class PlotData:
+    master: dict
+    studies: dict | None = None
+    master_size: int = 3
+    study_size: int = 1
+
+
+class IPlotter:
+
+    def get_plots(self) -> List[str]:
+        """
+        Get the list of plots that this object can generate.
+        """
+        ...
+
+    def get_plot_data(self, plot_name: str) -> Tuple[str, dict]:
+        """
+        Get the data for the specified plot.
+        """
+        ...

qubx/utils/runner/__init__.py

@@ -0,0 +1 @@
+from .runner import create_strategy_context, run_strategy, run_strategy_yaml

qubx/utils/runner/_jupyter_runner.pyt

@@ -0,0 +1,60 @@
+import qubx
+from qubx.core.basics import Instrument
+%qubxd
+
+import pandas as pd
+import nest_asyncio;
+nest_asyncio.apply()
+
+from pathlib import Path
+from qubx.core.context import StrategyContext
+from qubx.utils.misc import dequotify, quotify
+from qubx.utils.runner import run_strategy_yaml
+from qubx.pandaz.utils import *
+import qubx.pandaz.ta as pta
+import qubx.ta.indicators as ta
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+account_file = Path('{account_file}') if '{account_file}' != 'None' else None
+ctx: StrategyContext = run_strategy_yaml(Path('{config_file}'), account_file, {paper}) # type: ignore
+assert ctx is not None, 'Strategy context is not created'
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+def orders(instrument: Instrument | None=None):
+    return ctx.get_orders(instrument)
+
+def trade(instrument: Instrument, qty: float, price=None, tif='gtc'):
+    return ctx.trade(instrument, qty, price, tif)
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+def pnl_report(all=True):
+    from tabulate import tabulate
+
+    d = dict()
+    for s, p in ctx.get_positions().items():
+        mv = round(p.market_value_funds, 3)
+        if mv != 0.0 or all:
+            d[dequotify(s.symbol)] = dict(
+                Position=round(p.quantity, p.instrument.size_precision),  
+                PnL=p.total_pnl(), 
+                AvgPrice=round(p.position_avg_price_funds, p.instrument.price_precision), 
+                LastPrice=round(p.last_update_price, p.instrument.price_precision),
+                MktValue=mv
+            )
+    d = pd.DataFrame.from_dict(d).T
+    # d = d[d['PnL'] != 0.0]
+    if d.empty:
+        print('-(no open positions yet)-')
+        return
+
+    d = d.sort_values('PnL' ,ascending=False)
+    # d = pd.concat((d, pd.Series(dict(TOTAL=d['PnL'].sum()), name='PnL'))).fillna('')
+    d = pd.concat((d, scols(pd.Series(dict(TOTAL=d['PnL'].sum()), name='PnL'), pd.Series(dict(TOTAL=d['MktValue'].sum()), name='MktValue')))).fillna('')
+    print(tabulate(d, ['Position', 'PnL', 'AvgPrice', 'LastPrice', 'MktValue'], tablefmt='rounded_grid'))
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+__exit = exit
+def exit():
+    ctx.stop()
+    __exit()
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

qubx/utils/runner/accounts.py

@@ -0,0 +1,88 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+import toml
+from pydantic import BaseModel
+
+
+class ExchangeSettings(BaseModel):
+    exchange: str
+    testnet: bool = False
+    base_currency: str = "USDT"
+    commissions: str | None = None
+    initial_capital: float = 100_000
+
+
+class ExchangeCredentials(ExchangeSettings):
+    name: str
+    api_key: str
+    secret: str
+
+
+class AccountConfiguration(BaseModel):
+    defaults: list[ExchangeSettings]
+    accounts: list[ExchangeCredentials]
+
+
+class AccountConfigurationManager:
+    """
+    Manages account configurations.
+    """
+
+    def __init__(
+        self,
+        account_config: Path | None = None,
+        strategy_dir: Path | None = None,
+        search_qubx_dir: bool = False,
+    ):
+        self._exchange_settings: dict[str, ExchangeSettings] = {}
+        self._exchange_credentials: dict[str, ExchangeCredentials] = {}
+        self._settings_to_config: dict[str, Path] = {}
+        self._credentials_to_config: dict[str, Path] = {}
+
+        self._config_paths = [Path("~/.qubx/accounts.toml").expanduser()] if search_qubx_dir else []
+        if strategy_dir:
+            self._config_paths.append(strategy_dir / "accounts.toml")
+        if account_config:
+            self._config_paths.append(account_config)
+        self._config_paths = [config for config in self._config_paths if config.exists()]
+        for config in self._config_paths:
+            self._load(config)
+
+    def get_exchange_settings(self, exchange: str) -> ExchangeSettings:
+        """
+        Get the basic settings for an exchange such as the base currency and commission tier.
+        """
+        exchange = exchange.upper()
+        if exchange not in self._exchange_settings:
+            return ExchangeSettings(exchange=exchange)
+        return self._exchange_settings[exchange.upper()].model_copy()
+
+    def get_exchange_credentials(self, exchange: str) -> ExchangeCredentials:
+        """
+        Get the api key and secret for an exchange as well as the base currency and commission tier.
+        """
+        return self._exchange_credentials[exchange.upper()].model_copy()
+
+    def get_config_path_for_settings(self, exchange: str) -> Path:
+        return self._settings_to_config[exchange.upper()]
+
+    def get_config_path_for_credentials(self, exchange: str) -> Path:
+        return self._credentials_to_config[exchange.upper()]
+
+    def __repr__(self):
+        exchanges = set(self._exchange_credentials.keys()) | set(self._exchange_settings.keys())
+        _e_str = "\n".join([f" - {exchange}" for exchange in exchanges])
+        return f"AccountManager:\n{_e_str}"
+
+    def _load(self, config: Path):
+        config_dict = toml.load(config)
+        account_config = AccountConfiguration(**config_dict)
+        for exchange_config in account_config.defaults:
+            _exchange = exchange_config.exchange.upper()
+            self._exchange_settings[_exchange] = exchange_config
+            self._settings_to_config[_exchange] = config
+        for exchange_config in account_config.accounts:
+            _exchange = exchange_config.exchange.upper()
+            self._exchange_credentials[_exchange] = exchange_config
+            self._credentials_to_config[_exchange] = config

qubx/utils/runner/configs.py

@@ -0,0 +1,65 @@
+from pathlib import Path
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+class ExchangeConfig(BaseModel):
+    connector: str
+    universe: list[str]
+
+
+class AuxConfig(BaseModel):
+    reader: str
+    args: dict = Field(default_factory=dict)
+
+
+class LoggingConfig(BaseModel):
+    logger: str
+    position_interval: str
+    portfolio_interval: str
+    heartbeat_interval: str = "1m"
+
+
+class StrategyConfig(BaseModel):
+    strategy: str
+    parameters: dict = Field(default_factory=dict)
+    exchanges: dict[str, ExchangeConfig]
+    logging: LoggingConfig
+    aux: AuxConfig | None = None
+
+
+def load_strategy_config_from_yaml(path: Path | str, key: str | None = None) -> StrategyConfig:
+    """
+    Loads a strategy configuration from a YAML file.
+
+    Args:
+        path (str | Path): The path to the YAML file.
+        key (str | None): The key to extract from the YAML file.
+
+    Returns:
+        StrategyConfig: The parsed configuration.
+    """
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(f"File {path} not found.")
+    with path.open("r") as f:
+        config_dict = yaml.safe_load(f)
+        if key:
+            config_dict = config_dict[key]
+        return StrategyConfig(**config_dict)
+
+
+class StrategySimulationConfig(BaseModel):
+    strategy: str | list[str]
+    parameters: dict = Field(default_factory=dict)
+    data: dict = Field(default_factory=dict)
+    simulation: dict = Field(default_factory=dict)
+    description: str | list[str] | None = None
+    variate: dict = Field(default_factory=dict)
+
+
+def load_simulation_config_from_yaml(path: Path | str) -> StrategySimulationConfig:
+    with open(path, "r") as f:
+        cfg = yaml.safe_load(f)
+    return StrategySimulationConfig(**cfg)