finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/optionsnapshotlastquote.py

@@ -0,0 +1,116 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: ad69c74f5867
+
+from __future__ import annotations
+from finance_dev.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+import pydantic
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class OptionSnapshotLastQuoteTypedDict(TypedDict):
+    r"""Latest NBBO quote when included (`OptionSnapshotLastQuoteDTO`)."""
+
+    ask: NotRequired[float]
+    r"""Ask price"""
+    ask_exchange: NotRequired[Nullable[int]]
+    r"""Numeric identifier of the exchange quoting the ask, as supplied by the market data provider"""
+    ask_size: NotRequired[float]
+    r"""Size at the ask price"""
+    bid: NotRequired[float]
+    r"""Bid price"""
+    bid_exchange: NotRequired[Nullable[int]]
+    r"""Numeric identifier of the exchange quoting the bid, as supplied by the market data provider"""
+    bid_size: NotRequired[float]
+    r"""Size at the bid price"""
+    last_updated: NotRequired[int]
+    r"""Timestamp of the last quote update, as supplied by the market data provider"""
+    midpoint: NotRequired[float]
+    r"""Midpoint between the bid and ask prices"""
+    timeframe: NotRequired[str]
+    r"""Data timeframe of the quote, as supplied by the market data provider"""
+
+
+class OptionSnapshotLastQuote(BaseModel):
+    r"""Latest NBBO quote when included (`OptionSnapshotLastQuoteDTO`)."""
+
+    ask: Optional[float] = None
+    r"""Ask price"""
+
+    ask_exchange: Annotated[
+        OptionalNullable[int], pydantic.Field(alias="askExchange")
+    ] = UNSET
+    r"""Numeric identifier of the exchange quoting the ask, as supplied by the market data provider"""
+
+    ask_size: Annotated[Optional[float], pydantic.Field(alias="askSize")] = None
+    r"""Size at the ask price"""
+
+    bid: Optional[float] = None
+    r"""Bid price"""
+
+    bid_exchange: Annotated[
+        OptionalNullable[int], pydantic.Field(alias="bidExchange")
+    ] = UNSET
+    r"""Numeric identifier of the exchange quoting the bid, as supplied by the market data provider"""
+
+    bid_size: Annotated[Optional[float], pydantic.Field(alias="bidSize")] = None
+    r"""Size at the bid price"""
+
+    last_updated: Annotated[Optional[int], pydantic.Field(alias="lastUpdated")] = None
+    r"""Timestamp of the last quote update, as supplied by the market data provider"""
+
+    midpoint: Optional[float] = None
+    r"""Midpoint between the bid and ask prices"""
+
+    timeframe: Optional[str] = None
+    r"""Data timeframe of the quote, as supplied by the market data provider"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "ask",
+                "askExchange",
+                "askSize",
+                "bid",
+                "bidExchange",
+                "bidSize",
+                "lastUpdated",
+                "midpoint",
+                "timeframe",
+            ]
+        )
+        nullable_fields = set(["askExchange", "bidExchange"])
+        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
+
+
+try:
+    OptionSnapshotLastQuote.model_rebuild()
+except NameError:
+    pass

finance_dev/models/optionsnapshotlasttrade.py

@@ -0,0 +1,102 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 5e1c4e27b03c
+
+from __future__ import annotations
+from finance_dev.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+import pydantic
+from pydantic import model_serializer
+from typing import List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class OptionSnapshotLastTradeTypedDict(TypedDict):
+    r"""Latest trade when included (`OptionSnapshotLastTradeDTO`)."""
+
+    conditions: NotRequired[List[int]]
+    r"""Trade condition codes, as supplied by the market data provider"""
+    decimal_size: NotRequired[Nullable[str]]
+    r"""Trade size as a decimal string, when provided"""
+    exchange: NotRequired[int]
+    r"""Numeric exchange identifier supplied by the market data provider."""
+    price: NotRequired[float]
+    r"""Trade price"""
+    sip_timestamp: NotRequired[int]
+    r"""SIP timestamp of the trade, as supplied by the market data provider"""
+    size: NotRequired[float]
+    r"""Trade size"""
+    timeframe: NotRequired[str]
+    r"""Data timeframe of the trade, as supplied by the market data provider"""
+
+
+class OptionSnapshotLastTrade(BaseModel):
+    r"""Latest trade when included (`OptionSnapshotLastTradeDTO`)."""
+
+    conditions: Optional[List[int]] = None
+    r"""Trade condition codes, as supplied by the market data provider"""
+
+    decimal_size: Annotated[
+        OptionalNullable[str], pydantic.Field(alias="decimalSize")
+    ] = UNSET
+    r"""Trade size as a decimal string, when provided"""
+
+    exchange: Optional[int] = None
+    r"""Numeric exchange identifier supplied by the market data provider."""
+
+    price: Optional[float] = None
+    r"""Trade price"""
+
+    sip_timestamp: Annotated[Optional[int], pydantic.Field(alias="sipTimestamp")] = None
+    r"""SIP timestamp of the trade, as supplied by the market data provider"""
+
+    size: Optional[float] = None
+    r"""Trade size"""
+
+    timeframe: Optional[str] = None
+    r"""Data timeframe of the trade, as supplied by the market data provider"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "conditions",
+                "decimalSize",
+                "exchange",
+                "price",
+                "sipTimestamp",
+                "size",
+                "timeframe",
+            ]
+        )
+        nullable_fields = set(["decimalSize"])
+        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
+
+
+try:
+    OptionSnapshotLastTrade.model_rebuild()
+except NameError:
+    pass

