finance_dev 0.9.0__py3-none-any.whl

finance_dev/__init__.py

@@ -0,0 +1,18 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: cf03b85e16db
+
+from ._version import (
+    __title__,
+    __version__,
+    __openapi_doc_version__,
+    __gen_version__,
+    __user_agent__,
+)
+from .sdk import *
+from .sdkconfiguration import *
+
+
+VERSION: str = __version__
+OPENAPI_DOC_VERSION = __openapi_doc_version__
+SPEAKEASY_GENERATOR_VERSION = __gen_version__
+USER_AGENT = __user_agent__

finance_dev/_hooks/__init__.py

@@ -0,0 +1,7 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: c1472aa7f52f
+
+from .sdkhooks import *
+from .types import *
+from .registration import *
+from .oauth2scopes import *

finance_dev/_hooks/clientcredentials.py

@@ -0,0 +1,319 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 1ee49412e311
+
+import hashlib
+import httpx
+import threading
+import time
+from .types import (
+    SDKInitHook,
+    BeforeRequestContext,
+    BeforeRequestHook,
+    AfterErrorContext,
+    AfterErrorHook,
+    HookContext,
+)
+from typing import Any, ClassVar, Dict, List, Tuple, Union, Optional
+from urllib.parse import urlparse, urljoin
+from finance_dev.httpclient import HttpClient
+from finance_dev.sdkconfiguration import SDKConfiguration
+
+
+class Credentials:
+    client_id: str
+    client_secret: str
+    token_url: str
+    scopes: Optional[List[str]]
+    additional_properties: Dict[str, str]
+
+    def __init__(
+        self,
+        client_id: str,
+        client_secret: str,
+        token_url: str,
+        scopes: Optional[List[str]],
+        additional_properties: Optional[Dict[str, str]] = None,
+    ):
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.token_url = token_url
+        self.scopes = scopes
+        self.additional_properties = additional_properties or {}
+
+
+class Session:
+    credentials: Credentials
+    token: str
+    scopes: List[str]
+    expires_at: Optional[int] = None
+
+    def __init__(
+        self,
+        credentials: Credentials,
+        token: str,
+        scopes: List[str],
+        expires_at: Optional[int] = None,
+    ):
+        self.credentials = credentials
+        self.token = token
+        self.scopes = scopes
+        self.expires_at = expires_at
+
+
+class ClientCredentialsHook(SDKInitHook, BeforeRequestHook, AfterErrorHook):
+    client: HttpClient
+    _global_lock: ClassVar[threading.Lock] = threading.Lock()
+    _client_locks: ClassVar[Dict[str, threading.Lock]] = {}
+    _sessions: ClassVar[Dict[str, Dict[str, Session]]] = {}
+
+    @classmethod
+    def _get_client_lock(cls, client_key: str) -> threading.Lock:
+        """Get or create a lock for a specific client key (thread-safe)."""
+        with cls._global_lock:
+            if client_key not in cls._client_locks:
+                cls._client_locks[client_key] = threading.Lock()
+            return cls._client_locks[client_key]
+
+    def sdk_init(self, config: SDKConfiguration) -> SDKConfiguration:
+        if config.client is None:
+            raise Exception("Client is required")
+
+        self.client = config.client
+        return config
+
+    def before_request(
+        self, hook_ctx: BeforeRequestContext, request: httpx.Request
+    ) -> httpx.Request:
+        if self.is_hook_disabled(hook_ctx):
+            return request
+
+        credentials = self.get_credentials(hook_ctx)
+        if credentials is None:
+            return request
+
+        session_key = self.get_session_key(
+            credentials.client_id, credentials.client_secret
+        )
+
+        scopes = self.get_required_scopes(credentials, hook_ctx)
+        session = self.get_existing_session(session_key, scopes)
+
+        if session is None:
+            # Create new session
+            session = self.do_token_request(
+                hook_ctx,
+                credentials,
+                scopes,
+            )
+
+            self._store_session(session_key, scopes, session)
+
+        request.headers["Authorization"] = f"Bearer {session.token}"
+
+        return request
+
+    def after_error(
+        self,
+        hook_ctx: AfterErrorContext,
+        response: Optional[httpx.Response],
+        error: Optional[Exception],
+    ) -> Union[Tuple[Optional[httpx.Response], Optional[Exception]], Exception]:
+        if self.is_hook_disabled(hook_ctx):
+            return (response, error)
+
+        # We don't want to refresh the token if the error is not related to the token
+        if error is not None:
+            return (response, error)
+
+        credentials = self.get_credentials(hook_ctx)
+        if credentials is None:
+            return (response, error)
+
+        if response is not None and response.status_code == 401:
+            session_key = self.get_session_key(
+                credentials.client_id, credentials.client_secret
+            )
+            scopes = self.get_required_scopes(credentials, hook_ctx)
+            scope_key = self.get_scope_key(scopes)
+            self.remove_session(session_key, scope_key)
+
+        return (response, error)
+
+    def is_hook_disabled(self, hook_ctx: HookContext) -> bool:
+        return hook_ctx.oauth2_scopes is None
+
+    def get_credentials(self, hook_ctx: HookContext) -> Optional[Credentials]:
+        source = hook_ctx.security_source
+
+        if source is None:
+            return None
+
+        security = source() if callable(source) else source
+
+        return self.get_credentials_global(security)
+
+    def get_credentials_global(self, security: Any) -> Optional[Credentials]:
+        if (
+            security is None
+            or security.client_id is None
+            or security.client_secret is None
+        ):
+            return None
+
+        # Extract additional properties from security object
+        additional_properties = {}
+        for key, value in dict(security).items():
+            if key not in ["client_id", "client_secret", "token_url", "scopes"]:
+                additional_properties[key] = value
+
+        return Credentials(
+            client_id=security.client_id,
+            client_secret=security.client_secret,
+            token_url=security.token_url,
+            scopes=None,
+            additional_properties=additional_properties,
+        )
+
+    def do_token_request(
+        self, hook_ctx: HookContext, credentials: Credentials, scopes: List[str]
+    ) -> Session:
+        payload = {
+            "grant_type": "client_credentials",
+            "client_id": credentials.client_id,
+            "client_secret": credentials.client_secret,
+        }
+
+        if len(scopes) > 0:
+            payload["scope"] = " ".join(scopes)
+
+        # Add additional properties to payload
+        for key, value in credentials.additional_properties.items():
+            payload[key] = value
+
+        token_url = credentials.token_url
+        if not bool(urlparse(credentials.token_url).netloc):
+            token_url = urljoin(hook_ctx.base_url, credentials.token_url)
+        response = self.client.send(
+            self.client.build_request(method="POST", url=token_url, data=payload)
+        )
+
+        if response.status_code < 200 or response.status_code >= 300:
+            raise Exception(
+                f"Unexpected status code {response.status_code} from token endpoint"
+            )
+
+        response_data = response.json()
+
+        if response_data.get("token_type", "").lower() != "bearer":
+            raise Exception("Unexpected token type from token endpoint")
+
+        expires_at = None
+        if "expires_in" in response_data:
+            expires_at = int(time.time()) + response_data.get("expires_in")
+
+        return Session(
+            credentials=credentials,
+            token=response_data.get("access_token"),
+            scopes=scopes,
+            expires_at=expires_at,
+        )
+
+    def get_session_key(self, client_id: str, client_secret: str) -> str:
+        """Generate a consistent session key for the given client ID and secret."""
+        return hashlib.md5(f"{client_id}:{client_secret}".encode()).hexdigest()
+
+    def get_required_scopes(
+        self, credentials: Credentials, hook_ctx: HookContext
+    ) -> List[str]:
+        """Return the list of scopes that need to be requested."""
+        if credentials.scopes is not None:
+            return credentials.scopes
+        return hook_ctx.oauth2_scopes or []
+
+    def get_scope_key(self, scopes: List[str]) -> str:
+        """Generate a consistent scope key for the given scopes."""
+        if not scopes:
+            return ""
+
+        sorted_scopes = sorted(scopes)
+        return "&".join(sorted_scopes)
+
+    def _store_session(
+        self, client_key: str, scopes: List[str], session: Session
+    ) -> None:
+        """Store a session in the cache (thread-safe with per-client locking)."""
+        scope_key = self.get_scope_key(scopes)
+        lock = self._get_client_lock(client_key)
+        with lock:
+            if client_key not in self._sessions:
+                self._sessions[client_key] = {}
+            self._sessions[client_key][scope_key] = session
+
+    def remove_session(self, client_key: str, scope_key: str) -> None:
+        """Remove a session and clean up empty client session maps (thread-safe with per-client locking)."""
+        lock = self._get_client_lock(client_key)
+        with lock:
+            if client_key in self._sessions and scope_key in self._sessions[client_key]:
+                del self._sessions[client_key][scope_key]
+
+                # Clean up empty client sessions
+                if not self._sessions[client_key]:
+                    del self._sessions[client_key]
+
+    def get_existing_session(
+        self, client_key: str, required_scopes: List[str]
+    ) -> Optional[Session]:
+        """Find the best session for the required scopes (thread-safe with per-client locking)."""
+        scope_key = self.get_scope_key(required_scopes)
+        expired_keys: List[str] = []
+        result: Optional[Session] = None
+
+        lock = self._get_client_lock(client_key)
+        with lock:
+            if client_key not in self._sessions:
+                return None
+
+            client_sessions = self._sessions[client_key]
+
+            # Check for exact scope match first
+            if scope_key in client_sessions:
+                exact_match = client_sessions[scope_key]
+                if self.has_token_expired(exact_match.expires_at):
+                    expired_keys.append(scope_key)
+                else:
+                    result = exact_match
+
+            # If no exact match, look for a superset match
+            if result is None:
+                for key, session in client_sessions.items():
+                    if self.has_token_expired(session.expires_at):
+                        expired_keys.append(key)
+                    elif result is None and self.has_required_scopes(
+                        session.scopes, required_scopes
+                    ):
+                        result = session
+
+            # Clean up expired sessions (safe: we collected keys first, not iterating while modifying)
+            for key in expired_keys:
+                if key in client_sessions:
+                    del client_sessions[key]
+
+            # Clean up empty client sessions
+            if client_key in self._sessions and not self._sessions[client_key]:
+                del self._sessions[client_key]
+
+        return result
+
+    def has_required_scopes(
+        self, scopes: List[str], required_scopes: List[str]
+    ) -> bool:
+        """Check if all required scopes are present in the given scopes."""
+        return all(scope in scopes for scope in required_scopes)
+
+    def has_token_expired(self, expires_at: Optional[int]) -> bool:
+        """
+        Check if the token has expired.
+        If no expires_in field was returned by the authorization server, the token is considered to never expire.
+        A 60-second buffer is applied to refresh tokens before they actually expire.
+        """
+        return expires_at is not None and time.time() + 60 >= expires_at

