finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/optionquotesresponse.py

@@ -0,0 +1,138 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 5792c27d8c12
+
+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 OptionQuotesResponseResultTypedDict(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"""
+    sequence_number: NotRequired[int]
+    r"""Sequence number"""
+    sip_timestamp: NotRequired[int]
+    r"""SIP timestamp (nanoseconds)"""
+
+
+class OptionQuotesResponseResult(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"""
+
+    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 (nanoseconds)"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "askExchange",
+                "askPrice",
+                "askSize",
+                "bidExchange",
+                "bidPrice",
+                "bidSize",
+                "sequenceNumber",
+                "sipTimestamp",
+            ]
+        )
+        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 OptionQuotesResponseTypedDict(TypedDict):
+    r"""Paginated list of historical quotes for an options contract."""
+
+    next_url: NotRequired[str]
+    r"""URL for next page of results"""
+    request_id: NotRequired[str]
+    r"""Unique request ID"""
+    results: NotRequired[List[OptionQuotesResponseResultTypedDict]]
+    r"""Array of options 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 OptionQuotesResponse(BaseModel):
+    r"""Paginated list of historical quotes for an options contract."""
+
+    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[OptionQuotesResponseResult]] = None
+    r"""Array of options 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:
+    OptionQuotesResponseResult.model_rebuild()
+except NameError:
+    pass
+try:
+    OptionQuotesResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/optionsactivityresponse.py

