finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/optioncontractsresponse.py

@@ -0,0 +1,131 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: d1edab16d9c3
+
+from __future__ import annotations
+from datetime import date
+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 CallTypedDict(TypedDict):
+    strike_price: NotRequired[float]
+    r"""Strike price"""
+    symbol: NotRequired[str]
+    r"""OCC option ticker symbol"""
+
+
+class Call(BaseModel):
+    strike_price: Annotated[Optional[float], pydantic.Field(alias="strikePrice")] = None
+    r"""Strike price"""
+
+    symbol: Optional[str] = None
+    r"""OCC option ticker symbol"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["strikePrice", "symbol"])
+        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 PutTypedDict(TypedDict):
+    strike_price: NotRequired[float]
+    r"""Strike price"""
+    symbol: NotRequired[str]
+    r"""OCC option ticker symbol"""
+
+
+class Put(BaseModel):
+    strike_price: Annotated[Optional[float], pydantic.Field(alias="strikePrice")] = None
+    r"""Strike price"""
+
+    symbol: Optional[str] = None
+    r"""OCC option ticker symbol"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["strikePrice", "symbol"])
+        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 OptionContractsResponseTypedDict(TypedDict):
+    r"""Response containing the call and put option contracts for an underlying symbol and expiration date."""
+
+    calls: NotRequired[List[CallTypedDict]]
+    r"""Call option contracts for the expiration date"""
+    expiry_date: NotRequired[date]
+    r"""Expiration date YYYY-MM-DD"""
+    puts: NotRequired[List[PutTypedDict]]
+    r"""Put option contracts for the expiration date"""
+    symbol: NotRequired[str]
+    r"""Underlying symbol"""
+
+
+class OptionContractsResponse(BaseModel):
+    r"""Response containing the call and put option contracts for an underlying symbol and expiration date."""
+
+    calls: Optional[List[Call]] = None
+    r"""Call option contracts for the expiration date"""
+
+    expiry_date: Annotated[Optional[date], pydantic.Field(alias="expiryDate")] = None
+    r"""Expiration date YYYY-MM-DD"""
+
+    puts: Optional[List[Put]] = None
+    r"""Put option contracts for the expiration date"""
+
+    symbol: Optional[str] = None
+    r"""Underlying symbol"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["calls", "expiryDate", "puts", "symbol"])
+        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:
+    Call.model_rebuild()
+except NameError:
+    pass
+try:
+    Put.model_rebuild()
+except NameError:
+    pass
+try:
+    OptionContractsResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/optiondetailsdto.py

@@ -0,0 +1,72 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 2660a2f8936f
+
+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 OptionDetailsDTOTypedDict(TypedDict):
+    r"""One option contract's pricing snapshot from GET /v1/marketdata/options/details. Numeric prices are returned as JSON numbers."""
+
+    ask_price: NotRequired[float]
+    r"""Current best ask price."""
+    bid_price: NotRequired[float]
+    r"""Current best bid price."""
+    close_price: NotRequired[float]
+    r"""Previous session's closing price."""
+    last_price: NotRequired[float]
+    r"""Last traded price for the contract."""
+    mid_price: NotRequired[float]
+    r"""Midpoint between the bid and ask prices."""
+    symbol: NotRequired[str]
+    r"""OSI option symbol for the contract."""
+
+
+class OptionDetailsDTO(BaseModel):
+    r"""One option contract's pricing snapshot from GET /v1/marketdata/options/details. Numeric prices are returned as JSON numbers."""
+
+    ask_price: Annotated[Optional[float], pydantic.Field(alias="askPrice")] = None
+    r"""Current best ask price."""
+
+    bid_price: Annotated[Optional[float], pydantic.Field(alias="bidPrice")] = None
+    r"""Current best bid price."""
+
+    close_price: Annotated[Optional[float], pydantic.Field(alias="closePrice")] = None
+    r"""Previous session's closing price."""
+
+    last_price: Annotated[Optional[float], pydantic.Field(alias="lastPrice")] = None
+    r"""Last traded price for the contract."""
+
+    mid_price: Annotated[Optional[float], pydantic.Field(alias="midPrice")] = None
+    r"""Midpoint between the bid and ask prices."""
+
+    symbol: Optional[str] = None
+    r"""OSI option symbol for the contract."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["askPrice", "bidPrice", "closePrice", "lastPrice", "midPrice", "symbol"]
+        )
+        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:
+    OptionDetailsDTO.model_rebuild()
+except NameError:
+    pass

finance_dev/models/optionexpirydatesresponse.py

@@ -0,0 +1,53 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 5fee5b681dfb
+
+from __future__ import annotations
+from datetime import date
+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 OptionExpiryDatesResponseTypedDict(TypedDict):
+    r"""Response containing the option expiration dates for an underlying symbol."""
+
+    expiry_dates: NotRequired[List[date]]
+    r"""List of expiration dates in YYYY-MM-DD format"""
+    symbol: NotRequired[str]
+    r"""Underlying symbol"""
+
+
+class OptionExpiryDatesResponse(BaseModel):
+    r"""Response containing the option expiration dates for an underlying symbol."""
+
+    expiry_dates: Annotated[
+        Optional[List[date]], pydantic.Field(alias="expiryDates")
+    ] = None
+    r"""List of expiration dates in YYYY-MM-DD format"""
+
+    symbol: Optional[str] = None
+    r"""Underlying symbol"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["expiryDates", "symbol"])
+        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:
+    OptionExpiryDatesResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/optionlasttraderesponse.py

