finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/unifiedsnapshotresponse.py

@@ -0,0 +1,308 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: d7732ad18976
+
+from __future__ import annotations
+from .optionsnapshotcontractdetails import (
+    OptionSnapshotContractDetails,
+    OptionSnapshotContractDetailsTypedDict,
+)
+from .optionsnapshotdaybar import OptionSnapshotDayBar, OptionSnapshotDayBarTypedDict
+from .optionsnapshotgreeks import OptionSnapshotGreeks, OptionSnapshotGreeksTypedDict
+from .optionsnapshotlastquote import (
+    OptionSnapshotLastQuote,
+    OptionSnapshotLastQuoteTypedDict,
+)
+from .optionsnapshotlasttrade import (
+    OptionSnapshotLastTrade,
+    OptionSnapshotLastTradeTypedDict,
+)
+from .optionsnapshotunderlying import (
+    OptionSnapshotUnderlying,
+    OptionSnapshotUnderlyingTypedDict,
+)
+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 LastMinuteTypedDict(TypedDict):
+    r"""Last minute aggregate"""
+
+    close: NotRequired[float]
+    r"""Close price of the last minute aggregate."""
+    high: NotRequired[float]
+    r"""High price of the last minute aggregate."""
+    low: NotRequired[float]
+    r"""Low price of the last minute aggregate."""
+    open: NotRequired[float]
+    r"""Open price of the last minute aggregate."""
+    transactions: NotRequired[int]
+    r"""Number of transactions in the last minute aggregate."""
+    volume: NotRequired[int]
+    r"""Trading volume in the last minute aggregate."""
+    vwap: NotRequired[float]
+    r"""Volume-weighted average price of the last minute aggregate."""
+
+
+class LastMinute(BaseModel):
+    r"""Last minute aggregate"""
+
+    close: Optional[float] = None
+    r"""Close price of the last minute aggregate."""
+
+    high: Optional[float] = None
+    r"""High price of the last minute aggregate."""
+
+    low: Optional[float] = None
+    r"""Low price of the last minute aggregate."""
+
+    open: Optional[float] = None
+    r"""Open price of the last minute aggregate."""
+
+    transactions: Optional[int] = None
+    r"""Number of transactions in the last minute aggregate."""
+
+    volume: Optional[int] = None
+    r"""Trading volume in the last minute aggregate."""
+
+    vwap: Optional[float] = None
+    r"""Volume-weighted average price of the last minute aggregate."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["close", "high", "low", "open", "transactions", "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 UnifiedSnapshotResponseResultTypedDict(TypedDict):
+    break_even_price: NotRequired[float]
+    r"""Options-only break-even price when available"""
+    details: NotRequired[OptionSnapshotContractDetailsTypedDict]
+    r"""Static contract metadata (`OptionSnapshotDetailsDTO`)."""
+    error: NotRequired[str]
+    r"""Per-item error, when returned"""
+    fmv: NotRequired[float]
+    r"""Fair market value"""
+    fmv_last_updated: NotRequired[int]
+    r"""FMV last updated timestamp"""
+    greeks: NotRequired[OptionSnapshotGreeksTypedDict]
+    r"""Greeks when available (`OptionSnapshotGreeksDTO`)."""
+    implied_volatility: NotRequired[float]
+    r"""Options implied volatility when available"""
+    last_minute: NotRequired[LastMinuteTypedDict]
+    r"""Last minute aggregate"""
+    last_quote: NotRequired[OptionSnapshotLastQuoteTypedDict]
+    r"""Latest NBBO quote when included (`OptionSnapshotLastQuoteDTO`)."""
+    last_trade: NotRequired[OptionSnapshotLastTradeTypedDict]
+    r"""Latest trade when included (`OptionSnapshotLastTradeDTO`)."""
+    last_updated: NotRequired[int]
+    r"""Item-level last updated timestamp, when available"""
+    market_status: NotRequired[str]
+    r"""Market status"""
+    message: NotRequired[str]
+    r"""Per-item message, when returned"""
+    name: NotRequired[str]
+    r"""Company name"""
+    open_interest: NotRequired[int]
+    r"""Options open interest when available"""
+    session: NotRequired[OptionSnapshotDayBarTypedDict]
+    r"""Most recent daily OHLCV bar for the contract (`OptionSnapshotDayBarDTO`)."""
+    ticker: NotRequired[str]
+    r"""Ticker symbol"""
+    timeframe: NotRequired[str]
+    r"""Timeframe for the item, when available"""
+    type: NotRequired[str]
+    r"""Asset class returned by the provider, such as stocks or options."""
+    underlying_asset: NotRequired[OptionSnapshotUnderlyingTypedDict]
+    r"""Underlying equity snapshot (`OptionSnapshotUnderlyingDTO`)."""
+    value: NotRequired[float]
+    r"""Value field, when available"""
+
+
+class UnifiedSnapshotResponseResult(BaseModel):
+    break_even_price: Annotated[
+        Optional[float], pydantic.Field(alias="breakEvenPrice")
+    ] = None
+    r"""Options-only break-even price when available"""
+
+    details: Optional[OptionSnapshotContractDetails] = None
+    r"""Static contract metadata (`OptionSnapshotDetailsDTO`)."""
+
+    error: Optional[str] = None
+    r"""Per-item error, when returned"""
+
+    fmv: Optional[float] = None
+    r"""Fair market value"""
+
+    fmv_last_updated: Annotated[
+        Optional[int], pydantic.Field(alias="fmvLastUpdated")
+    ] = None
+    r"""FMV last updated timestamp"""
+
+    greeks: Optional[OptionSnapshotGreeks] = None
+    r"""Greeks when available (`OptionSnapshotGreeksDTO`)."""
+
+    implied_volatility: Annotated[
+        Optional[float], pydantic.Field(alias="impliedVolatility")
+    ] = None
+    r"""Options implied volatility when available"""
+
+    last_minute: Annotated[Optional[LastMinute], pydantic.Field(alias="lastMinute")] = (
+        None
+    )
+    r"""Last minute aggregate"""
+
+    last_quote: Annotated[
+        Optional[OptionSnapshotLastQuote], pydantic.Field(alias="lastQuote")
+    ] = None
+    r"""Latest NBBO quote when included (`OptionSnapshotLastQuoteDTO`)."""
+
+    last_trade: Annotated[
+        Optional[OptionSnapshotLastTrade], pydantic.Field(alias="lastTrade")
+    ] = None
+    r"""Latest trade when included (`OptionSnapshotLastTradeDTO`)."""
+
+    last_updated: Annotated[Optional[int], pydantic.Field(alias="lastUpdated")] = None
+    r"""Item-level last updated timestamp, when available"""
+
+    market_status: Annotated[Optional[str], pydantic.Field(alias="marketStatus")] = None
+    r"""Market status"""
+
+    message: Optional[str] = None
+    r"""Per-item message, when returned"""
+
+    name: Optional[str] = None
+    r"""Company name"""
+
+    open_interest: Annotated[Optional[int], pydantic.Field(alias="openInterest")] = None
+    r"""Options open interest when available"""
+
+    session: Optional[OptionSnapshotDayBar] = None
+    r"""Most recent daily OHLCV bar for the contract (`OptionSnapshotDayBarDTO`)."""
+
+    ticker: Optional[str] = None
+    r"""Ticker symbol"""
+
+    timeframe: Optional[str] = None
+    r"""Timeframe for the item, when available"""
+
+    type: Optional[str] = None
+    r"""Asset class returned by the provider, such as stocks or options."""
+
+    underlying_asset: Annotated[
+        Optional[OptionSnapshotUnderlying], pydantic.Field(alias="underlyingAsset")
+    ] = None
+    r"""Underlying equity snapshot (`OptionSnapshotUnderlyingDTO`)."""
+
+    value: Optional[float] = None
+    r"""Value field, when available"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "breakEvenPrice",
+                "details",
+                "error",
+                "fmv",
+                "fmvLastUpdated",
+                "greeks",
+                "impliedVolatility",
+                "lastMinute",
+                "lastQuote",
+                "lastTrade",
+                "lastUpdated",
+                "marketStatus",
+                "message",
+                "name",
+                "openInterest",
+                "session",
+                "ticker",
+                "timeframe",
+                "type",
+                "underlyingAsset",
+                "value",
+            ]
+        )
+        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 UnifiedSnapshotResponseTypedDict(TypedDict):
+    r"""Paginated unified snapshots across asset types, including stocks and options, with last quote, last trade and latest minute aggregate per item."""
+
+    next_url: NotRequired[str]
+    r"""URL for next page of results"""
+    request_id: NotRequired[str]
+    r"""Unique request ID"""
+    results: NotRequired[List[UnifiedSnapshotResponseResultTypedDict]]
+    r"""Array of unified snapshots"""
+    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 UnifiedSnapshotResponse(BaseModel):
+    r"""Paginated unified snapshots across asset types, including stocks and options, with last quote, last trade and latest minute aggregate per item."""
+
+    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[UnifiedSnapshotResponseResult]] = None
+    r"""Array of unified snapshots"""
+
+    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:
+    UnifiedSnapshotResponseResult.model_rebuild()
+except NameError:
+    pass
+try:
+    UnifiedSnapshotResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/updateconfigwatchlistbyidop.py

