smartbroker-plus-sdk 0.3.0__py3-none-any.whl

smartbroker_plus_sdk/__init__.py

@@ -0,0 +1,242 @@
+from ._client import AsyncSmartbrokerClient as AsyncSmartbrokerClient
+from ._client import SmartbrokerClient as SmartbrokerClient
+from ._auth._active_account._active_account import ActiveAccount as ActiveAccount
+from ._auth._active_account._active_account_store import (
+    ActiveAccountStore as ActiveAccountStore,
+)
+from ._auth._oauth import AsyncOAuthClient as AsyncOAuthClient
+from ._auth._oauth import generate_code_challenge as generate_code_challenge
+from ._auth._oauth import generate_code_verifier as generate_code_verifier
+from ._auth._oauth import OAuthClient as OAuthClient
+from ._auth._token_cache._cached_token import CachedToken as CachedToken
+from ._auth._token_cache._file_token_cache import FileTokenCache as FileTokenCache
+from ._auth._token_cache._path_resolver import resolve_cache_dir as resolve_cache_dir
+from ._exceptions import AuthenticationError as AuthenticationError
+from ._exceptions import AuthorizationError as AuthorizationError
+from ._exceptions import BuyingPowerExceededError as BuyingPowerExceededError
+from ._exceptions import InsufficientBalanceError as InsufficientBalanceError
+from ._exceptions import InvalidLimitStepError as InvalidLimitStepError
+from ._exceptions import (
+    MinimumInvestmentNotReachedError as MinimumInvestmentNotReachedError,
+)
+from ._exceptions import NotFoundError as NotFoundError
+from ._exceptions import NumbersNotAllowedError as NumbersNotAllowedError
+from ._exceptions import OrderRejectedError as OrderRejectedError
+from ._exceptions import PennyStockLimitRequiredError as PennyStockLimitRequiredError
+from ._exceptions import RefreshTokenExpiredError as RefreshTokenExpiredError
+from ._exceptions import RetryExhaustedError as RetryExhaustedError
+from ._exceptions import ServerError as ServerError
+from ._exceptions import SmartbrokerApiError as SmartbrokerApiError
+from ._exceptions import StopLimitTooLowError as StopLimitTooLowError
+from ._exceptions import TwoFactorError as TwoFactorError
+from ._exceptions import TwoFactorTokenExpiredError as TwoFactorTokenExpiredError
+from ._exceptions import ValidationError as ValidationError
+from ._models._auth import ApprovalRequiredError as ApprovalRequiredError
+from ._models._auth import Token as Token
+from ._models._auth import TokenResponse as TokenResponse
+from ._models._auth import TokenStatus as TokenStatus
+from ._models._account_transactions import AccountTransactions as AccountTransactions
+from ._models._account_transactions import (
+    RestAccountTransaction as RestAccountTransaction,
+)
+from ._models._marketstate import CloseData as CloseData
+from ._models._marketstate import Marketstate as Marketstate
+from ._models._marketstate import QuoteData as QuoteData
+from ._models._common import AssetQuotation as AssetQuotation
+from ._models._common import CostReportPositionType as CostReportPositionType
+from ._models._common import InstrumentType as InstrumentType
+from ._models._common import ModificationRequestStatus as ModificationRequestStatus
+from ._models._common import OrderDirection as OrderDirection
+from ._models._common import OrderDirectionFilter as OrderDirectionFilter
+from ._models._common import OrderModel as OrderModel
+from ._models._common import OrderStateScope as OrderStateScope
+from ._models._common import OrderState as OrderState
+from ._models._common import PaginatedResponse as PaginatedResponse
+from ._models._common import PaginationParams as PaginationParams
+from ._models._common import ProblemDetail as ProblemDetail
+from ._models._common import SortDirection as SortDirection
+from ._models._common import TrailingStopType as TrailingStopType
+from ._models._common import TransactionType as TransactionType
+from ._models._common import ValidityType as ValidityType
+from ._models._cost_report import CostReport as CostReport
+from ._models._cost_report import CostReportOrderData as CostReportOrderData
+from ._models._cost_report import CostReportPosition as CostReportPosition
+from ._models._modifications import (
+    CalculatedModificationValues as CalculatedModificationValues,
+)
+from ._models._modifications import (
+    CalculatedModificationValuesResponse as CalculatedModificationValuesResponse,
+)
+from ._models._modifications import (
+    ModificationCalculationRequest as ModificationCalculationRequest,
+)
+from ._models._modifications import ModificationCapabilities as ModificationCapabilities
+from ._models._modifications import ModificationHistory as ModificationHistory
+from ._models._modifications import ModificationHistoryEntry as ModificationHistoryEntry
+from ._models._modifications import ModificationProperties as ModificationProperties
+from ._models._modifications import ModificationRequest as ModificationRequest
+from ._models._modifications import ModificationValues as ModificationValues
+from ._models._orders import CalculatedOrder as CalculatedOrder
+from ._models._orders import CalculatedOrderRequest as CalculatedOrderRequest
+from ._models._orders import CalculatedRealtimeOrder as CalculatedRealtimeOrder
+from ._models._orders import (
+    CalculatedRealtimeOrderRequest as CalculatedRealtimeOrderRequest,
+)
+from ._models._orders import CalculationRealtimeResponse as CalculationRealtimeResponse
+from ._models._orders import CalculationResponse as CalculationResponse
+from ._models._orders import Fee as Fee
+from ._models._orders import Order as Order
+from ._models._orders import OrderRequest as OrderRequest
+from ._models._orders import Orders as Orders
+from ._models._orders import RealtimeOrderRequest as RealtimeOrderRequest
+from ._models._portfolios import CryptoAccount as CryptoAccount
+from ._models._portfolios import Portfolio as Portfolio
+from ._models._portfolios import PortfolioType as PortfolioType
+from ._models._portfolios import RestAccount as RestAccount
+from ._models._portfolios import SecurityAccount as SecurityAccount
+from ._models._profile import (
+    CustomerProfileAccountNumbers as CustomerProfileAccountNumbers,
+)
+from ._models._positions import Position as Position
+from ._models._positions import Positions as Positions
+from ._models._tradeability import AssetDetails as AssetDetails
+from ._models._tradeability import Exchange as Exchange
+from ._models._tradeability import RiskHint as RiskHint
+from ._models._tradeability import Tradeability as Tradeability
+from ._models._tradeability import TradeableExchanges as TradeableExchanges
+from ._models._transactions import Transaction as Transaction
+from ._models._transactions import TransactionDetail as TransactionDetail
+from ._models._transactions import TransactionDetailType as TransactionDetailType
+from ._models._transactions import TransactionMode as TransactionMode
+from ._models._transactions import TransactionStatus as TransactionStatus
+from ._models._transactions import TransactionStatusValue as TransactionStatusValue
+from ._resources._account_transactions_requests import (
+    AccountTransactionListFilters as AccountTransactionListFilters,
+)
+from ._resources._orders_requests import OrderListFilters as OrderListFilters
+from ._resources._positions_requests import PositionListFilters as PositionListFilters
+
+__all__ = [
+    # Clients
+    "SmartbrokerClient",
+    "AsyncSmartbrokerClient",
+    # Auth helpers
+    "CachedToken",
+    "FileTokenCache",
+    "ActiveAccount",
+    "ActiveAccountStore",
+    "resolve_cache_dir",
+    "OAuthClient",
+    "AsyncOAuthClient",
+    # OAuth PKCE helpers
+    "generate_code_verifier",
+    "generate_code_challenge",
+    # Exceptions
+    "SmartbrokerApiError",
+    "AuthenticationError",
+    "AuthorizationError",
+    "NotFoundError",
+    "ValidationError",
+    "OrderRejectedError",
+    "InsufficientBalanceError",
+    "BuyingPowerExceededError",
+    "InvalidLimitStepError",
+    "StopLimitTooLowError",
+    "MinimumInvestmentNotReachedError",
+    "PennyStockLimitRequiredError",
+    "NumbersNotAllowedError",
+    "ServerError",
+    "TwoFactorError",
+    "RefreshTokenExpiredError",
+    "TwoFactorTokenExpiredError",
+    "RetryExhaustedError",
+    # Enums — common
+    "OrderDirection",
+    "OrderModel",
+    "ValidityType",
+    "InstrumentType",
+    "AssetQuotation",
+    "OrderState",
+    "TrailingStopType",
+    "SortDirection",
+    "OrderDirectionFilter",
+    "OrderStateScope",
+    # Enums — domain
+    "PortfolioType",
+    "RiskHint",
+    "TokenStatus",
+    "ModificationRequestStatus",
+    "CostReportPositionType",
+    "TransactionType",
+    # Models — common
+    "ProblemDetail",
+    "PaginationParams",
+    "PaginatedResponse",
+    # Models — auth
+    "TokenResponse",
+    "Token",
+    "ApprovalRequiredError",
+    # Models — orders
+    "OrderRequest",
+    "RealtimeOrderRequest",
+    "Fee",
+    "CalculatedOrder",
+    "CalculationResponse",
+    "CalculatedRealtimeOrder",
+    "CalculationRealtimeResponse",
+    "CalculatedOrderRequest",
+    "CalculatedRealtimeOrderRequest",
+    "Order",
+    "Orders",
+    # Models — modifications
+    "ModificationValues",
+    "ModificationCapabilities",
+    "ModificationProperties",
+    "ModificationCalculationRequest",
+    "CalculatedModificationValues",
+    "CalculatedModificationValuesResponse",
+    "ModificationHistoryEntry",
+    "ModificationHistory",
+    "ModificationRequest",
+    # Models — portfolios
+    "RestAccount",
+    "SecurityAccount",
+    "CryptoAccount",
+    "Portfolio",
+    # Models — profile
+    "CustomerProfileAccountNumbers",
+    # Models — positions
+    "Position",
+    "Positions",
+    # Models — tradeability
+    "AssetDetails",
+    "Exchange",
+    "TradeableExchanges",
+    "Tradeability",
+    # Filters
+    "OrderListFilters",
+    "PositionListFilters",
+    "AccountTransactionListFilters",
+    # Models — cost report
+    "CostReport",
+    "CostReportOrderData",
+    "CostReportPosition",
+    # Models — account transactions
+    "AccountTransactions",
+    "RestAccountTransaction",
+    # Models — marketstate
+    "Marketstate",
+    "QuoteData",
+    "CloseData",
+    # Models — transactions
+    "Transaction",
+    "TransactionDetail",
+    "TransactionDetailType",
+    "TransactionMode",
+    "TransactionStatus",
+    "TransactionStatusValue",
+]
+
+__import__("logging").getLogger(__name__).addHandler(
+    __import__("logging").NullHandler(),
+)

