cyqnt-trd 0.1.9.dev2__tar.gz → 0.1.9.dev4__tar.gz

{cyqnt_trd-0.1.9.dev2/cyqnt_trd.egg-info → cyqnt_trd-0.1.9.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cyqnt-trd
-Version: 0.1.9.dev2
+Version: 0.1.9.dev4
 Summary: A cryptocurrency trading toolkit centered on the standard_bot backtesting, paper signal, and execution workflow
 Author-email: Haowen Wang <wanghw@zju.edu.cn>
 License-Expression: MIT
@@ -27,6 +27,7 @@ Requires-Dist: pyarrow==21.0.0
 Requires-Dist: matplotlib==3.7.5
 Requires-Dist: scipy==1.10.1
 Requires-Dist: requests==2.32.5
+Requires-Dist: websockets<17,>=15.0.1
 Requires-Dist: binance-sdk-spot==8.2.1
 Requires-Dist: binance-sdk-derivatives-trading-usds-futures==10.0.1
 Requires-Dist: binance-sdk-algo==2.6.0

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/__init__.py

@@ -0,0 +1,22 @@
+"""atomic_strategy_lib shim — thin re-export layer over cyqnt_trd.
+
+This is NOT the original atomic_strategy_lib. It is a backward-compatibility
+shim that lives next to cyqnt_trd and exposes the atomic public API surface
+by delegating to the matching cyqnt_trd implementations.
+
+Usage from a usage_project_case::
+
+    # _paths.py only needs to add this directory's parent
+    sys.path.insert(0, "<repo>/atomic_compat")
+
+    # Then existing code works unchanged:
+    from atomic_strategy_lib.signals.momentum import rsi_compute, rsi_current
+    from atomic_strategy_lib.scoring.gates import verdict_with_gate
+    # …etc
+
+Internally these route to cyqnt_trd.compat.atomic_signals,
+cyqnt_trd.blocks.verdicts, etc.
+"""
+
+__shim_for__ = "atomic_strategy_lib"
+__shim_target__ = "cyqnt_trd"

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/core/cli.py

@@ -0,0 +1,25 @@
+"""shim — atomic.core.cli helpers (run_cli / safe_float / CLIError).
+
+These are subprocess primitives. Re-export from cyqnt_trd's wrappers.
+"""
+from cyqnt_trd.data_cli._subprocess import run_binance_cli, run_binance_pro_cli  # noqa: F401
+from cyqnt_trd.exec_cli._subprocess import CLIError  # noqa: F401
+
+
+def run_cli(cmd, profile=None, timeout=30):
+    """atomic shim: dispatch to run_binance_cli or run_binance_pro_cli based on cmd[0]."""
+    if not cmd:
+        return None
+    binary = cmd[0] if isinstance(cmd, list) else "binance-cli"
+    args = cmd[1:] if isinstance(cmd, list) else []
+    if "pro" in binary:
+        return run_binance_pro_cli(args, timeout=timeout)
+    return run_binance_cli(args, timeout=timeout)
+
+
+def safe_float(val, default=0.0):
+    """atomic shim: convert to float, return default on error."""
+    try:
+        return float(val) if val is not None else default
+    except (TypeError, ValueError):
+        return default

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/core/config.py

@@ -0,0 +1,4 @@
+"""shim — re-export cyqnt_trd.compat.config"""
+from cyqnt_trd.compat.config import (  # noqa: F401
+    DEFAULT_CONFIG, load_config, merge_config, get_section, resolve_workspace_path,
+)

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/core/run_output.py

@@ -0,0 +1,125 @@
+"""shim — atomic.core.run_output.
+
+This is a verbatim copy of atomic_strategy_lib.core.run_output. It uses
+only stdlib (no atomic / cyqnt_trd dependencies), so we host it inline
+in the shim package to avoid placing IO helpers inside cyqnt_trd's
+main namespace.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+
+def atomic_write_text(path: Path, text: str, encoding: str = "utf-8") -> None:
+    """Write text to a file atomically via tmp-then-rename.
+
+    Why: pipeline artifacts and state files (positions, signal logs) hold
+    workflow-critical data. A crash mid-write with plain ``write_text`` leaves
+    a truncated file that breaks the next load.
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(text, encoding=encoding)
+    os.replace(tmp, path)
+
+
+@dataclass(frozen=True)
+class RunOutput:
+    """Resolved output paths for one pipeline run."""
+
+    path: Path
+    latest_path: Optional[Path]
+    runs_dir: Optional[Path]
+    run_id: Optional[str]
+
+
+def prepare_run_output(
+    requested_out: str,
+    *,
+    default_out: str = "tmp/pipeline_result.json",
+    resolve_path: Optional[Callable[[str], Path]] = None,
+) -> RunOutput:
+    """Resolve output paths.
+
+    If the caller uses the default output path, write the durable artifact
+    into a unique run directory and mirror it to ``tmp/latest/...``. If the
+    caller explicitly supplies ``--out``, honor that path exactly and skip
+    mirroring.
+    """
+    resolver = resolve_path or Path
+    requested = resolver(str(requested_out))
+    default = resolver(default_out)
+
+    if str(requested_out) != default_out and requested != default:
+        return RunOutput(path=requested, latest_path=None, runs_dir=None, run_id=None)
+
+    run_id = _new_run_id()
+    runs_dir = default.parent / "runs"
+    run_path = runs_dir / run_id / default.name
+    latest_path = default.parent / "latest" / default.name
+    return RunOutput(
+        path=run_path,
+        latest_path=latest_path,
+        runs_dir=runs_dir,
+        run_id=run_id,
+    )
+
+
+def write_json_output(
+    output,
+    data: Any,
+    *,
+    keep_runs: int = 20,
+    **json_kwargs: Any,
+) -> None:
+    """Write JSON to the run artifact and update the latest mirror."""
+    if isinstance(output, RunOutput):
+        run_output = output
+        target = run_output.path
+    else:
+        run_output = None
+        target = Path(output)
+
+    text = json.dumps(data, **json_kwargs)
+    atomic_write_text(target, text)
+
+    if run_output and run_output.latest_path:
+        atomic_write_text(run_output.latest_path, text)
+
+    if run_output and run_output.runs_dir and keep_runs > 0:
+        prune_run_dirs(run_output.runs_dir, keep=keep_runs)
+
+
+def prune_run_dirs(runs_dir: Path, *, keep: int = 20) -> None:
+    """Keep the newest run directories by lexical run id, deleting older runs."""
+    if keep <= 0 or not runs_dir.exists():
+        return
+
+    run_dirs = sorted(
+        (p for p in runs_dir.iterdir() if p.is_dir()),
+        key=lambda p: p.name,
+    )
+    stale = run_dirs[:-keep]
+    for path in stale:
+        shutil.rmtree(path, ignore_errors=True)
+
+
+def _new_run_id() -> str:
+    stamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S%fZ")
+    return f"{stamp}-{os.getpid()}"
+
+
+__all__ = [
+    "RunOutput",
+    "atomic_write_text",
+    "prepare_run_output",
+    "prune_run_dirs",
+    "write_json_output",
+]

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/core/template_hint.py

@@ -0,0 +1,47 @@
+"""shim — atomic.core.template_hint.
+
+Verbatim copy of atomic's template-hint emitter (pure stdlib utility,
+no atomic / cyqnt_trd dependencies).
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Iterable, Optional
+
+_HEADER = "=" * 100
+_TEMPLATE_DIR = "usage_project_cases/_templates"
+
+
+def emit_template_hint(
+    template: str,
+    data_path,
+    summary_lines: Iterable[str],
+    *,
+    secondary_template: Optional[str] = None,
+    stream=sys.stdout,
+) -> None:
+    """Print a structured agent-facing template hint.
+
+    The block contains the primary template path, optional secondary template,
+    and a compact summary. *data_path* is intentionally not printed because
+    local result paths are internal runtime details, not user-facing content.
+    """
+    stream.write(_HEADER + "\n")
+    stream.write("TEMPLATE HINT FOR AGENT\n")
+    stream.write(_HEADER + "\n")
+    stream.write(f"  primary_template:   {_TEMPLATE_DIR}/{template}\n")
+    if secondary_template:
+        stream.write(f"  secondary_template: {_TEMPLATE_DIR}/{secondary_template}\n")
+    stream.write("  usage: render the user-facing report by filling the sections\n")
+    stream.write("         of primary_template from the structured result data.\n")
+    stream.write("  visibility: do not mention local JSON/Markdown paths in the final answer\n")
+    stream.write("              unless the user explicitly asks for saved artifact paths.\n")
+    stream.write("\nSUMMARY (for quick scan, not the final answer):\n")
+    for line in summary_lines:
+        stream.write(f"  {line}\n")
+    stream.write(_HEADER + "\n")
+
+
+__all__ = ["emit_template_hint"]

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/core/types.py

@@ -0,0 +1,8 @@
+"""shim — re-export cyqnt_trd.compat.types"""
+from cyqnt_trd.compat.types import *  # noqa: F401,F403
+from cyqnt_trd.compat.types import (
+    Candle, Ticker, FundingRate, OpenInterest, OIHistoryPoint,
+    OrderBookLevel, OrderBook, Balance, Position, ExchangeFilter,
+    Signal, Score, Verdict, TradePlan, OrderResult, VelocityMetrics,
+    extract_closes,
+)

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/data/account.py

@@ -0,0 +1,52 @@
+"""shim — atomic.data.account"""
+from cyqnt_trd.data_cli import fetch_account_balance, fetch_positions  # noqa: F401
+from cyqnt_trd.compat.types import Balance, Position
+
+
+def account_balance_fetch(asset="USDT", market="futures", profile=None,
+                         binary="binance-cli"):
+    """atomic-style — returns Balance dataclass."""
+    df = fetch_account_balance(asset=asset, market=market)
+    if df is None or df.empty:
+        return Balance(asset=asset, free=0.0, locked=0.0, total=0.0)
+    row = df.iloc[0]
+    return Balance(
+        asset=str(row.get("asset", asset)),
+        free=float(row.get("free", 0)),
+        locked=float(row.get("locked", 0)),
+        total=float(row.get("total", row.get("balance", 0))),
+    )
+
+
+def account_info_fetch(market="futures", profile=None, binary="binance-cli"):
+    """atomic-style — returns dict with balances and positions."""
+    bal_df = fetch_account_balance(market=market)
+    pos_df = fetch_positions(market=market)
+    return {
+        "balances": bal_df.to_dict(orient="records") if bal_df is not None and not bal_df.empty else [],
+        "positions": pos_df.to_dict(orient="records") if pos_df is not None and not pos_df.empty else [],
+    }
+
+
+def position_fetch(symbol, market="futures", profile=None, binary="binance-cli"):
+    """atomic-style — returns Position dataclass for a single symbol."""
+    df = fetch_positions(symbol=symbol, market=market)
+    if df is None or df.empty:
+        return Position(
+            symbol=symbol, direction="LONG", entry_price=0.0, quantity=0.0,
+            unrealized_pnl=0.0, leverage=1, margin_type="ISOLATED",
+        )
+    row = df.iloc[0]
+    qty = float(row.get("quantity", row.get("positionAmt", 0)))
+    direction = "LONG" if qty >= 0 else "SHORT"
+    return Position(
+        symbol=str(row.get("symbol", symbol)),
+        direction=direction,
+        entry_price=float(row.get("entry_price", row.get("entryPrice", 0))),
+        quantity=abs(qty),
+        unrealized_pnl=float(row.get("unrealized_pnl", row.get("unRealizedProfit", 0))),
+        leverage=int(row.get("leverage", 1) or 1),
+        margin_type=str(row.get("margin_type", row.get("marginType", "ISOLATED"))).upper(),
+        notional=float(row.get("notional", 0) or 0),
+        mark_price=float(row.get("mark_price", row.get("markPrice", 0)) or 0),
+    )

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/data/derivatives.py

@@ -0,0 +1,52 @@
+"""shim — atomic.data.derivatives"""
+from cyqnt_trd.data_cli import fetch_long_short_ratio  # noqa: F401
+
+
+def long_short_ratio_fetch(symbol, period="5m", limit=30, ratio_type="topPosition",
+                           profile=None, binary="binance-cli"):
+    """atomic-style — returns list of dicts with timestamp + ratio.
+
+    ratio_type: 'topPosition' (top traders by position) or 'topAccount'
+    (top traders by account count) or 'global'.
+    """
+    df = fetch_long_short_ratio(symbol, ratio_type=ratio_type, period=period, limit=limit)
+    if df is None or df.empty:
+        return []
+    return df.to_dict(orient="records")
+
+
+def top_trader_ls_ratio_fetch(symbol, by="position", period="5m", limit=30,
+                              profile=None, binary="binance-cli"):
+    """atomic-style — top traders LS ratio."""
+    ratio_type = "topPosition" if by == "position" else "topAccount"
+    return long_short_ratio_fetch(symbol, period=period, limit=limit, ratio_type=ratio_type)
+
+
+def basis_fetch(symbol, period="5m", limit=30, profile=None, binary="binance-cli"):
+    """atomic-style basis (futures price - spot price). Returns list of dicts."""
+    try:
+        from cyqnt_trd.data_cli.ratios import fetch_basis as _impl
+        df = _impl(symbol, period=period, limit=limit)
+        return df.to_dict(orient="records") if df is not None and not df.empty else []
+    except (ImportError, AttributeError):
+        return []
+
+
+def taker_volume_fetch(symbol, period="5m", limit=30, profile=None, binary="binance-cli"):
+    """atomic-style taker buy/sell volume. Returns list of dicts."""
+    try:
+        from cyqnt_trd.data_cli.ratios import fetch_taker_volume as _impl
+        df = _impl(symbol, period=period, limit=limit)
+        return df.to_dict(orient="records") if df is not None and not df.empty else []
+    except (ImportError, AttributeError):
+        return []
+
+
+def leverage_brackets_fetch(symbol, profile=None, binary="binance-cli"):
+    """atomic-style leverage brackets. Returns list of dicts."""
+    try:
+        from cyqnt_trd.data_cli.ratios import fetch_leverage_brackets as _impl
+        df = _impl(symbol)
+        return df.to_dict(orient="records") if df is not None and not df.empty else []
+    except (ImportError, AttributeError):
+        return []

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/data/funding.py

@@ -0,0 +1,37 @@
+"""shim — atomic.data.funding"""
+from cyqnt_trd.data_cli import fetch_funding_rate, fetch_funding_history  # noqa: F401
+from cyqnt_trd.compat.types import FundingRate
+
+
+def funding_rate_current(symbol, profile=None, binary="binance-cli"):
+    """atomic-style — returns single FundingRate dataclass (latest)."""
+    df = fetch_funding_rate(symbol)
+    if df is None or df.empty:
+        return FundingRate(symbol=symbol, rate=0.0)
+    last = df.iloc[-1]
+    return FundingRate(
+        symbol=symbol,
+        rate=float(last.get("rate", last.get("funding_rate", 0))),
+        timestamp=int(last.get("timestamp", 0)) if "timestamp" in last else None,
+        mark_price=float(last.get("mark_price", 0) or 0) if "mark_price" in last else None,
+        index_price=float(last.get("index_price", 0) or 0) if "index_price" in last else None,
+        next_funding_time=int(last.get("next_funding_time", 0) or 0) if "next_funding_time" in last else None,
+    )
+
+
+def funding_rate_fetch(symbol, profile=None, binary="binance-cli"):
+    """atomic alias for funding_rate_current."""
+    return funding_rate_current(symbol)
+
+
+def funding_rate_info(symbol, profile=None, binary="binance-cli"):
+    """atomic alias — returns dict with rate + metadata."""
+    fr = funding_rate_current(symbol)
+    return {
+        "symbol": fr.symbol,
+        "rate": fr.rate,
+        "timestamp": fr.timestamp,
+        "mark_price": fr.mark_price,
+        "index_price": fr.index_price,
+        "next_funding_time": fr.next_funding_time,
+    }

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/data/http_client.py

@@ -0,0 +1,12 @@
+"""shim — atomic.data.http_client (NOT PORTED — stubs).
+
+Atomic's HTTP client wraps requests for direct REST. cyqnt_trd uses
+binance-cli subprocess instead, so we don't need this. Callers that
+import http_client get safe defaults.
+"""
+
+
+def __getattr__(name):
+    if name.startswith("_"):
+        raise AttributeError(name)
+    return lambda *a, **k: None

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/data/kline.py

@@ -0,0 +1,44 @@
+"""shim — atomic.data.kline (atomic-named wrappers around cyqnt_trd.data_cli)"""
+from cyqnt_trd.data_cli import fetch_klines, fetch_klines_multi_tf  # noqa: F401
+from cyqnt_trd.data_cli.kline import df_to_candles as _df_to_candles
+
+
+def kline_fetch(symbol, interval="1h", limit=100, market="spot",
+                profile=None, binary="binance-cli"):
+    """atomic-style kline_fetch — returns list[Candle].
+
+    Internally delegates to fetch_klines (returns DataFrame) then converts.
+    """
+    df = fetch_klines(symbol, interval=interval, limit=limit, market=market)
+    candles = []
+    if df.empty:
+        return candles
+    from cyqnt_trd.compat.types import Candle
+    for _, row in df.iterrows():
+        candles.append(Candle(
+            timestamp=int(row.get("open_time", 0)),
+            open=float(row.get("open", 0)),
+            high=float(row.get("high", 0)),
+            low=float(row.get("low", 0)),
+            close=float(row.get("close", 0)),
+            volume=float(row.get("volume", 0)),
+            quote_volume=float(row.get("quote_volume", 0)),
+            trades=int(row.get("trades", 0)),
+        ))
+    return candles
+
+
+def kline_fetch_multi_tf(symbol, timeframes, limits=None, limit=None,
+                        market="spot", profile=None, binary="binance-cli"):
+    """atomic-style — returns dict[tf -> list[Candle]]."""
+    out = {}
+    for tf in timeframes:
+        lim = (limits or {}).get(tf, limit or 100)
+        out[tf] = kline_fetch(symbol, interval=tf, limit=lim, market=market)
+    return out
+
+
+def listing_age_fetch(symbol, profile=None, binary="binance-cli"):
+    """atomic-style listing_age_fetch — re-export from data_cli."""
+    from cyqnt_trd.data_cli.kline import listing_age_fetch as _impl
+    return _impl(symbol)

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/data/market_bundle.py

@@ -0,0 +1,28 @@
+"""shim — atomic.data.market_bundle (cached facade over the per-source modules).
+
+Atomic's market_bundle re-exports kline_fetch / ticker_24h_fetch /
+funding_rate_current / open_interest_fetch / etc. with sqlite caching.
+We re-export the same names from our individual shim modules; cache
+behaviour is provided by cyqnt_trd.data_cli's in-memory cache.
+"""
+from atomic_strategy_lib.data.kline import (  # noqa: F401
+    kline_fetch, kline_fetch_multi_tf, listing_age_fetch,
+)
+from atomic_strategy_lib.data.ticker import (  # noqa: F401
+    ticker_24h_fetch, ticker_price_fetch, gainers_list_fetch,
+)
+from atomic_strategy_lib.data.funding import (  # noqa: F401
+    funding_rate_current, funding_rate_fetch, funding_rate_info,
+)
+from atomic_strategy_lib.data.open_interest import (  # noqa: F401
+    open_interest_fetch, oi_history_fetch,
+)
+from atomic_strategy_lib.data.orderbook import orderbook_fetch  # noqa: F401
+from atomic_strategy_lib.data.account import (  # noqa: F401
+    account_balance_fetch, account_info_fetch, position_fetch,
+)
+from atomic_strategy_lib.data.derivatives import (  # noqa: F401
+    long_short_ratio_fetch, top_trader_ls_ratio_fetch,
+    basis_fetch, taker_volume_fetch, leverage_brackets_fetch,
+)
+from atomic_strategy_lib.data.scanner import full_market_scan, scan_with_filter  # noqa: F401

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/data/market_cache.py

@@ -0,0 +1,47 @@
+"""shim — atomic.data.market_cache.
+
+Atomic uses sqlite-backed caching with typed read/write helpers. cyqnt_trd
+uses a generic in-memory dict cache. We expose atomic's typed names as
+no-op stubs so callers don't crash; actual caching happens transparently
+inside cyqnt_trd.data_cli.
+"""
+
+
+def cache_path(*args, **kwargs):
+    return None
+
+
+def get_conn():
+    return None
+
+
+def read_klines(*args, **kwargs):
+    return None
+
+
+def write_klines(*args, **kwargs):
+    return None
+
+
+def read_ticker(*args, **kwargs):
+    return None
+
+
+def write_tickers(*args, **kwargs):
+    return None
+
+
+def read_funding(*args, **kwargs):
+    return None
+
+
+def write_funding(*args, **kwargs):
+    return None
+
+
+def read_oi_history(*args, **kwargs):
+    return None
+
+
+def write_oi_history(*args, **kwargs):
+    return None

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/data/open_interest.py

@@ -0,0 +1,56 @@
+"""shim — atomic.data.open_interest"""
+from cyqnt_trd.data_cli import fetch_open_interest, fetch_oi_history  # noqa: F401
+from cyqnt_trd.compat.types import OpenInterest, OIHistoryPoint
+
+
+def open_interest_fetch(symbol, profile=None, binary="binance-cli"):
+    """atomic-style — returns OpenInterest dataclass."""
+    df = fetch_open_interest(symbol)
+    if df is None or df.empty:
+        return OpenInterest(symbol=symbol, oi_base=0.0, oi_value=0.0)
+    row = df.iloc[0]
+    return OpenInterest(
+        symbol=symbol,
+        oi_base=float(row.get("oi_base", row.get("openInterest", 0))),
+        oi_value=float(row.get("oi_value", row.get("openInterestValue", 0))),
+        timestamp=int(row.get("timestamp", 0) or 0),
+    )
+
+
+def oi_history_fetch(symbol, period="5m", limit=30, profile=None, binary="binance-cli"):
+    """atomic-style — returns list[OIHistoryPoint]."""
+    df = fetch_oi_history(symbol, interval=period, limit=limit)
+    if df is None or df.empty:
+        return []
+    out = []
+    for _, row in df.iterrows():
+        out.append(OIHistoryPoint(
+            timestamp=int(row.get("timestamp", 0)),
+            oi_value=float(row.get("oi_value", row.get("sumOpenInterestValue", 0))),
+            oi_base=float(row.get("oi_base", row.get("sumOpenInterest", 0))),
+        ))
+    return out
+
+
+def oi_delta_pct(history):
+    """Compute percentage change between oldest and newest OI points.
+
+    Sourced verbatim from atomic_strategy_lib.data.open_interest.oi_delta_pct.
+
+    Parameters
+    ----------
+    history : list[OIHistoryPoint]
+        OI history points ordered oldest → newest.
+
+    Returns
+    -------
+    Optional[float]
+        Percentage change, or None if fewer than 2 points or oldest is zero.
+    """
+    if len(history) < 2:
+        return None
+    oldest = history[0].oi_value
+    newest = history[-1].oi_value
+    if oldest == 0:
+        return None
+    return ((newest - oldest) / oldest) * 100

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/data/orderbook.py

@@ -0,0 +1,18 @@
+"""shim — atomic.data.orderbook"""
+from cyqnt_trd.data_cli import fetch_orderbook_depth, orderbook_imbalance  # noqa: F401
+from cyqnt_trd.compat.types import OrderBook, OrderBookLevel
+
+
+def orderbook_fetch(symbol, market="futures", limit=20, profile=None,
+                   binary="binance-cli"):
+    """atomic-style — returns OrderBook dataclass."""
+    df = fetch_orderbook_depth(symbol, market=market, limit=limit)
+    if df is None or df.empty:
+        return OrderBook(symbol=symbol, bids=[], asks=[])
+    bids, asks = [], []
+    for _, row in df.iterrows():
+        if row.get("side") == "bid":
+            bids.append(OrderBookLevel(price=float(row["price"]), quantity=float(row["quantity"])))
+        elif row.get("side") == "ask":
+            asks.append(OrderBookLevel(price=float(row["price"]), quantity=float(row["quantity"])))
+    return OrderBook(symbol=symbol, bids=bids, asks=asks)

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/data/pro.py

@@ -0,0 +1,9 @@
+"""shim — atomic.data.pro (re-export AI signal helpers)"""
+from cyqnt_trd.data_cli import (  # noqa: F401
+    pro_indicators_fetch, pro_trade_signal_query, pro_trade_signal_rank,
+)
+
+
+def pro_arb_scan(*args, **kwargs):
+    """Stub — atomic-only arb scanner."""
+    return []

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/data/scanner.py

@@ -0,0 +1,2 @@
+"""shim — atomic.data.scanner (re-export full_market_scan etc.)"""
+from cyqnt_trd.data_cli import full_market_scan, scan_with_filter  # noqa: F401

cyqnt_trd-0.1.9.dev4/atomic_compat/atomic_strategy_lib/data/search.py

@@ -0,0 +1,15 @@
+"""shim — atomic.data.search (NOT PORTED — stubs)."""
+
+
+def hotrank_fetch(*args, **kwargs):
+    return []
+
+
+def trending_fetch(*args, **kwargs):
+    return []
+
+
+def __getattr__(name):
+    if name.startswith("_"):
+        raise AttributeError(name)
+    return lambda *a, **k: []