sj-sync 0.1.0__tar.gz

sj_sync-0.1.0/PKG-INFO

@@ -0,0 +1,262 @@
+Metadata-Version: 2.3
+Name: sj-sync
+Version: 0.1.0
+Summary: Real-time position synchronization for Shioaji
+Keywords: shioaji,trading,position,real-time,taiwan,stock
+Author: yvictor
+Author-email: yvictor <yvictor3141@gmail.com>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: shioaji>=1.2.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: loguru>=0.7.0
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/yvictor/sj_sync
+Project-URL: Issues, https://github.com/yvictor/sj_sync/issues
+Project-URL: Repository, https://github.com/yvictor/sj_sync
+Description-Content-Type: text/markdown
+
+# sj_sync
+
+[![CI](https://github.com/yvictor/sj_sync/actions/workflows/ci.yml/badge.svg)](https://github.com/yvictor/sj_sync/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/yvictor/sj_sync/branch/master/graph/badge.svg)](https://codecov.io/gh/yvictor/sj_sync)
+[![PyPI version](https://badge.fury.io/py/sj-sync.svg)](https://badge.fury.io/py/sj-sync)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Real-time position synchronization for Shioaji.
+
+## Overview
+
+`sj_sync` provides real-time position tracking using deal callbacks instead of repeatedly calling `api.list_positions()`. This approach:
+
+- **Reduces API calls**: Initialize once with `list_positions()`, then update via callbacks
+- **More responsive**: Positions update immediately when deals are executed
+- **Tracks all details**: Supports cash, margin trading, short selling, day trading, and futures/options
+
+## Features
+
+- ✅ **Real-time updates** via `OrderState.StockDeal` and `OrderState.FuturesDeal` callbacks
+- ✅ **Multiple trading types**: Cash, margin trading, short selling, day trading settlement
+- ✅ **Futures/options support**: Tracks futures and options positions
+- ✅ **Yesterday's quantity tracking**: Maintains `yd_quantity` for each position
+- ✅ **Automatic cleanup**: Removes positions when quantity reaches zero
+- ✅ **Multi-account support**: Properly isolates positions across different accounts
+- ✅ **Pydantic models**: Type-safe position objects
+
+## Installation
+
+```bash
+uv add sj-sync
+```
+
+Or with pip:
+
+```bash
+pip install sj-sync
+```
+
+## Usage
+
+```python
+import shioaji as sj
+from sj_sync import PositionSync
+
+# Initialize and login
+api = sj.Shioaji()
+api.login("YOUR_API_KEY", "YOUR_SECRET_KEY")
+
+# Create PositionSync (auto-loads positions and registers callbacks)
+sync = PositionSync(api)
+
+# Get all positions
+positions = sync.list_positions()
+for pos in positions:
+    print(f"{pos.code}: {pos.direction} {pos.quantity}")
+
+# Get positions for specific account
+stock_positions = sync.list_positions(account=api.stock_account)
+futures_positions = sync.list_positions(account=api.futopt_account)
+
+# Positions auto-update when orders are filled!
+```
+
+## Position Models
+
+### StockPosition
+
+```python
+class StockPosition(BaseModel):
+    code: str           # Stock code (e.g., "2330")
+    direction: Action   # Action.Buy or Action.Sell
+    quantity: int       # Current position quantity
+    yd_quantity: int    # Yesterday's position quantity
+    cond: StockOrderCond  # Cash, MarginTrading, or ShortSelling
+```
+
+### FuturesPosition
+
+```python
+class FuturesPosition(BaseModel):
+    code: str           # Contract code (e.g., "TXFJ4")
+    direction: Action   # Action.Buy or Action.Sell
+    quantity: int       # Current position quantity
+```
+
+## API Reference
+
+### PositionSync
+
+#### `__init__(api: sj.Shioaji)`
+Initialize with Shioaji API instance. Automatically:
+- Loads all positions from all accounts
+- Registers deal callback for real-time updates
+
+#### `list_positions(account: Optional[Account] = None, unit: Unit = Unit.Common) -> Union[List[StockPosition], List[FuturesPosition]]`
+Get current positions.
+
+**Args:**
+- `account`: Account to filter. `None` uses default account (stock_account first, then futopt_account if no stock)
+- `unit`: `Unit.Common` (lots) or `Unit.Share` (shares) - for compatibility, not used in real-time tracking
+
+**Returns:**
+- Stock account: `List[StockPosition]`
+- Futures account: `List[FuturesPosition]`
+- `None` (default): Prioritizes stock_account, falls back to futopt_account
+
+**Example:**
+```python
+# Get default account positions
+positions = sync.list_positions()
+
+# Get specific account positions
+stock_positions = sync.list_positions(account=api.stock_account)
+futures_positions = sync.list_positions(account=api.futopt_account)
+```
+
+#### `on_order_deal_event(state: OrderState, data: Dict)`
+Callback for order deal events. Automatically registered on init.
+
+Handles:
+- `OrderState.StockDeal`: Stock deal events
+- `OrderState.FuturesDeal`: Futures/options deal events
+
+## How It Works
+
+1. **Initialization**:
+   - Calls `api.list_accounts()` to get all accounts
+   - Loads positions for each account via `api.list_positions(account)`
+   - Registers `on_order_deal_event` callback
+
+2. **Real-time Updates**:
+   - When orders are filled, Shioaji triggers the callback
+   - Callback updates internal position dictionaries
+   - Buy deals increase quantity (or create new position)
+   - Sell deals decrease quantity
+   - Zero quantity positions are automatically removed
+
+3. **Position Storage**:
+   - Stock positions: `{account_key: {(code, cond): StockPosition}}`
+   - Futures positions: `{account_key: {code: FuturesPosition}}`
+   - Account key = `broker_id + account_id`
+
+## Development
+
+### Setup
+
+```bash
+git clone https://github.com/yvictor/sj_sync.git
+cd sj_sync
+uv sync
+```
+
+### Run Tests
+
+```bash
+# All tests
+uv run pytest tests/ -v
+
+# With coverage
+uv run pytest --cov=sj_sync --cov-report=html
+```
+
+### Code Quality
+
+```bash
+# Linting
+uv run ruff check src/ tests/
+
+# Formatting
+uv run ruff format src/ tests/
+
+# Type checking
+uv run zuban check src/
+```
+
+### CI/CD
+
+Every push and pull request triggers automated:
+- ✅ Code quality checks (ruff, zuban)
+- ✅ All 32 tests (unit + BDD)
+- ✅ Coverage report to Codecov
+- ✅ Build verification
+
+See [CI Setup Guide](.github/CI_SETUP.md) for details.
+
+## Testing
+
+The project includes comprehensive pytest tests covering:
+
+**Unit Tests (18 tests):**
+- ✅ Position initialization from `list_positions()`
+- ✅ Buy/sell deal events
+- ✅ Day trading scenarios
+- ✅ Margin trading and short selling
+- ✅ Futures/options deals
+- ✅ Multi-account support
+- ✅ Edge cases and error handling
+
+**BDD Tests (14 scenarios in Chinese):**
+- ✅ 當沖交易 (Day trading offset rules)
+- ✅ 融資融券 (Margin/short trading with yesterday's positions)
+- ✅ 混合場景 (Complex mixed trading scenarios)
+- ✅ Correct handling of `yd_quantity` and `yd_offset_quantity`
+
+Run tests with:
+```bash
+# All tests (32 total)
+uv run pytest tests/ -v
+
+# With coverage report
+uv run pytest --cov=sj_sync --cov-report=html --cov-report=term-missing
+```
+
+View coverage report:
+```bash
+open htmlcov/index.html  # macOS
+xdg-open htmlcov/index.html  # Linux
+```
+
+## License
+
+MIT License
+
+## Contributing
+
+Contributions welcome! Please:
+1. Fork the repository
+2. Create a feature branch
+3. Add tests for new functionality
+4. Ensure all tests pass (`pytest`, `zuban check`, `ruff check`)
+5. Submit a pull request

sj_sync-0.1.0/README.md

@@ -0,0 +1,233 @@
+# sj_sync
+
+[![CI](https://github.com/yvictor/sj_sync/actions/workflows/ci.yml/badge.svg)](https://github.com/yvictor/sj_sync/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/yvictor/sj_sync/branch/master/graph/badge.svg)](https://codecov.io/gh/yvictor/sj_sync)
+[![PyPI version](https://badge.fury.io/py/sj-sync.svg)](https://badge.fury.io/py/sj-sync)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Real-time position synchronization for Shioaji.
+
+## Overview
+
+`sj_sync` provides real-time position tracking using deal callbacks instead of repeatedly calling `api.list_positions()`. This approach:
+
+- **Reduces API calls**: Initialize once with `list_positions()`, then update via callbacks
+- **More responsive**: Positions update immediately when deals are executed
+- **Tracks all details**: Supports cash, margin trading, short selling, day trading, and futures/options
+
+## Features
+
+- ✅ **Real-time updates** via `OrderState.StockDeal` and `OrderState.FuturesDeal` callbacks
+- ✅ **Multiple trading types**: Cash, margin trading, short selling, day trading settlement
+- ✅ **Futures/options support**: Tracks futures and options positions
+- ✅ **Yesterday's quantity tracking**: Maintains `yd_quantity` for each position
+- ✅ **Automatic cleanup**: Removes positions when quantity reaches zero
+- ✅ **Multi-account support**: Properly isolates positions across different accounts
+- ✅ **Pydantic models**: Type-safe position objects
+
+## Installation
+
+```bash
+uv add sj-sync
+```
+
+Or with pip:
+
+```bash
+pip install sj-sync
+```
+
+## Usage
+
+```python
+import shioaji as sj
+from sj_sync import PositionSync
+
+# Initialize and login
+api = sj.Shioaji()
+api.login("YOUR_API_KEY", "YOUR_SECRET_KEY")
+
+# Create PositionSync (auto-loads positions and registers callbacks)
+sync = PositionSync(api)
+
+# Get all positions
+positions = sync.list_positions()
+for pos in positions:
+    print(f"{pos.code}: {pos.direction} {pos.quantity}")
+
+# Get positions for specific account
+stock_positions = sync.list_positions(account=api.stock_account)
+futures_positions = sync.list_positions(account=api.futopt_account)
+
+# Positions auto-update when orders are filled!
+```
+
+## Position Models
+
+### StockPosition
+
+```python
+class StockPosition(BaseModel):
+    code: str           # Stock code (e.g., "2330")
+    direction: Action   # Action.Buy or Action.Sell
+    quantity: int       # Current position quantity
+    yd_quantity: int    # Yesterday's position quantity
+    cond: StockOrderCond  # Cash, MarginTrading, or ShortSelling
+```
+
+### FuturesPosition
+
+```python
+class FuturesPosition(BaseModel):
+    code: str           # Contract code (e.g., "TXFJ4")
+    direction: Action   # Action.Buy or Action.Sell
+    quantity: int       # Current position quantity
+```
+
+## API Reference
+
+### PositionSync
+
+#### `__init__(api: sj.Shioaji)`
+Initialize with Shioaji API instance. Automatically:
+- Loads all positions from all accounts
+- Registers deal callback for real-time updates
+
+#### `list_positions(account: Optional[Account] = None, unit: Unit = Unit.Common) -> Union[List[StockPosition], List[FuturesPosition]]`
+Get current positions.
+
+**Args:**
+- `account`: Account to filter. `None` uses default account (stock_account first, then futopt_account if no stock)
+- `unit`: `Unit.Common` (lots) or `Unit.Share` (shares) - for compatibility, not used in real-time tracking
+
+**Returns:**
+- Stock account: `List[StockPosition]`
+- Futures account: `List[FuturesPosition]`
+- `None` (default): Prioritizes stock_account, falls back to futopt_account
+
+**Example:**
+```python
+# Get default account positions
+positions = sync.list_positions()
+
+# Get specific account positions
+stock_positions = sync.list_positions(account=api.stock_account)
+futures_positions = sync.list_positions(account=api.futopt_account)
+```
+
+#### `on_order_deal_event(state: OrderState, data: Dict)`
+Callback for order deal events. Automatically registered on init.
+
+Handles:
+- `OrderState.StockDeal`: Stock deal events
+- `OrderState.FuturesDeal`: Futures/options deal events
+
+## How It Works
+
+1. **Initialization**:
+   - Calls `api.list_accounts()` to get all accounts
+   - Loads positions for each account via `api.list_positions(account)`
+   - Registers `on_order_deal_event` callback
+
+2. **Real-time Updates**:
+   - When orders are filled, Shioaji triggers the callback
+   - Callback updates internal position dictionaries
+   - Buy deals increase quantity (or create new position)
+   - Sell deals decrease quantity
+   - Zero quantity positions are automatically removed
+
+3. **Position Storage**:
+   - Stock positions: `{account_key: {(code, cond): StockPosition}}`
+   - Futures positions: `{account_key: {code: FuturesPosition}}`
+   - Account key = `broker_id + account_id`
+
+## Development
+
+### Setup
+
+```bash
+git clone https://github.com/yvictor/sj_sync.git
+cd sj_sync
+uv sync
+```
+
+### Run Tests
+
+```bash
+# All tests
+uv run pytest tests/ -v
+
+# With coverage
+uv run pytest --cov=sj_sync --cov-report=html
+```
+
+### Code Quality
+
+```bash
+# Linting
+uv run ruff check src/ tests/
+
+# Formatting
+uv run ruff format src/ tests/
+
+# Type checking
+uv run zuban check src/
+```
+
+### CI/CD
+
+Every push and pull request triggers automated:
+- ✅ Code quality checks (ruff, zuban)
+- ✅ All 32 tests (unit + BDD)
+- ✅ Coverage report to Codecov
+- ✅ Build verification
+
+See [CI Setup Guide](.github/CI_SETUP.md) for details.
+
+## Testing
+
+The project includes comprehensive pytest tests covering:
+
+**Unit Tests (18 tests):**
+- ✅ Position initialization from `list_positions()`
+- ✅ Buy/sell deal events
+- ✅ Day trading scenarios
+- ✅ Margin trading and short selling
+- ✅ Futures/options deals
+- ✅ Multi-account support
+- ✅ Edge cases and error handling
+
+**BDD Tests (14 scenarios in Chinese):**
+- ✅ 當沖交易 (Day trading offset rules)
+- ✅ 融資融券 (Margin/short trading with yesterday's positions)
+- ✅ 混合場景 (Complex mixed trading scenarios)
+- ✅ Correct handling of `yd_quantity` and `yd_offset_quantity`
+
+Run tests with:
+```bash
+# All tests (32 total)
+uv run pytest tests/ -v
+
+# With coverage report
+uv run pytest --cov=sj_sync --cov-report=html --cov-report=term-missing
+```
+
+View coverage report:
+```bash
+open htmlcov/index.html  # macOS
+xdg-open htmlcov/index.html  # Linux
+```
+
+## License
+
+MIT License
+
+## Contributing
+
+Contributions welcome! Please:
+1. Fork the repository
+2. Create a feature branch
+3. Add tests for new functionality
+4. Ensure all tests pass (`pytest`, `zuban check`, `ruff check`)
+5. Submit a pull request

sj_sync-0.1.0/pyproject.toml

@@ -0,0 +1,101 @@
+[project]
+name = "sj-sync"
+version = "0.1.0"
+description = "Real-time position synchronization for Shioaji"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [
+    { name = "yvictor", email = "yvictor3141@gmail.com" }
+]
+license = { text = "MIT" }
+keywords = ["shioaji", "trading", "position", "real-time", "taiwan", "stock"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Financial and Insurance Industry",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Office/Business :: Financial :: Investment",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "shioaji>=1.2.0",
+    "pydantic>=2.0.0",
+    "loguru>=0.7.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/yvictor/sj_sync"
+Repository = "https://github.com/yvictor/sj_sync"
+Issues = "https://github.com/yvictor/sj_sync/issues"
+
+[project.scripts]
+sj-sync = "sj_sync:main"
+
+[build-system]
+requires = ["uv_build>=0.9.5,<0.10.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "ruff>=0.14.4",
+    "zuban>=0.2.2",
+    "pytest>=8.0.0",
+    "pytest-mock>=3.12.0",
+    "pytest-bdd>=7.0.0",
+    "pytest-cov>=6.0.0",
+    "tomli>=2.0.0",
+    "ipykernel>=7.1.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = [
+    "-v",
+    "--strict-markers",
+    "--strict-config",
+    "--cov=sj_sync",
+    "--cov-report=term-missing:skip-covered",
+    "--cov-report=html",
+    "--cov-report=xml",
+]
+markers = [
+    "slow: marks tests as slow (deselect with '-m \"not slow\"')",
+    "integration: marks tests as integration tests",
+]
+
+[tool.coverage.run]
+source = ["sj_sync"]
+branch = true
+omit = [
+    "*/tests/*",
+    "*/test_*.py",
+    "*/__pycache__/*",
+    "*/site-packages/*",
+]
+
+[tool.coverage.report]
+precision = 2
+show_missing = true
+skip_covered = false
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+    "class .*\\bProtocol\\):",
+    "@(abc\\.)?abstractmethod",
+]
+
+[tool.coverage.html]
+directory = "htmlcov"

sj_sync-0.1.0/src/sj_sync/__init__.py

@@ -0,0 +1,17 @@
+"""sj_sync - Real-time position synchronization for Shioaji."""
+
+from .position_sync import PositionSync
+from .models import StockPosition, FuturesPosition, Position, AccountDict
+
+__all__ = [
+    "PositionSync",
+    "StockPosition",
+    "FuturesPosition",
+    "Position",
+    "AccountDict",
+]
+
+
+def main() -> None:
+    """Main entry point for CLI."""
+    print("Hello from sj-sync!")

sj_sync-0.1.0/src/sj_sync/models.py

@@ -0,0 +1,66 @@
+"""Position models for sj_sync."""
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Union, TypedDict
+from shioaji.constant import Action, StockOrderCond
+
+
+class AccountDict(TypedDict):
+    """Account dictionary structure from deal callback."""
+
+    broker_id: str
+    account_id: str
+
+
+class StockPosition(BaseModel):
+    """Stock position model compatible with shioaji Position interface.
+
+    Tracks real-time position with minimal fields:
+    - code: Stock symbol
+    - direction: Buy or Sell (Action enum)
+    - quantity: Current position quantity (in shares or lots depending on unit)
+    - yd_quantity: Yesterday's position quantity (fixed reference, never modified)
+    - yd_offset_quantity: Yesterday's offset quantity (accumulated today)
+    - cond: Order condition (StockOrderCond enum)
+
+    Calculations:
+    - Yesterday's actual remaining = yd_quantity - yd_offset_quantity
+    - Today's actual remaining = quantity - (yd_quantity - yd_offset_quantity)
+    """
+
+    model_config = ConfigDict(frozen=False, arbitrary_types_allowed=True)
+
+    code: str = Field(..., description="Stock code/symbol")
+    direction: Action = Field(..., description="Buy or Sell")
+    quantity: int = Field(default=0, description="Current position quantity")
+    yd_quantity: int = Field(
+        default=0, description="Yesterday's position quantity (fixed)"
+    )
+    yd_offset_quantity: int = Field(
+        default=0, description="Yesterday's offset quantity (today)"
+    )
+    cond: StockOrderCond = Field(
+        default=StockOrderCond.Cash, description="Order condition"
+    )
+
+
+class FuturesPosition(BaseModel):
+    """Futures/Options position model.
+
+    Simplified futures position tracking:
+    - code: Contract code
+    - direction: Buy or Sell (Action enum)
+    - quantity: Current position quantity
+    # - yd_quantity: Yesterday's position quantity
+    """
+
+    model_config = ConfigDict(frozen=False, arbitrary_types_allowed=True)
+
+    code: str = Field(..., description="Contract code")
+    direction: Action = Field(..., description="Buy or Sell")
+    quantity: int = Field(default=0, description="Current position quantity")
+    # yd_quantity: int = Field(default=0, description="Yesterday's position quantity")
+
+
+# Type alias for any position type
+Position = Union[StockPosition, FuturesPosition]

sj_sync-0.1.0/src/sj_sync/position_sync.py

@@ -0,0 +1,530 @@
+"""Real-time position synchronization for Shioaji."""
+
+from loguru import logger
+from typing import Dict, List, Optional, Union, Tuple
+import shioaji as sj
+from shioaji.constant import OrderState, Action, StockOrderCond, Unit
+from shioaji.account import Account, AccountType
+from shioaji.position import StockPosition as SjStockPostion
+from shioaji.position import FuturePosition as SjFuturePostion
+from .models import StockPosition, FuturesPosition, AccountDict
+
+
+class PositionSync:
+    """Synchronize positions in real-time using deal callbacks.
+
+    Usage:
+        sync = PositionSync(api)
+        # Positions are automatically loaded on init
+        positions = sync.list_positions()  # Get all positions
+        positions = sync.list_positions(account=api.stock_account)  # Filter by account
+    """
+
+    def __init__(self, api: sj.Shioaji):
+        """Initialize PositionSync with Shioaji API instance.
+
+        Automatically loads all positions and registers deal callback.
+
+        Args:
+            api: Shioaji API instance
+        """
+        self.api = api
+        self.api.set_order_callback(self.on_order_deal_event)
+
+        # Separate dicts for stock and futures positions
+        # Stock: {account_key: {(code, cond): StockPosition}}
+        # Futures: {account_key: {code: FuturesPosition}}
+        # account_key = broker_id + account_id
+        self._stock_positions: Dict[
+            str, Dict[Tuple[str, StockOrderCond], StockPosition]
+        ] = {}
+        self._futures_positions: Dict[str, Dict[str, FuturesPosition]] = {}
+
+        # Auto-load positions on init
+        self._initialize_positions()
+
+    def _get_account_key(self, account: Union[Account, AccountDict]) -> str:
+        """Generate account key from Account object or dict.
+
+        Args:
+            account: Account object or AccountDict with broker_id and account_id
+
+        Returns:
+            Account key string (broker_id + account_id)
+        """
+        if isinstance(account, dict):
+            return f"{account['broker_id']}{account['account_id']}"
+        return f"{account.broker_id}{account.account_id}"
+
+    def _initialize_positions(self) -> None:
+        """Initialize positions from api.list_positions() for all accounts."""
+        # Get all accounts
+        accounts = self.api.list_accounts()
+
+        for account in accounts:
+            account_key = self._get_account_key(account)
+
+            try:
+                # Load positions for this account
+                positions_pnl = self.api.list_positions(
+                    account=account, unit=Unit.Common
+                )
+            except Exception as e:
+                logger.warning(f"Failed to load positions for account {account}: {e}")
+                continue
+
+            # Determine if this is stock or futures account based on account_type
+            account_type = account.account_type
+            if account_type == AccountType.Stock:
+                for pnl in positions_pnl:
+                    if isinstance(pnl, SjStockPostion):
+                        position = StockPosition(
+                            code=pnl.code,
+                            direction=pnl.direction,
+                            quantity=pnl.quantity,
+                            yd_quantity=pnl.yd_quantity,
+                            yd_offset_quantity=0,  # Today starts with 0 offset
+                            cond=pnl.cond,
+                        )
+                        if account_key not in self._stock_positions:
+                            self._stock_positions[account_key] = {}
+                        key = (position.code, position.cond)
+                        self._stock_positions[account_key][key] = position
+
+            elif account_type == AccountType.Future:
+                for pnl in positions_pnl:
+                    if isinstance(pnl, SjFuturePostion):
+                        position = FuturesPosition(
+                            code=pnl.code,
+                            direction=pnl.direction,
+                            quantity=pnl.quantity,
+                        )
+                        if account_key not in self._futures_positions:
+                            self._futures_positions[account_key] = {}
+                        self._futures_positions[account_key][position.code] = position
+
+            logger.info(f"Initialized positions for account {account_key}")
+
+    def list_positions(  # noqa: ARG002
+        self, account: Optional[Account] = None, unit: Unit = Unit.Common
+    ) -> Union[List[StockPosition], List[FuturesPosition]]:
+        """Get all current positions.
+
+        Args:
+            account: Account to filter. None uses default stock_account first, then futopt_account if no stock.
+            unit: Unit.Common or Unit.Share (for compatibility, not used in real-time tracking)
+
+        Returns:
+            List of position objects for the specified account type:
+            - Stock account: List[StockPosition]
+            - Futures account: List[FuturesPosition]
+            - None (default): List[StockPosition] from stock_account, or List[FuturesPosition] if no stock
+        """
+        if account is None:
+            # Use default accounts - prioritize stock_account
+            if (
+                hasattr(self.api, "stock_account")
+                and self.api.stock_account is not None
+            ):
+                stock_account_key = self._get_account_key(self.api.stock_account)
+                if stock_account_key in self._stock_positions:
+                    return list(self._stock_positions[stock_account_key].values())
+
+            # No stock positions, try futures
+            if (
+                hasattr(self.api, "futopt_account")
+                and self.api.futopt_account is not None
+            ):
+                futopt_account_key = self._get_account_key(self.api.futopt_account)
+                if futopt_account_key in self._futures_positions:
+                    futures_list: List[FuturesPosition] = list(
+                        self._futures_positions[futopt_account_key].values()
+                    )
+                    return futures_list
+
+            # No positions at all
+            return []
+        else:
+            # Specific account - use AccountType enum
+            account_key = self._get_account_key(account)
+            account_type = account.account_type
+
+            if account_type == AccountType.Stock:
+                if account_key in self._stock_positions:
+                    return list(self._stock_positions[account_key].values())
+                return []
+            elif account_type == AccountType.Future:
+                if account_key in self._futures_positions:
+                    futures_list: List[FuturesPosition] = list(
+                        self._futures_positions[account_key].values()
+                    )
+                    return futures_list
+                return []
+
+            return []
+
+    def on_order_deal_event(self, state: OrderState, data: Dict) -> None:
+        """Callback for order deal events.
+
+        Args:
+            state: OrderState enum value
+            data: Order/deal data dictionary
+        """
+        # Handle stock deals
+        if state == OrderState.StockDeal:
+            self._update_position(data, is_futures=False)
+        # Handle futures deals
+        elif state == OrderState.FuturesDeal:
+            self._update_position(data, is_futures=True)
+
+    def _update_position(self, deal: Dict, is_futures: bool = False) -> None:
+        """Update position based on deal event.
+
+        Args:
+            deal: Deal data from callback
+            is_futures: True if futures/options deal, False if stock deal
+        """
+        code = deal.get("code")
+        action_value = deal.get("action")
+        quantity = deal.get("quantity", 0)
+        price = deal.get("price", 0)
+        account = deal.get("account")
+
+        if not code or not action_value or not account:
+            logger.warning(f"Deal missing required fields: {deal}")
+            return
+
+        action = self._normalize_direction(action_value)
+
+        if is_futures:
+            self._update_futures_position(account, code, action, quantity, price)
+        else:
+            order_cond = self._normalize_cond(
+                deal.get("order_cond", StockOrderCond.Cash)
+            )
+            self._update_stock_position(
+                account, code, action, quantity, price, order_cond
+            )
+
+    def _is_day_trading_offset(
+        self, code: str, account_key: str, action: Action, order_cond: StockOrderCond
+    ) -> tuple[bool, StockOrderCond | None]:
+        """Check if this is a day trading offset transaction.
+
+        Day trading rules:
+        - MarginTrading Buy + ShortSelling Sell = offset MarginTrading today's quantity
+        - ShortSelling Sell + MarginTrading Buy = offset ShortSelling today's quantity
+        - Cash Buy + Cash Sell = offset Cash today's quantity
+        - Cash Sell (short) + Cash Buy = offset Cash today's quantity
+
+        Returns:
+            (is_day_trading, opposite_cond)
+        """
+        # MarginTrading + ShortSelling day trading
+        if order_cond == StockOrderCond.ShortSelling and action == Action.Sell:
+            # Check if there's today's MarginTrading position
+            margin_key = (code, StockOrderCond.MarginTrading)
+            if margin_key in self._stock_positions.get(account_key, {}):
+                margin_pos = self._stock_positions[account_key][margin_key]
+                # Today's quantity = quantity - (yd_quantity - yd_offset_quantity)
+                yd_remaining = margin_pos.yd_quantity - margin_pos.yd_offset_quantity
+                today_qty = margin_pos.quantity - yd_remaining
+                if today_qty > 0:
+                    return True, StockOrderCond.MarginTrading
+
+        if order_cond == StockOrderCond.MarginTrading and action == Action.Buy:
+            # Check if there's today's ShortSelling position
+            short_key = (code, StockOrderCond.ShortSelling)
+            if short_key in self._stock_positions.get(account_key, {}):
+                short_pos = self._stock_positions[account_key][short_key]
+                # Today's quantity = quantity - (yd_quantity - yd_offset_quantity)
+                yd_remaining = short_pos.yd_quantity - short_pos.yd_offset_quantity
+                today_qty = short_pos.quantity - yd_remaining
+                if today_qty > 0:
+                    return True, StockOrderCond.ShortSelling
+
+        # Cash day trading
+        if order_cond == StockOrderCond.Cash:
+            cash_key = (code, StockOrderCond.Cash)
+            if cash_key in self._stock_positions.get(account_key, {}):
+                cash_pos = self._stock_positions[account_key][cash_key]
+                # Buy then Sell or Sell then Buy
+                if cash_pos.direction != action:
+                    # Today's quantity = quantity - (yd_quantity - yd_offset_quantity)
+                    yd_remaining = cash_pos.yd_quantity - cash_pos.yd_offset_quantity
+                    today_qty = cash_pos.quantity - yd_remaining
+                    if today_qty > 0:
+                        return True, StockOrderCond.Cash
+
+        return False, None
+
+    def _update_stock_position(
+        self,
+        account: Union[Account, AccountDict],
+        code: str,
+        action: Action,
+        quantity: int,
+        price: float,
+        order_cond: StockOrderCond,
+    ) -> None:
+        """Update stock position.
+
+        Args:
+            account: Account object or AccountDict from deal callback
+            code: Stock code
+            action: Buy or Sell action
+            quantity: Trade quantity
+            price: Trade price
+            order_cond: Order condition (Cash, MarginTrading, ShortSelling)
+        """
+        account_key = self._get_account_key(account)
+
+        # Initialize account dict if needed
+        if account_key not in self._stock_positions:
+            self._stock_positions[account_key] = {}
+
+        # Check for day trading offset
+        is_day_trading, opposite_cond = self._is_day_trading_offset(
+            code, account_key, action, order_cond
+        )
+
+        if is_day_trading and opposite_cond:
+            # Day trading: offset today's position in opposite condition
+            self._process_day_trading_offset(
+                account_key, code, quantity, price, order_cond, opposite_cond, action
+            )
+        else:
+            # Normal trading or same-cond offset
+            self._process_normal_trading(
+                account_key, code, action, quantity, price, order_cond
+            )
+
+    def _process_day_trading_offset(
+        self,
+        account_key: str,
+        code: str,
+        quantity: int,
+        price: float,
+        order_cond: StockOrderCond,
+        opposite_cond: StockOrderCond,
+        action: Action,
+    ) -> None:
+        """Process day trading offset transaction.
+
+        Day trading offsets today's quantity only.
+        Note: yd_quantity and yd_offset_quantity are NOT modified in day trading.
+        """
+        opposite_key = (code, opposite_cond)
+        opposite_pos = self._stock_positions[account_key][opposite_key]
+
+        # Calculate today's quantity: quantity - (yd_quantity - yd_offset_quantity)
+        yd_remaining = opposite_pos.yd_quantity - opposite_pos.yd_offset_quantity
+        today_qty = opposite_pos.quantity - yd_remaining
+        offset_qty = min(quantity, today_qty)
+        remaining_qty = quantity - offset_qty
+
+        # Offset today's position (only reduce quantity, yd_quantity & yd_offset_quantity stay unchanged)
+        opposite_pos.quantity -= offset_qty
+        logger.info(
+            f"{code} DAY-TRADE OFFSET {action} {price} x {offset_qty} "
+            f"[{order_cond}] offsets [{opposite_cond}] -> {opposite_pos}"
+        )
+
+        # Remove if zero
+        if opposite_pos.quantity == 0:
+            del self._stock_positions[account_key][opposite_key]
+            logger.info(f"{code} [{opposite_cond}] REMOVED (day trading closed)")
+
+        # If there's remaining quantity after offsetting today's, it offsets yesterday's position
+        if remaining_qty > 0 and opposite_key in self._stock_positions[account_key]:
+            # Calculate how much yesterday's position is left
+            opposite_pos = self._stock_positions[account_key][opposite_key]
+            yd_available = opposite_pos.yd_quantity - opposite_pos.yd_offset_quantity
+            yd_offset = min(remaining_qty, yd_available)
+
+            if yd_offset > 0:
+                # Reduce quantity and increase yd_offset_quantity (yd_quantity never changes)
+                opposite_pos.quantity -= yd_offset
+                opposite_pos.yd_offset_quantity += yd_offset
+                remaining_qty -= yd_offset
+                logger.info(
+                    f"{code} OFFSET YD {action} {price} x {yd_offset} "
+                    f"[{order_cond}] offsets [{opposite_cond}] yd -> {opposite_pos}"
+                )
+
+                if opposite_pos.quantity == 0:
+                    del self._stock_positions[account_key][opposite_key]
+                    logger.info(f"{code} [{opposite_cond}] REMOVED (fully closed)")
+
+        # If still remaining, create new position
+        if remaining_qty > 0:
+            self._create_or_update_position(
+                account_key, code, action, remaining_qty, price, order_cond
+            )
+
+    def _process_normal_trading(
+        self,
+        account_key: str,
+        code: str,
+        action: Action,
+        quantity: int,
+        price: float,
+        order_cond: StockOrderCond,
+    ) -> None:
+        """Process normal trading (non-day-trading).
+
+        For margin/short trading with opposite direction:
+        - Can only offset yesterday's position
+        - Increase yd_offset_quantity, decrease quantity
+        - yd_quantity never changes
+        """
+        key = (code, order_cond)
+        position = self._stock_positions[account_key].get(key)
+
+        if position is None:
+            # Create new position
+            self._create_or_update_position(
+                account_key, code, action, quantity, price, order_cond
+            )
+        else:
+            # Existing position
+            if position.direction == action:
+                # Same direction: add to position
+                position.quantity += quantity
+                logger.info(
+                    f"{code} ADD {action} {price} x {quantity} [{order_cond}] -> {position}"
+                )
+            else:
+                # Opposite direction: can only offset yesterday's position
+                # Calculate yesterday's remaining
+                yd_available = position.yd_quantity - position.yd_offset_quantity
+                offset_qty = min(quantity, yd_available)
+
+                if offset_qty > 0:
+                    # Reduce quantity and increase yd_offset_quantity (yd_quantity never changes)
+                    position.quantity -= offset_qty
+                    position.yd_offset_quantity += offset_qty
+                    logger.info(
+                        f"{code} OFFSET YD {action} {price} x {offset_qty} [{order_cond}] -> {position}"
+                    )
+
+                    # Remove if zero
+                    if position.quantity == 0:
+                        del self._stock_positions[account_key][key]
+                        logger.info(f"{code} CLOSED [{order_cond}] -> REMOVED")
+
+    def _create_or_update_position(
+        self,
+        account_key: str,
+        code: str,
+        action: Action,
+        quantity: int,
+        price: float,
+        order_cond: StockOrderCond,
+    ) -> None:
+        """Create new position or add to existing."""
+        key = (code, order_cond)
+        position = self._stock_positions[account_key].get(key)
+
+        if position is None:
+            position = StockPosition(
+                code=code,
+                direction=action,
+                quantity=quantity,
+                yd_quantity=0,
+                yd_offset_quantity=0,  # New position today has no offset
+                cond=order_cond,
+            )
+            self._stock_positions[account_key][key] = position
+            logger.info(
+                f"{code} NEW {action} {price} x {quantity} [{order_cond}] -> {position}"
+            )
+        else:
+            position.quantity += quantity
+            logger.info(
+                f"{code} ADD {action} {price} x {quantity} [{order_cond}] -> {position}"
+            )
+
+    def _update_futures_position(
+        self,
+        account: Union[Account, AccountDict],
+        code: str,
+        action: Action,
+        quantity: int,
+        price: float,
+    ) -> None:
+        """Update futures position.
+
+        Args:
+            account: Account object or AccountDict from deal callback
+            code: Contract code
+            action: Buy or Sell action
+            quantity: Trade quantity
+            price: Trade price
+        """
+        account_key = self._get_account_key(account)
+
+        # Initialize account dict if needed
+        if account_key not in self._futures_positions:
+            self._futures_positions[account_key] = {}
+
+        position = self._futures_positions[account_key].get(code)
+
+        if position is None:
+            # Create new position
+            position = FuturesPosition(
+                code=code,
+                direction=action,
+                quantity=quantity,
+            )
+            self._futures_positions[account_key][code] = position
+            logger.info(f"{code} NEW {action} {price} x {quantity} -> {position}")
+        else:
+            # Update existing position
+            if position.direction == action:
+                position.quantity += quantity
+            else:
+                position.quantity -= quantity
+
+            # Remove if quantity becomes zero
+            if position.quantity == 0:
+                del self._futures_positions[account_key][code]
+                logger.info(f"{code} CLOSED {action} {price} x {quantity} -> REMOVED")
+            else:
+                logger.info(f"{code} {action} {price} x {quantity} -> {position}")
+
+    def _normalize_direction(self, direction: Union[Action, str]) -> Action:
+        """Normalize direction to Action enum.
+
+        Args:
+            direction: Action enum or string
+
+        Returns:
+            Action enum (Buy or Sell)
+        """
+        if isinstance(direction, Action):
+            return direction
+        # Convert string to Action enum
+        if direction == "Buy" or direction == "buy":
+            return Action.Buy
+        elif direction == "Sell" or direction == "sell":
+            return Action.Sell
+        return Action[direction]  # Fallback to enum lookup
+
+    def _normalize_cond(self, cond: Union[StockOrderCond, str]) -> StockOrderCond:
+        """Normalize order condition to StockOrderCond enum.
+
+        Args:
+            cond: StockOrderCond enum or string
+
+        Returns:
+            StockOrderCond enum
+        """
+        if isinstance(cond, StockOrderCond):
+            return cond
+        # Convert string to StockOrderCond enum
+        try:
+            return StockOrderCond[cond]
+        except KeyError:
+            # Fallback to Cash if invalid
+            return StockOrderCond.Cash