smartbroker_plus_sdk/__main__.py

@@ -0,0 +1,9 @@
+"""Entry point for ``python -m smartbroker_plus_sdk``."""
+
+
+def main() -> None:
+    print("hello from smartbroker_plus_sdk")  # noqa: WPS421
+
+
+if __name__ == "__main__":
+    main()

smartbroker_plus_sdk/_auth/_account_prefs/__init__.py

@@ -0,0 +1,8 @@
+"""Account preferences package — preference model and disk store."""
+
+from smartbroker_plus_sdk._auth._account_prefs._account_preferences import (
+    AccountPreferences as AccountPreferences,
+)
+from smartbroker_plus_sdk._auth._account_prefs._account_prefs_store import (
+    AccountPreferencesStore as AccountPreferencesStore,
+)

smartbroker_plus_sdk/_auth/_account_prefs/_account_preferences.py

@@ -0,0 +1,68 @@
+"""AccountPreferences — persisted environment preference for a login account."""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class AccountPreferences:
+    """Persisted environment preference for a single cached account.
+
+    Exactly one of ``environment`` or ``auth_base_override`` must be non-None.
+
+    Args:
+        schema_version: Schema format version; must be 1.
+        environment: Named environment (``"sand"`` or ``"prod"``), or None.
+        auth_base_override: Custom auth base URL, or None.
+    """
+
+    schema_version: int
+    environment: Optional[str]
+    auth_base_override: Optional[str]
+
+    def to_dict(self) -> dict[str, object]:
+        """Serialize to a plain dict for JSON storage.
+
+        Returns:
+            Dict including ``schema_version: 1``.
+        """
+        return {
+            "schema_version": self.schema_version,
+            "environment": self.environment,
+            "auth_base_override": self.auth_base_override,
+        }
+
+    @classmethod
+    def from_dict(cls, source: dict[str, object]) -> "AccountPreferences":
+        """Deserialize from a dict.
+
+        Args:
+            source: Raw dict, typically from JSON.
+
+        Returns:
+            A validated AccountPreferences instance.
+
+        Raises:
+            TypeError: If ``schema_version`` is missing or not equal to 1.
+            ValueError: If invariant is violated (both fields None or both set).
+        """
+        version = source.get("schema_version")
+        if version != 1:
+            raise TypeError(
+                f"Unsupported or missing schema_version: {version!r}. Expected 1."
+            )
+        environment = source.get("environment")
+        auth_base_override = source.get("auth_base_override")
+        # Normalise absent keys to None
+        env_val = environment if isinstance(environment, str) else None
+        auth_val = auth_base_override if isinstance(auth_base_override, str) else None
+        if (env_val is None) == (auth_val is None):
+            raise ValueError(
+                "Exactly one of environment or auth_base_override must be set; "
+                f"got environment={env_val!r}, auth_base_override={auth_val!r}"
+            )
+        return cls(
+            schema_version=1,
+            environment=env_val,
+            auth_base_override=auth_val,
+        )