finance_dev/_hooks/oauth2scopes.py

@@ -0,0 +1,50 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 9f26a4e27905
+
+from enum import Enum
+
+
+class OAuth2Scope(str, Enum):
+    r"""Available scopes for the OAuth2 OAuth 2.0 scheme (clientCredentials flow).
+
+    OAuth2 Bearer token: obtain an access token from the token endpoint and send it in the Authorization header.
+    """
+
+    ACCOUNT_INFORMATION = "account:information"
+    r"""View account balances, positions, and transaction history"""
+
+    ANALYTICS_INFORMATION = "analytics:information"
+    r"""View analytics, ratings, and market insights"""
+
+    CALENDAR_INFORMATION = "calendar:information"
+    r"""Access earnings, economic, and market schedule data"""
+
+    MARKET_INFORMATION = "market:information"
+    r"""Access live and historical market data"""
+
+    MARKET_SUPPLEMENTAL = "market:supplemental"
+    r"""News, company profiles, financials, filings, ETF data, technical analysis"""
+
+    OPTIONS_INFORMATION = "options:information"
+    r"""Access options chains and expiration data"""
+
+    ORDER_EXECUTION = "order:execution"
+    r"""Place, modify, and cancel orders"""
+
+    ORDER_INFORMATION = "order:information"
+    r"""View order history and status"""
+
+    POSITION_INFORMATION = "position:information"
+    r"""View current positions and holdings"""
+
+    USER_INFORMATION = "user:information"
+    r"""View user profile and personal details"""
+
+    USER_MANAGEMENT = "user:management"
+    r"""Manage user-scoped resources and saved configuration (internal)."""
+
+    WATCHLIST_INFORMATION = "watchlist:information"
+    r"""View your watchlists and their symbols."""
+
+    WATCHLIST_MANAGEMENT = "watchlist:management"
+    r"""Create, update, replace, and delete your watchlists."""

