walrasquant-lib 0.4.20__py3-none-any.whl

walrasquant/web/__init__.py

@@ -0,0 +1,26 @@
+"""Public interface for strategy web integration."""
+
+from __future__ import annotations
+
+from .app import StrategyFastAPI, create_strategy_app
+from .server import StrategyWebServer
+
+__all__ = [
+    "StrategyFastAPI",
+    "StrategyWebServer",
+    "create_strategy_app",
+    "app",
+]
+
+
+def __getattr__(name: str) -> object:
+    """Lazy-initialise the convenience ``app`` singleton on first access."""
+    if name == "app":
+        import sys
+
+        module = sys.modules[__name__]
+        instance = create_strategy_app()
+        # Cache so subsequent attribute access is O(1)
+        module.app = instance  # type: ignore[attr-defined]
+        return instance
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

walrasquant/web/app.py

@@ -0,0 +1,157 @@
+"""Strategy-aware FastAPI app utilities."""
+
+from __future__ import annotations
+
+import inspect
+from dataclasses import dataclass
+from functools import update_wrapper
+from typing import Any, Callable, Dict, List, Optional
+
+from fastapi import FastAPI
+from fastapi.routing import APIRouter, APIRoute
+
+
+@dataclass
+class _StrategyRoute:
+    path: str
+    endpoint: Callable[..., Any]
+    kwargs: Dict[str, Any]
+    bound_route: Optional[APIRoute] = None
+    bound_endpoint: Optional[Callable[..., Any]] = None
+
+
+class StrategyAPIRouter(APIRouter):
+    """APIRouter that defers binding of strategy instance methods."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._strategy_routes: List[_StrategyRoute] = []
+        self._baseline_route_count = len(self.routes)
+
+    # when @app.post(...) is called, this method is invoked
+    def add_api_route(
+        self, path: str, endpoint: Callable[..., Any], **kwargs: Any
+    ) -> None:
+        if self._is_strategy_endpoint(
+            endpoint
+        ):  # first parameter is 'self', indicating a method, save it to self._strategy_routes
+            self._strategy_routes.append(
+                _StrategyRoute(path=path, endpoint=endpoint, kwargs=dict(kwargs))
+            )
+            return None
+        return super().add_api_route(path, endpoint, **kwargs)
+
+    def bind_strategy(self, strategy: Any) -> None:
+        for route_def in self._strategy_routes:
+            self._remove_existing_route(route_def)
+            bound = self._wrap_endpoint(route_def.endpoint, strategy)
+            super().add_api_route(route_def.path, bound, **route_def.kwargs)
+            # Newly added route is the last item in self.routes
+            route_def.bound_route = self.routes[-1]  # type: ignore[assignment]
+            route_def.bound_endpoint = bound
+
+    def unbind_strategy(self) -> None:
+        for route_def in self._strategy_routes:
+            if route_def.bound_route and route_def.bound_route in self.routes:
+                self.routes.remove(route_def.bound_route)
+                route_def.bound_route = None
+                route_def.bound_endpoint = None
+
+    def has_strategy_routes(self) -> bool:
+        return bool(self._strategy_routes)
+
+    def has_user_defined_routes(self) -> bool:
+        return (
+            self.has_strategy_routes() or len(self.routes) > self._baseline_route_count
+        )
+
+    @staticmethod
+    def _is_strategy_endpoint(endpoint: Callable[..., Any]) -> bool:
+        try:
+            signature = inspect.signature(endpoint)
+        except (TypeError, ValueError):
+            return False
+
+        params = list(signature.parameters.values())
+        if not params:
+            return False
+        return params[0].name == "self"
+
+    @staticmethod
+    def _wrap_endpoint(
+        endpoint: Callable[..., Any], strategy: Any
+    ) -> Callable[..., Any]:
+        signature = inspect.signature(endpoint)
+        params = list(signature.parameters.values())
+        if not params or params[0].name != "self":
+            return endpoint
+
+        stripped_signature = signature.replace(parameters=params[1:])
+
+        if inspect.iscoroutinefunction(endpoint):
+
+            async def _call(*args: Any, **kwargs: Any) -> Any:
+                return await endpoint(strategy, *args, **kwargs)
+
+        else:
+
+            def _call(*args: Any, **kwargs: Any) -> Any:
+                return endpoint(strategy, *args, **kwargs)
+
+        update_wrapper(_call, endpoint)
+        _call.__signature__ = stripped_signature  # type: ignore[attr-defined]
+        return _call
+
+    def _remove_existing_route(self, route_def: _StrategyRoute) -> None:
+        if not route_def.bound_route:
+            return
+        if route_def.bound_route in self.routes:
+            self.routes.remove(route_def.bound_route)
+        route_def.bound_route = None
+        route_def.bound_endpoint = None
+
+
+class StrategyFastAPI(FastAPI):
+    """FastAPI application that understands strategy instance methods."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+        original_router: APIRouter = self.router
+        router = StrategyAPIRouter(
+            prefix=original_router.prefix,
+            tags=original_router.tags,
+            dependencies=original_router.dependencies,
+            default_response_class=original_router.default_response_class,
+            responses=original_router.responses,
+            callbacks=original_router.callbacks,
+            routes=list(original_router.routes),
+            deprecated=original_router.deprecated,
+            include_in_schema=original_router.include_in_schema,
+            generate_unique_id_function=original_router.generate_unique_id_function,
+        )
+        router.route_class = original_router.route_class
+        router.on_startup = original_router.on_startup
+        router.on_shutdown = original_router.on_shutdown
+        router.lifespan_context = original_router.lifespan_context
+
+        self.router = router
+        self._strategy_router: StrategyAPIRouter = router
+
+    def bind_strategy(self, strategy: Any) -> None:
+        self._strategy_router.bind_strategy(strategy)
+
+    def unbind_strategy(self) -> None:
+        self._strategy_router.unbind_strategy()
+
+    def has_strategy_routes(self) -> bool:
+        return self._strategy_router.has_strategy_routes()
+
+    def has_user_routes(self) -> bool:
+        return self._strategy_router.has_user_defined_routes()
+
+
+def create_strategy_app(**kwargs: Any) -> StrategyFastAPI:
+    """Create a strategy-aware FastAPI application."""
+
+    return StrategyFastAPI(**kwargs)