smartbroker_plus_sdk/_auth/_account_prefs/_account_prefs_store.py

@@ -0,0 +1,133 @@
+"""AccountPreferencesStore — disk-backed store for per-account preferences."""
+
+import json
+import logging
+import os
+import stat
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+from smartbroker_plus_sdk._auth._account_prefs._account_preferences import (
+    AccountPreferences,
+)
+
+logger = logging.getLogger(__name__)
+
+_FILENAME = "account_prefs.json"
+_DIR_MODE = 0o700
+_FILE_MODE = stat.S_IRUSR | stat.S_IWUSR  # 0o600
+
+
+class AccountPreferencesStore:
+    """Persists per-account environment preferences as JSON on disk.
+
+    The store uses a single flat JSON file keyed by ``cache_key_for(account)``
+    (``base_url|client_id``).
+
+    Args:
+        cache_dir: Directory that will contain ``account_prefs.json``.
+    """
+
+    def __init__(self, cache_dir: Path) -> None:
+        self._cache_dir = cache_dir
+        self._path = cache_dir / _FILENAME
+
+    def load(self, key: str) -> Optional[AccountPreferences]:
+        """Load preferences for the given account key.
+
+        Args:
+            key: Cache key (``base_url|client_id``).
+
+        Returns:
+            The stored preferences, or None if the file is missing, corrupt,
+            or the entry is malformed.  Never raises.
+        """
+        store = self._read_store()
+        entry = store.get(key)
+        if entry is None:
+            return None
+        if not isinstance(entry, dict):
+            return None
+        try:
+            return AccountPreferences.from_dict(entry)
+        except (TypeError, ValueError, KeyError):
+            logger.warning("Malformed account_prefs entry for key %r", key)
+            return None
+
+    def save(self, key: str, prefs: AccountPreferences) -> None:
+        """Persist preferences for the given account key.
+
+        Writes atomically via a temp file.  Directory is created with mode
+        ``0700``; file is written with mode ``0600``.
+
+        Args:
+            key: Cache key (``base_url|client_id``).
+            prefs: Preferences to store.
+        """
+        store = self._read_store()
+        store[key] = prefs.to_dict()
+        self._write_store(store)
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _read_store(self) -> dict[str, object]:
+        if not self._path.exists():
+            return {}
+        try:
+            raw = self._path.read_text(encoding="utf-8")
+        except OSError:
+            logger.warning(
+                "Unreadable account_prefs at %s; treating as empty", self._path
+            )
+            return {}
+        try:
+            loaded = json.loads(raw)
+        except json.JSONDecodeError:
+            logger.warning("Corrupt account_prefs at %s; treating as empty", self._path)
+            return {}
+        if not isinstance(loaded, dict):
+            return {}
+        return dict(loaded)
+
+    def _write_store(self, store: dict[str, object]) -> None:
+        self._cache_dir.mkdir(parents=True, exist_ok=True, mode=_DIR_MODE)
+        os.chmod(self._cache_dir, _DIR_MODE)
+
+        fd, tmp_path = tempfile.mkstemp(
+            dir=str(self._cache_dir),
+            suffix=".tmp",
+        )
+        try:
+            self._flush_and_replace(fd, tmp_path, store)
+        except BaseException:
+            _cleanup_temp(fd, tmp_path)
+            raise
+
+    def _flush_and_replace(
+        self,
+        fd: int,
+        tmp_path: str,
+        store: dict[str, object],
+    ) -> None:
+        encoded = json.dumps(store, indent=2).encode("utf-8")
+        os.write(fd, encoded)
+        os.close(fd)
+        os.chmod(tmp_path, _FILE_MODE)
+        os.replace(tmp_path, str(self._path))
+
+
+def _cleanup_temp(fd: int, tmp_path: str) -> None:
+    _try_close_fd(fd)
+    if os.path.exists(tmp_path):
+        os.unlink(tmp_path)
+
+
+def _try_close_fd(fd: int) -> None:
+    try:
+        os.fstat(fd)
+    except OSError:
+        return
+    os.close(fd)