@@ -0,0 +1,169 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 48276e4f7bf1
+
+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 OptionLastTradeResponseResultsTypedDict(TypedDict):
+    r"""Last options trade object"""
+
+    conditions: NotRequired[List[int]]
+    r"""Trade conditions"""
+    correction: NotRequired[int]
+    r"""Correction indicator"""
+    exchange: NotRequired[int]
+    r"""Numeric exchange identifier supplied by the market data provider."""
+    id: NotRequired[str]
+    r"""Trade ID"""
+    participant_timestamp: NotRequired[int]
+    r"""Participant timestamp"""
+    price: NotRequired[float]
+    r"""Trade price"""
+    sequence_number: NotRequired[int]
+    r"""Sequence number"""
+    sip_timestamp: NotRequired[int]
+    r"""SIP timestamp"""
+    size: NotRequired[float]
+    r"""Trade size (contracts)"""
+    tape: NotRequired[int]
+    r"""Tape"""
+    ticker: NotRequired[str]
+    r"""Options contract ticker symbol. Enter the exact option symbol returned by option search or chain endpoints."""
+    trf_id: NotRequired[int]
+    r"""TRF ID"""
+    trf_timestamp: NotRequired[int]
+    r"""TRF timestamp"""
+
+
+class OptionLastTradeResponseResults(BaseModel):
+    r"""Last options trade object"""
+
+    conditions: Optional[List[int]] = None
+    r"""Trade conditions"""
+
+    correction: Optional[int] = None
+    r"""Correction indicator"""
+
+    exchange: Optional[int] = None
+    r"""Numeric exchange identifier supplied by the market data provider."""
+
+    id: Optional[str] = None
+    r"""Trade ID"""
+
+    participant_timestamp: Annotated[
+        Optional[int], pydantic.Field(alias="participantTimestamp")
+    ] = None
+    r"""Participant timestamp"""
+
+    price: Optional[float] = None
+    r"""Trade price"""
+
+    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"""
+
+    size: Optional[float] = None
+    r"""Trade size (contracts)"""
+
+    tape: Optional[int] = None
+    r"""Tape"""
+
+    ticker: Optional[str] = None
+    r"""Options contract ticker symbol. Enter the exact option symbol returned by option search or chain endpoints."""
+
+    trf_id: Annotated[Optional[int], pydantic.Field(alias="trfId")] = None
+    r"""TRF ID"""
+
+    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(
+            [
+                "conditions",
+                "correction",
+                "exchange",
+                "id",
+                "participantTimestamp",
+                "price",
+                "sequenceNumber",
+                "sipTimestamp",
+                "size",
+                "tape",
+                "ticker",
+                "trfId",
+                "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 OptionLastTradeResponseTypedDict(TypedDict):
+    r"""Most recent trade for an options contract."""
+
+    request_id: NotRequired[str]
+    r"""Unique request ID"""
+    results: NotRequired[OptionLastTradeResponseResultsTypedDict]
+    r"""Last options trade object"""
+    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 OptionLastTradeResponse(BaseModel):
+    r"""Most recent trade for an options contract."""
+
+    request_id: Annotated[Optional[str], pydantic.Field(alias="requestId")] = None
+    r"""Unique request ID"""
+
+    results: Optional[OptionLastTradeResponseResults] = None
+    r"""Last options trade object"""
+
+    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(["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:
+    OptionLastTradeResponseResults.model_rebuild()
+except NameError:
+    pass
+try:
+    OptionLastTradeResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/optionopencloseresponse.py

@@ -0,0 +1,97 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 7df7aed2b328
+
+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 OptionOpenCloseResponseTypedDict(TypedDict):
+    r"""Daily open, high, low, close and volume for an option contract on a given date, including pre-market and after-hours prices."""
+
+    after_hours: NotRequired[float]
+    r"""Last traded price in after-hours session"""
+    close: NotRequired[float]
+    r"""Closing price for the trading session"""
+    date_: NotRequired[str]
+    r"""Trade date in YYYY-MM-DD format"""
+    high: NotRequired[float]
+    r"""Highest price reached during the trading session"""
+    low: NotRequired[float]
+    r"""Lowest price reached during the trading session"""
+    open: NotRequired[float]
+    r"""Opening price for the trading session"""
+    pre_market: NotRequired[float]
+    r"""Last traded price in pre-market session"""
+    ticker: NotRequired[str]
+    r"""OCC option ticker symbol"""
+    volume: NotRequired[float]
+    r"""Total number of contracts traded during the session"""
+
+
+class OptionOpenCloseResponse(BaseModel):
+    r"""Daily open, high, low, close and volume for an option contract on a given date, including pre-market and after-hours prices."""
+
+    after_hours: Annotated[Optional[float], pydantic.Field(alias="afterHours")] = None
+    r"""Last traded price in after-hours session"""
+
+    close: Optional[float] = None
+    r"""Closing price for the trading session"""
+
+    date_: Annotated[Optional[str], pydantic.Field(alias="date")] = None
+    r"""Trade date in YYYY-MM-DD format"""
+
+    high: Optional[float] = None
+    r"""Highest price reached during the trading session"""
+
+    low: Optional[float] = None
+    r"""Lowest price reached during the trading session"""
+
+    open: Optional[float] = None
+    r"""Opening price for the trading session"""
+
+    pre_market: Annotated[Optional[float], pydantic.Field(alias="preMarket")] = None
+    r"""Last traded price in pre-market session"""
+
+    ticker: Optional[str] = None
+    r"""OCC option ticker symbol"""
+
+    volume: Optional[float] = None
+    r"""Total number of contracts traded during the session"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "afterHours",
+                "close",
+                "date",
+                "high",
+                "low",
+                "open",
+                "preMarket",
+                "ticker",
+                "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:
+    OptionOpenCloseResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/optionpreviousdayresponse.py