walrasquant/web/server.py

@@ -0,0 +1,92 @@
+"""Background web server runner for strategy FastAPI apps."""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+
+import uvicorn
+from fastapi import FastAPI
+import platform
+
+
+class StrategyWebServer:
+    """Run a FastAPI application in a dedicated background thread."""
+
+    def __init__(
+        self,
+        app: FastAPI,
+        *,
+        host: str = "0.0.0.0",
+        port: int = 8000,
+        log_level: str = "info",
+    ) -> None:
+        self._app = app
+        self._host = host
+        self._port = port
+        self._log_level = log_level
+
+        self._server: uvicorn.Server | None = None
+        self._thread: threading.Thread | None = None
+        self._started = threading.Event()
+
+    @property
+    def app(self) -> FastAPI:
+        return self._app
+
+    def start(self) -> None:
+        if self._server is not None:
+            return
+
+        try:
+            import uvloop  # noqa: F401
+
+            _uvloop_available = True
+        except Exception:
+            _uvloop_available = False
+
+        loop_type = (
+            "uvloop"
+            if platform.system() in {"Linux", "Darwin"} and _uvloop_available
+            else "asyncio"
+        )
+
+        config = uvicorn.Config(
+            self._app,
+            host=self._host,
+            port=self._port,
+            log_level=self._log_level,
+            loop=loop_type,
+            lifespan="on",
+        )
+        self._server = uvicorn.Server(config)
+
+        def _run() -> None:
+            server = self._server
+            if server is None:
+                return
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            self._started.set()
+            try:
+                loop.run_until_complete(server.serve())
+            finally:
+                loop.run_until_complete(loop.shutdown_asyncgens())
+                loop.close()
+
+        self._thread = threading.Thread(
+            target=_run, name="StrategyWebServer", daemon=True
+        )
+        self._thread.start()
+        self._started.wait()
+
+    def stop(self) -> None:
+        if not self._server:
+            return
+
+        self._server.should_exit = True
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=1.0)
+        self._server = None
+        self._thread = None
+        self._started.clear()