finance_dev/models/optionsnapshotunderlying.py

@@ -0,0 +1,86 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: f783a0a350b0
+
+from __future__ import annotations
+from finance_dev.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+import pydantic
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class OptionSnapshotUnderlyingTypedDict(TypedDict):
+    r"""Underlying equity snapshot (`OptionSnapshotUnderlyingDTO`)."""
+
+    change_to_break_even: NotRequired[Nullable[float]]
+    r"""Change in the underlying price needed for the contract to reach break-even"""
+    last_updated: NotRequired[Nullable[int]]
+    r"""Timestamp of the last update to the underlying price, as supplied by the market data provider"""
+    price: NotRequired[Nullable[float]]
+    r"""Current price of the underlying asset"""
+    ticker: NotRequired[str]
+    r"""Ticker symbol of the underlying asset"""
+    timeframe: NotRequired[str]
+    r"""Data timeframe of the underlying price, as supplied by the market data provider"""
+
+
+class OptionSnapshotUnderlying(BaseModel):
+    r"""Underlying equity snapshot (`OptionSnapshotUnderlyingDTO`)."""
+
+    change_to_break_even: Annotated[
+        OptionalNullable[float], pydantic.Field(alias="changeToBreakEven")
+    ] = UNSET
+    r"""Change in the underlying price needed for the contract to reach break-even"""
+
+    last_updated: Annotated[
+        OptionalNullable[int], pydantic.Field(alias="lastUpdated")
+    ] = UNSET
+    r"""Timestamp of the last update to the underlying price, as supplied by the market data provider"""
+
+    price: OptionalNullable[float] = UNSET
+    r"""Current price of the underlying asset"""
+
+    ticker: Optional[str] = None
+    r"""Ticker symbol of the underlying asset"""
+
+    timeframe: Optional[str] = None
+    r"""Data timeframe of the underlying price, as supplied by the market data provider"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["changeToBreakEven", "lastUpdated", "price", "ticker", "timeframe"]
+        )
+        nullable_fields = set(["changeToBreakEven", "lastUpdated", "price"])
+        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
+
+
+try:
+    OptionSnapshotUnderlying.model_rebuild()
+except NameError:
+    pass

finance_dev/models/optionsscreeneritem.py

@@ -0,0 +1,151 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 4b8072ae6866
+
+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 Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class OptionsScreenerItemType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Option type returned by the API. `c` = Call; `P` = Put."""
+
+    C = "c"
+    P = "P"
+
+
+class OptionsScreenerItemTypedDict(TypedDict):
+    r"""Option contract details returned by options top-volume and top-gainers endpoints."""
+
+    ask: NotRequired[float]
+    r"""Lowest current seller price for the option. Use it as the reference price when buying."""
+    bid: NotRequired[float]
+    r"""Highest current buyer price for the option. Use it as the reference price when selling."""
+    change: NotRequired[float]
+    r"""Price change from previous close"""
+    change_percent: NotRequired[float]
+    r"""Percentage change from previous close"""
+    expiry: NotRequired[str]
+    r"""Option expiration date. Use it to group contracts by expiry and show time remaining."""
+    implied_volatility: NotRequired[float]
+    r"""Market-implied volatility for the option. Use it to compare how expensive option premium is across contracts."""
+    last_price: NotRequired[float]
+    r"""Most recent traded option price. Use bid and ask when estimating immediate execution cost."""
+    logo_url: NotRequired[str]
+    r"""URL to the underlying company or ETF logo"""
+    open_interest: NotRequired[int]
+    r"""Number of outstanding contracts. Use it to estimate option liquidity beyond today's trading volume."""
+    strike: NotRequired[float]
+    r"""Option strike price. Use it to explain the price level where the option can be exercised."""
+    symbol: NotRequired[str]
+    r"""Option contract symbol. Use this exact value when requesting option quotes, snapshots, or trades."""
+    type: NotRequired[OptionsScreenerItemType]
+    r"""Option type returned by the API. `c` = Call; `P` = Put."""
+    underlying_symbol: NotRequired[str]
+    r"""Underlying stock or ETF symbol"""
+    volume: NotRequired[int]
+    r"""Contracts traded during the current session. Use it to identify active option contracts."""
+
+
+class OptionsScreenerItem(BaseModel):
+    r"""Option contract details returned by options top-volume and top-gainers endpoints."""
+
+    ask: Optional[float] = None
+    r"""Lowest current seller price for the option. Use it as the reference price when buying."""
+
+    bid: Optional[float] = None
+    r"""Highest current buyer price for the option. Use it as the reference price when selling."""
+
+    change: Optional[float] = None
+    r"""Price change from previous close"""
+
+    change_percent: Annotated[
+        Optional[float], pydantic.Field(alias="changePercent")
+    ] = None
+    r"""Percentage change from previous close"""
+
+    expiry: Optional[str] = None
+    r"""Option expiration date. Use it to group contracts by expiry and show time remaining."""
+
+    implied_volatility: Annotated[
+        Optional[float], pydantic.Field(alias="impliedVolatility")
+    ] = None
+    r"""Market-implied volatility for the option. Use it to compare how expensive option premium is across contracts."""
+
+    last_price: Annotated[Optional[float], pydantic.Field(alias="lastPrice")] = None
+    r"""Most recent traded option price. Use bid and ask when estimating immediate execution cost."""
+
+    logo_url: Annotated[Optional[str], pydantic.Field(alias="logoUrl")] = None
+    r"""URL to the underlying company or ETF logo"""
+
+    open_interest: Annotated[Optional[int], pydantic.Field(alias="openInterest")] = None
+    r"""Number of outstanding contracts. Use it to estimate option liquidity beyond today's trading volume."""
+
+    strike: Optional[float] = None
+    r"""Option strike price. Use it to explain the price level where the option can be exercised."""
+
+    symbol: Optional[str] = None
+    r"""Option contract symbol. Use this exact value when requesting option quotes, snapshots, or trades."""
+
+    type: Optional[OptionsScreenerItemType] = None
+    r"""Option type returned by the API. `c` = Call; `P` = Put."""
+
+    underlying_symbol: Annotated[
+        Optional[str], pydantic.Field(alias="underlyingSymbol")
+    ] = None
+    r"""Underlying stock or ETF symbol"""
+
+    volume: Optional[int] = None
+    r"""Contracts traded during the current session. Use it to identify active option contracts."""
+
+    @field_serializer("type")
+    def serialize_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OptionsScreenerItemType(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "ask",
+                "bid",
+                "change",
+                "changePercent",
+                "expiry",
+                "impliedVolatility",
+                "lastPrice",
+                "logoUrl",
+                "openInterest",
+                "strike",
+                "symbol",
+                "type",
+                "underlyingSymbol",
+                "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
+
+
+try:
+    OptionsScreenerItem.model_rebuild()
+except NameError:
+    pass

finance_dev/models/optionsunusualactivityresponse.py

@@ -0,0 +1,62 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 25c84896715f
+
+from __future__ import annotations
+from .optionsunusualactivitytrade import (
+    OptionsUnusualActivityTrade,
+    OptionsUnusualActivityTradeTypedDict,
+)
+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 OptionsUnusualActivityResponseTypedDict(TypedDict):
+    r"""Response for GET /v1/options/unusual_activity/{symbol}. Contains unusual activity trades and optional pagination pointer."""
+
+    next_page: NotRequired[Nullable[str]]
+    r"""Absolute link to the next page when more results are available."""
+    trades: NotRequired[List[OptionsUnusualActivityTradeTypedDict]]
+    r"""List of unusual options activity trades"""
+
+
+class OptionsUnusualActivityResponse(BaseModel):
+    r"""Response for GET /v1/options/unusual_activity/{symbol}. Contains unusual activity trades and optional pagination pointer."""
+
+    next_page: OptionalNullable[str] = UNSET
+    r"""Absolute link to the next page when more results are available."""
+
+    trades: Optional[List[OptionsUnusualActivityTrade]] = None
+    r"""List of unusual options activity trades"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["next_page", "trades"])
+        nullable_fields = set(["next_page"])
+        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

finance_dev/models/optionsunusualactivitytrade.py

@@ -0,0 +1,103 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 95038c369e18
+
+from __future__ import annotations
+from datetime import datetime
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class OptionsUnusualActivityTradeTypedDict(TypedDict):
+    r"""Single options unusual activity trade"""
+
+    ask_at_execution: NotRequired[float]
+    r"""Ask price at execution"""
+    average_price: NotRequired[float]
+    r"""Average price per contract"""
+    bid_at_execution: NotRequired[float]
+    r"""Bid price at execution"""
+    contract: NotRequired[str]
+    r"""Option contract identifier"""
+    sentiment: NotRequired[str]
+    r"""Sentiment (e.g. bearish, bullish)"""
+    symbol: NotRequired[str]
+    r"""Underlying symbol (e.g. AAPL)"""
+    timestamp: NotRequired[datetime]
+    r"""Trade timestamp (ISO 8601)"""
+    total_size: NotRequired[float]
+    r"""Total contract size"""
+    total_value: NotRequired[float]
+    r"""Total dollar value of the trade"""
+    type: NotRequired[str]
+    r"""Provider-supplied unusual activity classification for the trade, such as block, sweep, or split."""
+    underlying_price_at_execution: NotRequired[float]
+    r"""Underlying price at execution"""
+
+
+class OptionsUnusualActivityTrade(BaseModel):
+    r"""Single options unusual activity trade"""
+
+    ask_at_execution: Optional[float] = None
+    r"""Ask price at execution"""
+
+    average_price: Optional[float] = None
+    r"""Average price per contract"""
+
+    bid_at_execution: Optional[float] = None
+    r"""Bid price at execution"""
+
+    contract: Optional[str] = None
+    r"""Option contract identifier"""
+
+    sentiment: Optional[str] = None
+    r"""Sentiment (e.g. bearish, bullish)"""
+
+    symbol: Optional[str] = None
+    r"""Underlying symbol (e.g. AAPL)"""
+
+    timestamp: Optional[datetime] = None
+    r"""Trade timestamp (ISO 8601)"""
+
+    total_size: Optional[float] = None
+    r"""Total contract size"""
+
+    total_value: Optional[float] = None
+    r"""Total dollar value of the trade"""
+
+    type: Optional[str] = None
+    r"""Provider-supplied unusual activity classification for the trade, such as block, sweep, or split."""
+
+    underlying_price_at_execution: Optional[float] = None
+    r"""Underlying price at execution"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "ask_at_execution",
+                "average_price",
+                "bid_at_execution",
+                "contract",
+                "sentiment",
+                "symbol",
+                "timestamp",
+                "total_size",
+                "total_value",
+                "type",
+                "underlying_price_at_execution",
+            ]
+        )
+        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