finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/stocktradesresponse.py

@@ -0,0 +1,164 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 2b6bdc510e4a
+
+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 StockTradesResponseResultTypedDict(TypedDict):
+    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 (nanoseconds)"""
+    price: NotRequired[float]
+    r"""Trade price"""
+    sequence_number: NotRequired[int]
+    r"""Sequence number"""
+    sip_timestamp: NotRequired[int]
+    r"""SIP timestamp (nanoseconds)"""
+    size: NotRequired[float]
+    r"""Trade size (shares)"""
+    tape: NotRequired[int]
+    r"""Tape"""
+    trf_id: NotRequired[int]
+    r"""TRF ID"""
+    trf_timestamp: NotRequired[int]
+    r"""TRF timestamp"""
+
+
+class StockTradesResponseResult(BaseModel):
+    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 (nanoseconds)"""
+
+    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 (nanoseconds)"""
+
+    size: Optional[float] = None
+    r"""Trade size (shares)"""
+
+    tape: Optional[int] = None
+    r"""Tape"""
+
+    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",
+                "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 StockTradesResponseTypedDict(TypedDict):
+    r"""Paginated list of historical tick-level trades 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[StockTradesResponseResultTypedDict]]
+    r"""Array of trade 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 StockTradesResponse(BaseModel):
+    r"""Paginated list of historical tick-level trades 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[StockTradesResponseResult]] = None
+    r"""Array of trade 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:
+    StockTradesResponseResult.model_rebuild()
+except NameError:
+    pass
+try:
+    StockTradesResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/supplychainresponse.py

@@ -0,0 +1,158 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 1edd5fdda7b1
+
+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 SupplyChainResponseDataTypedDict(TypedDict):
+    country: NotRequired[str]
+    r"""Country of the related company."""
+    customer: NotRequired[bool]
+    r"""Whether the related company is a customer."""
+    industry: NotRequired[str]
+    r"""Industry of the related company."""
+    name: NotRequired[str]
+    r"""Name of the related company."""
+    one_month_correlation: NotRequired[float]
+    r"""Price correlation with the related company over one month."""
+    one_year_correlation: NotRequired[float]
+    r"""Price correlation with the related company over one year."""
+    six_month_correlation: NotRequired[float]
+    r"""Price correlation with the related company over six months."""
+    supplier: NotRequired[bool]
+    r"""Whether the related company is a supplier."""
+    symbol: NotRequired[str]
+    r"""Ticker symbol of the related company."""
+    three_month_correlation: NotRequired[float]
+    r"""Price correlation with the related company over three months."""
+    two_week_correlation: NotRequired[float]
+    r"""Price correlation with the related company over two weeks."""
+    two_year_correlation: NotRequired[float]
+    r"""Price correlation with the related company over two years."""
+
+
+class SupplyChainResponseData(BaseModel):
+    country: Optional[str] = None
+    r"""Country of the related company."""
+
+    customer: Optional[bool] = None
+    r"""Whether the related company is a customer."""
+
+    industry: Optional[str] = None
+    r"""Industry of the related company."""
+
+    name: Optional[str] = None
+    r"""Name of the related company."""
+
+    one_month_correlation: Annotated[
+        Optional[float], pydantic.Field(alias="oneMonthCorrelation")
+    ] = None
+    r"""Price correlation with the related company over one month."""
+
+    one_year_correlation: Annotated[
+        Optional[float], pydantic.Field(alias="oneYearCorrelation")
+    ] = None
+    r"""Price correlation with the related company over one year."""
+
+    six_month_correlation: Annotated[
+        Optional[float], pydantic.Field(alias="sixMonthCorrelation")
+    ] = None
+    r"""Price correlation with the related company over six months."""
+
+    supplier: Optional[bool] = None
+    r"""Whether the related company is a supplier."""
+
+    symbol: Optional[str] = None
+    r"""Ticker symbol of the related company."""
+
+    three_month_correlation: Annotated[
+        Optional[float], pydantic.Field(alias="threeMonthCorrelation")
+    ] = None
+    r"""Price correlation with the related company over three months."""
+
+    two_week_correlation: Annotated[
+        Optional[float], pydantic.Field(alias="twoWeekCorrelation")
+    ] = None
+    r"""Price correlation with the related company over two weeks."""
+
+    two_year_correlation: Annotated[
+        Optional[float], pydantic.Field(alias="twoYearCorrelation")
+    ] = None
+    r"""Price correlation with the related company over two years."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "country",
+                "customer",
+                "industry",
+                "name",
+                "oneMonthCorrelation",
+                "oneYearCorrelation",
+                "sixMonthCorrelation",
+                "supplier",
+                "symbol",
+                "threeMonthCorrelation",
+                "twoWeekCorrelation",
+                "twoYearCorrelation",
+            ]
+        )
+        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 SupplyChainResponseTypedDict(TypedDict):
+    r"""Supply chain relationships (suppliers and customers) for a company."""
+
+    data: NotRequired[List[SupplyChainResponseDataTypedDict]]
+    r"""Related companies in the supply chain."""
+    symbol: NotRequired[str]
+    r"""Ticker symbol of the company."""
+
+
+class SupplyChainResponse(BaseModel):
+    r"""Supply chain relationships (suppliers and customers) for a company."""
+
+    data: Optional[List[SupplyChainResponseData]] = None
+    r"""Related companies in the supply chain."""
+
+    symbol: Optional[str] = None
+    r"""Ticker symbol of the company."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["data", "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:
+    SupplyChainResponseData.model_rebuild()
+except NameError:
+    pass

finance_dev/models/supportresistancelevelsresponse.py

@@ -0,0 +1,68 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 7ce068aa1c31
+
+from __future__ import annotations
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class SupportResistanceLevelsResponseDataTypedDict(TypedDict):
+    r"""Support and resistance payload."""
+
+    levels: NotRequired[List[float]]
+    r"""List of support and resistance price levels."""
+
+
+class SupportResistanceLevelsResponseData(BaseModel):
+    r"""Support and resistance payload."""
+
+    levels: Optional[List[float]] = None
+    r"""List of support and resistance price levels."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["levels"])
+        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 SupportResistanceLevelsResponseTypedDict(TypedDict):
+    r"""Support and resistance price levels for a symbol and resolution from Finnhub."""
+
+    data: NotRequired[SupportResistanceLevelsResponseDataTypedDict]
+    r"""Support and resistance payload."""
+
+
+class SupportResistanceLevelsResponse(BaseModel):
+    r"""Support and resistance price levels for a symbol and resolution from Finnhub."""
+
+    data: Optional[SupportResistanceLevelsResponseData] = None
+    r"""Support and resistance payload."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["data"])
+        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/symboldetails.py

@@ -0,0 +1,119 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 1c2726ca5c1b
+
+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 SymbolDetailsTypedDict(TypedDict):
+    r"""Compact symbol summary returned by top movers and activity endpoints. Use it for market lists such as gainers, losers, and most active."""
+
+    change: NotRequired[float]
+    r"""Price change from previous close"""
+    change_percent: NotRequired[float]
+    r"""Percentage change from previous close"""
+    is_etf: NotRequired[bool]
+    r"""Whether the symbol is an ETF"""
+    last_price: NotRequired[float]
+    r"""Most recent trading price"""
+    logo_url: NotRequired[str]
+    r"""URL to the company or ETF logo. Use it for visual identification in symbol lists."""
+    previous_close: NotRequired[float]
+    r"""Previous session close price. Use it as the baseline for change and changePercent."""
+    sector: NotRequired[str]
+    r"""Sector classification for the asset. Use it for grouping and filtering symbol lists."""
+    sic_code: NotRequired[str]
+    r"""Standard Industrial Classification code"""
+    symbol: NotRequired[str]
+    r"""Trading symbol for the asset. Use this exact value when fetching quotes, charts, or research."""
+    timestamp: NotRequired[float]
+    r"""Timestamp of the last update"""
+    type: NotRequired[str]
+    r"""Instrument class or provider category returned by the market data service. This value is not the trading order type."""
+    volume: NotRequired[float]
+    r"""Shares or contracts traded during the session. Use it to rank activity and liquidity."""
+
+
+class SymbolDetails(BaseModel):
+    r"""Compact symbol summary returned by top movers and activity endpoints. Use it for market lists such as gainers, losers, and most active."""
+
+    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"""
+
+    is_etf: Annotated[Optional[bool], pydantic.Field(alias="isETF")] = None
+    r"""Whether the symbol is an ETF"""
+
+    last_price: Annotated[Optional[float], pydantic.Field(alias="lastPrice")] = None
+    r"""Most recent trading price"""
+
+    logo_url: Annotated[Optional[str], pydantic.Field(alias="logoUrl")] = None
+    r"""URL to the company or ETF logo. Use it for visual identification in symbol lists."""
+
+    previous_close: Annotated[
+        Optional[float], pydantic.Field(alias="previousClose")
+    ] = None
+    r"""Previous session close price. Use it as the baseline for change and changePercent."""
+
+    sector: Optional[str] = None
+    r"""Sector classification for the asset. Use it for grouping and filtering symbol lists."""
+
+    sic_code: Annotated[Optional[str], pydantic.Field(alias="sicCode")] = None
+    r"""Standard Industrial Classification code"""
+
+    symbol: Optional[str] = None
+    r"""Trading symbol for the asset. Use this exact value when fetching quotes, charts, or research."""
+
+    timestamp: Optional[float] = None
+    r"""Timestamp of the last update"""
+
+    type: Optional[str] = None
+    r"""Instrument class or provider category returned by the market data service. This value is not the trading order type."""
+
+    volume: Optional[float] = None
+    r"""Shares or contracts traded during the session. Use it to rank activity and liquidity."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "change",
+                "changePercent",
+                "isETF",
+                "lastPrice",
+                "logoUrl",
+                "previousClose",
+                "sector",
+                "sicCode",
+                "symbol",
+                "timestamp",
+                "type",
+                "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:
+    SymbolDetails.model_rebuild()
+except NameError:
+    pass

finance_dev/models/symbolerror.py

@@ -0,0 +1,43 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: c5c04db1a652
+
+from __future__ import annotations
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class SymbolErrorTypedDict(TypedDict):
+    r"""Error entry for a symbol that could not be resolved in a details request."""
+
+    error: NotRequired[str]
+    r"""Error detail as a string. Exact message content is not fixed and should not be hard-coded."""
+    symbol: NotRequired[str]
+    r"""Symbol that had an error"""
+
+
+class SymbolError(BaseModel):
+    r"""Error entry for a symbol that could not be resolved in a details request."""
+
+    error: Optional[str] = None
+    r"""Error detail as a string. Exact message content is not fixed and should not be hard-coded."""
+
+    symbol: Optional[str] = None
+    r"""Symbol that had an error"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["error", "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