walrasquant-lib 0.5.2__tar.gz → 0.5.3__tar.gz

{walrasquant_lib-0.5.2 → walrasquant_lib-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: walrasquant-lib
-Version: 0.5.2
+Version: 0.5.3
 Summary: fastest python trading bot
 Author: River-Shi
 Author-email: River-Shi <nachuan.shi.quant@gmail.com>

{walrasquant_lib-0.5.2 → walrasquant_lib-0.5.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "walrasquant-lib"
-version = "0.5.2"
+version = "0.5.3"
 description = "fastest python trading bot"
 authors = [
     {name = "River-Shi",email = "nachuan.shi.quant@gmail.com"}

{walrasquant_lib-0.5.2 → walrasquant_lib-0.5.3}/src/walrasquant/config.py

@@ -74,6 +74,27 @@ class BasicConfig:
     testnet: bool = False
     passphrase: str | None = None
 
+    @classmethod
+    def from_settings(cls, path: str, testnet: bool = False) -> "BasicConfig":
+        """Resolve credentials from the ``.keys`` config section at *path*.
+
+        ``BasicConfig.from_settings("DERIBIT.TESTNET", testnet=True)`` reads
+        ``settings.DERIBIT.TESTNET.API_KEY`` / ``.SECRET`` and, when present,
+        ``.PASSPHRASE``. A missing section or field raises
+        ``MissingSettingError`` describing exactly what to add and where.
+        """
+        from walrasquant.settings import settings
+
+        node = settings
+        for segment in path.split("."):
+            node = getattr(node, segment)
+        return cls(
+            api_key=node.API_KEY,
+            secret=node.SECRET,
+            testnet=testnet,
+            passphrase=node.get("PASSPHRASE"),
+        )
+
 
 @dataclass
 class PublicConnectorConfig:
@@ -261,7 +282,8 @@ class Config:
         private_conn_config (Dict[ExchangeType, List[PrivateConnectorConfig]]):
             Private connector configurations by exchange.
         zero_mq_signal_config (ZeroMQSignalConfig | None): Configuration for ZeroMQ signal, if used.
-        db_path (str): Path to the database file. Defaults to ".keys/cache.db".
+        db_path (str): Path to the database file. Defaults to ".keys/cache.db",
+            anchored to the discovered .keys directory when one exists.
         storage_backend (StorageType): Type of storage backend to use. Defaults to SQLITE.
         cache_sync_interval (int): Interval in seconds for cache synchronization. Defaults to 60.
         cache_expired_time (int): Time in seconds after which cache entries expire. Defaults to 3600.
@@ -303,3 +325,13 @@ class Config:
             self.log_config.filename = (
                 f"{log_folder}/{self.strategy_id}_{self.user_id}.log"
             )
+
+        # Anchor the default db_path to the discovered .keys directory so the
+        # cache lands in the same place regardless of cwd; explicit paths are
+        # left untouched.
+        if self.db_path == ".keys/cache.db":
+            from walrasquant.settings import discover
+
+            keys_dir = discover().keys_dir
+            if keys_dir is not None:
+                self.db_path = str(keys_dir / "cache.db")

{walrasquant_lib-0.5.2 → walrasquant_lib-0.5.3}/src/walrasquant/constants.py

@@ -1,71 +1,14 @@
-import os
-import sys
 from typing import Literal, Dict, List, TypedDict, NotRequired
 from enum import Enum
-from dynaconf import Dynaconf
 
-BACKEND_LITERAL = Literal["memory", "redis"]
-
-
-def is_sphinx_build():
-    return "sphinx" in sys.modules
-
-
-if not os.path.exists(".keys/"):
-    os.makedirs(".keys/")
-
-_SECRETS_CANDIDATES = [
-    ".keys/.secrets.toml",
-    ".keys/.secrets.yaml",
-    ".keys/.secrets.yml",
-]
-_SETTINGS_CANDIDATES = [
-    ".keys/settings.toml",
-    ".keys/settings.yaml",
-    ".keys/settings.yml",
-]
-
-_secrets_file = next((f for f in _SECRETS_CANDIDATES if os.path.exists(f)), None)
-_settings_file = next((f for f in _SETTINGS_CANDIDATES if os.path.exists(f)), None)
-_config_files = [f for f in (_settings_file, _secrets_file) if f]
-
-if _secrets_file is None and not is_sphinx_build():
-    raise FileNotFoundError(
-        "Config file not found, please create a secrets file at one of: "
-        + ", ".join(_SECRETS_CANDIDATES)
-    )
-
-
-settings = Dynaconf(
-    envvar_prefix="NEXUS",
-    settings_files=_config_files,
-    secrets=_secrets_file,
-    environments=False,
-    load_dotenv=True,
+from walrasquant.settings import (  # noqa: F401  (re-exported for compat)
+    MissingSettingError,
+    get_postgresql_config,
+    get_redis_config,
+    settings,
 )
 
-
-def get_postgresql_config():
-    """Get PostgreSQL configuration from environment variables or settings files."""
-    return {
-        "host": settings.get("PG_HOST", "localhost"),
-        "port": settings.get("PG_PORT", 5432),
-        "user": settings.get("PG_USER", "postgres"),
-        "password": settings.get("PG_PASSWORD", ""),
-        "database": settings.get("PG_DATABASE", "postgres"),
-    }
-
-
-def get_redis_config():
-    try:
-        return {
-            "host": settings.REDIS_HOST,
-            "port": settings.REDIS_PORT,
-            "db": settings.REDIS_DB,
-            "password": settings.REDIS_PASSWORD,
-        }
-    except Exception as e:
-        raise ValueError(f"Failed to get Redis password: {e}")
+BACKEND_LITERAL = Literal["memory", "redis"]
 
 
 IntervalType = Literal[

walrasquant_lib-0.5.3/src/walrasquant/settings.py

@@ -0,0 +1,404 @@
+"""Lazy, location-independent access to the ``.keys/`` configuration.
+
+Importing this module never touches the filesystem. The ``settings`` object
+below discovers and loads the dynaconf config on first attribute access:
+
+1. ``NEXUS_KEYS_DIR`` environment variable, if set.
+2. A directory passed to :func:`configure` before first access.
+3. Walking up from the current working directory looking for a ``.keys/``
+   directory that contains a secrets or settings file, stopping at the
+   project root (a directory containing ``.git`` or ``pyproject.toml``).
+
+If no config file is found this is not an error: settings are served from
+``NEXUS_*`` environment variables only, and a missing key raises
+:class:`MissingSettingError` describing the searched locations and how to fix
+it. Section paths inside the config files are free-form — whatever path is
+written in the file is the path read from code
+(``[BYBIT.LIVE.ACCOUNT1]`` -> ``settings.BYBIT.LIVE.ACCOUNT1.API_KEY``).
+"""
+
+from __future__ import annotations
+
+import os
+import threading
+from collections.abc import Iterator, Mapping
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from dynaconf import Dynaconf
+
+KEYS_DIR_ENV = "NEXUS_KEYS_DIR"
+
+SECRETS_FILENAMES = (".secrets.toml", ".secrets.yaml", ".secrets.yml")
+SETTINGS_FILENAMES = ("settings.toml", "settings.yaml", "settings.yml")
+
+_ROOT_MARKERS = (".git", "pyproject.toml")
+
+_CREDENTIAL_FIELD_NAMES = frozenset({"API_KEY", "SECRET", "PASSPHRASE"})
+
+
+class MissingSettingError(AttributeError):
+    """A requested setting does not exist in any loaded source.
+
+    Subclasses :class:`AttributeError` so existing ``except AttributeError``
+    handlers and ``getattr(..., default)`` calls keep working.
+    """
+
+
+@dataclass(frozen=True)
+class CredentialSpec:
+    """Credential shape for one exchange: which fields a section needs."""
+
+    fields: tuple[str, ...]
+    notes: tuple[str, ...] = ()
+    placeholders: dict[str, str] = field(default_factory=dict)
+
+    def placeholder(self, field_name: str) -> str:
+        return self.placeholders.get(field_name, f"your_{field_name.lower()}")
+
+
+GENERIC_CREDENTIAL_SPEC = CredentialSpec(fields=("API_KEY", "SECRET"))
+
+# Single source of truth for credential shapes, consumed by three places:
+# ``wq init`` template rendering, ``wq doctor`` validation, and the
+# MissingSettingError fix snippet. Keys are matched case-sensitively against
+# the first segment of a section path.
+EXCHANGE_CREDENTIALS: dict[str, CredentialSpec] = {
+    "BINANCE": CredentialSpec(fields=("API_KEY", "SECRET")),
+    "OKX": CredentialSpec(fields=("API_KEY", "SECRET", "PASSPHRASE")),
+    "BYBIT": CredentialSpec(fields=("API_KEY", "SECRET")),
+    "BITGET": CredentialSpec(fields=("API_KEY", "SECRET", "PASSPHRASE")),
+    "DERIBIT": CredentialSpec(
+        fields=("API_KEY", "SECRET"),
+        notes=("API_KEY = client_id, SECRET = client_secret",),
+        placeholders={"API_KEY": "your_client_id", "SECRET": "your_client_secret"},
+    ),
+    "HYPERLIQUID": CredentialSpec(
+        fields=("API_KEY", "SECRET"),
+        notes=(
+            "API_KEY = main wallet address (NOT the agent address)",
+            "SECRET = agent private key, see https://app.hyperliquid.xyz/API",
+        ),
+        placeholders={
+            "API_KEY": "your_wallet_address",
+            "SECRET": "your_agent_private_key",
+        },
+    ),
+}
+
+# Sentinel values emitted by ``wq init``; ``wq doctor`` flags them as unfilled.
+PLACEHOLDER_VALUES: frozenset[str] = frozenset(
+    spec.placeholder(f)
+    for spec in (*EXCHANGE_CREDENTIALS.values(), GENERIC_CREDENTIAL_SPEC)
+    for f in spec.fields
+)
+
+
+def credential_spec_for(section_path: str) -> CredentialSpec:
+    """Spec for a dotted section path, chosen by its first segment.
+
+    Matching is case-sensitive; unknown first segments get the generic
+    API_KEY/SECRET spec.
+    """
+    first = section_path.split(".", 1)[0]
+    return EXCHANGE_CREDENTIALS.get(first, GENERIC_CREDENTIAL_SPEC)
+
+
+@dataclass(frozen=True)
+class DiscoveryResult:
+    """Where the config was (or was not) found."""
+
+    keys_dir: Path | None
+    secrets_file: Path | None
+    settings_file: Path | None
+    searched: tuple[Path, ...]
+    source: str  # "env" | "configure" | "search" | "none"
+
+    @property
+    def config_files(self) -> list[Path]:
+        return [f for f in (self.settings_file, self.secrets_file) if f is not None]
+
+
+def _find_file(directory: Path, names: tuple[str, ...]) -> Path | None:
+    for name in names:
+        candidate = directory / name
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def find_project_root(start: Path | None = None) -> Path | None:
+    """Nearest ancestor (including *start*) containing ``.git`` or
+    ``pyproject.toml``; None if there is no such directory."""
+    current = (start or Path.cwd()).resolve()
+    for candidate in (current, *current.parents):
+        if any((candidate / marker).exists() for marker in _ROOT_MARKERS):
+            return candidate
+    return None
+
+
+def discover(start: Path | None = None) -> DiscoveryResult:
+    """Resolve the ``.keys/`` directory without depending on cwd.
+
+    Never raises: when nothing is found the result has ``source="none"`` and
+    records every searched location for error messages.
+    """
+    env_dir = os.environ.get(KEYS_DIR_ENV)
+    if env_dir:
+        keys_dir = Path(env_dir).expanduser().resolve()
+        return DiscoveryResult(
+            keys_dir=keys_dir,
+            secrets_file=_find_file(keys_dir, SECRETS_FILENAMES),
+            settings_file=_find_file(keys_dir, SETTINGS_FILENAMES),
+            searched=(keys_dir,),
+            source="env",
+        )
+
+    if _configured_keys_dir is not None:
+        keys_dir = _configured_keys_dir
+        return DiscoveryResult(
+            keys_dir=keys_dir,
+            secrets_file=_find_file(keys_dir, SECRETS_FILENAMES),
+            settings_file=_find_file(keys_dir, SETTINGS_FILENAMES),
+            searched=(keys_dir,),
+            source="configure",
+        )
+
+    current = (start or Path.cwd()).resolve()
+    searched: list[Path] = []
+    for candidate in (current, *current.parents):
+        keys_dir = candidate / ".keys"
+        searched.append(keys_dir)
+        if keys_dir.is_dir():
+            secrets_file = _find_file(keys_dir, SECRETS_FILENAMES)
+            settings_file = _find_file(keys_dir, SETTINGS_FILENAMES)
+            if secrets_file or settings_file:
+                return DiscoveryResult(
+                    keys_dir=keys_dir,
+                    secrets_file=secrets_file,
+                    settings_file=settings_file,
+                    searched=tuple(searched),
+                    source="search",
+                )
+        if any((candidate / marker).exists() for marker in _ROOT_MARKERS):
+            break
+
+    return DiscoveryResult(
+        keys_dir=None,
+        secrets_file=None,
+        settings_file=None,
+        searched=tuple(searched),
+        source="none",
+    )
+
+
+_configured_keys_dir: Path | None = None
+
+
+def configure(keys_dir: str | Path) -> None:
+    """Programmatically pin the ``.keys/`` directory.
+
+    Must be called before the first ``settings`` access; raises RuntimeError
+    once settings are already loaded (env ``NEXUS_KEYS_DIR`` still wins over
+    this when both are set).
+    """
+    global _configured_keys_dir
+    if settings._loaded:
+        raise RuntimeError(
+            "walrasquant settings are already loaded; call configure() "
+            "before the first settings access"
+        )
+    _configured_keys_dir = Path(keys_dir).expanduser().resolve()
+
+
+def _render_missing(path: tuple[str, ...], discovery: DiscoveryResult) -> str:
+    dotted = ".".join(path)
+    lines = [f"Setting '{dotted}' not found."]
+
+    if discovery.config_files:
+        loaded = ", ".join(str(f) for f in discovery.config_files)
+        lines.append(f"Loaded config: {loaded}")
+    else:
+        lines.append("No config file was found. Searched:")
+        lines.extend(f"  {p}" for p in discovery.searched)
+        lines.append(f"(create one with 'wq init -e <SECTION>', or set {KEYS_DIR_ENV})")
+
+    secrets_target = discovery.secrets_file or (
+        discovery.keys_dir / ".secrets.toml"
+        if discovery.keys_dir
+        else Path(".keys/.secrets.toml")
+    )
+
+    leaf_is_field = path[-1].upper() in _CREDENTIAL_FIELD_NAMES
+    env_var = "NEXUS_" + "__".join(path)
+
+    if len(path) == 1 and not leaf_is_field:
+        if path[0] in EXCHANGE_CREDENTIALS:
+            spec = EXCHANGE_CREDENTIALS[path[0]]
+            lines.append(f"Fix - add a section to {secrets_target}:")
+            lines.extend(f"    # {note}" for note in spec.notes)
+            lines.append(
+                f"    [{path[0]}.<ACCOUNT>]  # section path = path read in code"
+            )
+            lines.extend(f'    {name} = "..."' for name in spec.fields)
+        else:
+            lines.append(
+                f"Fix - add '{path[0]} = ...' to {secrets_target} or set env: {env_var}"
+            )
+        return "\n".join(lines)
+
+    section = path[:-1] if leaf_is_field else path
+    spec = credential_spec_for(section[0])
+    lines.append(f"Fix - add to {secrets_target}:")
+    lines.extend(f"    # {note}" for note in spec.notes)
+    lines.append(f"    [{'.'.join(section)}]")
+    lines.extend(f'    {name} = "..."' for name in spec.fields)
+    if not leaf_is_field:
+        lines.append("    # the section path must match the path your code reads")
+    lines.append(f"or set env: {env_var}")
+    return "\n".join(lines)
+
+
+def _wrap(value: Any, path: tuple[str, ...], root: "LazySettings") -> Any:
+    if isinstance(value, Mapping):
+        return _SettingsNode(value, path, root)
+    return value
+
+
+class _SettingsNode(Mapping):
+    """Path-tracking view over a nested config mapping.
+
+    Behaves as a read-only Mapping; attribute access on a missing key raises
+    :class:`MissingSettingError` with the full dotted path and a fix snippet.
+    """
+
+    __slots__ = ("_box", "_path", "_root")
+
+    def __init__(
+        self, box: Mapping, path: tuple[str, ...], root: "LazySettings"
+    ) -> None:
+        object.__setattr__(self, "_box", box)
+        object.__setattr__(self, "_path", path)
+        object.__setattr__(self, "_root", root)
+
+    def __getattr__(self, name: str) -> Any:
+        try:
+            value = getattr(self._box, name)
+        except AttributeError:
+            raise MissingSettingError(
+                _render_missing((*self._path, name), self._root._discovery)
+            ) from None
+        return _wrap(value, (*self._path, name), self._root)
+
+    def __getitem__(self, key: Any) -> Any:
+        value = self._box[key]  # missing -> BoxKeyError (a KeyError), as Mapping
+        return _wrap(value, (*self._path, str(key)), self._root)
+
+    def __iter__(self) -> Iterator:
+        return iter(self._box)
+
+    def __len__(self) -> int:
+        return len(self._box)
+
+    def as_dict(self) -> dict:
+        return {key: value for key, value in self._box.items()}
+
+    def __repr__(self) -> str:
+        return f"<Settings {'.'.join(self._path)} {list(self._box)}>"
+
+
+class LazySettings:
+    """Dynaconf facade that loads on first access and never fails at import."""
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._dynaconf: Dynaconf | None = None
+        self._discovery: DiscoveryResult = DiscoveryResult(
+            keys_dir=None,
+            secrets_file=None,
+            settings_file=None,
+            searched=(),
+            source="none",
+        )
+
+    @property
+    def _loaded(self) -> bool:
+        return self._dynaconf is not None
+
+    def _load(self) -> Dynaconf:
+        if self._dynaconf is None:
+            with self._lock:
+                if self._dynaconf is None:
+                    discovery = discover()
+                    self._discovery = discovery
+                    self._dynaconf = Dynaconf(
+                        envvar_prefix="NEXUS",
+                        settings_files=[str(f) for f in discovery.config_files],
+                        secrets=(
+                            str(discovery.secrets_file)
+                            if discovery.secrets_file
+                            else None
+                        ),
+                        environments=False,
+                        load_dotenv=True,
+                    )
+        return self._dynaconf
+
+    def _reset(self) -> None:
+        """Drop the loaded state so the next access re-discovers (tests only)."""
+        global _configured_keys_dir
+        with self._lock:
+            self._dynaconf = None
+            _configured_keys_dir = None
+
+    @property
+    def discovery(self) -> DiscoveryResult:
+        """Discovery outcome of the loaded config (loads on first use)."""
+        self._load()
+        return self._discovery
+
+    def __getattr__(self, name: str) -> Any:
+        dynaconf = self._load()
+        try:
+            value = getattr(dynaconf, name)
+        except AttributeError:
+            raise MissingSettingError(
+                _render_missing((name,), self._discovery)
+            ) from None
+        return _wrap(value, (name,), self)
+
+    def __getitem__(self, key: Any) -> Any:
+        value = self._load()[key]
+        return _wrap(value, (str(key),), self)
+
+    def __contains__(self, key: Any) -> bool:
+        return key in self._load()
+
+    def __repr__(self) -> str:
+        if not self._loaded:
+            return "<LazySettings (not loaded)>"
+        return f"<LazySettings {self._discovery.source}: {self._discovery.keys_dir}>"
+
+
+settings = LazySettings()
+
+
+def get_postgresql_config() -> dict:
+    """Get PostgreSQL configuration from environment variables or settings files."""
+    return {
+        "host": settings.get("PG_HOST", "localhost"),
+        "port": settings.get("PG_PORT", 5432),
+        "user": settings.get("PG_USER", "postgres"),
+        "password": settings.get("PG_PASSWORD", ""),
+        "database": settings.get("PG_DATABASE", "postgres"),
+    }
+
+
+def get_redis_config() -> dict:
+    return {
+        "host": settings.REDIS_HOST,
+        "port": settings.REDIS_PORT,
+        "db": settings.REDIS_DB,
+        "password": settings.REDIS_PASSWORD,
+    }