ccxt-gateway 1.8.0__tar.gz

ccxt_gateway-1.8.0/.gitignore

@@ -0,0 +1,44 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+venv/
+ENV/
+env/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Project specific
+.env
+logs/
+*.log
+.cache/

ccxt_gateway-1.8.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ccxt-gateway contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ccxt_gateway-1.8.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.5
+Name: ccxt-gateway
+Version: 1.8.0
+Summary: High-performance self-hosted gateway for 100+ crypto exchanges via CCXT
+Author: ccxt-gateway contributors
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: aiofiles>=24.1.0
+Requires-Dist: ccxt[pro]>=4.4.0
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: orjson>=3.10.0
+Requires-Dist: packaging>=24.0
+Requires-Dist: psutil>=6.0.0
+Requires-Dist: pydantic-settings>=2.14.2
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: pyzmq>=26.0.0
+Requires-Dist: setuptools>=83.0.0
+Requires-Dist: uvicorn[standard]>=0.30.0
+Requires-Dist: uvloop>=0.20.0
+Provides-Extra: dev
+Requires-Dist: httpx>=0.27.0; extra == 'dev'
+Requires-Dist: mypy>=1.10.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: types-pyyaml>=6.0.0; extra == 'dev'
+Requires-Dist: types-requests>=2.31.0; extra == 'dev'
+Provides-Extra: server
+Requires-Dist: granian>=1.4.0; extra == 'server'
+Description-Content-Type: text/markdown
+
+# ccxt-gateway
+
+High-performance, self-hosted gateway for 100+ cryptocurrency exchanges via CCXT.
+
+## Features
+
+- **High Performance**: Built with FastAPI, uvloop, and orjson for maximum throughput
+- **Rock Solid Stability**: Multi-process design with automatic restart on failures
+- **Memory Management**: Automatic subprocess restart when memory limits exceeded
+- **WebSocket Support**: Proxy CCXT watch* functions via WebSocket connections
+- **Auto-Update**: Automatic CCXT version management
+- **Unified API**: Single REST and WebSocket API for all supported exchanges
+
+## Quick Start
+
+### Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/ccxt-gateway.git
+cd ccxt-gateway
+
+# Install dependencies
+pip install -e ".[server]"
+```
+
+### Running
+
+```bash
+# Start the gateway
+ccxt-gateway
+
+# Or directly with Python
+python -m ccxt_gateway.main
+```
+
+The gateway will start on `http://0.0.0.0:8000` by default.
+
+### Basic Usage
+
+```bash
+# Create a Binance exchange instance
+curl -X POST "http://localhost:8000/exchanges/my-binance?exchange_name=binance"
+
+# Get ticker for BTC/USDT
+curl "http://localhost:8000/exchanges/my-binance/fetch_ticker?symbol=BTC/USDT"
+
+# Delete the exchange instance
+curl -X DELETE "http://localhost:8000/exchanges/my-binance"
+```
+
+## Configuration
+
+Configuration is loaded from (in order):
+1. Environment variables (prefixed with `CCXT_GATEWAY_`)
+2. `.env` file
+3. `config/default.yaml`
+
+See `config/default.yaml` for all available options.
+
+## API Documentation
+
+Once running, visit:
+- Swagger UI: `http://localhost:8000/docs`
+- ReDoc: `http://localhost:8000/redoc`
+
+## Architecture
+
+```
+Client -> FastAPI -> ZMQ Broker -> Exchange Subprocess (CCXT)
+```
+
+Each exchange runs in its own subprocess, communicating via ZeroMQ for isolation and stability.
+
+## Development
+
+```bash
+# Install dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Format code
+black src/
+```
+
+## License
+
+MIT

ccxt_gateway-1.8.0/README.md

