aptis-strategy-sdk 0.1.0__tar.gz

aptis_strategy_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: aptis-strategy-sdk
+Version: 0.1.0
+Summary: Python SDK for building plugin trading strategies on the Aptis platform
+Author: Richard Chung
+Project-URL: Homepage, https://aptis.com
+Project-URL: Documentation, https://aptis.com/docs
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+
+# Aptis Strategy SDK
+
+Python SDK for building trading strategies on the Aptis platform.
+
+**Author:** Richard Chung
+
+## Installation
+
+```bash
+pip install aptis-strategy-sdk
+```
+
+## Environment Variables
+
+```bash
+APTIS_API_KEY=your_api_key_here     # Your API key
+APTIS_ACCOUNT=Theme                  # Account to trade under (Theme or QSpark)
+APTIS_API_URL=http://localhost:8082  # Backend URL
+```
+
+Never hardcode these — always read from env vars.
+
+## Quick Start
+
+```python
+import os
+from aptis_strategy_sdk import AptisClient, Strategy, Signal
+from datetime import date
+
+client = AptisClient(
+    api_key=os.getenv("APTIS_API_KEY", "test_key_123"),
+    base_url=os.getenv("APTIS_API_URL", "http://localhost:8082")
+)
+
+class MyStrategy(Strategy):
+    def generate_signals(self, run_date: date):
+        # your logic here
+        return [Signal(symbol="AAPL", asset_class="equity",
+                       quantity=100, side="BUY", signal_type="ENTRY")]
+
+strategy = MyStrategy(
+    name="My Strategy",
+    client=client,
+    account=os.getenv("APTIS_ACCOUNT", "Theme")
+)
+result = strategy.run(date.today())
+```
+
+## Accounts
+
+The platform supports multiple accounts (trading scenarios). Each account has its own API key. Set `APTIS_ACCOUNT` to target the correct account:
+
+```bash
+# Run against Theme account
+APTIS_ACCOUNT=Theme APTIS_API_KEY=test_key_123 python my_strategy.py
+
+# Run against QSpark account
+APTIS_ACCOUNT=QSpark APTIS_API_KEY=qspark_key_123 python my_strategy.py
+```
+
+## API Methods
+
+### AptisClient
+
+- `submit_signal(signal, strategy_name, account)` — submit a trading signal
+- `get_config(strategy_name)` — get NAV, funds, portfolio_weight, enabled
+- `get_quotes(symbols, asset_class)` — get market quotes
+- `get_bars(symbol, asset_class, timeframe, start, end)` — get OHLCV bars
+- `get_positions(account, strategy_name)` — get current positions
+- `get_pnl(account, start_date, end_date, strategy_name)` — get P&L
+
+### Strategy Base Class
+
+- `generate_signals(date)` — override with your logic, return `List[Signal]`
+- `run(date)` — calls `generate_signals`, submits all signals
+- `get_features(symbols, date, features)` — fetch Dagster features
+- `get_positions()` — get positions for this strategy
+
+## Signal Fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `symbol` | Yes | Ticker |
+| `asset_class` | Yes | `equity`, `etf`, `crypto`, `forex`, `commodity` |
+| `quantity` | Yes | Units |
+| `side` | Yes | `BUY` or `SELL` |
+| `signal_type` | Yes | `ENTRY`, `EXIT`, `ADJUST` |
+| `order_parameters` | No | `order_type`, `limit_price`, etc. |
+| `metadata` | No | Notes only, not used for execution |
+
+## Full Documentation
+
+See [docs/customer-integration/](../docs/customer-integration/) for complete guides.

aptis_strategy_sdk-0.1.0/README.md

