sory 0.0.2__py3-none-any.whl

sory/__init__.py

@@ -0,0 +1,15 @@
+"""Sory package for cryptocurrency trading."""
+from sory.client import SoryClient
+from sory.models import OrderbookConfig, TradesConfig, APIConfig, OrderConfig
+from sory.exceptions import SoryError
+
+__version__ = "3.0.2"
+
+__all__ = [
+    "SoryClient",
+    "SoryError",
+    "OrderbookConfig",
+    "TradesConfig",
+    "APIConfig",
+    "OrderConfig",
+]

sory/client.py

@@ -0,0 +1,183 @@
+import asyncio
+from typing import Dict, List, Optional, Callable
+from sory.utils.logger import logger, catch_exception
+import ccxt.pro as ccxt
+
+from sory.models import OrderbookConfig, TradesConfig, APIConfig, OrderConfig
+from sory.core.orderbook import OrderbookManager
+from sory.core.trades import TradesManager
+from sory.core.executor import OrderExecutor
+from sory.exceptions import SoryError
+
+
+class SoryClient:
+
+    @catch_exception
+    def __init__(self):
+        self._orderbook_manager = None
+        self._trades_manager = None
+        self._order_executor = None
+        self._running = True
+        logger.info("Initialized Sory Client")
+
+    @catch_exception
+    async def __aenter__(self):
+        """Async context manager entry point."""
+        return self
+
+    @catch_exception
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit point that automatically cleans up resources."""
+        await self.close()
+        return False  # Allow any exceptions to propagate
+
+    @catch_exception
+    async def set_config(self, *, type: str, **config_params) -> Dict:
+        """Unified configuration method for both orderbook and trades.
+
+        Args:
+            type: The type of configuration ('orderbook' or 'trades')
+            **config_params: Configuration parameters specific to the type
+
+        Returns:
+            Dict with status and message
+
+        Examples:
+            --> await sory.set_config(
+            ...     type="orderbook",
+            ...     aggregated=True,
+            ...     exchanges=["binance", "okx"],
+            ...     symbols=["BTC/USDT"],
+            ...     depth=10
+            ... )
+        """
+        if not isinstance(type, str):
+            raise SoryError(f"Config type must be a string, got {type.__class__.__name__}")
+
+        type = type.lower()
+        if type not in ['orderbook', 'trades']:
+            raise SoryError(
+                f"Invalid config type: '{type}'. Must be 'orderbook' or 'trades'."
+                "\nExample usage:"
+                "\n  await sory.set_config("
+                "\n      type='orderbook',"
+                "\n      aggregated=True,"
+                "\n      exchanges=['binance', 'okx'],"
+                "\n      symbols=['BTC/USDT'],"
+                "\n      depth=10"
+                "\n  )"
+            )
+
+        if type == 'orderbook':
+            config = OrderbookConfig(**config_params)
+            self._orderbook_manager = OrderbookManager(config)
+            return {"status": "success", "message": "Orderbook configuration set"}
+        else:  # trades
+            config = TradesConfig(**config_params)
+            self._trades_manager = TradesManager(config)
+            return {"status": "success", "message": "Trades configuration set"}
+
+    @catch_exception
+    async def start_stream(self, stream_type: str, callback: Optional[Callable] = None,
+                           timeout: Optional[float] = None) -> Dict:
+        """
+        Unified method to start either orderbook or trades stream.
+
+        Args:
+            stream_type: Either 'orderbook' or 'trades'
+            callback: Optional callback function to receive updates
+            timeout: Optional timeout in seconds. If None, runs indefinitely.
+
+        Returns:
+            Dict: Status and message
+        """
+        if stream_type not in ['orderbook', 'trades']:
+            raise SoryError(f"Invalid stream type: {stream_type}. Must be 'orderbook' or 'trades'")
+
+        if stream_type == 'orderbook':
+            if not self._orderbook_manager:
+                raise SoryError("Orderbook not configured. Call set_config(type='orderbook', ...) first")
+            if callback:
+                self._orderbook_manager.add_callback(callback)
+            await self._orderbook_manager.start(timeout=timeout)
+            return {"status": "success", "message": "Orderbook stream started"}
+        else:  # trades
+            if not self._trades_manager:
+                raise SoryError("Trades not configured. Call set_config(type='trades', ...) first")
+            if callback:
+                self._trades_manager.add_callback(callback)
+            await self._trades_manager.start(timeout=timeout)
+            return {"status": "success", "message": "Trades stream started"}
+
+    @catch_exception
+    async def stop_stream(self, stream_type: str) -> Dict:
+        """Unified method to stop either orderbook or trades stream."""
+        if stream_type not in ['orderbook', 'trades']:
+            raise SoryError(f"Invalid stream type: {stream_type}. Must be 'orderbook' or 'trades'")
+
+        if stream_type == 'orderbook':
+            if self._orderbook_manager:
+                await self._orderbook_manager.close()
+                return {"status": "success", "message": "Orderbook stream stopped"}
+        else:  # trades
+            if self._trades_manager:
+                await self._trades_manager.close()
+                return {"status": "success", "message": "Trades stream stopped"}
+        return {"status": "success", "message": f"{stream_type} stream was not running"}
+
+    @catch_exception
+    async def get_latest_data(self, data_type: str) -> Dict:
+        """Unified method to get latest data from either orderbook or trades."""
+        if data_type not in ['orderbook', 'trades']:
+            raise SoryError(f"Invalid data type: {data_type}. Must be 'orderbook' or 'trades'")
+
+        if data_type == 'orderbook':
+            if not self._orderbook_manager:
+                raise SoryError("Orderbook not configured. Call set_config(type='orderbook', ...) first")
+            return await self._orderbook_manager.get_latest_orderbooks()
+        else:  # trades
+            if not self._trades_manager:
+                raise SoryError("Trades not configured. Call set_config(type='trades', ...) first")
+            return await self._trades_manager.get_latest_trades()
+
+    @catch_exception
+    async def initialize_executor(self, api_configs: List[APIConfig], margin_mode: bool = False) -> None:
+        """Initialize the order executor with API configs."""
+        if not self._orderbook_manager:
+            raise SoryError("Orderbook must be configured before initializing executor. Call set_config(type='orderbook', ...) first")
+
+        if not self._orderbook_manager.config.aggregated:
+            raise SoryError("Orderbook must be configured with aggregation enabled for order execution")
+
+        # Create and initialize executor
+        self._order_executor = OrderExecutor(self._orderbook_manager.config, api_configs, margin_mode)
+        await self._order_executor.initialize()
+
+    @catch_exception
+    async def execute_order(self, order: OrderConfig) -> Dict:
+        """Execute an order using the initialized executor."""
+        if not self._order_executor:
+            raise SoryError("Order executor not initialized. Call initialize_executor first")
+
+        # Get latest orderbook data for execution
+        orderbook = await self.get_latest_data('orderbook')
+
+        # Execute the order
+        await self._order_executor.update_orderbook(orderbook)
+        return await self._order_executor.execute_order(order)
+
+    @catch_exception
+    async def close(self):
+        """Clean up resources and close connections."""
+        self._running = False
+        tasks = []
+
+        if self._orderbook_manager:
+            tasks.append(self._orderbook_manager.close())
+        if self._trades_manager:
+            tasks.append(self._trades_manager.close())
+        if self._order_executor:
+            tasks.append(self._order_executor.close())
+
+        await asyncio.gather(*tasks, return_exceptions=True)
+        logger.info("Sory closed")

sory/config.py

@@ -0,0 +1,45 @@
+# Available orderbook depth levels for each exchange
+EXCHANGES = {
+    'ascendex': {'available_depth': range(51)},
+    'binance': {'available_depth': range(51)},
+    'binancecoinm': {'available_depth': [5, 10, 20]},
+    'binanceus': {'available_depth': range(51)},
+    'binanceusdm': {'available_depth': [5, 10, 20]},
+    'bitget': {'available_depth': range(51)},
+    'bitmart': {'available_depth': range(51)},
+    'bitmex': {'available_depth': [25]},
+    'bingx': {'available_depth': range(51)},
+    'bitrue': {'available_depth': range(51)},
+    'bitstamp': {'available_depth': range(51)},
+    'bybit': {'available_depth': [1, 50, 200]},
+    'coinbase': {'available_depth': range(51)},
+    'cryptocom': {'available_depth': [10, 50]},
+    'deribit': {'available_depth': range(51)},
+    'gate': {'available_depth': range(51)},
+    'gemini': {'available_depth': range(51)},
+    'htx': {'available_depth': [20, 150]},
+    'hyperliquid': {'available_depth': range(51)},
+    'kraken': {'available_depth': [10, 25, 100, 500, 1000]},
+    'krakenfutures': {'available_depth': range(51)},
+    'kucoin': {'available_depth': [5, 20, 50, 100]},
+    'kucoinfutures': {'available_depth': [20, 100]},
+    'lbank': {'available_depth': range(51)},
+    'mexc': {'available_depth': range(51)},
+    'okx': {'available_depth': range(50)},
+    'p2b': {'available_depth': [5, 10, 20, 30, 50]},
+    'paradex': {'available_depth': range(51)},
+    'phemex': {'available_depth': range(51)},
+    'probit': {'available_depth': range(51)},
+    'upbit': {'available_depth': range(51)},
+    'whitebit': {'available_depth': range(51)},
+    'woo': {'available_depth': range(51)},
+    'xt': {'available_depth': range(51)},
+}
+
+# Sandbox exchanges with their available depth levels
+SANDBOX_EXCHANGES = {
+    'binanceusdm': {'available_depth': [5, 10, 20]},
+    'bybit': {'available_depth': [1, 50, 200]},
+    'deribit': {'available_depth': range(51)},
+    'bitmex': {'available_depth': [25]},
+}

sory/core/__init__.py

@@ -0,0 +1 @@
+"""Core functionality for the Sory package."""

sory/core/base.py

@@ -0,0 +1,104 @@
+import asyncio
+import time
+from typing import Dict, List, Set, Optional, Callable
+import ccxt.pro as ccxt
+from sory.utils.logger import logger, catch_exception
+
+
+class BaseExchangeManager:
+    """Base class for exchange data managers (orderbook and trades)."""
+    @catch_exception
+    def __init__(self, config):
+        self.config = config
+        self.exchanges = self._initialize_exchanges()
+        self.exchange_symbols = {}  # Map of exchange -> supported symbols
+        self.running = True
+        self.lock = asyncio.Lock()
+        self.update_event = asyncio.Event()
+        self._callbacks = []
+        self._collection_tasks = []
+
+    @catch_exception
+    def _initialize_exchanges(self) -> Dict[str, ccxt.Exchange]:
+        """Initialize exchange instances with appropriate settings."""
+        exchanges = {}
+        for exchange_id in self.config.exchanges:
+            exchange_class = getattr(ccxt, exchange_id)
+            instance = exchange_class({
+                'enableRateLimit': True,
+            })
+            is_sandbox = self.config.sandbox_mode.get(exchange_id, False)
+            instance.set_sandbox_mode(is_sandbox)
+            exchanges[exchange_id] = instance
+        return exchanges
+
+    @catch_exception
+    async def _verify_exchange_symbols(self):
+        """Verify which symbols are available on each exchange."""
+        for exchange_id, exchange in self.exchanges.items():
+            markets = await exchange.load_markets()
+            available_symbols = set()
+            for symbol in self.config.symbols:
+                if symbol in markets:
+                    available_symbols.add(symbol)
+            self.exchange_symbols[exchange_id] = available_symbols
+            logger.info(f"Exchange {exchange_id} supports symbols: {available_symbols}")
+
+    @catch_exception
+    def add_callback(self, callback):
+        """Register a new callback function."""
+        self._callbacks.append(callback)
+
+    @catch_exception
+    def remove_callback(self, callback):
+        """Remove a registered callback function."""
+        if callback in self._callbacks:
+            self._callbacks.remove(callback)
+
+    @catch_exception
+    async def _execute_callbacks(self, data):
+        """Execute registered callbacks with data."""
+        for callback in self._callbacks:
+            await callback(data)
+
+    @catch_exception
+    async def start(self, timeout=None):
+        """
+        Start collecting data for all valid exchange-symbol combinations.
+        Args:
+            timeout: Optional timeout in seconds. If None, runs indefinitely.
+        """
+        # First verify which exchanges support which symbols
+        await self._verify_exchange_symbols()
+
+        # Subclasses should override and implement this method to create collection tasks
+        # using self._create_collection_tasks() and then call super().start(timeout)
+
+        # If timeout is set, create a task to handle it
+        if timeout is not None:
+            asyncio.create_task(self._handle_timeout(timeout))
+
+    @catch_exception
+    async def _handle_timeout(self, timeout):
+        """Handle timeout for the manager."""
+        await asyncio.sleep(timeout)
+        logger.info(f"Manager reached timeout of {timeout} seconds")
+        self.running = False
+
+    @catch_exception
+    async def close(self):
+        """Clean up resources and close exchange connections."""
+        self.running = False
+
+        # Cancel any running collection tasks
+        for task in self._collection_tasks:
+            task.cancel()
+        if self._collection_tasks:
+            await asyncio.gather(*self._collection_tasks, return_exceptions=True)
+        self._collection_tasks.clear()
+
+        # Close exchange connections
+        await asyncio.gather(*[exchange.close() for exchange in self.exchanges.values()], return_exceptions=True)
+        self._callbacks.clear()
+
+        logger.info(f"{self.__class__.__name__} closed")

sory/core/executor.py

@@ -0,0 +1,233 @@
+import asyncio
+from typing import Dict, List, Tuple
+import ccxt.pro as ccxt
+import time
+from sory.models import OrderbookConfig, OrderConfig, APIConfig
+from sory.utils.logger import logger, catch_exception
+from sory.exceptions import SoryError
+
+
+class OrderExecutor:
+    @catch_exception
+    def __init__(self, orderbook_config: OrderbookConfig, api_configs: List[APIConfig], margin_mode: bool = False):
+        """Initialize the order executor with the given configuration."""
+        if not orderbook_config.aggregated or len(orderbook_config.symbols) != 1:
+            raise ValueError("OrderExecutor requires aggregated data and exactly one symbol in orderbook_config")
+
+        self.orderbook_config = orderbook_config
+        self.api_configs = {config.exchange: config for config in api_configs}
+        self.margin_mode = margin_mode
+        self.exchanges = {}
+        self.symbol = orderbook_config.symbols[0]
+        self.latest_orderbook = None
+        self._initialized = False
+
+    @catch_exception
+    async def initialize(self):
+        """Initialize connection to exchanges and load markets."""
+        if self._initialized:
+            logger.info("OrderExecutor already initialized")
+            return
+
+        for exchange_id in self.orderbook_config.exchanges:
+            if exchange_id not in self.api_configs:
+                continue
+
+            config = self.api_configs[exchange_id]
+            exchange_class = getattr(ccxt, exchange_id)
+
+            options = {
+                'adjustForTimeDifference': True,
+                'recvWindow': 20000
+            }
+
+            if self.margin_mode:
+                options['defaultType'] = 'margin'
+
+            exchange = exchange_class({
+                'apiKey': config.api_key,
+                'secret': config.secret,
+                'password': config.password,
+                'enableRateLimit': True,
+                'options': options
+            })
+
+            # Test authentication
+            exchange.check_required_credentials()
+
+            is_sandbox = self.orderbook_config.sandbox_mode.get(exchange_id, False)
+            exchange.set_sandbox_mode(is_sandbox)
+
+            # Load markets
+            await exchange.load_markets()
+            logger.info(f"Markets loaded for {exchange_id}")
+
+            self.exchanges[exchange_id] = exchange
+
+        if not self.exchanges:
+            raise SoryError("No exchanges could be initialized with provided API configurations")
+
+        self._initialized = True
+        logger.info("OrderExecutor initialized successfully")
+
+    @catch_exception
+    def _prepare_margin_params(self, exchange_id: str) -> Dict:
+        """Prepare exchange-specific margin parameters."""
+        if not self.margin_mode:
+            return {}  # Return empty params for spot trading
+
+        # Return margin params only if margin_mode is True
+        if exchange_id == 'binance':
+            return {
+                'marginMode': 'cross',
+                'sideEffectType': 'AUTO_BORROW_REPAY'
+            }
+        elif exchange_id == 'bybit':
+            return {
+                'isLeverage': 1,
+                'leverageType': 'cross_margin',
+                'spotMarginTrading': True,
+                'marginTrading': True
+            }
+        elif exchange_id == 'gate':
+            return {
+                'account': 'cross_margin',
+                'auto_borrow': True,
+                'marginMode': 'cross',
+                'unifiedAccount': True
+            }
+        return {}
+
+    @catch_exception
+    async def update_orderbook(self, orderbook: Dict):
+        """Update the latest orderbook data."""
+        if self.symbol not in orderbook:
+            raise SoryError(f"No orderbook data available for symbol {self.symbol}")
+        self.latest_orderbook = orderbook[self.symbol]
+
+    @catch_exception
+    async def execute_order(self, order: OrderConfig) -> Dict:
+        """Execute market orders across available exchanges."""
+        if not self._initialized:
+            raise SoryError("OrderExecutor not initialized. Call initialize_executor() first")
+
+        if not self.latest_orderbook:
+            raise SoryError("No orderbook data available")
+
+        execution_plan = self._create_execution_plan(order)
+        if not execution_plan:
+            raise SoryError("Could not create valid execution plan with available liquidity")
+
+        start_time = time.time()
+
+        # Execute all orders in parallel
+        execution_tasks = [
+            self.execute_single_order(exchange_id, amount, order)
+            for exchange_id, amount in execution_plan
+        ]
+        execution_results = await asyncio.gather(*execution_tasks)
+
+        # Calculate totals
+        total_filled_amount = sum(
+            result['filled_amount']
+            for result in execution_results
+            if result['status'] == 'success'
+        )
+        remaining_amount = max(0, order.amount - total_filled_amount)
+
+        # Get execution times
+        execution_times = {
+            'total': round((time.time() - start_time) * 1000, 2)
+        }
+        for result in execution_results:
+            execution_times[result['exchange']] = result['execution_time']
+
+        return {
+            "status": "completed" if remaining_amount <= 1e-8 else "partially_filled",
+            "original_amount": order.amount,
+            "filled_amount": total_filled_amount,
+            "remaining_amount": remaining_amount,
+            "execution_results": execution_results,
+            "execution_plan": execution_plan,
+            "execution_times": execution_times
+        }
+
+    @catch_exception
+    async def execute_single_order(self, exchange_id: str, amount: float, order: OrderConfig) -> Dict:
+        """Execute a single market order on one exchange."""
+        execution_start_time = time.time()
+
+        exchange = self.exchanges[exchange_id]
+        params = self._prepare_margin_params(exchange_id)
+
+        logger.info(f"Executing market order on {exchange_id}: {order.side} | {amount} | {self.symbol}")
+
+        # Gate requires price for market orders, others don't
+        price = None if exchange_id != 'gate' else 1
+        executed_order = await exchange.createOrder(
+            self.symbol,
+            'market',
+            order.side,
+            amount,
+            price,
+            params
+        )
+
+        execution_time = round((time.time() - execution_start_time) * 1000, 2)
+        filled_amount = float(executed_order.get('filled', 0) or 0)
+
+        return {
+            "exchange": exchange_id,
+            "order": executed_order,
+            "status": "success",
+            "planned_amount": amount,
+            "filled_amount": filled_amount,
+            "execution_time": execution_time
+        }
+
+    @catch_exception
+    def _create_execution_plan(self, order: OrderConfig) -> List[Tuple[str, float]]:
+        """Create an execution plan for market orders based on available liquidity."""
+        book_side = self.latest_orderbook['bids'] if order.side == 'sell' else self.latest_orderbook['asks']
+        executions = {}
+        remaining = order.amount
+
+        # Fast path: Just accumulate by exchange until we hit our target
+        for _, size, exchange in book_side:
+            if exchange in self.exchanges:
+                amount = min(size, remaining)
+                if exchange in executions:
+                    executions[exchange] += amount
+                else:
+                    executions[exchange] = amount
+                remaining -= amount
+                if remaining <= 0:
+                    break
+
+        # Final plan considering minimum amounts
+        final_plan = []
+        for exchange, amount in executions.items():
+            min_amount = self.exchanges[exchange].market(self.symbol)['limits']['amount']['min']
+            if amount >= min_amount:
+                final_plan.append((exchange, amount))
+
+        # Log the execution plan
+        logger.info(f"Created market order execution plan:")
+        for exchange, amount in final_plan:
+            logger.info(f"{exchange}: {amount}")
+
+        return final_plan
+
+    @catch_exception
+    async def close(self):
+        """Close all exchange connections."""
+        close_tasks = []
+        for exchange in self.exchanges.values():
+            if hasattr(exchange, 'close'):
+                close_tasks.append(exchange.close())
+
+        if close_tasks:
+            await asyncio.gather(*close_tasks, return_exceptions=True)
+
+        self._initialized = False
+        logger.info("OrderExecutor closed")