walrasquant_lib-0.4.20.dist-info/METADATA

@@ -0,0 +1,162 @@
+Metadata-Version: 2.3
+Name: walrasquant-lib
+Version: 0.4.20
+Summary: fastest python trading bot
+Author: River-Shi
+Author-email: River-Shi <nachuan.shi.quant@gmail.com>
+License: MIT LICENSE
+Requires-Dist: numpy>=1.26.4,<2.2.1
+Requires-Dist: redis>=5.2.1,<6.0.0
+Requires-Dist: zmq>=0.0.0,<0.0.1
+Requires-Dist: apscheduler>=3.11.0,<4.0.0
+Requires-Dist: returns>=0.24.0,<0.25.0
+Requires-Dist: aiosqlite>=0.21.0,<0.22.0
+Requires-Dist: uvloop>=0.21.0
+Requires-Dist: throttled-py>=2.2.3
+Requires-Dist: asyncpg>=0.30.0
+Requires-Dist: psycopg2-binary>=2.9.10
+Requires-Dist: click>=8.1.0
+Requires-Dist: pycryptodome>=3.23.0
+Requires-Dist: eth-account>=0.13.7
+Requires-Dist: fastapi>=0.117.1
+Requires-Dist: uvicorn>=0.36.0
+Requires-Dist: dynaconf[redis]>=3.2.12
+Requires-Dist: pandas>=2.3.3,<3.0.0
+Requires-Dist: aiohttp>=3.13.3
+Requires-Dist: rich>=14.0.0
+Requires-Dist: picows>=2.1.1
+Requires-Dist: ccxt>=4.5.63
+Requires-Dist: nexuscore-lib>=0.2.0
+Requires-Dist: flashduty-lib>=0.2.0
+Requires-Dist: nexuslog-lib>=0.5.0
+Requires-Dist: msgspec>=0.21.1
+Requires-Python: >=3.11, <3.15
+Description-Content-Type: text/markdown
+
+# walrasquant
+
+`walrasquant` is a high-performance Python framework for quantitative trading.
+It is designed for low-latency execution, multi-exchange connectivity, and strategy development at scale.
+
+## Highlights
+
+- Async-first architecture for real-time trading workflows
+- Multi-exchange support (OKX, Binance, Bybit, Hyperliquid, Bitget)
+- Built-in order and position lifecycle management
+- Strategy framework with execution algorithms (including TWAP)
+- Optional web API integration with FastAPI
+- CLI and PM2 tooling for monitoring and operations
+
+## Installation
+
+### Requirements
+
+- Python `>=3.11,<3.14`
+- Redis (recommended for monitoring and shared runtime state)
+
+### From PyPI
+
+```bash
+pip install walrasquant
+```
+
+### From source
+
+```bash
+git clone https://github.com/walras-group/WalrasQuant.git
+cd WalrasQuant
+uv pip install -e .
+```
+
+## Quick start
+
+```python
+from decimal import Decimal
+
+from walrasquant.constants import settings, ExchangeType, OrderSide, OrderType
+from walrasquant.config import Config, BasicConfig, PublicConnectorConfig, PrivateConnectorConfig
+from walrasquant.engine import Engine
+from walrasquant.exchange.okx import OkxAccountType
+from walrasquant.schema import BookL1, Order
+from walrasquant.strategy import Strategy
+
+
+OKX_API_KEY = settings.OKX.DEMO_1.api_key
+OKX_SECRET = settings.OKX.DEMO_1.secret
+OKX_PASSPHRASE = settings.OKX.DEMO_1.passphrase
+
+
+class DemoStrategy(Strategy):
+    def __init__(self):
+        super().__init__()
+        self.subscribe_bookl1(symbols=["BTCUSDT-PERP.OKX"])
+        self.signal = True
+
+    def on_filled_order(self, order: Order):
+        print(order)
+
+    def on_bookl1(self, bookl1: BookL1):
+        if not self.signal:
+            return
+
+        self.create_order(
+            symbol="BTCUSDT-PERP.OKX",
+            side=OrderSide.BUY,
+            type=OrderType.MARKET,
+            amount=Decimal("0.1"),
+        )
+        self.create_order(
+            symbol="BTCUSDT-PERP.OKX",
+            side=OrderSide.SELL,
+            type=OrderType.MARKET,
+            amount=Decimal("0.1"),
+        )
+        self.signal = False
+
+
+config = Config(
+    strategy_id="okx_demo_buy_sell",
+    user_id="user_test",
+    strategy=DemoStrategy(),
+    basic_config={
+        ExchangeType.OKX: BasicConfig(
+            api_key=OKX_API_KEY,
+            secret=OKX_SECRET,
+            passphrase=OKX_PASSPHRASE,
+            testnet=True,
+        )
+    },
+    public_conn_config={
+        ExchangeType.OKX: [PublicConnectorConfig(account_type=OkxAccountType.DEMO)]
+    },
+    private_conn_config={
+        ExchangeType.OKX: [PrivateConnectorConfig(account_type=OkxAccountType.DEMO)]
+    },
+)
+
+engine = Engine(config)
+
+if __name__ == "__main__":
+    try:
+        engine.start()
+    finally:
+        engine.dispose()
+```
+
+## CLI tools
+
+After installation, the following commands are available:
+
+- `wq` for PM2-based strategy process operations
+
+## Documentation
+
+- Local docs source: `docs/`
+
+## Contributing
+
+Contributions are welcome. Please open an issue or submit a PR.
+
+## License
+
+MIT License