@@ -0,0 +1,93 @@
+# Aptis Strategy SDK
+
+Python SDK for building trading strategies on the Aptis platform.
+
+**Author:** Richard Chung
+
+## Installation
+
+```bash
+pip install aptis-strategy-sdk
+```
+
+## Environment Variables
+
+```bash
+APTIS_API_KEY=your_api_key_here     # Your API key
+APTIS_ACCOUNT=Theme                  # Account to trade under (Theme or QSpark)
+APTIS_API_URL=http://localhost:8082  # Backend URL
+```
+
+Never hardcode these — always read from env vars.
+
+## Quick Start
+
+```python
+import os
+from aptis_strategy_sdk import AptisClient, Strategy, Signal
+from datetime import date
+
+client = AptisClient(
+    api_key=os.getenv("APTIS_API_KEY", "test_key_123"),
+    base_url=os.getenv("APTIS_API_URL", "http://localhost:8082")
+)
+
+class MyStrategy(Strategy):
+    def generate_signals(self, run_date: date):
+        # your logic here
+        return [Signal(symbol="AAPL", asset_class="equity",
+                       quantity=100, side="BUY", signal_type="ENTRY")]
+
+strategy = MyStrategy(
+    name="My Strategy",
+    client=client,
+    account=os.getenv("APTIS_ACCOUNT", "Theme")
+)
+result = strategy.run(date.today())
+```
+
+## Accounts
+
+The platform supports multiple accounts (trading scenarios). Each account has its own API key. Set `APTIS_ACCOUNT` to target the correct account:
+
+```bash
+# Run against Theme account
+APTIS_ACCOUNT=Theme APTIS_API_KEY=test_key_123 python my_strategy.py
+
+# Run against QSpark account
+APTIS_ACCOUNT=QSpark APTIS_API_KEY=qspark_key_123 python my_strategy.py
+```
+
+## API Methods
+
+### AptisClient
+
+- `submit_signal(signal, strategy_name, account)` — submit a trading signal
+- `get_config(strategy_name)` — get NAV, funds, portfolio_weight, enabled
+- `get_quotes(symbols, asset_class)` — get market quotes
+- `get_bars(symbol, asset_class, timeframe, start, end)` — get OHLCV bars
+- `get_positions(account, strategy_name)` — get current positions
+- `get_pnl(account, start_date, end_date, strategy_name)` — get P&L
+
+### Strategy Base Class
+
+- `generate_signals(date)` — override with your logic, return `List[Signal]`
+- `run(date)` — calls `generate_signals`, submits all signals
+- `get_features(symbols, date, features)` — fetch Dagster features
+- `get_positions()` — get positions for this strategy
+
+## Signal Fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `symbol` | Yes | Ticker |
+| `asset_class` | Yes | `equity`, `etf`, `crypto`, `forex`, `commodity` |
+| `quantity` | Yes | Units |
+| `side` | Yes | `BUY` or `SELL` |
+| `signal_type` | Yes | `ENTRY`, `EXIT`, `ADJUST` |
+| `order_parameters` | No | `order_type`, `limit_price`, etc. |
+| `metadata` | No | Notes only, not used for execution |
+
+## Full Documentation
+
+See [docs/customer-integration/](../docs/customer-integration/) for complete guides.

aptis_strategy_sdk-0.1.0/aptis_strategy_sdk/__init__.py

@@ -0,0 +1,22 @@
+"""
+Aptis Strategy SDK - Build trading strategies on Aptis platform
+
+Author: Richard Chung
+"""
+from aptis_strategy_sdk.client import AptisClient
+from aptis_strategy_sdk.strategy import Strategy
+from aptis_strategy_sdk.models import Signal, Position, Bar, Quote
+from aptis_strategy_sdk.exceptions import AptisAPIError, AuthenticationError
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AptisClient",
+    "Strategy",
+    "Signal",
+    "Position",
+    "Bar",
+    "Quote",
+    "AptisAPIError",
+    "AuthenticationError",
+]

aptis_strategy_sdk-0.1.0/aptis_strategy_sdk/client.py