@@ -0,0 +1,90 @@
+# ccxt-gateway
+
+High-performance, self-hosted gateway for 100+ cryptocurrency exchanges via CCXT.
+
+## Features
+
+- **High Performance**: Built with FastAPI, uvloop, and orjson for maximum throughput
+- **Rock Solid Stability**: Multi-process design with automatic restart on failures
+- **Memory Management**: Automatic subprocess restart when memory limits exceeded
+- **WebSocket Support**: Proxy CCXT watch* functions via WebSocket connections
+- **Auto-Update**: Automatic CCXT version management
+- **Unified API**: Single REST and WebSocket API for all supported exchanges
+
+## Quick Start
+
+### Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/ccxt-gateway.git
+cd ccxt-gateway
+
+# Install dependencies
+pip install -e ".[server]"
+```
+
+### Running
+
+```bash
+# Start the gateway
+ccxt-gateway
+
+# Or directly with Python
+python -m ccxt_gateway.main
+```
+
+The gateway will start on `http://0.0.0.0:8000` by default.
+
+### Basic Usage
+
+```bash
+# Create a Binance exchange instance
+curl -X POST "http://localhost:8000/exchanges/my-binance?exchange_name=binance"
+
+# Get ticker for BTC/USDT
+curl "http://localhost:8000/exchanges/my-binance/fetch_ticker?symbol=BTC/USDT"
+
+# Delete the exchange instance
+curl -X DELETE "http://localhost:8000/exchanges/my-binance"
+```
+
+## Configuration
+
+Configuration is loaded from (in order):
+1. Environment variables (prefixed with `CCXT_GATEWAY_`)
+2. `.env` file
+3. `config/default.yaml`
+
+See `config/default.yaml` for all available options.
+
+## API Documentation
+
+Once running, visit:
+- Swagger UI: `http://localhost:8000/docs`
+- ReDoc: `http://localhost:8000/redoc`
+
+## Architecture
+
+```
+Client -> FastAPI -> ZMQ Broker -> Exchange Subprocess (CCXT)
+```
+
+Each exchange runs in its own subprocess, communicating via ZeroMQ for isolation and stability.
+
+## Development
+
+```bash
+# Install dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Format code
+black src/
+```
+
+## License
+
+MIT

ccxt_gateway-1.8.0/config/default.yaml

@@ -0,0 +1,49 @@
+# ccxt-gateway default configuration
+
+server:
+  host: "0.0.0.0"
+  port: 8999
+  debug: false
+  use_ssl: false
+  ssl_cert: null
+  ssl_key: null
+  # Use granian for higher performance (pip install ccxt-gateway[server])
+  use_granian: false
+
+zmq:
+  # Main broker address (for main process to communicate with subprocesses)
+  broker_address: "tcp://127.0.0.1:5557"
+  # Subprocess connect to this address
+  subprocess_connect: "tcp://127.0.0.1:5557"
+  # High water mark for ZMQ (prevent memory issues)
+  high_water_mark: 1000
+  # Timeout for request-reply (ms)
+  timeout_ms: 30000
+
+process_manager:
+  # Maximum RSS per exchange subprocess (in MB)
+  max_rss_mb: 512
+  # Interval to check memory usage (seconds)
+  check_interval: 30
+  # Auto-restart subprocesses on memory limit or crash
+  auto_restart: true
+  # Maximum restarts per hour per exchange
+  max_restarts_per_hour: 5
+  # Subprocess startup timeout (seconds)
+  startup_timeout: 30
+
+update:
+  # Check for ccxt updates interval (hours, 0 to disable)
+  check_interval_hours: 24
+  # Auto-update ccxt when new version available
+  auto_update: false
+  # PyPI package name for ccxt
+  pypi_package: "ccxt"
+
+exchanges:
+  # Default settings for exchange instances
+  default_enable_rate_limit: true
+  # Timeout for exchange API calls (ms)
+  default_timeout: 30000
+  # Enable verbose logging per exchange
+  default_verbose: false

ccxt_gateway-1.8.0/pyproject.toml

@@ -0,0 +1,84 @@
+[project]
+name = "ccxt-gateway"
+dynamic = ["version"]
+description = "High-performance self-hosted gateway for 100+ crypto exchanges via CCXT"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+authors = [
+    {name = "ccxt-gateway contributors"}
+]
+dependencies = [
+    "fastapi>=0.115.0",
+    "uvicorn[standard]>=0.30.0",
+    "pyzmq>=26.0.0",
+    "pydantic-settings>=2.14.2",
+    "psutil>=6.0.0",
+    "ccxt[pro]>=4.4.0",
+    "setuptools>=83.0.0",
+    "uvloop>=0.20.0",
+    "orjson>=3.10.0",
+    "aiofiles>=24.1.0",
+    "httpx>=0.27.0",
+    "python-dotenv>=1.0.0",
+    "pyyaml>=6.0.0",
+    "packaging>=24.0",
+]
+
+[project.optional-dependencies]
+server = [
+    "granian>=1.4.0",
+]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "pytest-cov>=5.0.0",
+    "mypy>=1.10.0",
+    "httpx>=0.27.0",
+    "types-pyyaml>=6.0.0",
+    "types-requests>=2.31.0",
+]
+
+[tool.mypy]
+python_version = "3.14"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+ignore_missing_imports = true
+strict = true
+
+[tool.pytest.ini_options]
+asyncio_mode = "strict"
+testpaths = ["tests"]
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { search_parent_directories = true }
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.3",
+    "pytest-asyncio>=1.3.0",
+    "pytest-cov>=7.1.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ccxt_gateway"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/ccxt_gateway/**/*",
+    "config/**/*",
+    "scripts/**/*",
+    "tests/**/*",
+]
+
+[project.scripts]
+ccxt-gateway = "ccxt_gateway.main:main"
+ccxt-gateway-daemon = "ccxt_gateway.daemon_gateway:main"