@@ -0,0 +1,265 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 3d4104e6512f
+
+from __future__ import annotations
+from enum import Enum
+from finance_dev import models, utils
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+import pydantic
+from pydantic import field_serializer, model_serializer
+from typing import List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class OptionsActivityResponsePutCall(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Option type (PUT or CALL)"""
+
+    PUT = "PUT"
+    CALL = "CALL"
+    P = "P"
+    C = "C"
+
+
+class ActivityTypedDict(TypedDict):
+    aggressor_ind: NotRequired[str]
+    r"""Aggressor indicator showing buyer/seller aggressiveness"""
+    ask: NotRequired[str]
+    r"""Current ask price"""
+    bid: NotRequired[str]
+    r"""Current bid price"""
+    cost_basis: NotRequired[str]
+    r"""Total cost of the options position"""
+    date_: NotRequired[str]
+    r"""Trade date in YYYY-MM-DD format"""
+    date_expiration: NotRequired[str]
+    r"""Option expiration date in YYYY-MM-DD format"""
+    description: NotRequired[str]
+    r"""Brief description of the options activity"""
+    description_extended: NotRequired[str]
+    r"""Detailed description with full trade context"""
+    exchange: NotRequired[str]
+    r"""Exchange code where the data originates. Format depends on the upstream data source and may use MIC, ISO 10383, or a vendor-specific code."""
+    execution_estimate: NotRequired[str]
+    r"""Estimated execution location (AT_BID, AT_ASK, AT_MID)"""
+    id: NotRequired[str]
+    r"""Unique identifier for the options activity record"""
+    midpoint: NotRequired[str]
+    r"""Midpoint between bid and ask prices"""
+    open_interest: NotRequired[str]
+    r"""Total open interest for this option contract"""
+    option_activity_type: NotRequired[str]
+    r"""Type of activity (SWEEP, BLOCK, LARGE, UNUSUAL)"""
+    option_symbol: NotRequired[str]
+    r"""OCC option symbol identifier"""
+    price: NotRequired[str]
+    r"""Execution price per contract"""
+    put_call: NotRequired[OptionsActivityResponsePutCall]
+    r"""Option type (PUT or CALL)"""
+    sentiment: NotRequired[str]
+    r"""Market sentiment indicator (BULLISH, BEARISH, NEUTRAL)"""
+    size: NotRequired[str]
+    r"""Number of contracts traded"""
+    strike_price: NotRequired[str]
+    r"""Strike price of the option contract"""
+    ticker: NotRequired[str]
+    r"""Underlying stock ticker symbol"""
+    time: NotRequired[str]
+    r"""Trade execution time in HH:MM:SS format"""
+    trade_count: NotRequired[str]
+    r"""Number of individual trades in this activity"""
+    underlying_price: NotRequired[str]
+    r"""Current price of the underlying security"""
+    underlying_type: NotRequired[str]
+    r"""Type of underlying security (STOCK, ETF, INDEX)"""
+    updated: NotRequired[int]
+    r"""Unix timestamp when the record was last updated"""
+    volume: NotRequired[str]
+    r"""Total volume traded for the day"""
+
+
+class Activity(BaseModel):
+    aggressor_ind: Annotated[Optional[str], pydantic.Field(alias="aggressorInd")] = None
+    r"""Aggressor indicator showing buyer/seller aggressiveness"""
+
+    ask: Optional[str] = None
+    r"""Current ask price"""
+
+    bid: Optional[str] = None
+    r"""Current bid price"""
+
+    cost_basis: Annotated[Optional[str], pydantic.Field(alias="costBasis")] = None
+    r"""Total cost of the options position"""
+
+    date_: Annotated[Optional[str], pydantic.Field(alias="date")] = None
+    r"""Trade date in YYYY-MM-DD format"""
+
+    date_expiration: Annotated[
+        Optional[str], pydantic.Field(alias="dateExpiration")
+    ] = None
+    r"""Option expiration date in YYYY-MM-DD format"""
+
+    description: Optional[str] = None
+    r"""Brief description of the options activity"""
+
+    description_extended: Annotated[
+        Optional[str], pydantic.Field(alias="descriptionExtended")
+    ] = None
+    r"""Detailed description with full trade context"""
+
+    exchange: Optional[str] = None
+    r"""Exchange code where the data originates. Format depends on the upstream data source and may use MIC, ISO 10383, or a vendor-specific code."""
+
+    execution_estimate: Annotated[
+        Optional[str], pydantic.Field(alias="executionEstimate")
+    ] = None
+    r"""Estimated execution location (AT_BID, AT_ASK, AT_MID)"""
+
+    id: Optional[str] = None
+    r"""Unique identifier for the options activity record"""
+
+    midpoint: Optional[str] = None
+    r"""Midpoint between bid and ask prices"""
+
+    open_interest: Annotated[Optional[str], pydantic.Field(alias="openInterest")] = None
+    r"""Total open interest for this option contract"""
+
+    option_activity_type: Annotated[
+        Optional[str], pydantic.Field(alias="optionActivityType")
+    ] = None
+    r"""Type of activity (SWEEP, BLOCK, LARGE, UNUSUAL)"""
+
+    option_symbol: Annotated[Optional[str], pydantic.Field(alias="optionSymbol")] = None
+    r"""OCC option symbol identifier"""
+
+    price: Optional[str] = None
+    r"""Execution price per contract"""
+
+    put_call: Annotated[
+        Optional[OptionsActivityResponsePutCall], pydantic.Field(alias="putCall")
+    ] = None
+    r"""Option type (PUT or CALL)"""
+
+    sentiment: Optional[str] = None
+    r"""Market sentiment indicator (BULLISH, BEARISH, NEUTRAL)"""
+
+    size: Optional[str] = None
+    r"""Number of contracts traded"""
+
+    strike_price: Annotated[Optional[str], pydantic.Field(alias="strikePrice")] = None
+    r"""Strike price of the option contract"""
+
+    ticker: Optional[str] = None
+    r"""Underlying stock ticker symbol"""
+
+    time: Optional[str] = None
+    r"""Trade execution time in HH:MM:SS format"""
+
+    trade_count: Annotated[Optional[str], pydantic.Field(alias="tradeCount")] = None
+    r"""Number of individual trades in this activity"""
+
+    underlying_price: Annotated[
+        Optional[str], pydantic.Field(alias="underlyingPrice")
+    ] = None
+    r"""Current price of the underlying security"""
+
+    underlying_type: Annotated[
+        Optional[str], pydantic.Field(alias="underlyingType")
+    ] = None
+    r"""Type of underlying security (STOCK, ETF, INDEX)"""
+
+    updated: Optional[int] = None
+    r"""Unix timestamp when the record was last updated"""
+
+    volume: Optional[str] = None
+    r"""Total volume traded for the day"""
+
+    @field_serializer("put_call")
+    def serialize_put_call(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OptionsActivityResponsePutCall(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "aggressorInd",
+                "ask",
+                "bid",
+                "costBasis",
+                "date",
+                "dateExpiration",
+                "description",
+                "descriptionExtended",
+                "exchange",
+                "executionEstimate",
+                "id",
+                "midpoint",
+                "openInterest",
+                "optionActivityType",
+                "optionSymbol",
+                "price",
+                "putCall",
+                "sentiment",
+                "size",
+                "strikePrice",
+                "ticker",
+                "time",
+                "tradeCount",
+                "underlyingPrice",
+                "underlyingType",
+                "updated",
+                "volume",
+            ]
+        )
+        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 OptionsActivityResponseTypedDict(TypedDict):
+    r"""Response containing unusual options activity records."""
+
+    activities: NotRequired[List[ActivityTypedDict]]
+    r"""Array of options activity records"""
+
+
+class OptionsActivityResponse(BaseModel):
+    r"""Response containing unusual options activity records."""
+
+    activities: Optional[List[Activity]] = None
+    r"""Array of options activity records"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["activities"])
+        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:
+    Activity.model_rebuild()
+except NameError:
+    pass

finance_dev/models/optionsnapshotcontractdetails.py

@@ -0,0 +1,85 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: e027c7c6888e
+
+from __future__ import annotations
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class OptionSnapshotContractDetailsTypedDict(TypedDict):
+    r"""Static contract metadata (`OptionSnapshotDetailsDTO`)."""
+
+    contract_type: NotRequired[str]
+    r"""Contract type (for example call or put)."""
+    exercise_style: NotRequired[str]
+    r"""Exercise style of the contract (for example american or european)"""
+    expiration_date: NotRequired[str]
+    r"""Expiration date (ISO date string)."""
+    shares_per_contract: NotRequired[float]
+    r"""Number of shares of the underlying covered by one contract"""
+    strike_price: NotRequired[float]
+    r"""Strike price of the contract"""
+    ticker: NotRequired[str]
+    r"""OCC-format options ticker."""
+
+
+class OptionSnapshotContractDetails(BaseModel):
+    r"""Static contract metadata (`OptionSnapshotDetailsDTO`)."""
+
+    contract_type: Annotated[Optional[str], pydantic.Field(alias="contractType")] = None
+    r"""Contract type (for example call or put)."""
+
+    exercise_style: Annotated[Optional[str], pydantic.Field(alias="exerciseStyle")] = (
+        None
+    )
+    r"""Exercise style of the contract (for example american or european)"""
+
+    expiration_date: Annotated[
+        Optional[str], pydantic.Field(alias="expirationDate")
+    ] = None
+    r"""Expiration date (ISO date string)."""
+
+    shares_per_contract: Annotated[
+        Optional[float], pydantic.Field(alias="sharesPerContract")
+    ] = None
+    r"""Number of shares of the underlying covered by one contract"""
+
+    strike_price: Annotated[Optional[float], pydantic.Field(alias="strikePrice")] = None
+    r"""Strike price of the contract"""
+
+    ticker: Optional[str] = None
+    r"""OCC-format options ticker."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "contractType",
+                "exerciseStyle",
+                "expirationDate",
+                "sharesPerContract",
+                "strikePrice",
+                "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))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+try:
+    OptionSnapshotContractDetails.model_rebuild()
+except NameError:
+    pass

finance_dev/models/optionsnapshotdaybar.py

@@ -0,0 +1,107 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 54ddba7ce2b0
+
+from __future__ import annotations
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class OptionSnapshotDayBarTypedDict(TypedDict):
+    r"""Most recent daily OHLCV bar for the contract (`OptionSnapshotDayBarDTO`)."""
+
+    change: NotRequired[float]
+    r"""Price change for the day"""
+    change_percent: NotRequired[float]
+    r"""Percentage price change for the day"""
+    close: NotRequired[float]
+    r"""Closing price for the day"""
+    high: NotRequired[float]
+    r"""Highest price for the day"""
+    last_updated: NotRequired[int]
+    r"""Timestamp of the last update to the day bar, as supplied by the market data provider"""
+    low: NotRequired[float]
+    r"""Lowest price for the day"""
+    open: NotRequired[float]
+    r"""Opening price for the day"""
+    previous_close: NotRequired[float]
+    r"""Previous day's closing price"""
+    volume: NotRequired[float]
+    r"""Trading volume for the day"""
+    vwap: NotRequired[float]
+    r"""Volume-weighted average price for the day"""
+
+
+class OptionSnapshotDayBar(BaseModel):
+    r"""Most recent daily OHLCV bar for the contract (`OptionSnapshotDayBarDTO`)."""
+
+    change: Optional[float] = None
+    r"""Price change for the day"""
+
+    change_percent: Annotated[
+        Optional[float], pydantic.Field(alias="changePercent")
+    ] = None
+    r"""Percentage price change for the day"""
+
+    close: Optional[float] = None
+    r"""Closing price for the day"""
+
+    high: Optional[float] = None
+    r"""Highest price for the day"""
+
+    last_updated: Annotated[Optional[int], pydantic.Field(alias="lastUpdated")] = None
+    r"""Timestamp of the last update to the day bar, as supplied by the market data provider"""
+
+    low: Optional[float] = None
+    r"""Lowest price for the day"""
+
+    open: Optional[float] = None
+    r"""Opening price for the day"""
+
+    previous_close: Annotated[
+        Optional[float], pydantic.Field(alias="previousClose")
+    ] = None
+    r"""Previous day's closing price"""
+
+    volume: Optional[float] = None
+    r"""Trading volume for the day"""
+
+    vwap: Optional[float] = None
+    r"""Volume-weighted average price for the day"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "change",
+                "changePercent",
+                "close",
+                "high",
+                "lastUpdated",
+                "low",
+                "open",
+                "previousClose",
+                "volume",
+                "vwap",
+            ]
+        )
+        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:
+    OptionSnapshotDayBar.model_rebuild()
+except NameError:
+    pass

finance_dev/models/optionsnapshotgreeks.py

@@ -0,0 +1,67 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: f57d4a6afeca
+
+from __future__ import annotations
+from finance_dev.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from pydantic import model_serializer
+from typing_extensions import NotRequired, TypedDict
+
+
+class OptionSnapshotGreeksTypedDict(TypedDict):
+    r"""Greeks when available (`OptionSnapshotGreeksDTO`)."""
+
+    delta: NotRequired[Nullable[float]]
+    r"""Delta of the contract"""
+    gamma: NotRequired[Nullable[float]]
+    r"""Gamma of the contract"""
+    theta: NotRequired[Nullable[float]]
+    r"""Theta of the contract"""
+    vega: NotRequired[Nullable[float]]
+    r"""Vega of the contract"""
+
+
+class OptionSnapshotGreeks(BaseModel):
+    r"""Greeks when available (`OptionSnapshotGreeksDTO`)."""
+
+    delta: OptionalNullable[float] = UNSET
+    r"""Delta of the contract"""
+
+    gamma: OptionalNullable[float] = UNSET
+    r"""Gamma of the contract"""
+
+    theta: OptionalNullable[float] = UNSET
+    r"""Theta of the contract"""
+
+    vega: OptionalNullable[float] = UNSET
+    r"""Vega of the contract"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["delta", "gamma", "theta", "vega"])
+        nullable_fields = set(["delta", "gamma", "theta", "vega"])
+        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