@@ -0,0 +1,115 @@
+"""Aptis API client"""
+import requests
+from typing import List, Dict, Any, Optional
+from datetime import date
+from aptis_strategy_sdk.models import Signal, Position, Bar, Quote
+from aptis_strategy_sdk.exceptions import AptisAPIError, AuthenticationError
+
+class AptisClient:
+    """Client for Aptis platform API"""
+    
+    def __init__(self, api_key: str, base_url: str = "http://localhost:8082"):
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.session = requests.Session()
+        self.session.headers.update({"Authorization": f"Bearer {api_key}"})
+        self._config_cache = {}
+    
+    def get_config(self, strategy_name: str) -> Dict[str, Any]:
+        """Get strategy configuration (NAV, funds, portfolio_weight)"""
+        if strategy_name in self._config_cache:
+            return self._config_cache[strategy_name]
+        
+        response = self._request("GET", "/api/v1/strategy/config", params={"strategy_name": strategy_name})
+        config = response.get("config", {})
+        self._config_cache[strategy_name] = config
+        return config
+    
+    def _request(self, method: str, endpoint: str, **kwargs) -> Dict[str, Any]:
+        """Make API request with error handling"""
+        url = f"{self.base_url}{endpoint}"
+        try:
+            response = self.session.request(method, url, **kwargs)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.HTTPError as e:
+            if e.response.status_code == 401:
+                raise AuthenticationError("Invalid API key")
+            raise AptisAPIError(f"API error: {e.response.text}")
+        except requests.exceptions.RequestException as e:
+            raise AptisAPIError(f"Request failed: {str(e)}")
+    
+    def submit_signal(self, signal: Signal = None, strategy_name: str = None,
+                       account: str = None, symbol: str = None, asset_class: str = None,
+                       quantity: float = None, side: str = None, signal_type: str = None,
+                       order_parameters: dict = None, metadata: dict = None) -> Dict[str, Any]:
+        """Submit trading signal - accepts Signal object or individual kwargs"""
+        if signal is None:
+            signal = Signal(symbol=symbol, asset_class=asset_class, quantity=quantity,
+                            side=side, signal_type=signal_type,
+                            order_parameters=order_parameters, metadata=metadata)
+        payload = {
+            "symbol": signal.symbol,
+            "asset_class": signal.asset_class,
+            "quantity": signal.quantity,
+            "side": signal.side,
+            "signal_type": signal.signal_type,
+            "strategy_name": strategy_name,
+            "account": account,
+            "order_parameters": signal.order_parameters,
+            "metadata": signal.metadata,
+        }
+        return self._request("POST", "/api/v1/strategy/signals/submit", json=payload)
+    
+    def get_features(self, symbols: List[str], date: date, features: List[str]) -> Dict[str, Dict[str, float]]:
+        """Get Dagster-calculated features"""
+        params = {
+            "symbols": ",".join(symbols),
+            "date": date.isoformat(),
+            "features": ",".join(features),
+        }
+        response = self._request("GET", "/api/v1/strategy/features", params=params)
+        return response.get("data", {})
+    
+    def get_quotes(self, symbols: List[str], asset_class: Optional[str] = None) -> List[Dict]:
+        """Get market quotes"""
+        params = {"symbols": ",".join(symbols)}
+        if asset_class:
+            params["asset_class"] = asset_class
+        response = self._request("GET", "/api/v1/strategy/market-data/quotes", params=params)
+        return response.get("data", [])
+    
+    def get_bars(self, symbol: str, asset_class: str, timeframe: str, 
+                 start: str, end: str, limit: int = 1000) -> List[Bar]:
+        """Get OHLCV bars"""
+        params = {
+            "symbol": symbol,
+            "asset_class": asset_class,
+            "timeframe": timeframe,
+            "start": start,
+            "end": end,
+            "limit": limit,
+        }
+        response = self._request("GET", "/api/v1/strategy/market-data/bars", params=params)
+        return response.get("bars", [])
+    
+    def get_positions(self, account: str, strategy_name: Optional[str] = None) -> List[Position]:
+        """Get current positions"""
+        params = {"account": account}
+        if strategy_name:
+            params["strategy_name"] = strategy_name
+        response = self._request("GET", "/api/v1/strategy/positions", params=params)
+        return [Position(**p) for p in response.get("positions", [])]
+    
+    def get_pnl(self, account: str, start_date: date, end_date: date, 
+                strategy_name: Optional[str] = None) -> Dict[str, Any]:
+        """Get P&L summary"""
+        params = {
+            "account": account,
+            "start_date": start_date.isoformat(),
+            "end_date": end_date.isoformat(),
+        }
+        if strategy_name:
+            params["strategy_name"] = strategy_name
+        response = self._request("GET", "/api/v1/strategy/pnl", params=params)
+        return response.get("summary", {})

aptis_strategy_sdk-0.1.0/aptis_strategy_sdk/exceptions.py

@@ -0,0 +1,17 @@
+"""SDK exceptions"""
+
+class AptisAPIError(Exception):
+    """Base exception for Aptis API errors"""
+    pass
+
+class AuthenticationError(AptisAPIError):
+    """Authentication failed"""
+    pass
+
+class ValidationError(AptisAPIError):
+    """Request validation failed"""
+    pass
+
+class RateLimitError(AptisAPIError):
+    """API rate limit exceeded"""
+    pass

