Qubx 1.0.0.dev3__tar.gz → 1.0.0.dev4__tar.gz

{qubx-1.0.0.dev3 → qubx-1.0.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 1.0.0.dev3
+Version: 1.0.0.dev4
 Summary: Qubx - Quantitative Trading Framework
 Project-URL: homepage, https://xlydian.com
 Project-URL: repository, https://github.com/xLydianSoftware/Qubx
@@ -33,6 +33,7 @@ Requires-Dist: psycopg-binary<4,>=3.1.19
 Requires-Dist: psycopg-pool<4,>=3.2.2
 Requires-Dist: psycopg<4,>=3.1.18
 Requires-Dist: pyarrow>=15.0.0
+Requires-Dist: pydantic-settings<3,>=2.4.0
 Requires-Dist: pydantic<3,>=2.9.2
 Requires-Dist: pymongo<5,>=4.6.1
 Requires-Dist: python-binance<2,>=1.0.19

{qubx-1.0.0.dev3 → qubx-1.0.0.dev4}/pyproject.toml

@@ -34,6 +34,7 @@ dependencies = [
     "importlib-metadata",
     "stackprinter>=0.2.10,<1",
     "pydantic>=2.9.2,<3",
+    "pydantic-settings>=2.4.0,<3",
     "python-dotenv>=1.0.0,<2",
     "cython==3.0.8",
     "croniter>=2.0.5,<3",

{qubx-1.0.0.dev3 → qubx-1.0.0.dev4}/src/qubx/__init__.py

@@ -57,7 +57,13 @@ def formatter(record):
 class QubxLogConfig:
     @staticmethod
     def get_log_level():
-        return os.getenv("QUBX_LOG_LEVEL", "WARNING")
+        # Env var takes priority (for CLI --log-level override), then settings
+        env_level = os.getenv("QUBX_LOG_LEVEL")
+        if env_level:
+            return env_level
+        from qubx.config import settings
+
+        return settings.log_level
 
     @staticmethod
     def set_log_level(level: str):

{qubx-1.0.0.dev3 → qubx-1.0.0.dev4}/src/qubx/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.0.0.dev3'
-__version_tuple__ = version_tuple = (1, 0, 0, 'dev3')
+__version__ = version = '1.0.0.dev4'
+__version_tuple__ = version_tuple = (1, 0, 0, 'dev4')
 
 __commit_id__ = commit_id = None

{qubx-1.0.0.dev3 → qubx-1.0.0.dev4}/src/qubx/backtester/management.py

@@ -105,11 +105,7 @@ class BacktestStorage:
 
         Args:
             base_path: Root path for backtest storage (local dir or cloud URI)
-            storage_options: Cloud storage credentials. None = auto-detect from:
-                             QUBX_S3_KEY / AWS_ACCESS_KEY_ID
-                             QUBX_S3_SECRET / AWS_SECRET_ACCESS_KEY
-                             QUBX_S3_REGION / AWS_DEFAULT_REGION
-                             QUBX_S3_ENDPOINT / AWS_ENDPOINT_URL
+            storage_options: Cloud storage credentials dict. None = uses default_s3_account from settings.
         """
         try:
             import duckdb
@@ -217,33 +213,12 @@ class BacktestStorage:
 
     def _load_from_path(self, run_path: str) -> TradingSessionResult:
         """
-        Load a TradingSessionResult using the already-configured DuckDB connection.
+        Load a TradingSessionResult from parquet storage (local or cloud).
 
-        All parquet reads go through ``self._conn`` (httpfs for S3, local for disk)
-        so no s3fs / aiobotocore dependency is needed and connection pooling is
-        handled by DuckDB internally.
+        Delegates to SimulationResultsSaver.load() which reads data files
+        in parallel using a ThreadPoolExecutor.
         """
-
-        def _read(filename: str) -> pd.DataFrame:
-            p = f"{run_path.rstrip('/')}/{filename}"
-            try:
-                return self._conn.execute(f"SELECT * FROM read_parquet('{p}')").df()
-            except Exception:
-                return pd.DataFrame()
-
-        meta_df = _read(SimulationResultsSaver.METADATA_FILE)
-        if meta_df.empty:
-            raise FileNotFoundError(f"Metadata not found at '{run_path}'")
-
-        return SimulationResultsSaver._from_dfs(
-            meta=meta_df.iloc[0].to_dict(),
-            portfolio=_read(SimulationResultsSaver.DATA_FILES["portfolio"]),
-            executions=_read(SimulationResultsSaver.DATA_FILES["executions"]),
-            signals=_read(SimulationResultsSaver.DATA_FILES["signals"]),
-            targets=_read(SimulationResultsSaver.DATA_FILES["targets"]),
-            transfers=_read(SimulationResultsSaver.DATA_FILES["transfers"]),
-            emitter=_read(SimulationResultsSaver.DATA_FILES["emitter"]),
-        )
+        return SimulationResultsSaver.load(run_path, self._storage_options)
 
     def load(self, backtest_id: str) -> TradingSessionResult:
         """

{qubx-1.0.0.dev3 → qubx-1.0.0.dev4}/src/qubx/backtester/runner.py

@@ -33,7 +33,6 @@ from qubx.data.storage import IStorage
 from qubx.health import DummyHealthMonitor
 from qubx.loggers.inmemory import InMemoryLogsWriter
 from qubx.pandaz.utils import _frame_to_str
-from qubx.utils.results import SimulationResultsSaver
 from qubx.utils.runner.configs import PrefetchConfig
 from qubx.utils.time import now_ns
 

qubx-1.0.0.dev4/src/qubx/config.py

@@ -0,0 +1,139 @@
+"""Unified configuration management for Qubx.
+
+Provides a single source of truth for all Qubx settings using pydantic-settings.
+Configuration is loaded from (in priority order):
+1. Environment variables (prefix QUBX_)
+2. ~/.qubx/config.json
+
+Usage:
+    from qubx.config import settings, get_s3_account
+
+    # Access settings
+    print(settings.log_level)
+    print(settings.s3)
+
+    # Get a named S3 account
+    account = get_s3_account("hetzner")
+    print(account.endpoint_url)
+"""
+
+import json
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, ClassVar
+
+from pydantic import BaseModel
+from pydantic_settings import BaseSettings, PydanticBaseSettingsSource
+
+
+class S3Account(BaseModel):
+    """S3-compatible storage account credentials."""
+
+    endpoint_url: str
+    access_key_id: str
+    secret_access_key: str
+    region: str | None = None
+
+
+class LookupConfig(BaseModel):
+    """Configuration for instrument/fees lookups."""
+
+    type: str = "file"
+    mongo_url: str | None = None
+    reload_interval: str | None = None
+    path: str | None = None
+
+
+class _QubxJsonConfigSource(PydanticBaseSettingsSource):
+    """Load settings from ~/.qubx/config.json."""
+
+    _CONFIG_PATH: ClassVar[Path] = Path.home() / ".qubx" / "config.json"
+
+    def __init__(self, settings_cls: type[BaseSettings], config_path: Path | None = None):
+        super().__init__(settings_cls)
+        self._path = config_path or self._CONFIG_PATH
+
+    def get_field_value(self, field: Any, field_name: str) -> tuple[Any, str, bool]:
+        data = self._load()
+        value = data.get(field_name)
+        return value, field_name, value is not None
+
+    def _load(self) -> dict:
+        if not self._path.exists():
+            return {}
+        try:
+            return json.loads(self._path.read_text())
+        except (json.JSONDecodeError, OSError):
+            return {}
+
+    def __call__(self) -> dict[str, Any]:
+        data = self._load()
+        return {k: v for k, v in data.items() if v is not None}
+
+
+class QubxSettings(BaseSettings):
+    """Qubx framework settings.
+
+    Resolution order:
+    1. Environment variables (prefix QUBX_, nested with __)
+    2. ~/.qubx/config.json
+    3. Defaults
+    """
+
+    s3: dict[str, S3Account] = {}
+    default_s3_account: str | None = None
+    log_level: str = "WARNING"
+    instrument_lookup: LookupConfig = LookupConfig()
+    fees_lookup: LookupConfig = LookupConfig()
+
+    model_config = {"env_prefix": "QUBX_", "env_nested_delimiter": "__"}
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
+    ) -> tuple[PydanticBaseSettingsSource, ...]:
+        return (
+            init_settings,
+            env_settings,
+            dotenv_settings,
+            _QubxJsonConfigSource(settings_cls),
+        )
+
+
+@lru_cache(maxsize=1)
+def get_settings() -> QubxSettings:
+    """Get the singleton QubxSettings instance."""
+    return QubxSettings()
+
+
+def get_s3_account(name: str) -> S3Account:
+    """Look up a named S3 account from settings.
+
+    Args:
+        name: Account name (e.g., "hetzner")
+
+    Returns:
+        S3Account with credentials
+
+    Raises:
+        KeyError: If account not found
+    """
+    s = get_settings()
+    if name not in s.s3:
+        available = list(s.s3.keys()) or "(none)"
+        raise KeyError(f"S3 account '{name}' not found in config. Available: {available}")
+    return s.s3[name]
+
+
+def reset_settings() -> None:
+    """Clear the cached settings (useful for testing)."""
+    get_settings.cache_clear()
+
+
+# Module-level singleton
+settings = get_settings()

{qubx-1.0.0.dev3 → qubx-1.0.0.dev4}/src/qubx/core/lookups.py

@@ -27,9 +27,6 @@ _DEF_FEES_FOLDER = "fees"
 
 _PACKAGED_FEES_FILE = "crypto-fees.ini"
 
-_INI_FILE = "settings.ini"
-_INI_SECTION_INSTRUMENTS = "instrument-lookup"
-_INI_SECTION_FEES = "fees-lookup"
 
 
 class _InstrumentEncoder(json.JSONEncoder):
@@ -451,19 +448,24 @@ class LookupsManager(InstrumentsLookup, FeesLookup):
         if not hasattr(cls, "instance"):
             cls.instance = super(LookupsManager, cls).__new__(cls)
 
-            # - try to load settings
-            parser = configparser.ConfigParser()
-            parser.read(Path(get_local_qubx_folder()) / _INI_FILE)
+            from qubx.config import settings
 
-            if _INI_SECTION_INSTRUMENTS in parser:
-                cls.instance._i_lookup = LookupsManager._get_instrument_lookup(**dict(parser[_INI_SECTION_INSTRUMENTS]))
-            else:
-                cls.instance._i_lookup = FileInstrumentsLookupWithCCXT()
+            i_cfg = settings.instrument_lookup
+            f_cfg = settings.fees_lookup
 
-            if _INI_SECTION_FEES in parser:
-                cls.instance._t_lookup = LookupsManager._get_fees_lookup(**dict(parser[_INI_SECTION_FEES]))
-            else:
-                cls.instance._t_lookup = FeesLookupFile()
+            i_kwargs = {}
+            if i_cfg.mongo_url:
+                i_kwargs["mongo_url"] = i_cfg.mongo_url
+            if i_cfg.reload_interval:
+                i_kwargs["reload_interval"] = i_cfg.reload_interval
+            if i_cfg.path:
+                i_kwargs["path"] = i_cfg.path
+            cls.instance._i_lookup = LookupsManager._get_instrument_lookup(type=i_cfg.type, **i_kwargs)
+
+            f_kwargs = {}
+            if f_cfg.path:
+                f_kwargs["path"] = f_cfg.path
+            cls.instance._t_lookup = LookupsManager._get_fees_lookup(type=f_cfg.type, **f_kwargs)
 
         return cls.instance
 

{qubx-1.0.0.dev3 → qubx-1.0.0.dev4}/src/qubx/core/metrics.py

@@ -713,8 +713,12 @@ class TradingSessionResult:
             creation_time=self.creation_time,
             author=self.author,
             variation_name=self.variation_name,
-            emitter_data=_slice_df(self.emitter_data),
-            transfers_log=_slice_df(self.transfers_log),
+            emitter_data=_slice_df(self.emitter_data.set_index("timestamp")).reset_index()
+            if self.emitter_data is not None
+            else None,
+            transfers_log=_slice_df(self.transfers_log.set_index("timestamp")).reset_index()
+            if self.transfers_log is not None
+            else None,
         )
         tsr.qubx_version = self.qubx_version
         tsr.description = self.description