@@ -0,0 +1,89 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 7504755158c1
+
+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 OptionPreviousDayResponseTypedDict(TypedDict):
+    r"""Previous trading session OHLC bar for an option contract."""
+
+    close: float
+    r"""Closing trade price of the contract at the end of the previous regular trading session, in U.S. dollars per contract."""
+    high: float
+    r"""Highest trade price reached during the previous regular trading session, in U.S. dollars per contract."""
+    low: float
+    r"""Lowest trade price reached during the previous regular trading session, in U.S. dollars per contract."""
+    open: float
+    r"""Opening trade price of the contract during the previous regular trading session, in U.S. dollars per contract."""
+    ticker: str
+    r"""Canonical OCC/OSI option symbol the data is for (always returned in uppercase, without the `O:` prefix even if you sent one)."""
+    volume: float
+    r"""Total number of contracts that traded during the previous regular trading session. Higher volume usually means tighter bid/ask spreads and easier fills."""
+    timestamp: NotRequired[int]
+    r"""When the bar applies to, as a Unix timestamp in **milliseconds** (UTC). Omitted if the upstream source did not provide it."""
+    transaction_count: NotRequired[int]
+    r"""Number of individual trade prints that made up the previous session's bar. (Each transaction can be many contracts — see `volume` for total contract count.) Omitted if the upstream source did not provide it."""
+    volume_weighted: NotRequired[float]
+    r"""Volume-Weighted Average Price (VWAP) for the previous session — the average trade price weighted by contract size. Useful as a 'fair' reference price for the day. Omitted if the upstream source did not provide it."""
+
+
+class OptionPreviousDayResponse(BaseModel):
+    r"""Previous trading session OHLC bar for an option contract."""
+
+    close: float
+    r"""Closing trade price of the contract at the end of the previous regular trading session, in U.S. dollars per contract."""
+
+    high: float
+    r"""Highest trade price reached during the previous regular trading session, in U.S. dollars per contract."""
+
+    low: float
+    r"""Lowest trade price reached during the previous regular trading session, in U.S. dollars per contract."""
+
+    open: float
+    r"""Opening trade price of the contract during the previous regular trading session, in U.S. dollars per contract."""
+
+    ticker: str
+    r"""Canonical OCC/OSI option symbol the data is for (always returned in uppercase, without the `O:` prefix even if you sent one)."""
+
+    volume: float
+    r"""Total number of contracts that traded during the previous regular trading session. Higher volume usually means tighter bid/ask spreads and easier fills."""
+
+    timestamp: Optional[int] = None
+    r"""When the bar applies to, as a Unix timestamp in **milliseconds** (UTC). Omitted if the upstream source did not provide it."""
+
+    transaction_count: Annotated[
+        Optional[int], pydantic.Field(alias="transactionCount")
+    ] = None
+    r"""Number of individual trade prints that made up the previous session's bar. (Each transaction can be many contracts — see `volume` for total contract count.) Omitted if the upstream source did not provide it."""
+
+    volume_weighted: Annotated[
+        Optional[float], pydantic.Field(alias="volumeWeighted")
+    ] = None
+    r"""Volume-Weighted Average Price (VWAP) for the previous session — the average trade price weighted by contract size. Useful as a 'fair' reference price for the day. Omitted if the upstream source did not provide it."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["timestamp", "transactionCount", "volumeWeighted"])
+        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:
+    OptionPreviousDayResponse.model_rebuild()
+except NameError:
+    pass