aptis_strategy_sdk-0.1.0/aptis_strategy_sdk/models.py

@@ -0,0 +1,47 @@
+"""Data models for Aptis SDK"""
+from dataclasses import dataclass
+from typing import Optional, Dict, Any
+from datetime import datetime
+
+@dataclass
+class Signal:
+    """Trading signal"""
+    symbol: str
+    asset_class: str
+    quantity: float
+    side: str  # BUY or SELL
+    signal_type: str  # ENTRY, EXIT, ADJUST
+    order_parameters: Optional[Dict[str, Any]] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+@dataclass
+class Position:
+    """Current position"""
+    symbol: str
+    asset_class: str
+    quantity: float
+    avg_entry_price: float
+    current_price: float
+    unrealized_pnl: float
+    realized_pnl: float
+
+@dataclass
+class Bar:
+    """OHLCV bar"""
+    symbol: str
+    timestamp: datetime
+    open: float
+    high: float
+    low: float
+    close: float
+    volume: float
+
+@dataclass
+class Quote:
+    """Market quote"""
+    symbol: str
+    timestamp: datetime
+    bid: float
+    ask: float
+    last: float
+    volume: float

aptis_strategy_sdk-0.1.0/aptis_strategy_sdk/strategy.py

@@ -0,0 +1,59 @@
+"""Base strategy class"""
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any
+from datetime import date
+from aptis_strategy_sdk.client import AptisClient
+from aptis_strategy_sdk.models import Signal
+
+class Strategy(ABC):
+    """Base class for trading strategies"""
+    
+    def __init__(self, name: str, client: AptisClient, account: str):
+        self.name = name
+        self.client = client
+        self.account = account
+    
+    @abstractmethod
+    def generate_signals(self, date: date) -> List[Signal]:
+        """
+        Generate trading signals for the given date
+
+        Override this method with your strategy logic
+
+        Returns:
+            List of Signal objects to execute
+        """
+        pass
+    
+    def run(self, date: date) -> Dict[str, Any]:
+        """
+        Run strategy for the given date
+
+        1. Generate signals
+        2. Submit to Aptis platform
+        3. Return results
+        """
+        signals = self.generate_signals(date)
+        
+        results = []
+        for signal in signals:
+            response = self.client.submit_signal(signal, self.name)
+            results.append(response)
+        
+        return {
+            "date": date.isoformat(),
+            "signals_generated": len(signals),
+            "results": results,
+        }
+    
+    def get_features(self, symbols: List[str], date: date, features: List[str]) -> Dict[str, Dict[str, float]]:
+        """Get Dagster-calculated features"""
+        return self.client.get_features(symbols, date, features)
+    
+    def get_positions(self) -> List:
+        """Get current positions for this strategy"""
+        return self.client.get_positions(self.account, self.name)
+    
+    def get_pnl(self, start_date: date, end_date: date) -> Dict[str, Any]:
+        """Get P&L for this strategy"""
+        return self.client.get_pnl(self.account, start_date, end_date, self.name)