@@ -0,0 +1,65 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: ebd6b51101d5
+
+from __future__ import annotations
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .updatewatchlistrequest_union import (
+    UpdateWatchlistRequestUnion,
+    UpdateWatchlistRequestUnionTypedDict,
+)
+from .watchlist import Watchlist, WatchlistTypedDict
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from finance_dev.utils import FieldMetadata, PathParamMetadata, RequestMetadata
+import pydantic
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class UpdateConfigWatchlistByIDRequestTypedDict(TypedDict):
+    watchlist_id: int
+    r"""The numeric ID of the watchlist to update. You can get this from a previous list/create/update response (the `id` field in the returned watchlist)."""
+    update_watchlist_request: UpdateWatchlistRequestUnionTypedDict
+    r"""At least one of `name`, `add_symbols`, or `remove_symbols` must be included."""
+
+
+class UpdateConfigWatchlistByIDRequest(BaseModel):
+    watchlist_id: Annotated[
+        int, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
+    ]
+    r"""The numeric ID of the watchlist to update. You can get this from a previous list/create/update response (the `id` field in the returned watchlist)."""
+
+    update_watchlist_request: Annotated[
+        UpdateWatchlistRequestUnion,
+        FieldMetadata(request=RequestMetadata(media_type="application/json")),
+    ]
+    r"""At least one of `name`, `add_symbols`, or `remove_symbols` must be included."""
+
+
+class UpdateConfigWatchlistByIDResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    watchlist: NotRequired[WatchlistTypedDict]
+    r"""Watchlist updated. The response contains the full, updated watchlist; check `invalid_symbols` for any submitted symbols that were dropped."""
+
+
+class UpdateConfigWatchlistByIDResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    watchlist: Optional[Watchlist] = None
+    r"""Watchlist updated. The response contains the full, updated watchlist; check `invalid_symbols` for any submitted symbols that were dropped."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["Watchlist"])
+        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/updatewatchlistrequest_union.py

@@ -0,0 +1,134 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 5667a6ca5147
+
+from __future__ import annotations
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import List, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
+
+
+class UpdateWatchlistRequest3TypedDict(TypedDict):
+    remove_symbols: List[str]
+    r"""Symbols to remove from the watchlist."""
+    add_symbols: NotRequired[List[str]]
+    r"""Symbols to add to the watchlist. Use exact uppercase ticker symbols; symbols that can't be resolved are dropped and returned in the response's `invalid_symbols` field."""
+    name: NotRequired[str]
+    r"""New name for the watchlist. Omit to leave the name unchanged; if included, it cannot be empty and must not match the name of another of the user's watchlists (case-sensitive)."""
+
+
+class UpdateWatchlistRequest3(BaseModel):
+    remove_symbols: List[str]
+    r"""Symbols to remove from the watchlist."""
+
+    add_symbols: Optional[List[str]] = None
+    r"""Symbols to add to the watchlist. Use exact uppercase ticker symbols; symbols that can't be resolved are dropped and returned in the response's `invalid_symbols` field."""
+
+    name: Optional[str] = None
+    r"""New name for the watchlist. Omit to leave the name unchanged; if included, it cannot be empty and must not match the name of another of the user's watchlists (case-sensitive)."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["add_symbols", "name"])
+        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 UpdateWatchlistRequest2TypedDict(TypedDict):
+    add_symbols: List[str]
+    r"""Symbols to add to the watchlist. Use exact uppercase ticker symbols; symbols that can't be resolved are dropped and returned in the response's `invalid_symbols` field."""
+    name: NotRequired[str]
+    r"""New name for the watchlist. Omit to leave the name unchanged; if included, it cannot be empty and must not match the name of another of the user's watchlists (case-sensitive)."""
+    remove_symbols: NotRequired[List[str]]
+    r"""Symbols to remove from the watchlist."""
+
+
+class UpdateWatchlistRequest2(BaseModel):
+    add_symbols: List[str]
+    r"""Symbols to add to the watchlist. Use exact uppercase ticker symbols; symbols that can't be resolved are dropped and returned in the response's `invalid_symbols` field."""
+
+    name: Optional[str] = None
+    r"""New name for the watchlist. Omit to leave the name unchanged; if included, it cannot be empty and must not match the name of another of the user's watchlists (case-sensitive)."""
+
+    remove_symbols: Optional[List[str]] = None
+    r"""Symbols to remove from the watchlist."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["name", "remove_symbols"])
+        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 UpdateWatchlistRequest1TypedDict(TypedDict):
+    name: str
+    r"""New name for the watchlist. Omit to leave the name unchanged; if included, it cannot be empty and must not match the name of another of the user's watchlists (case-sensitive)."""
+    add_symbols: NotRequired[List[str]]
+    r"""Symbols to add to the watchlist. Use exact uppercase ticker symbols; symbols that can't be resolved are dropped and returned in the response's `invalid_symbols` field."""
+    remove_symbols: NotRequired[List[str]]
+    r"""Symbols to remove from the watchlist."""
+
+
+class UpdateWatchlistRequest1(BaseModel):
+    name: str
+    r"""New name for the watchlist. Omit to leave the name unchanged; if included, it cannot be empty and must not match the name of another of the user's watchlists (case-sensitive)."""
+
+    add_symbols: Optional[List[str]] = None
+    r"""Symbols to add to the watchlist. Use exact uppercase ticker symbols; symbols that can't be resolved are dropped and returned in the response's `invalid_symbols` field."""
+
+    remove_symbols: Optional[List[str]] = None
+    r"""Symbols to remove from the watchlist."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["add_symbols", "remove_symbols"])
+        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
+
+
+UpdateWatchlistRequestUnionTypedDict = TypeAliasType(
+    "UpdateWatchlistRequestUnionTypedDict",
+    Union[
+        UpdateWatchlistRequest1TypedDict,
+        UpdateWatchlistRequest2TypedDict,
+        UpdateWatchlistRequest3TypedDict,
+    ],
+)
+r"""Request body for partially updating a watchlist. Include at least one of `name`, `add_symbols`, or `remove_symbols`."""
+
+
+UpdateWatchlistRequestUnion = TypeAliasType(
+    "UpdateWatchlistRequestUnion",
+    Union[UpdateWatchlistRequest1, UpdateWatchlistRequest2, UpdateWatchlistRequest3],
+)
+r"""Request body for partially updating a watchlist. Include at least one of `name`, `add_symbols`, or `remove_symbols`."""

finance_dev/models/upgradesdowngradesresponse.py

@@ -0,0 +1,98 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 172f3b892ed5
+
+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 UpgradesDowngradesResponseDataTypedDict(TypedDict):
+    action: NotRequired[str]
+    r"""Type of rating action, such as upgrade, downgrade, initiate or maintain"""
+    company: NotRequired[str]
+    r"""Name of the firm that issued the rating change"""
+    from_grade: NotRequired[str]
+    r"""Previous rating"""
+    grade_time: NotRequired[int]
+    r"""Time of the rating change as a Unix timestamp"""
+    symbol: NotRequired[str]
+    r"""Stock ticker symbol"""
+    to_grade: NotRequired[str]
+    r"""New rating"""
+
+
+class UpgradesDowngradesResponseData(BaseModel):
+    action: Optional[str] = None
+    r"""Type of rating action, such as upgrade, downgrade, initiate or maintain"""
+
+    company: Optional[str] = None
+    r"""Name of the firm that issued the rating change"""
+
+    from_grade: Annotated[Optional[str], pydantic.Field(alias="fromGrade")] = None
+    r"""Previous rating"""
+
+    grade_time: Annotated[Optional[int], pydantic.Field(alias="gradeTime")] = None
+    r"""Time of the rating change as a Unix timestamp"""
+
+    symbol: Optional[str] = None
+    r"""Stock ticker symbol"""
+
+    to_grade: Annotated[Optional[str], pydantic.Field(alias="toGrade")] = None
+    r"""New rating"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["action", "company", "fromGrade", "gradeTime", "symbol", "toGrade"]
+        )
+        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 UpgradesDowngradesResponseTypedDict(TypedDict):
+    r"""Analyst rating upgrades and downgrades for a stock, sourced from Finnhub."""
+
+    data: NotRequired[List[UpgradesDowngradesResponseDataTypedDict]]
+    r"""List of analyst rating change events"""
+
+
+class UpgradesDowngradesResponse(BaseModel):
+    r"""Analyst rating upgrades and downgrades for a stock, sourced from Finnhub."""
+
+    data: Optional[List[UpgradesDowngradesResponseData]] = None
+    r"""List of analyst rating change events"""
+
+    @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
+
+
+try:
+    UpgradesDowngradesResponseData.model_rebuild()
+except NameError:
+    pass