finance_dev/_hooks/registration.py

@@ -0,0 +1,13 @@
+from .types import Hooks
+
+
+# This file is only ever generated once on the first generation and then is free to be modified.
+# Any hooks you wish to add should be registered in the init_hooks function. Feel free to define them
+# in this file or in separate files in the hooks folder.
+
+
+def init_hooks(hooks: Hooks):
+    # pylint: disable=unused-argument
+    """Add hooks by calling hooks.register{sdk_init/before_request/after_success/after_error}Hook
+    with an instance of a hook that implements that specific Hook interface
+    Hooks are registered per SDK instance, and are valid for the lifetime of the SDK instance"""

finance_dev/_hooks/sdkhooks.py

@@ -0,0 +1,82 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 4433dbe03188
+
+import httpx
+from .clientcredentials import ClientCredentialsHook
+from .types import (
+    SDKInitHook,
+    BeforeRequestContext,
+    BeforeRequestHook,
+    AfterSuccessContext,
+    AfterSuccessHook,
+    AfterErrorContext,
+    AfterErrorHook,
+    Hooks,
+)
+from .registration import init_hooks
+from typing import List, Optional, Tuple
+from finance_dev.sdkconfiguration import SDKConfiguration
+
+
+class SDKHooks(Hooks):
+    def __init__(self) -> None:
+        self.sdk_init_hooks: List[SDKInitHook] = []
+        self.before_request_hooks: List[BeforeRequestHook] = []
+        self.after_success_hooks: List[AfterSuccessHook] = []
+        self.after_error_hooks: List[AfterErrorHook] = []
+        client_credentials = ClientCredentialsHook()
+        self.sdk_init_hooks.append(client_credentials)
+        self.before_request_hooks.append(client_credentials)
+        self.after_error_hooks.append(client_credentials)
+        init_hooks(self)
+
+    def register_sdk_init_hook(self, hook: SDKInitHook) -> None:
+        self.sdk_init_hooks.append(hook)
+
+    def register_before_request_hook(self, hook: BeforeRequestHook) -> None:
+        self.before_request_hooks.append(hook)
+
+    def register_after_success_hook(self, hook: AfterSuccessHook) -> None:
+        self.after_success_hooks.append(hook)
+
+    def register_after_error_hook(self, hook: AfterErrorHook) -> None:
+        self.after_error_hooks.append(hook)
+
+    def sdk_init(self, config: SDKConfiguration) -> SDKConfiguration:
+        for hook in self.sdk_init_hooks:
+            config = hook.sdk_init(config)
+        return config
+
+    def before_request(
+        self, hook_ctx: BeforeRequestContext, request: httpx.Request
+    ) -> httpx.Request:
+        for hook in self.before_request_hooks:
+            out = hook.before_request(hook_ctx, request)
+            if isinstance(out, Exception):
+                raise out
+            request = out
+
+        return request
+
+    def after_success(
+        self, hook_ctx: AfterSuccessContext, response: httpx.Response
+    ) -> httpx.Response:
+        for hook in self.after_success_hooks:
+            out = hook.after_success(hook_ctx, response)
+            if isinstance(out, Exception):
+                raise out
+            response = out
+        return response
+
+    def after_error(
+        self,
+        hook_ctx: AfterErrorContext,
+        response: Optional[httpx.Response],
+        error: Optional[Exception],
+    ) -> Tuple[Optional[httpx.Response], Optional[Exception]]:
+        for hook in self.after_error_hooks:
+            result = hook.after_error(hook_ctx, response, error)
+            if isinstance(result, Exception):
+                raise result
+            response, error = result
+        return response, error

