finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/stocksnapshotsresponse.py

@@ -0,0 +1,454 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 71a981035aca
+
+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 DayTypedDict(TypedDict):
+    r"""Current day aggregate"""
+
+    close: NotRequired[float]
+    r"""Close price"""
+    high: NotRequired[float]
+    r"""High price"""
+    low: NotRequired[float]
+    r"""Low price"""
+    open: NotRequired[float]
+    r"""Open price"""
+    volume: NotRequired[float]
+    r"""Volume"""
+    vwap: NotRequired[float]
+    r"""VWAP"""
+
+
+class Day(BaseModel):
+    r"""Current day aggregate"""
+
+    close: Optional[float] = None
+    r"""Close price"""
+
+    high: Optional[float] = None
+    r"""High price"""
+
+    low: Optional[float] = None
+    r"""Low price"""
+
+    open: Optional[float] = None
+    r"""Open price"""
+
+    volume: Optional[float] = None
+    r"""Volume"""
+
+    vwap: Optional[float] = None
+    r"""VWAP"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["close", "high", "low", "open", "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
+
+
+class LastQuoteTypedDict(TypedDict):
+    r"""Last quote information"""
+
+    ask_price: NotRequired[float]
+    r"""Ask price of the last quote."""
+    ask_size: NotRequired[int]
+    r"""Ask size of the last quote."""
+    bid_price: NotRequired[float]
+    r"""Bid price of the last quote."""
+    bid_size: NotRequired[int]
+    r"""Bid size of the last quote."""
+    timestamp: NotRequired[int]
+    r"""Timestamp of the last quote as an integer from the upstream provider."""
+
+
+class LastQuote(BaseModel):
+    r"""Last quote information"""
+
+    ask_price: Annotated[Optional[float], pydantic.Field(alias="askPrice")] = None
+    r"""Ask price of the last quote."""
+
+    ask_size: Annotated[Optional[int], pydantic.Field(alias="askSize")] = None
+    r"""Ask size of the last quote."""
+
+    bid_price: Annotated[Optional[float], pydantic.Field(alias="bidPrice")] = None
+    r"""Bid price of the last quote."""
+
+    bid_size: Annotated[Optional[int], pydantic.Field(alias="bidSize")] = None
+    r"""Bid size of the last quote."""
+
+    timestamp: Optional[int] = None
+    r"""Timestamp of the last quote as an integer from the upstream provider."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["askPrice", "askSize", "bidPrice", "bidSize", "timestamp"]
+        )
+        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 LastTradeTypedDict(TypedDict):
+    r"""Last trade information"""
+
+    conditions: NotRequired[List[int]]
+    r"""Provider-defined numeric condition codes attached to the last trade."""
+    exchange_id: NotRequired[int]
+    r"""Numeric identifier of the exchange where the last trade occurred."""
+    price: NotRequired[float]
+    r"""Price of the last trade."""
+    size: NotRequired[int]
+    r"""Size of the last trade."""
+    timestamp: NotRequired[int]
+    r"""Timestamp of the last trade as an integer from the upstream provider."""
+    trade_id: NotRequired[str]
+    r"""Identifier of the last trade."""
+
+
+class LastTrade(BaseModel):
+    r"""Last trade information"""
+
+    conditions: Optional[List[int]] = None
+    r"""Provider-defined numeric condition codes attached to the last trade."""
+
+    exchange_id: Annotated[Optional[int], pydantic.Field(alias="exchangeId")] = None
+    r"""Numeric identifier of the exchange where the last trade occurred."""
+
+    price: Optional[float] = None
+    r"""Price of the last trade."""
+
+    size: Optional[int] = None
+    r"""Size of the last trade."""
+
+    timestamp: Optional[int] = None
+    r"""Timestamp of the last trade as an integer from the upstream provider."""
+
+    trade_id: Annotated[Optional[str], pydantic.Field(alias="tradeId")] = None
+    r"""Identifier of the last trade."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["conditions", "exchangeId", "price", "size", "timestamp", "tradeId"]
+        )
+        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 MinTypedDict(TypedDict):
+    r"""Latest minute aggregate"""
+
+    accumulated_volume: NotRequired[int]
+    r"""Accumulated volume for the trading day up to this minute bar."""
+    close: NotRequired[float]
+    r"""Close price of the latest minute bar."""
+    high: NotRequired[float]
+    r"""High price of the latest minute bar."""
+    low: NotRequired[float]
+    r"""Low price of the latest minute bar."""
+    number_of_trades: NotRequired[int]
+    r"""Number of trades in the latest minute bar."""
+    open: NotRequired[float]
+    r"""Open price of the latest minute bar."""
+    timestamp: NotRequired[int]
+    r"""Timestamp of the latest minute bar as an integer from the upstream provider."""
+    volume: NotRequired[int]
+    r"""Trading volume in the latest minute bar."""
+    vwap: NotRequired[float]
+    r"""Volume-weighted average price of the latest minute bar."""
+
+
+class Min(BaseModel):
+    r"""Latest minute aggregate"""
+
+    accumulated_volume: Annotated[
+        Optional[int], pydantic.Field(alias="accumulatedVolume")
+    ] = None
+    r"""Accumulated volume for the trading day up to this minute bar."""
+
+    close: Optional[float] = None
+    r"""Close price of the latest minute bar."""
+
+    high: Optional[float] = None
+    r"""High price of the latest minute bar."""
+
+    low: Optional[float] = None
+    r"""Low price of the latest minute bar."""
+
+    number_of_trades: Annotated[
+        Optional[int], pydantic.Field(alias="numberOfTrades")
+    ] = None
+    r"""Number of trades in the latest minute bar."""
+
+    open: Optional[float] = None
+    r"""Open price of the latest minute bar."""
+
+    timestamp: Optional[int] = None
+    r"""Timestamp of the latest minute bar as an integer from the upstream provider."""
+
+    volume: Optional[int] = None
+    r"""Trading volume in the latest minute bar."""
+
+    vwap: Optional[float] = None
+    r"""Volume-weighted average price of the latest minute bar."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "accumulatedVolume",
+                "close",
+                "high",
+                "low",
+                "numberOfTrades",
+                "open",
+                "timestamp",
+                "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
+
+
+class PrevDayTypedDict(TypedDict):
+    r"""Previous day aggregate"""
+
+    close: NotRequired[float]
+    r"""Close price of the previous trading day."""
+    high: NotRequired[float]
+    r"""High price of the previous trading day."""
+    low: NotRequired[float]
+    r"""Low price of the previous trading day."""
+    open: NotRequired[float]
+    r"""Open price of the previous trading day."""
+    volume: NotRequired[int]
+    r"""Trading volume of the previous trading day."""
+    vwap: NotRequired[float]
+    r"""Volume-weighted average price of the previous trading day."""
+
+
+class PrevDay(BaseModel):
+    r"""Previous day aggregate"""
+
+    close: Optional[float] = None
+    r"""Close price of the previous trading day."""
+
+    high: Optional[float] = None
+    r"""High price of the previous trading day."""
+
+    low: Optional[float] = None
+    r"""Low price of the previous trading day."""
+
+    open: Optional[float] = None
+    r"""Open price of the previous trading day."""
+
+    volume: Optional[int] = None
+    r"""Trading volume of the previous trading day."""
+
+    vwap: Optional[float] = None
+    r"""Volume-weighted average price of the previous trading day."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["close", "high", "low", "open", "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
+
+
+class TickerTypedDict(TypedDict):
+    day: NotRequired[DayTypedDict]
+    r"""Current day aggregate"""
+    last_quote: NotRequired[LastQuoteTypedDict]
+    r"""Last quote information"""
+    last_trade: NotRequired[LastTradeTypedDict]
+    r"""Last trade information"""
+    min: NotRequired[MinTypedDict]
+    r"""Latest minute aggregate"""
+    prev_day: NotRequired[PrevDayTypedDict]
+    r"""Previous day aggregate"""
+    ticker: NotRequired[str]
+    r"""Ticker symbol"""
+    todays_change: NotRequired[float]
+    r"""Today's change"""
+    todays_change_perc: NotRequired[float]
+    r"""Today's change percent"""
+    updated: NotRequired[int]
+    r"""Last updated timestamp"""
+
+
+class Ticker(BaseModel):
+    day: Optional[Day] = None
+    r"""Current day aggregate"""
+
+    last_quote: Annotated[Optional[LastQuote], pydantic.Field(alias="lastQuote")] = None
+    r"""Last quote information"""
+
+    last_trade: Annotated[Optional[LastTrade], pydantic.Field(alias="lastTrade")] = None
+    r"""Last trade information"""
+
+    min: Optional[Min] = None
+    r"""Latest minute aggregate"""
+
+    prev_day: Annotated[Optional[PrevDay], pydantic.Field(alias="prevDay")] = None
+    r"""Previous day aggregate"""
+
+    ticker: Optional[str] = None
+    r"""Ticker symbol"""
+
+    todays_change: Annotated[Optional[float], pydantic.Field(alias="todaysChange")] = (
+        None
+    )
+    r"""Today's change"""
+
+    todays_change_perc: Annotated[
+        Optional[float], pydantic.Field(alias="todaysChangePerc")
+    ] = None
+    r"""Today's change percent"""
+
+    updated: Optional[int] = None
+    r"""Last updated timestamp"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "day",
+                "lastQuote",
+                "lastTrade",
+                "min",
+                "prevDay",
+                "ticker",
+                "todaysChange",
+                "todaysChangePerc",
+                "updated",
+            ]
+        )
+        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 StockSnapshotsResponseTypedDict(TypedDict):
+    r"""Market snapshots for a set of stock tickers, including the current day aggregate, last quote, last trade, latest minute aggregate and previous day aggregate."""
+
+    count: NotRequired[int]
+    r"""Number of tickers returned"""
+    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."""
+    tickers: NotRequired[List[TickerTypedDict]]
+    r"""Array of ticker snapshots"""
+
+
+class StockSnapshotsResponse(BaseModel):
+    r"""Market snapshots for a set of stock tickers, including the current day aggregate, last quote, last trade, latest minute aggregate and previous day aggregate."""
+
+    count: Optional[int] = None
+    r"""Number of tickers returned"""
+
+    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."""
+
+    tickers: Optional[List[Ticker]] = None
+    r"""Array of ticker snapshots"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["count", "status", "tickers"])
+        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:
+    LastQuote.model_rebuild()
+except NameError:
+    pass
+try:
+    LastTrade.model_rebuild()
+except NameError:
+    pass
+try:
+    Min.model_rebuild()
+except NameError:
+    pass
+try:
+    Ticker.model_rebuild()
+except NameError:
+    pass