walrasquant_lib-0.4.20.dist-info/RECORD

@@ -0,0 +1,105 @@
+walrasquant/__init__.py,sha256=A2Cke68pmeuBin50KHfD0n_O9QZBQVZM4Rqo7sySAts,170
+walrasquant/aggregation.py,sha256=Mbz9Ps2BfFK46Hbt9X9nE3Lv5dw5luTxv9NC403iG3s,13098
+walrasquant/backends/__init__.py,sha256=QGZK3ABQteHQQWvRNFCsBV8qX352EgbB-tKq_fd7L2w,246
+walrasquant/backends/db.py,sha256=PP7Q1fMSDt4AfM0JV7VvZhiEYehojlo49OHRPtaojIM,2755
+walrasquant/backends/db_memory.py,sha256=Xa2twotFbRBlWK7_EQpiJent4Ps7fXx4d-DdOs8nKzo,1787
+walrasquant/backends/db_postgresql.py,sha256=iYoHtYJmha1wB96eeagFYJX5Vion-S5P3xzmRlQn7SA,12812
+walrasquant/backends/db_sqlite.py,sha256=EAygEVJ1vJb0kKbdZaK4ir87XO6s2akd3QMmQ4CpCec,12030
+walrasquant/base/__init__.py,sha256=cTIW90ws8PjiaE5--hhmYmEl8EFbFzp17dnpM91yn80,699
+walrasquant/base/api_client.py,sha256=IbixhCNNcZDp3Beb0y1dk3h2lxzy55owi2vXGZyAz2s,1536
+walrasquant/base/connector.py,sha256=keiTuIz3fmhqyaoNoxa0PGs7pQhWYkNbLXU0iyim7FY,28733
+walrasquant/base/ems.py,sha256=0SRuXBzHbo5xRzWW1vLihMRLaLeXHceNBVEDyqkQbDs,29364
+walrasquant/base/exchange.py,sha256=7vm_b3hN4nTfbNHsDgE_6V0M8UehQ278ExBAwPZ4OyI,6865
+walrasquant/base/oms.py,sha256=7oTEzxtIrHH8BFIgaMGeYRdJBRNpRJbgnlOSoS043fA,14305
+walrasquant/base/retry.py,sha256=g2MgJMxgJjF5nzQQWy7dHd2AH_Qf1dToiE_lasTt_LA,6903
+walrasquant/base/sms.py,sha256=PBr6cEkXyTJ8whhlHni-Ihr0X_4oRvxzTslSsIKTCrc,21728
+walrasquant/base/ws_client.py,sha256=-kphgR6OYFgdM4338AccCiQBr7Jv7AbppMX6pN3scBs,15677
+walrasquant/config.py,sha256=AGSr5gBE9Uzm0k8ovvR_s3mnTp_z5uXjOOB1Z3mKfw8,10697
+walrasquant/constants.py,sha256=e0H9VcHhQ6urwttuxnHMeVr_4iXgKLSHkPl_J31-INc,9389
+walrasquant/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+walrasquant/core/cache.py,sha256=30KO0Y8Zif9U6GHZFbE7aAsE4fLMX9faUrp7qx1RONY,25337
+walrasquant/core/clock.py,sha256=IfFZNr6mBt5DGsJ9O9oCtRQuyBhkTK1wtwc5IEF1DiI,1866
+walrasquant/core/connection.py,sha256=Psp2b8yoTft2vZ5FHMYHTTiK0oX8ZS1oXHwrjnQO9jM,794
+walrasquant/core/entity.py,sha256=6st4msoTp2_n6Z6oQ1RFcJYV0KwP2Kawp4pwXSfAAoU,17897
+walrasquant/core/nautilius_core.py,sha256=V_PUnOfDBqtABRYZvFbP1Tgl865JRO2E_yLcx4TNwVg,3189
+walrasquant/core/registry.py,sha256=QHxs9pBAumVnLryxy1zXnJgT0mSzCC4DKDQMuC5uLyg,1449
+walrasquant/engine.py,sha256=LmNRNIXvtshyto7U_RuEGAoFZD8TP_ZwCDkYC97H_dQ,28025
+walrasquant/error.py,sha256=lKmA5t5npXiAWHaS2J7F0lVKApPXHFTSddAPETf_Mdg,840
+walrasquant/exchange/__init__.py,sha256=4gv6koc7ZAXgvK26QaMY3XVrga4Gp5rFa__w1h9HGcI,436
+walrasquant/exchange/base_factory.py,sha256=MXMbUqWQ7zUXUbxlNEf-AE4PhPiMBmc2jEkyF97EdQY,4652
+walrasquant/exchange/binance/__init__.py,sha256=tP5To0h9R61ac7WQa_sjJG3Wdn7AMVtL5zveSRm8tfQ,1014
+walrasquant/exchange/binance/connector.py,sha256=SVZpEX0_psJHYh1-8rqRSqL4TmpPjcOhEmz2V7hUKzs,40107
+walrasquant/exchange/binance/constants.py,sha256=TX6xZmoMpEZoU9QzG40918YQl_XW7iWAZV7OvGSXyVA,31032
+walrasquant/exchange/binance/ems.py,sha256=a6obprsQSkM3rhaPeSdPDYljiIk_qyvVzOGTJQ7-43g,5318
+walrasquant/exchange/binance/error.py,sha256=x2PIQZBag1fYGr4V82N98uY_DZdETHaX8ALR4Ye_TJE,1212
+walrasquant/exchange/binance/exchange.py,sha256=SH6sg0_w1lbDBTJ5ihQpRRU369UcPdjMlTd7Sun5N0c,5294
+walrasquant/exchange/binance/factory.py,sha256=7LcfwOZywSTIaT7lVrpD5WKRP7_Nd51QG2Zs9kL1yTM,4284
+walrasquant/exchange/binance/oms.py,sha256=9peVk1MlR_y6VdLZpso5rk2hLiJH7OCm36b3T2KwoQ8,71682
+walrasquant/exchange/binance/rest_api.py,sha256=pZUXz0GULNoqdE1nqgk7OpLISkWMcCON5e779ypa1dk,60943
+walrasquant/exchange/binance/schema.py,sha256=K8KyQ450kjYwthslqcJuiK8teMYLDDXQ0Rmkvt2DBrM,32236
+walrasquant/exchange/binance/websockets.py,sha256=wQVoFjVt0dfMnq49C3G2l_jofR-s-MQ3Yk9g2qKE-Rs,13496
+walrasquant/exchange/bitget/__init__.py,sha256=1X8yx_GH6PtbplAKgVHMCZho8TMyQ_51mO46V-oxXAQ,902
+walrasquant/exchange/bitget/connector.py,sha256=azNNTaGNIeUyXYA1tGPn1fJQYa-oZqe_fQfKIVETSco,21240
+walrasquant/exchange/bitget/constants.py,sha256=11trNiYGmcS4hjOhuZWzje9nc5rfHzk8nCLyFvn7OQU,11649
+walrasquant/exchange/bitget/ems.py,sha256=fJlj2ZNJba3s9DUb2LjCRph9PasqspqdACjs-PV6-MU,7609
+walrasquant/exchange/bitget/error.py,sha256=SC6bixnF86cijFQqKSwXQcWv8xs9UhlZoEG4IkbsKwM,825
+walrasquant/exchange/bitget/exchange.py,sha256=6_khiYygt4nWQAD6rG38IHfNnqGpnpnOI49p9mEagDs,5101
+walrasquant/exchange/bitget/factory.py,sha256=We6CmObESJMohXMDQoTQU2H85GxfQ919RXtYOs28d3w,4977
+walrasquant/exchange/bitget/oms.py,sha256=T6UJUz4RPZhadGV_H0qeAilq3qVuuw2D9yG2ACbvOSw,62204
+walrasquant/exchange/bitget/rest_api.py,sha256=UqnuJ6OgjrsGMO1xqzBzzifFUgyFV59zAaja2JnRDsQ,18732
+walrasquant/exchange/bitget/schema.py,sha256=Ay3pQNlut7whqHIjQtwkel3gZyaW2RSQsmUDXMFHoJY,21644
+walrasquant/exchange/bitget/websockets.py,sha256=k9DvNWiI6Li9A0w78lADN8cu1YjXvtibfghAJ_mdRUE,21551
+walrasquant/exchange/bybit/__init__.py,sha256=ENq_1JMVvqHUNg-v2nkOcUCrmrEMUBA1kgUXNQcw0I0,1051
+walrasquant/exchange/bybit/connector.py,sha256=JurFXbdjZREPwBIcbbCRmgGTFZcaclrCbB_lfO_eEbc,28301
+walrasquant/exchange/bybit/constants.py,sha256=0LPO6WERxxDE8l9pc9o7vdIeEyy2WWaFHbj2fnZjl3c,14914
+walrasquant/exchange/bybit/ems.py,sha256=owue3dRZ_rMKDghVSQthLzxrVM9ovLJIE0wtR9yjb_w,3583
+walrasquant/exchange/bybit/error.py,sha256=d74RM-kxB1TpS4nhZEABwUVptlbDU1qSmAkwEAT-mKU,822
+walrasquant/exchange/bybit/exchange.py,sha256=5jDPtnpABdzaUEdMO7yTfj5XB_aZZtmkLNHQGBNN7KU,4322
+walrasquant/exchange/bybit/factory.py,sha256=EXpSNA4hzvET4Vn-wuGy7wL4jmi0HF4XIurzdmo2UJs,4678
+walrasquant/exchange/bybit/oms.py,sha256=pOMYL0NeUyPj3497aHgpPe6KlBgkqGngaMEqgLxZBiw,45395
+walrasquant/exchange/bybit/rest_api.py,sha256=PzHOWnFTh3PX0XiqCew7-kRwIAuuYYigX8VnLrtzmoA,19289
+walrasquant/exchange/bybit/schema.py,sha256=xHBeKAyN_m6DYQXGaLLPD-eAUBw-h4_HFdIPEI0x-_g,22462
+walrasquant/exchange/bybit/websockets.py,sha256=rkgjv6eW_BqcFIr2z0G9QclHJ48HQfBUNKVT8aTo0CU,10361
+walrasquant/exchange/hyperliquid/__init__.py,sha256=00hjGrV2z1E7TcPzr_oerwf_sgne-2E1f6WKmXopiYs,1007
+walrasquant/exchange/hyperliquid/connector.py,sha256=OVgzYRuhLgiOae2jKQRHGeAcEfj9eguzd5z72hzz5cU,13493
+walrasquant/exchange/hyperliquid/constants.py,sha256=88fKuKgH1EUeJs4YotuAM97V4exW-3FGI1pk0-xEkVo,13243
+walrasquant/exchange/hyperliquid/ems.py,sha256=jKbybVNCrtbBUvt9ISakgOykPdq7zeF-Tcdo3oK4UKc,5704
+walrasquant/exchange/hyperliquid/error.py,sha256=bGMUqd0q3JuiwUtlMa9DuKjntRZeE95R6ayoPq4XA5M,1264
+walrasquant/exchange/hyperliquid/exchange.py,sha256=ImPGTFvEMilvIkBSCBY2PHapZe1yvlnxQCfq-_Ll6vE,4982
+walrasquant/exchange/hyperliquid/factory.py,sha256=IlP7pZalnofjwlNdywWKBEj7QNPKZFURS7VnuyGYlqY,5012
+walrasquant/exchange/hyperliquid/oms.py,sha256=8F2xmH9Ai7lo4kGB2KO6sxOYvP0wN9az3OeB-NJLkW4,41463
+walrasquant/exchange/hyperliquid/rest_api.py,sha256=TulgC9Ezsmwa8t4I7vjQR0w1EOQqjT13onGDzJ9DKug,12457
+walrasquant/exchange/hyperliquid/schema.py,sha256=Mhh19CN1IBUhXhO-2f8AyFy-79OyZ6jcfySd8mmsrzI,13622
+walrasquant/exchange/hyperliquid/websockets.py,sha256=Ow-iZ-VEnvwxTXCCFLotshZuSDPUulDxm3lY0SPglyQ,18889
+walrasquant/exchange/okx/__init__.py,sha256=PJg4CxjCxR8iGVV3qoFvSL51ofXNV5WFtWHHE4zQAsY,826
+walrasquant/exchange/okx/connector.py,sha256=uFAZ8GAL0qEcqfzktKDVuexeRKKPkZtV7pIIN1BxTvw,33116
+walrasquant/exchange/okx/constants.py,sha256=8hN693cAnAuDW-2zRT3ZvstISotQJwYh5TLa2iDMTlQ,15957
+walrasquant/exchange/okx/ems.py,sha256=UhTNWARz9uNJ4ZbXKr3JusUTaWwvexInc5hqkCh46Eo,5821
+walrasquant/exchange/okx/error.py,sha256=_-ZXlbqwOLW4dgTi7gnOofsoFfoETLoTaJ_Ic2Y_4JY,1645
+walrasquant/exchange/okx/exchange.py,sha256=S1Jt9Oh2HEneS6wDdQ-pavZDJ3YrMlB7rI8ZY23ZUfE,4413
+walrasquant/exchange/okx/factory.py,sha256=gn3-VF6TQlp3-n-03Ob9xcvV4jTe4DVR73TVSycnNpY,5147
+walrasquant/exchange/okx/oms.py,sha256=ZtjtLWZajNYoQ9lTfy8LvyZGFlMv9b6xa2F3y9R3RDQ,45308
+walrasquant/exchange/okx/rest_api.py,sha256=pURULpkDwz47y0bc4Iy_CMMLgOzzgrhv5rHrtfn7b6E,29708
+walrasquant/exchange/okx/schema.py,sha256=S6tyZPf1fKLsoWgJ_aaaTury5e9P9qs6KGjupBiWW_E,39438
+walrasquant/exchange/okx/websockets.py,sha256=ySL-Zyu67qXmiYH5eSAwO1vo92pCX1_sNI3S_v_iIgs,13652
+walrasquant/exchange/registry.py,sha256=14XIbIZWxh_GKURqHlGtyfZXRkvjutGKTEPrO-PNvho,5982
+walrasquant/execution/__init__.py,sha256=Sk93f9WIgStiUWKALa2kjnxk_jsRl-GNk9P33FsaMG8,673
+walrasquant/execution/algorithm.py,sha256=vbbjmQM216aDvbtTCm3de2VLHMO8j7K4qOo7mndaX1E,32676
+walrasquant/execution/algorithms/__init__.py,sha256=j2MLJXeTy5JVrfd3-_gbTK_9K0CF4dCqJ64BrSvpKic,101
+walrasquant/execution/algorithms/twap.py,sha256=PHIyyz2qx_pBIfz7GWMaRW_HzgeRluVehkvl71MnsSE,14800
+walrasquant/execution/config.py,sha256=VgLvXj8-ScTAjUx_KyvSxWEqObwCdEEI-YDkuvPv_GQ,927
+walrasquant/execution/constants.py,sha256=KE8PGOV4qBiCbSi1Ybp68FtarNyfVBI1rISbP4XkZkk,792
+walrasquant/execution/schema.py,sha256=oKFprpHZK3KrvuZ9e0fzP67oRSXnL2YVZJMOqV_wY3s,1854
+walrasquant/indicator.py,sha256=ZICABnUvQyMkL4fOb4dWY_94V_ivzvfy1pd_0NllX18,13496
+walrasquant/push.py,sha256=ZgHgh9glecjqYqYoAOCYCVs-2c13n0Ibd9_fia6vdpc,2281
+walrasquant/schema.py,sha256=cQ2_RfDKx6GbERAOVpwkYNhGLIqmspU_iyNzoK-mc-c,20698
+walrasquant/strategy.py,sha256=nWKy72pT6dZLDCI9p-Jm7ltiN5SwCz3QZyuqo9Ngt2k,63658
+walrasquant/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+walrasquant/tools/pm2_wrapper.py,sha256=6Wc-7gvqW7f78zI9Xl-yyV0rXMKvwvrCsckfxNifNm4,29806
+walrasquant/web/__init__.py,sha256=yz4Elsi-8dJY3WUfrORr1-XtTLICss19KooqalPHf8I,736
+walrasquant/web/app.py,sha256=K8-O19kAXnd8CpO96pvO_GzOgZxYVx50Xrjhk0WI0tI,5676
+walrasquant/web/server.py,sha256=6XerIbfvCswf0yCrYqF1vER4gwaCtuwjnALIPuII6dY,2351
+walrasquant_lib-0.4.20.dist-info/WHEEL,sha256=uOqnPWqgFlbov4NeTCercq7cBQ2UN7xh5fiW55lOnAg,81
+walrasquant_lib-0.4.20.dist-info/entry_points.txt,sha256=RVdNOLYwpk1cp4s-USe_0N6PD0k0-Jf6gLE3AN6GPOg,59
+walrasquant_lib-0.4.20.dist-info/METADATA,sha256=wpNBcuvgSYFTNC3CDZ2IQOg-IOJBlSia-OT9WatqYbM,4173
+walrasquant_lib-0.4.20.dist-info/RECORD,,

walrasquant_lib-0.4.20.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.26
+Root-Is-Purelib: true
+Tag: py3-none-any

walrasquant_lib-0.4.20.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+wq = walrasquant.tools.pm2_wrapper:main
+