finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/stockquotesresponse.py

@@ -0,0 +1,170 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 9a60e9279e12
+
+from __future__ import annotations
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class StockQuotesResponseResultTypedDict(TypedDict):
+    ask_exchange: NotRequired[int]
+    r"""Ask exchange ID"""
+    ask_price: NotRequired[float]
+    r"""Ask price"""
+    ask_size: NotRequired[float]
+    r"""Ask size"""
+    bid_exchange: NotRequired[int]
+    r"""Bid exchange ID"""
+    bid_price: NotRequired[float]
+    r"""Bid price"""
+    bid_size: NotRequired[float]
+    r"""Bid size"""
+    conditions: NotRequired[List[int]]
+    r"""Quote conditions"""
+    indicators: NotRequired[List[int]]
+    r"""Quote indicators"""
+    participant_timestamp: NotRequired[int]
+    r"""Participant timestamp"""
+    sequence_number: NotRequired[int]
+    r"""Sequence number"""
+    sip_timestamp: NotRequired[int]
+    r"""SIP timestamp"""
+    tape: NotRequired[int]
+    r"""Tape"""
+    trf_timestamp: NotRequired[int]
+    r"""TRF timestamp"""
+
+
+class StockQuotesResponseResult(BaseModel):
+    ask_exchange: Annotated[Optional[int], pydantic.Field(alias="askExchange")] = None
+    r"""Ask exchange ID"""
+
+    ask_price: Annotated[Optional[float], pydantic.Field(alias="askPrice")] = None
+    r"""Ask price"""
+
+    ask_size: Annotated[Optional[float], pydantic.Field(alias="askSize")] = None
+    r"""Ask size"""
+
+    bid_exchange: Annotated[Optional[int], pydantic.Field(alias="bidExchange")] = None
+    r"""Bid exchange ID"""
+
+    bid_price: Annotated[Optional[float], pydantic.Field(alias="bidPrice")] = None
+    r"""Bid price"""
+
+    bid_size: Annotated[Optional[float], pydantic.Field(alias="bidSize")] = None
+    r"""Bid size"""
+
+    conditions: Optional[List[int]] = None
+    r"""Quote conditions"""
+
+    indicators: Optional[List[int]] = None
+    r"""Quote indicators"""
+
+    participant_timestamp: Annotated[
+        Optional[int], pydantic.Field(alias="participantTimestamp")
+    ] = None
+    r"""Participant timestamp"""
+
+    sequence_number: Annotated[
+        Optional[int], pydantic.Field(alias="sequenceNumber")
+    ] = None
+    r"""Sequence number"""
+
+    sip_timestamp: Annotated[Optional[int], pydantic.Field(alias="sipTimestamp")] = None
+    r"""SIP timestamp"""
+
+    tape: Optional[int] = None
+    r"""Tape"""
+
+    trf_timestamp: Annotated[Optional[int], pydantic.Field(alias="trfTimestamp")] = None
+    r"""TRF timestamp"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "askExchange",
+                "askPrice",
+                "askSize",
+                "bidExchange",
+                "bidPrice",
+                "bidSize",
+                "conditions",
+                "indicators",
+                "participantTimestamp",
+                "sequenceNumber",
+                "sipTimestamp",
+                "tape",
+                "trfTimestamp",
+            ]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class StockQuotesResponseTypedDict(TypedDict):
+    r"""Paginated list of historical NBBO quotes for a stock ticker."""
+
+    next_url: NotRequired[str]
+    r"""URL for next page of results"""
+    request_id: NotRequired[str]
+    r"""Unique request ID"""
+    results: NotRequired[List[StockQuotesResponseResultTypedDict]]
+    r"""Array of NBBO quote objects"""
+    status: NotRequired[str]
+    r"""Status string from the upstream data provider — typically `OK` for a successful response. Treat any other value as an error indicator alongside the HTTP status code."""
+
+
+class StockQuotesResponse(BaseModel):
+    r"""Paginated list of historical NBBO quotes for a stock ticker."""
+
+    next_url: Annotated[Optional[str], pydantic.Field(alias="nextUrl")] = None
+    r"""URL for next page of results"""
+
+    request_id: Annotated[Optional[str], pydantic.Field(alias="requestId")] = None
+    r"""Unique request ID"""
+
+    results: Optional[List[StockQuotesResponseResult]] = None
+    r"""Array of NBBO quote objects"""
+
+    status: Optional[str] = None
+    r"""Status string from the upstream data provider — typically `OK` for a successful response. Treat any other value as an error indicator alongside the HTTP status code."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["nextUrl", "requestId", "results", "status"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+try:
+    StockQuotesResponseResult.model_rebuild()
+except NameError:
+    pass
+try:
+    StockQuotesResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/stockscreenerop.py