finance_dev/models/stocksplitsresponse.py

@@ -0,0 +1,144 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 1ce8dc4aacb1
+
+from __future__ import annotations
+from datetime import date
+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 AdjustmentType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Type of stock split adjustment"""
+
+    FORWARD_SPLIT = "forward_split"
+    REVERSE_SPLIT = "reverse_split"
+    STOCK_DIVIDEND = "stock_dividend"
+
+
+class StockSplitsResponseResultTypedDict(TypedDict):
+    execution_date: date
+    r"""Execution date of the split in YYYY-MM-DD format"""
+    split_from: float
+    r"""The pre-split factor in the split ratio"""
+    split_to: float
+    r"""The post-split factor in the split ratio"""
+    ticker: str
+    r"""Stock ticker symbol, such as AAPL. Use the exact ticker for the company you want to research."""
+    adjustment_type: NotRequired[AdjustmentType]
+    r"""Type of stock split adjustment"""
+    historical_adjustment_factor: NotRequired[float]
+    r"""Factor used to adjust historical prices"""
+    id: NotRequired[str]
+    r"""Stock split event identifier"""
+
+
+class StockSplitsResponseResult(BaseModel):
+    execution_date: Annotated[date, pydantic.Field(alias="executionDate")]
+    r"""Execution date of the split in YYYY-MM-DD format"""
+
+    split_from: Annotated[float, pydantic.Field(alias="splitFrom")]
+    r"""The pre-split factor in the split ratio"""
+
+    split_to: Annotated[float, pydantic.Field(alias="splitTo")]
+    r"""The post-split factor in the split ratio"""
+
+    ticker: str
+    r"""Stock ticker symbol, such as AAPL. Use the exact ticker for the company you want to research."""
+
+    adjustment_type: Annotated[
+        Optional[AdjustmentType], pydantic.Field(alias="adjustmentType")
+    ] = None
+    r"""Type of stock split adjustment"""
+
+    historical_adjustment_factor: Annotated[
+        Optional[float], pydantic.Field(alias="historicalAdjustmentFactor")
+    ] = None
+    r"""Factor used to adjust historical prices"""
+
+    id: Optional[str] = None
+    r"""Stock split event identifier"""
+
+    @field_serializer("adjustment_type")
+    def serialize_adjustment_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.AdjustmentType(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["adjustmentType", "historicalAdjustmentFactor", "id"])
+        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 StockSplitsResponseTypedDict(TypedDict):
+    r"""Stock split events with ratio and adjustment details, as returned by the upstream data provider."""
+
+    results: List[StockSplitsResponseResultTypedDict]
+    r"""Array of stock split events"""
+    status: 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."""
+    next_url: NotRequired[str]
+    r"""Pagination URL for the next page, when available"""
+    request_id: NotRequired[str]
+    r"""Provider request identifier, when available"""
+
+
+class StockSplitsResponse(BaseModel):
+    r"""Stock split events with ratio and adjustment details, as returned by the upstream data provider."""
+
+    results: List[StockSplitsResponseResult]
+    r"""Array of stock split events"""
+
+    status: 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."""
+
+    next_url: Annotated[Optional[str], pydantic.Field(alias="nextUrl")] = None
+    r"""Pagination URL for the next page, when available"""
+
+    request_id: Annotated[Optional[str], pydantic.Field(alias="requestId")] = None
+    r"""Provider request identifier, when available"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["nextUrl", "requestId"])
+        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:
+    StockSplitsResponseResult.model_rebuild()
+except NameError:
+    pass
+try:
+    StockSplitsResponse.model_rebuild()
+except NameError:
+    pass