publicdotcom-py 0.1.0__py3-none-any.whl

public_api_sdk/__init__.py

@@ -0,0 +1,111 @@
+from .auth_config import AuthConfig, ApiKeyAuthConfig, OAuthAuthConfig
+from .exceptions import APIError, AuthenticationError, RateLimitError
+from .models import (
+    Account,
+    AccountType,
+    HistoryRequest,
+    HistoryResponsePage,
+    InstrumentsRequest,
+    InstrumentsResponse,
+    InstrumentType,
+    Trading,
+    OptionChainRequest,
+    OptionChainResponse,
+    OptionExpirationsRequest,
+    OptionExpirationsResponse,
+    OrderExpirationRequest,
+    OrderInstrument,
+    OrderSide,
+    OrderType,
+    Order,
+    OrderRequest,
+    OrderResponse,
+    OrderStatus,
+    NewOrder,
+    OrderUpdate,
+    OrderSubscriptionConfig,
+    WaitTimeoutError,
+    PreflightRequest,
+    PreflightMultiLegRequest,
+    PreflightMultiLegResponse,
+    MultilegOrderRequest,
+    MultilegOrderResult,
+    OptionGreeks,
+    Portfolio,
+    TimeInForce,
+    LegInstrument,
+    LegInstrumentType,
+    OpenCloseIndicator,
+    OrderLegRequest,
+    Quote,
+    QuoteOutcome,
+    PriceChange,
+    PriceChangeCallback,
+    SubscriptionConfig,
+    SubscriptionStatus,
+    Subscription,
+    SubscriptionInfo,
+)
+from .public_api_client import PublicApiClient, PublicApiClientConfiguration
+from .subscription_manager import PriceSubscriptionManager
+from .price_stream import PriceStream
+
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AuthConfig",
+    "ApiKeyAuthConfig", 
+    "OAuthAuthConfig",
+    "Account",
+    "AccountType",
+    "HistoryRequest",
+    "HistoryResponsePage",
+    "InstrumentsRequest",
+    "InstrumentsResponse",
+    "InstrumentType",
+    "Trading",
+    "OptionChainRequest",
+    "OptionChainResponse",
+    "OptionExpirationsRequest",
+    "OptionExpirationsResponse",
+    "OrderExpirationRequest",
+    "OrderInstrument",
+    "OrderSide",
+    "OrderType",
+    "Order",
+    "OrderRequest",
+    "OrderResponse",
+    "OrderStatus",
+    "NewOrder",
+    "OrderUpdate",
+    "OrderSubscriptionConfig",
+    "WaitTimeoutError",
+    "PreflightRequest",
+    "PreflightMultiLegRequest",
+    "PreflightMultiLegResponse",
+    "MultilegOrderRequest",
+    "MultilegOrderResult",
+    "LegInstrument",
+    "LegInstrumentType",
+    "OpenCloseIndicator",
+    "OrderLegRequest",
+    "OptionGreeks",
+    "Portfolio",
+    "TimeInForce",
+    "Quote",
+    "QuoteOutcome",
+    "PriceChange",
+    "PriceChangeCallback",
+    "SubscriptionConfig",
+    "SubscriptionStatus",
+    "Subscription",
+    "SubscriptionInfo",
+    "PublicApiClient",
+    "PublicApiClientConfiguration",
+    "PriceSubscriptionManager",
+    "PriceStream",
+    "APIError",
+    "AuthenticationError",
+    "RateLimitError",
+]

public_api_sdk/api_client.py

