broker-sync/broker_sync/providers/trading212.py

from __future__ import annotations

import re
from collections.abc import AsyncIterator
from datetime import datetime
from decimal import Decimal
from pathlib import Path
from typing import Any

import httpx

from broker_sync.models import Account, Activity, ActivityType
from broker_sync.providers._checkpoint import Checkpoint

_BASE_URL = "https://live.trading212.com"
_ORDERS_PATH = "/api/v0/equity/history/orders"
_PAGE_LIMIT = 50

_SUFFIX_RE = re.compile(r"(?:_US)?(?:[a-z])?_EQ$")


def _normalise_ticker(raw: str) -> str:
    """Strip T212's exchange-suffix decoration from a ticker."""
    return _SUFFIX_RE.sub("", raw)


class Trading212Error(Exception):
    """Any non-retryable Trading212 API failure."""


class Trading212AuthError(Trading212Error):
    """HTTP 401 from Trading212 — API key is invalid or revoked."""


class Trading212Provider:
    """Concrete Provider for Trading212.

    One instance serves every T212 wrapper the user owns (ISA + Invest)
    — the caller hands over (Account, api_key) pairs and `fetch()` walks
    each account's history in turn.
    """

    name = "trading212"

    def __init__(
        self,
        *,
        accounts: list[tuple[Account, str]],
        checkpoint_dir: Path,
        transport: httpx.AsyncBaseTransport | None = None,
    ) -> None:
        self._accounts = accounts
        self._checkpoint_dir = checkpoint_dir
        self._client = httpx.AsyncClient(
            base_url=_BASE_URL,
            timeout=30.0,
            transport=transport,
        )

    def accounts(self) -> list[Account]:
        return [acc for acc, _ in self._accounts]

    async def close(self) -> None:
        await self._client.aclose()

    async def fetch(
        self,
        *,
        since: datetime | None = None,
        before: datetime | None = None,
    ) -> AsyncIterator[Activity]:
        for account, api_key in self._accounts:
            async for activity in self._fetch_account(account, api_key, since, before):
                yield activity

    async def _fetch_account(
        self,
        account: Account,
        api_key: str,
        since: datetime | None,
        before: datetime | None,
    ) -> AsyncIterator[Activity]:
        checkpoint = Checkpoint(
            self._checkpoint_dir,
            provider=self.name,
            account_id=account.id,
        )
        page = await self._get_page(api_key, cursor=None)
        for item in page.get("items", []):
            activity = _item_to_activity(item, account)
            if activity is None:
                continue
            if since is not None and activity.date < since:
                continue
            if before is not None and activity.date >= before:
                continue
            yield activity
        # Checkpoint saved at end of page — resume on next run.
        next_cursor = page.get("nextPagePath")
        if isinstance(next_cursor, str):
            checkpoint.save(next_cursor)

    async def _get_page(self, api_key: str, cursor: str | None) -> dict[str, Any]:
        params: dict[str, str | int] = {"limit": _PAGE_LIMIT}
        if cursor is not None:
            params["cursor"] = cursor
        resp = await self._client.get(
            _ORDERS_PATH,
            params=params,
            headers={"Authorization": api_key},
        )
        if resp.status_code == 401:
            raise Trading212AuthError("Trading212 rejected API key (HTTP 401)")
        if resp.status_code >= 400:
            raise Trading212Error(f"Trading212 /orders HTTP {resp.status_code}: {resp.text}")
        raw = resp.json()
        assert isinstance(raw, dict)
        return raw


def _item_to_activity(item: dict[str, Any], account: Account) -> Activity | None:
    fill = item.get("fill")
    if fill is None:
        return None
    order = item["order"]
    quantity_raw = Decimal(str(fill["quantity"]))
    activity_type = ActivityType.BUY if quantity_raw > 0 else ActivityType.SELL
    return Activity(
        external_id=f"t212:fill:{fill['id']}",
        account_id=account.id,
        account_type=account.account_type,
        date=_parse_iso(fill["filledAt"]),
        activity_type=activity_type,
        symbol=_normalise_ticker(order["ticker"]),
        quantity=abs(quantity_raw),
        unit_price=Decimal(str(fill["price"])),
        currency=order["currency"],
    )


def _parse_iso(ts: str) -> datetime:
    # T212 always emits `...Z`; datetime.fromisoformat handles `+00:00`.
    return datetime.fromisoformat(ts.replace("Z", "+00:00"))