finance_dev/_hooks/types.py

@@ -0,0 +1,125 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: a8f278e0b7e7
+
+from abc import ABC, abstractmethod
+from finance_dev.sdkconfiguration import SDKConfiguration
+import httpx
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+
+class HookContext:
+    config: SDKConfiguration
+    base_url: str
+    operation_id: str
+    oauth2_scopes: Optional[List[str]] = None
+    security_source: Optional[Union[Any, Callable[[], Any]]] = None
+    tags: Optional[List[str]] = None
+    extensions: Optional[Dict[str, Any]] = None
+
+    def __init__(
+        self,
+        config: SDKConfiguration,
+        base_url: str,
+        operation_id: str,
+        oauth2_scopes: Optional[List[str]],
+        security_source: Optional[Union[Any, Callable[[], Any]]],
+        tags: Optional[List[str]],
+        extensions: Optional[Dict[str, Any]],
+    ):
+        self.config = config
+        self.base_url = base_url
+        self.operation_id = operation_id
+        self.oauth2_scopes = oauth2_scopes
+        self.security_source = security_source
+        self.tags = tags
+        self.extensions = extensions
+
+
+class BeforeRequestContext(HookContext):
+    def __init__(self, hook_ctx: HookContext):
+        super().__init__(
+            hook_ctx.config,
+            hook_ctx.base_url,
+            hook_ctx.operation_id,
+            hook_ctx.oauth2_scopes,
+            hook_ctx.security_source,
+            hook_ctx.tags,
+            hook_ctx.extensions,
+        )
+
+
+class AfterSuccessContext(HookContext):
+    def __init__(self, hook_ctx: HookContext):
+        super().__init__(
+            hook_ctx.config,
+            hook_ctx.base_url,
+            hook_ctx.operation_id,
+            hook_ctx.oauth2_scopes,
+            hook_ctx.security_source,
+            hook_ctx.tags,
+            hook_ctx.extensions,
+        )
+
+
+class AfterErrorContext(HookContext):
+    def __init__(self, hook_ctx: HookContext):
+        super().__init__(
+            hook_ctx.config,
+            hook_ctx.base_url,
+            hook_ctx.operation_id,
+            hook_ctx.oauth2_scopes,
+            hook_ctx.security_source,
+            hook_ctx.tags,
+            hook_ctx.extensions,
+        )
+
+
+class SDKInitHook(ABC):
+    @abstractmethod
+    def sdk_init(self, config: SDKConfiguration) -> SDKConfiguration:
+        pass
+
+
+class BeforeRequestHook(ABC):
+    @abstractmethod
+    def before_request(
+        self, hook_ctx: BeforeRequestContext, request: httpx.Request
+    ) -> Union[httpx.Request, Exception]:
+        pass
+
+
+class AfterSuccessHook(ABC):
+    @abstractmethod
+    def after_success(
+        self, hook_ctx: AfterSuccessContext, response: httpx.Response
+    ) -> Union[httpx.Response, Exception]:
+        pass
+
+
+class AfterErrorHook(ABC):
+    @abstractmethod
+    def after_error(
+        self,
+        hook_ctx: AfterErrorContext,
+        response: Optional[httpx.Response],
+        error: Optional[Exception],
+    ) -> Union[Tuple[Optional[httpx.Response], Optional[Exception]], Exception]:
+        pass
+
+
+class Hooks(ABC):
+    @abstractmethod
+    def register_sdk_init_hook(self, hook: SDKInitHook):
+        pass
+
+    @abstractmethod
+    def register_before_request_hook(self, hook: BeforeRequestHook):
+        pass
+
+    @abstractmethod
+    def register_after_success_hook(self, hook: AfterSuccessHook):
+        pass
+
+    @abstractmethod
+    def register_after_error_hook(self, hook: AfterErrorHook):
+        pass

finance_dev/_version.py

@@ -0,0 +1,16 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 31abe97f59a6
+
+import importlib.metadata
+
+__title__: str = "finance_dev"
+__version__: str = "0.9.0"
+__openapi_doc_version__: str = "1.0.0"
+__gen_version__: str = "2.948.4"
+__user_agent__: str = "speakeasy-sdk/python 0.9.0 2.948.4 1.0.0 finance_dev"
+
+try:
+    if __package__ is not None:
+        __version__ = importlib.metadata.version(__package__)
+except importlib.metadata.PackageNotFoundError:
+    pass