@@ -0,0 +1,181 @@
+import json
+from typing import Any, Dict, Optional
+from urllib.parse import urljoin
+
+import requests
+from requests.adapters import HTTPAdapter, BaseAdapter
+from urllib3.util.retry import Retry
+
+from .exceptions import (
+    APIError,
+    AuthenticationError,
+    NotFoundError,
+    RateLimitError,
+    ServerError,
+    ValidationError,
+)
+
+
+class BlockHTTPAdapter(BaseAdapter):
+    def send(self, request, **kwargs):
+        raise RuntimeError("Insecure HTTP requests are not allowed. Use HTTPS endpoints only.")
+
+    def close(self):
+        pass
+
+
+class ApiClient:
+    """HTTP client with error handling and retry logic."""
+
+    def __init__(
+        self,
+        base_url: str,
+        timeout: int = 30,
+        max_retries: int = 3,
+        backoff_factor: float = 0.3,
+    ) -> None:
+        """Initialize the base client.
+
+        Args:
+            base_url: Base URL for the API
+            timeout: Request timeout in seconds
+            max_retries: Maximum number of retries for failed requests
+            backoff_factor: Backoff factor for retry delays
+        """
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+        # create session with retry strategy
+        self.session = requests.Session()
+        retry_strategy = Retry(
+            total=max_retries,
+            status_forcelist=[429, 500, 502, 503, 504],
+            backoff_factor=backoff_factor,
+            allowed_methods=["HEAD", "GET", "OPTIONS"],
+        )
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+        self.session.mount("http://", BlockHTTPAdapter())
+        self.session.mount("https://", adapter)
+
+        # default headers
+        version = self._get_version()
+        self.session.headers.update(
+            {
+                "Content-Type": "application/json",
+                "User-Agent": f"public-python-api-sdk-{version}",
+                "X-App-Version": f"public-python-api-sdk-{version}",
+            }
+        )
+
+    def _get_version(self) -> str:
+        """Get the package version."""
+        try:
+            # Import here to avoid circular import during module initialization
+            from . import __version__
+            return __version__
+        except (ImportError, AttributeError):
+            # Fallback if version is not available
+            return "0.1.0"
+
+    def set_auth_header(self, token: str) -> None:
+        """Set the `Authorization` header with a bearer token."""
+        self.session.headers["Authorization"] = f"Bearer {token}"
+
+    def remove_auth_header(self) -> None:
+        """Remove the Authorization header."""
+        self.session.headers.pop("Authorization", None)
+
+    def _build_url(self, endpoint: str) -> str:
+        """Build full URL from endpoint."""
+        return urljoin(self.base_url + "/", endpoint.lstrip("/"))
+
+    def _handle_response(self, response: requests.Response) -> Dict[str, Any]:
+        """Handle HTTP response and raise appropriate exceptions."""
+        try:
+            response_data = response.json() if response.content else {}
+        except json.JSONDecodeError:
+            response_data = {"raw_content": response.text}
+
+        if response.status_code == 200:
+            return response_data
+
+        # extract error message from response
+        error_message = response_data.get("message", "Unknown error")
+        if isinstance(error_message, dict):
+            error_message = str(error_message)
+
+        # raise specific exceptions based on status code
+        if response.status_code == 401:
+            raise AuthenticationError(
+                error_message, response.status_code, response_data
+            )
+        elif response.status_code == 400:
+            raise ValidationError(error_message, response.status_code, response_data)
+        elif response.status_code == 404:
+            raise NotFoundError(error_message, response.status_code, response_data)
+        elif response.status_code == 429:
+            retry_after = response.headers.get("Retry-After")
+            retry_after_int = int(retry_after) if retry_after else None
+            raise RateLimitError(
+                error_message, response.status_code, retry_after_int, response_data
+            )
+        elif 500 <= response.status_code < 600:
+            raise ServerError(error_message, response.status_code, response_data)
+        else:
+            raise APIError(error_message, response.status_code, response_data)
+
+    def get(
+        self,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        url = self._build_url(endpoint)
+        response = self.session.get(url, params=params, timeout=self.timeout, **kwargs)
+        return self._handle_response(response)
+
+    def post(
+        self,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        url = self._build_url(endpoint)
+        response = self.session.post(
+            url,
+            data=data,
+            json=json_data,
+            timeout=self.timeout,
+            **kwargs,
+        )
+        return self._handle_response(response)
+
+    def put(
+        self,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        url = self._build_url(endpoint)
+        response = self.session.put(
+            url,
+            data=data,
+            json=json_data,
+            timeout=self.timeout,
+            **kwargs,
+        )
+        return self._handle_response(response)
+
+    def delete(
+        self,
+        endpoint: str,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        url = self._build_url(endpoint)
+        response = self.session.delete(url, timeout=self.timeout, **kwargs)
+        return self._handle_response(response)
+
+    def close(self) -> None:
+        self.session.close()

public_api_sdk/auth_config.py

@@ -0,0 +1,90 @@
+from typing import Optional, Protocol, TYPE_CHECKING
+
+from .auth_provider import ApiKeyAuthProvider, OAuthAuthProvider
+
+if TYPE_CHECKING:
+    from .api_client import ApiClient
+    from .auth_provider import AuthProvider
+
+
+class AuthConfig(Protocol):  # pylint: disable=too-few-public-methods
+    """Protocol for authentication configuration."""
+
+    def create_provider(self, api_client: "ApiClient") -> "AuthProvider":
+        """Create an auth provider instance with the given API client.
+
+        Args:
+            api_client: API client for making HTTP requests
+
+        Returns:
+            Configured auth provider instance
+        """
+
+
+class ApiKeyAuthConfig:  # pylint: disable=too-few-public-methods
+    """Configuration for API key authentication."""
+
+    def __init__(self, api_secret_key: str, validity_minutes: int = 15) -> None:
+        """Initialize API key auth configuration.
+
+        Args:
+            api_secret_key: API secret key generated in the Public API settings page (secret)
+            validity_minutes: Token validity in minutes (5-1440)
+        """
+        if not 5 <= validity_minutes <= 1440:
+            raise ValueError("Validity must be between 5 and 1440 minutes")
+
+        self.api_secret_key = api_secret_key
+        self.validity_minutes = validity_minutes
+
+    def create_provider(self, api_client: "ApiClient") -> "AuthProvider":
+        return ApiKeyAuthProvider(
+            api_client=api_client,
+            api_secret_key=self.api_secret_key,
+            validity_minutes=self.validity_minutes,
+        )
+
+
+class OAuthAuthConfig:  # pylint: disable=too-few-public-methods
+    """Configuration for OAuth2 authentication."""
+
+    def __init__(
+        self,
+        client_id: str,
+        redirect_uri: str,
+        client_secret: Optional[str] = None,
+        scope: Optional[str] = None,
+        use_pkce: bool = True,
+        authorization_base_url: str = "/userapiauthservice/oauth2/authorize",
+        token_url: str = "/userapiauthservice/oauth2/token",
+    ) -> None:
+        """Initialize OAuth auth configuration.
+
+        Args:
+            client_id: OAuth client ID
+            redirect_uri: Redirect URI for OAuth flow
+            client_secret: OAuth client secret (optional for public clients)
+            scope: Space-separated list of scopes
+            use_pkce: Whether to use PKCE for enhanced security
+            authorization_base_url: Authorization endpoint path
+            token_url: Token exchange endpoint path
+        """
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.redirect_uri = redirect_uri
+        self.scope = scope
+        self.use_pkce = use_pkce
+        self.authorization_base_url = authorization_base_url
+        self.token_url = token_url
+
+    def create_provider(self, api_client: "ApiClient") -> "AuthProvider":
+        return OAuthAuthProvider(
+            api_client=api_client,
+            client_id=self.client_id,
+            client_secret=self.client_secret,
+            redirect_uri=self.redirect_uri,
+            scope=self.scope,
+            use_pkce=self.use_pkce,
+            authorization_base_url=self.authorization_base_url,
+            token_url=self.token_url,
+        )

public_api_sdk/auth_manager.py

@@ -0,0 +1,38 @@
+"""Authentication manager for managing access tokens"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .auth_provider import AuthProvider
+
+
+class AuthManager:
+    """Authentication manager that delegates to auth providers"""
+
+    def __init__(self, auth_provider: "AuthProvider") -> None:
+        """Initialize the authentication manager.
+
+        Args:
+            auth_provider: Authentication provider (already initialized with ApiClient)
+        """
+        super().__init__()
+
+        self.auth_provider = auth_provider
+        self.initialize_auth()
+
+    def initialize_auth(self) -> None:
+        """Initialize authentication by getting the first token."""
+        try:
+            # try to get an access token (will create one for API key auth)
+            self.auth_provider.get_access_token()
+        except ValueError:
+            # for oauth, user needs to complete the flow first
+            pass
+
+    def refresh_token_if_needed(self) -> None:
+        """Refresh the access token if it's expired or about to expire."""
+        self.auth_provider.refresh_if_needed()
+
+    def revoke_current_token(self) -> None:
+        """Revoke the current access token and clear it from memory."""
+        self.auth_provider.revoke_token()