smartbroker_plus_sdk/_auth/_active_account/_active_account.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ActiveAccount:
+    """Identifies a specific Smartbroker+ account environment."""
+
+    base_url: str
+    client_id: str
+
+    def to_dict(self) -> dict[str, str]:
+        """Serialize to a plain dict for JSON storage."""
+        return {"base_url": self.base_url, "client_id": self.client_id}
+
+    @classmethod
+    def from_dict(cls, source: dict[str, object]) -> "ActiveAccount":
+        """Deserialize from a dict, raising ValueError on invalid data."""
+        base_url = source.get("base_url")
+        client_id = source.get("client_id")
+        if not isinstance(base_url, str) or not isinstance(client_id, str):
+            raise ValueError("Invalid active account data")
+        return cls(base_url=base_url, client_id=client_id)

smartbroker_plus_sdk/_auth/_active_account/_active_account_store.py

@@ -0,0 +1,68 @@
+import json
+import logging
+import os
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+from smartbroker_plus_sdk._auth._active_account._active_account import ActiveAccount
+
+logger = logging.getLogger(__name__)
+
+_FILENAME = "active_account.json"
+_DIR_MODE = 0o700
+
+
+class ActiveAccountStore:
+    """Persists the currently active account pointer to disk."""
+
+    def __init__(self, cache_dir: Path) -> None:
+        self._path = cache_dir / _FILENAME
+
+    def load(self) -> Optional[ActiveAccount]:
+        """Load the active account, or None if missing/corrupt."""
+        if not self._path.exists():
+            return None
+        try:
+            raw = json.loads(self._path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            logger.warning("Corrupt active account file at %s", self._path)
+            return None
+        try:
+            return ActiveAccount.from_dict(raw)
+        except (ValueError, KeyError):
+            logger.warning("Corrupt active account file at %s", self._path)
+            return None
+
+    def save(self, account: ActiveAccount) -> None:
+        """Persist the active account pointer."""
+        self._path.parent.mkdir(parents=True, exist_ok=True, mode=_DIR_MODE)
+        fd, staging_path = tempfile.mkstemp(
+            dir=str(self._path.parent),
+            suffix=".tmp",
+        )
+        try:
+            self._write_and_move(fd, staging_path, account)
+        except BaseException:
+            if os.path.exists(staging_path):
+                os.unlink(staging_path)
+            raise
+
+    def clear(self) -> None:
+        """Remove the active account pointer. Idempotent."""
+        self._path.unlink(missing_ok=True)
+
+    @property
+    def path(self) -> Path:
+        """The path to the active account file."""
+        return self._path
+
+    def _write_and_move(
+        self,
+        fd: int,
+        staging_path: str,
+        account: ActiveAccount,
+    ) -> None:
+        with os.fdopen(fd, "w", encoding="utf-8") as fobj:
+            json.dump(account.to_dict(), fobj)
+        os.replace(staging_path, str(self._path))

smartbroker_plus_sdk/_auth/_environments.py

@@ -0,0 +1,91 @@
+"""OAuth environment resolver — Environment enum, AuthEndpoints, resolve().
+
+This module is shared across the CLI and sandbox test harness; it does not
+belong inside ``_cli/``.  CLI code imports from here via the thin re-export
+in ``_cli/_environments.py``.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+_REALM = "smartbroker"
+_API_URL = "https://api.{env}.paas.winning.wocio.de"
+_AUTH_BASE_URL = "https://auth.{env}.paas.winning.wocio.de/realms/{realm}"
+_TOKEN_SUFFIX = "/protocol/openid-connect/token"
+_LOGOUT_SUFFIX = "/protocol/openid-connect/logout"
+
+
+class Environment(str, Enum):
+    """Supported deployment environments."""
+
+    SAND = "sand"
+    PROD = "prod"
+
+
+@dataclass(frozen=True)
+class AuthEndpoints:
+    """Resolved OAuth endpoint URLs for a given environment."""
+
+    api_base_url: str
+    auth_url: str
+    token_url: str
+    logout_url: str
+
+
+def resolve_custom(auth_base: str) -> AuthEndpoints:
+    """Resolve OAuth endpoint URLs for a fully custom auth base URL.
+
+    Used when neither the sand nor prod environment is appropriate and the
+    caller supplies an explicit auth server base (e.g. a self-hosted Keycloak
+    realm URL).  The API base URL is set to ``auth_base`` because no
+    environment-derived API URL is available in this mode.
+
+    Args:
+        auth_base: The auth server base URL ending in the realm path segment
+            (e.g. ``https://sso.example.com/realms/myapp``).
+
+    Returns:
+        A fully populated AuthEndpoints value object.
+    """
+    return AuthEndpoints(
+        api_base_url=auth_base,
+        auth_url=auth_base,
+        token_url=f"{auth_base}{_TOKEN_SUFFIX}",
+        logout_url=f"{auth_base}{_LOGOUT_SUFFIX}",
+    )
+
+
+def resolve(
+    env: Environment,
+    override_auth_base: Optional[str] = None,
+) -> AuthEndpoints:
+    """Resolve OAuth endpoint URLs for the given environment.
+
+    When ``override_auth_base`` is supplied it must end in
+    ``/realms/<realm-name>`` (e.g. ``https://sso.example.com/realms/myapp``)
+    because the token and logout URL suffixes are appended to it verbatim.
+    Supplying a bare base URL (without the realm path segment) will produce
+    malformed endpoint URLs.
+
+    Args:
+        env: The target deployment environment.
+        override_auth_base: When provided, replaces the derived auth base URL
+            for auth_url, token_url, and logout_url. The api_base_url is
+            always derived from env.
+
+    Returns:
+        A fully populated AuthEndpoints value object.
+    """
+    api_base_url = _API_URL.format(env=env.value)
+    auth_base = (
+        _AUTH_BASE_URL.format(env=env.value, realm=_REALM)
+        if override_auth_base is None
+        else override_auth_base
+    )
+    return AuthEndpoints(
+        api_base_url=api_base_url,
+        auth_url=auth_base,
+        token_url=f"{auth_base}{_TOKEN_SUFFIX}",
+        logout_url=f"{auth_base}{_LOGOUT_SUFFIX}",
+    )