ccxt_gateway-1.8.0/src/ccxt_gateway/__init__.py

@@ -0,0 +1,8 @@
+"""ccxt-gateway: High-performance self-hosted gateway for 100+ crypto exchanges via CCXT."""
+
+try:
+    from importlib.metadata import PackageNotFoundError, version as _metadata_version
+
+    __version__ = _metadata_version("ccxt-gateway")
+except PackageNotFoundError:
+    __version__ = "0.0.0"

ccxt_gateway-1.8.0/src/ccxt_gateway/api/__init__.py

@@ -0,0 +1 @@
+"""API package for ccxt-gateway."""

ccxt_gateway-1.8.0/src/ccxt_gateway/api/admin.py

@@ -0,0 +1,267 @@
+"""Admin API endpoints for ccxt-gateway."""
+
+import logging
+import time
+from typing import Any, Dict, List, Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+router: APIRouter = APIRouter()
+
+
+def get_process_manager(request: Request) -> Any:
+    """Dependency to get process manager."""
+    process_manager = getattr(request.app.state, "process_manager", None)
+
+    if process_manager is None:
+        raise HTTPException(status_code=503, detail="Process manager not initialized")
+    return process_manager
+
+
+def get_broker(request: Request) -> Any:
+    """Dependency to get ZMQ broker."""
+    broker = getattr(request.app.state, "broker", None)
+
+    if broker is None:
+        raise HTTPException(status_code=503, detail="ZMQ broker not initialized")
+    return broker
+
+
+@router.get("/exchanges")
+async def list_exchanges(
+    process_manager: Any = Depends(get_process_manager),
+) -> List[Dict[str, Any]]:
+    """List all exchange instances."""
+    result: List[Dict[str, Any]] = []
+    for exchange_id, proc in process_manager.processes.items():
+        proc.update_memory()
+        result.append(
+            {
+                "exchange_id": exchange_id,
+                "exchange_name": proc.exchange_name,
+                "pid": proc.pid,
+                "running": proc.is_running,
+                "rss_mb": round(proc.rss_mb, 2),
+                "restart_count": proc.restart_count,
+                "uptime_seconds": round(time.time() - proc.started_at, 2)
+                if proc.started_at
+                else None,
+            }
+        )
+    return result
+
+
+@router.get("/exchanges/{exchange_id}")
+async def get_exchange_details(
+    exchange_id: str,
+    process_manager: Any = Depends(get_process_manager),
+) -> Dict[str, Any]:
+    """Get details of a specific exchange instance."""
+    if exchange_id not in process_manager.processes:
+        raise HTTPException(status_code=404, detail=f"Exchange {exchange_id} not found")
+
+    proc: Any = process_manager.processes[exchange_id]
+    proc.update_memory()
+
+    return {
+        "exchange_id": exchange_id,
+        "exchange_name": proc.exchange_name,
+        "pid": proc.pid,
+        "running": proc.is_running,
+        "rss_mb": round(proc.rss_mb, 2),
+        "restart_count": proc.restart_count,
+        "last_restart": proc.last_restart,
+        "uptime_seconds": round(time.time() - proc.started_at, 2)
+        if proc.started_at
+        else None,
+        "config": proc.config,
+    }
+
+
+@router.post("/exchanges/{exchange_id}/restart")
+async def restart_exchange(
+    exchange_id: str,
+    process_manager: Any = Depends(get_process_manager),
+) -> Dict[str, Any]:
+    """Manually restart an exchange instance."""
+    if exchange_id not in process_manager.processes:
+        raise HTTPException(status_code=404, detail=f"Exchange {exchange_id} not found")
+
+    await process_manager._restart_exchange(exchange_id)
+
+    return {"status": "restart initiated", "exchange_id": exchange_id}
+
+
+@router.get("/stats")
+async def get_stats(
+    process_manager: Any = Depends(get_process_manager),
+    broker: Any = Depends(get_broker),
+) -> Dict[str, Any]:
+    """Get gateway statistics."""
+    total_exchanges: int = len(process_manager.processes)
+    running: int = sum(1 for p in process_manager.processes.values() if p.is_running)
+    total_memory: float = sum(p.rss_mb for p in process_manager.processes.values())
+
+    return {
+        "total_exchanges": total_exchanges,
+        "running_exchanges": running,
+        "stopped_exchanges": total_exchanges - running,
+        "total_memory_mb": round(total_memory, 2),
+        "pending_requests": len(broker.pending_requests)
+        if hasattr(broker, "pending_requests")
+        else 0,
+        "registered_exchanges": len(broker.exchange_identities)
+        if hasattr(broker, "exchange_identities")
+        else 0,
+    }
+
+
+@router.get("/info")
+async def get_info(request: Request) -> Dict[str, Any]:
+    """Get gateway server info."""
+    import time
+    start_time: float = getattr(request.app.state, "start_time", time.time())
+    uptime: float = time.time() - start_time
+    return {
+        "result": {
+            "status": "running",
+            "version": "0.1.0",
+            "uptime_seconds": round(uptime, 2),
+            "python_version": __import__("sys").version,
+        },
+        "error": None,
+        "error_code": None,
+    }
+
+
+@router.get("/memory")
+async def get_memory(
+    process_manager: Any = Depends(get_process_manager),
+) -> Dict[str, Any]:
+    """Get memory usage."""
+    total_memory: float = sum(p.rss_mb for p in process_manager.processes.values())
+    return {
+        "result": {
+            "total_memory_mb": round(total_memory, 2),
+            "exchange_count": len(process_manager.processes),
+        },
+        "error": None,
+        "error_code": None,
+    }
+
+
+@router.get("/exchange_names")
+async def get_exchange_names() -> Dict[str, Any]:
+    """Get all CCXT exchange names."""
+    try:
+        import ccxt
+        names = sorted(ccxt.exchanges)
+        return {
+            "result": names,
+            "error": None,
+            "error_code": None,
+        }
+    except Exception as e:
+        return {
+            "result": None,
+            "error": str(e),
+            "error_code": "EXCHANGE_NAMES_FAILED",
+        }
+
+
+@router.post("/update/ccxt")
+async def trigger_ccxt_update(
+    broker: Any = Depends(get_broker),
+) -> Dict[str, Any]:
+    """Manually trigger CCXT update."""
+    from ccxt_gateway.utils.updates import update_ccxt, check_update
+
+    update_available: bool
+    current: Optional[str]
+    latest: Optional[str]
+    update_available, current, latest = await check_update()
+
+    if not update_available:
+        return {
+            "status": "no update available",
+            "current_version": current,
+            "latest_version": latest,
+        }
+
+    success: bool
+    message: str
+    success, message = await update_ccxt()
+
+    return {
+        "status": "success" if success else "failed",
+        "message": message,
+        "previous_version": current,
+        "new_version": latest,
+    }
+
+
+@router.get("/update/check")
+async def check_ccxt_update(
+    broker: Any = Depends(get_broker),
+) -> Dict[str, Any]:
+    """Check if CCXT update is available."""
+    from ccxt_gateway.utils.updates import check_update
+
+    update_available: bool
+    current: Optional[str]
+    latest: Optional[str]
+    update_available, current, latest = await check_update()
+
+    return {
+        "update_available": update_available,
+        "current_version": current,
+        "latest_version": latest,
+    }
+
+
+@router.get("/errors")
+async def list_errors(
+    broker: Any = Depends(get_broker),
+) -> Dict[str, Any]:
+    """List all ccxt error names."""
+    try:
+        import ccxt
+        from ccxt.base.errors import ExchangeError, NetworkError, AuthenticationError, PermissionError, RequestTimeout, ExchangeNotAvailable, NotSupported, OperationFailed, BaseError
+        
+        error_names = [
+            "BaseError",
+            "ExchangeError", 
+            "NetworkError",
+            "AuthenticationError",
+            "PermissionError",
+            "RequestTimeout",
+            "ExchangeNotAvailable",
+            "NotSupported",
+            "OperationFailed",
+        ]
+        
+        return {
+            "result": error_names,
+            "error": None,
+            "error_code": None,
+        }
+    except Exception as e:
+        return {
+            "result": None,
+            "error": str(e),
+            "error_code": "ERROR_LIST_FAILED",
+        }
+
+
+@router.post("/shutdown")
+async def shutdown_server(request: Request) -> Dict[str, str]:
+    """Gracefully shut down the gateway: closes all exchange subprocesses, then exits."""
+    logger.info("Shutdown requested via /admin/shutdown")
+    import asyncio, sys
+    async def _delayed_shutdown():
+        await asyncio.sleep(0.2)
+        sys.exit(0)
+    asyncio.create_task(_delayed_shutdown())
+    return {"status": "shutting_down"}