aptis_strategy_sdk-0.1.0/aptis_strategy_sdk.egg-info/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: aptis-strategy-sdk
+Version: 0.1.0
+Summary: Python SDK for building plugin trading strategies on the Aptis platform
+Author: Richard Chung
+Project-URL: Homepage, https://aptis.com
+Project-URL: Documentation, https://aptis.com/docs
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+
+# Aptis Strategy SDK
+
+Python SDK for building trading strategies on the Aptis platform.
+
+**Author:** Richard Chung
+
+## Installation
+
+```bash
+pip install aptis-strategy-sdk
+```
+
+## Environment Variables
+
+```bash
+APTIS_API_KEY=your_api_key_here     # Your API key
+APTIS_ACCOUNT=Theme                  # Account to trade under (Theme or QSpark)
+APTIS_API_URL=http://localhost:8082  # Backend URL
+```
+
+Never hardcode these — always read from env vars.
+
+## Quick Start
+
+```python
+import os
+from aptis_strategy_sdk import AptisClient, Strategy, Signal
+from datetime import date
+
+client = AptisClient(
+    api_key=os.getenv("APTIS_API_KEY", "test_key_123"),
+    base_url=os.getenv("APTIS_API_URL", "http://localhost:8082")
+)
+
+class MyStrategy(Strategy):
+    def generate_signals(self, run_date: date):
+        # your logic here
+        return [Signal(symbol="AAPL", asset_class="equity",
+                       quantity=100, side="BUY", signal_type="ENTRY")]
+
+strategy = MyStrategy(
+    name="My Strategy",
+    client=client,
+    account=os.getenv("APTIS_ACCOUNT", "Theme")
+)
+result = strategy.run(date.today())
+```
+
+## Accounts
+
+The platform supports multiple accounts (trading scenarios). Each account has its own API key. Set `APTIS_ACCOUNT` to target the correct account:
+
+```bash
+# Run against Theme account
+APTIS_ACCOUNT=Theme APTIS_API_KEY=test_key_123 python my_strategy.py
+
+# Run against QSpark account
+APTIS_ACCOUNT=QSpark APTIS_API_KEY=qspark_key_123 python my_strategy.py
+```
+
+## API Methods
+
+### AptisClient
+
+- `submit_signal(signal, strategy_name, account)` — submit a trading signal
+- `get_config(strategy_name)` — get NAV, funds, portfolio_weight, enabled
+- `get_quotes(symbols, asset_class)` — get market quotes
+- `get_bars(symbol, asset_class, timeframe, start, end)` — get OHLCV bars
+- `get_positions(account, strategy_name)` — get current positions
+- `get_pnl(account, start_date, end_date, strategy_name)` — get P&L
+
+### Strategy Base Class
+
+- `generate_signals(date)` — override with your logic, return `List[Signal]`
+- `run(date)` — calls `generate_signals`, submits all signals
+- `get_features(symbols, date, features)` — fetch Dagster features
+- `get_positions()` — get positions for this strategy
+
+## Signal Fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `symbol` | Yes | Ticker |
+| `asset_class` | Yes | `equity`, `etf`, `crypto`, `forex`, `commodity` |
+| `quantity` | Yes | Units |
+| `side` | Yes | `BUY` or `SELL` |
+| `signal_type` | Yes | `ENTRY`, `EXIT`, `ADJUST` |
+| `order_parameters` | No | `order_type`, `limit_price`, etc. |
+| `metadata` | No | Notes only, not used for execution |
+
+## Full Documentation
+
+See [docs/customer-integration/](../docs/customer-integration/) for complete guides.

aptis_strategy_sdk-0.1.0/aptis_strategy_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+aptis_strategy_sdk/__init__.py
+aptis_strategy_sdk/client.py
+aptis_strategy_sdk/exceptions.py
+aptis_strategy_sdk/models.py
+aptis_strategy_sdk/strategy.py
+aptis_strategy_sdk.egg-info/PKG-INFO
+aptis_strategy_sdk.egg-info/SOURCES.txt
+aptis_strategy_sdk.egg-info/dependency_links.txt
+aptis_strategy_sdk.egg-info/requires.txt
+aptis_strategy_sdk.egg-info/top_level.txt

aptis_strategy_sdk-0.1.0/aptis_strategy_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aptis_strategy_sdk-0.1.0/aptis_strategy_sdk.egg-info/requires.txt

@@ -0,0 +1,8 @@
+requests>=2.31.0
+pandas>=2.0.0
+pydantic>=2.0.0
+
+[dev]
+pytest>=7.0.0
+black>=23.0.0
+mypy>=1.0.0

aptis_strategy_sdk-0.1.0/aptis_strategy_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+aptis_strategy_sdk

aptis_strategy_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aptis-strategy-sdk"
+version = "0.1.0"
+description = "Python SDK for building plugin trading strategies on the Aptis platform"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+  "License :: Other/Proprietary License",
+  "Programming Language :: Python :: 3",
+]
+authors = [
+  {name = "Richard Chung"}
+]
+dependencies = [
+  "requests>=2.31.0",
+  "pandas>=2.0.0",
+  "pydantic>=2.0.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0.0", "black>=23.0.0", "mypy>=1.0.0"]
+
+[project.urls]
+Homepage = "https://aptis.com"
+Documentation = "https://aptis.com/docs"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["aptis_strategy_sdk*"]

aptis_strategy_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+