@@ -0,0 +1,144 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: c7990651d6df
+
+from __future__ import annotations
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .sortorderenum import SortOrderEnum
+from .stockscreenerrequest import StockScreenerRequest, StockScreenerRequestTypedDict
+from .stockscreenerresponse import StockScreenerResponse, StockScreenerResponseTypedDict
+from finance_dev import models
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from finance_dev.utils import FieldMetadata, QueryParamMetadata, RequestMetadata
+import pydantic
+from pydantic import field_serializer, model_serializer
+from typing import List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class StockScreenerRequestRequestTypedDict(TypedDict):
+    stock_screener_request: StockScreenerRequestTypedDict
+    r"""Screener request with operator (AND, OR, or NOT), clauses (field, operator, value), and optional groups."""
+    page_size: NotRequired[int]
+    r"""Number of results to return per page. Use smaller values (10–50) for UI screens, larger (100–500) for batch exports. Defaults to the upstream provider's default."""
+    order_column: NotRequired[str]
+    r"""Which data column to sort the screened results by. Accepts any column the upstream screener exposes — not a fixed enum on our side. Common columns:
+    - `marketcap` — market capitalization.
+    - `pricetoearnings` — trailing P/E ratio.
+    - `pricetobook` — price-to-book ratio.
+    - `roe` — return on equity.
+    - `volume` — average daily volume.
+    - `open_price` / `close_price` — most recent open / close.
+    - `dilutedeps` — diluted earnings per share (TTM).
+    - `cashandequivalents` — cash + cash equivalents on the balance sheet.
+
+    Pair with `order_direction` (`asc` / `desc`).
+    """
+    order_direction: NotRequired[SortOrderEnum]
+    r"""Direction to sort `order_column` in:
+    - `asc` — ascending (smallest first).
+    - `desc` — descending (largest first).
+    """
+    primary_only: NotRequired[str]
+    r"""When `true`, return only the primary listing for each company (e.g. NYSE for a U.S. dual-listed stock) instead of every listing. Defaults to `false`."""
+
+
+class StockScreenerRequestRequest(BaseModel):
+    stock_screener_request: Annotated[
+        StockScreenerRequest,
+        FieldMetadata(request=RequestMetadata(media_type="application/json")),
+    ]
+    r"""Screener request with operator (AND, OR, or NOT), clauses (field, operator, value), and optional groups."""
+
+    page_size: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Number of results to return per page. Use smaller values (10–50) for UI screens, larger (100–500) for batch exports. Defaults to the upstream provider's default."""
+
+    order_column: Annotated[
+        Optional[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Which data column to sort the screened results by. Accepts any column the upstream screener exposes — not a fixed enum on our side. Common columns:
+    - `marketcap` — market capitalization.
+    - `pricetoearnings` — trailing P/E ratio.
+    - `pricetobook` — price-to-book ratio.
+    - `roe` — return on equity.
+    - `volume` — average daily volume.
+    - `open_price` / `close_price` — most recent open / close.
+    - `dilutedeps` — diluted earnings per share (TTM).
+    - `cashandequivalents` — cash + cash equivalents on the balance sheet.
+
+    Pair with `order_direction` (`asc` / `desc`).
+    """
+
+    order_direction: Annotated[
+        Optional[SortOrderEnum],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Direction to sort `order_column` in:
+    - `asc` — ascending (smallest first).
+    - `desc` — descending (largest first).
+    """
+
+    primary_only: Annotated[
+        Optional[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""When `true`, return only the primary listing for each company (e.g. NYSE for a U.S. dual-listed stock) instead of every listing. Defaults to `false`."""
+
+    @field_serializer("order_direction")
+    def serialize_order_direction(self, value):
+        if isinstance(value, str):
+            try:
+                return models.SortOrderEnum(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["page_size", "order_column", "order_direction", "primary_only"]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class StockScreenerResponseResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    stock_screener_response: NotRequired[List[StockScreenerResponseTypedDict]]
+    r"""Array of screened securities; each item has security (id, ticker, name, etc.) and data (array of tag, number_value, text_value)"""
+
+
+class StockScreenerResponseResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    stock_screener_response: Optional[List[StockScreenerResponse]] = None
+    r"""Array of screened securities; each item has security (id, ticker, name, etc.) and data (array of tag, number_value, text_value)"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["StockScreenerResponse"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m

finance_dev/models/stockscreenerrequest.py

@@ -0,0 +1,131 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 15ca9ede6f77
+
+from __future__ import annotations
+from .screenclause import ScreenClause, ScreenClauseTypedDict
+from .screengroup import ScreenGroup, ScreenGroupTypedDict
+from enum import Enum
+from finance_dev import models, utils
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from pydantic import field_serializer, model_serializer
+from typing import List, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
+
+
+class StockScreenerRequestOperator2(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Logical operator for combining clauses: AND, OR, or NOT"""
+
+    AND = "AND"
+    OR = "OR"
+    NOT = "NOT"
+
+
+class StockScreenerRequest2TypedDict(TypedDict):
+    groups: List[ScreenGroupTypedDict]
+    r"""Optional nested groups of clauses for complex logic"""
+    operator: StockScreenerRequestOperator2
+    r"""Logical operator for combining clauses: AND, OR, or NOT"""
+    clauses: NotRequired[List[ScreenClauseTypedDict]]
+    r"""List of filter conditions (field, operator, value). Required unless groups is non-empty."""
+
+
+class StockScreenerRequest2(BaseModel):
+    groups: List[ScreenGroup]
+    r"""Optional nested groups of clauses for complex logic"""
+
+    operator: StockScreenerRequestOperator2
+    r"""Logical operator for combining clauses: AND, OR, or NOT"""
+
+    clauses: Optional[List[ScreenClause]] = None
+    r"""List of filter conditions (field, operator, value). Required unless groups is non-empty."""
+
+    @field_serializer("operator")
+    def serialize_operator(self, value):
+        if isinstance(value, str):
+            try:
+                return models.StockScreenerRequestOperator2(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["clauses"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class StockScreenerRequestOperator1(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Logical operator for combining clauses: AND, OR, or NOT"""
+
+    AND = "AND"
+    OR = "OR"
+    NOT = "NOT"
+
+
+class StockScreenerRequest1TypedDict(TypedDict):
+    clauses: List[ScreenClauseTypedDict]
+    r"""List of filter conditions (field, operator, value). Required unless groups is non-empty."""
+    operator: StockScreenerRequestOperator1
+    r"""Logical operator for combining clauses: AND, OR, or NOT"""
+    groups: NotRequired[List[ScreenGroupTypedDict]]
+    r"""Optional nested groups of clauses for complex logic"""
+
+
+class StockScreenerRequest1(BaseModel):
+    clauses: List[ScreenClause]
+    r"""List of filter conditions (field, operator, value). Required unless groups is non-empty."""
+
+    operator: StockScreenerRequestOperator1
+    r"""Logical operator for combining clauses: AND, OR, or NOT"""
+
+    groups: Optional[List[ScreenGroup]] = None
+    r"""Optional nested groups of clauses for complex logic"""
+
+    @field_serializer("operator")
+    def serialize_operator(self, value):
+        if isinstance(value, str):
+            try:
+                return models.StockScreenerRequestOperator1(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["groups"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+StockScreenerRequestTypedDict = TypeAliasType(
+    "StockScreenerRequestTypedDict",
+    Union[StockScreenerRequest1TypedDict, StockScreenerRequest2TypedDict],
+)
+r"""Request body for POST /v1/stock/screener. At least one of clauses or groups must be non-empty."""
+
+
+StockScreenerRequest = TypeAliasType(
+    "StockScreenerRequest", Union[StockScreenerRequest1, StockScreenerRequest2]
+)
+r"""Request body for POST /v1/stock/screener. At least one of clauses or groups must be non-empty."""

finance_dev/models/stockscreenerresponse.py

@@ -0,0 +1,197 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: bfc1ee05ecf0
+
+from __future__ import annotations
+from finance_dev.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from pydantic import model_serializer
+from typing import List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class StockScreenerResponseDataTypedDict(TypedDict):
+    number_value: NotRequired[Nullable[float]]
+    tag: NotRequired[str]
+    r"""Data tag name (e.g. pricetoearnings, marketcap)"""
+    text_value: NotRequired[Nullable[str]]
+
+
+class StockScreenerResponseData(BaseModel):
+    number_value: OptionalNullable[float] = UNSET
+
+    tag: Optional[str] = None
+    r"""Data tag name (e.g. pricetoearnings, marketcap)"""
+
+    text_value: OptionalNullable[str] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["number_value", "tag", "text_value"])
+        nullable_fields = set(["number_value", "text_value"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+class StockScreenerResponseSecurityTypedDict(TypedDict):
+    r"""Security identity and metadata"""
+
+    code: NotRequired[Nullable[str]]
+    company_id: NotRequired[Nullable[str]]
+    composite_figi: NotRequired[Nullable[str]]
+    composite_ticker: NotRequired[Nullable[str]]
+    currency: NotRequired[Nullable[str]]
+    exchange: NotRequired[Nullable[str]]
+    exchange_mic: NotRequired[Nullable[str]]
+    figi: NotRequired[Nullable[str]]
+    id: NotRequired[str]
+    r"""Security ID"""
+    name: NotRequired[Nullable[str]]
+    primary_listing: NotRequired[Nullable[bool]]
+    share_class_figi: NotRequired[Nullable[str]]
+    stock_exchange_id: NotRequired[Nullable[str]]
+    ticker: NotRequired[Nullable[str]]
+
+
+class StockScreenerResponseSecurity(BaseModel):
+    r"""Security identity and metadata"""
+
+    code: OptionalNullable[str] = UNSET
+
+    company_id: OptionalNullable[str] = UNSET
+
+    composite_figi: OptionalNullable[str] = UNSET
+
+    composite_ticker: OptionalNullable[str] = UNSET
+
+    currency: OptionalNullable[str] = UNSET
+
+    exchange: OptionalNullable[str] = UNSET
+
+    exchange_mic: OptionalNullable[str] = UNSET
+
+    figi: OptionalNullable[str] = UNSET
+
+    id: Optional[str] = None
+    r"""Security ID"""
+
+    name: OptionalNullable[str] = UNSET
+
+    primary_listing: OptionalNullable[bool] = UNSET
+
+    share_class_figi: OptionalNullable[str] = UNSET
+
+    stock_exchange_id: OptionalNullable[str] = UNSET
+
+    ticker: OptionalNullable[str] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "code",
+                "company_id",
+                "composite_figi",
+                "composite_ticker",
+                "currency",
+                "exchange",
+                "exchange_mic",
+                "figi",
+                "id",
+                "name",
+                "primary_listing",
+                "share_class_figi",
+                "stock_exchange_id",
+                "ticker",
+            ]
+        )
+        nullable_fields = set(
+            [
+                "code",
+                "company_id",
+                "composite_figi",
+                "composite_ticker",
+                "currency",
+                "exchange",
+                "exchange_mic",
+                "figi",
+                "name",
+                "primary_listing",
+                "share_class_figi",
+                "stock_exchange_id",
+                "ticker",
+            ]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+class StockScreenerResponseTypedDict(TypedDict):
+    data: NotRequired[List[StockScreenerResponseDataTypedDict]]
+    r"""Screened data-tag values (e.g. pricetoearnings, marketcap)"""
+    security: NotRequired[StockScreenerResponseSecurityTypedDict]
+    r"""Security identity and metadata"""
+
+
+class StockScreenerResponse(BaseModel):
+    data: Optional[List[StockScreenerResponseData]] = None
+    r"""Screened data-tag values (e.g. pricetoearnings, marketcap)"""
+
+    security: Optional[StockScreenerResponseSecurity] = None
+    r"""Security identity and metadata"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["data", "security"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m