finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/createwatchlistrequest.py

@@ -0,0 +1,43 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 69fc27baa900
+
+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 CreateWatchlistRequestTypedDict(TypedDict):
+    r"""Request body for creating a new watchlist."""
+
+    name: str
+    r"""User-facing name for the new watchlist, such as Tech Stocks or Dividend Ideas. Must not match the name of another watchlist the user already has (case-sensitive)."""
+    symbols: NotRequired[List[str]]
+    r"""Symbols to save in the new watchlist. Use exact uppercase ticker symbols; symbols that can't be resolved are dropped from the saved list and returned in the response's `invalid_symbols` field."""
+
+
+class CreateWatchlistRequest(BaseModel):
+    r"""Request body for creating a new watchlist."""
+
+    name: str
+    r"""User-facing name for the new watchlist, such as Tech Stocks or Dividend Ideas. Must not match the name of another watchlist the user already has (case-sensitive)."""
+
+    symbols: Optional[List[str]] = None
+    r"""Symbols to save in the new watchlist. Use exact uppercase ticker symbols; symbols that can't be resolved are dropped from the saved list and returned in the response's `invalid_symbols` field."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["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

finance_dev/models/dailymarketsummaryresponse.py

@@ -0,0 +1,73 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 915df4ff8b4f
+
+from __future__ import annotations
+from .stockohlcbar import StockOhlcBar, StockOhlcBarTypedDict
+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 DailyMarketSummaryResponseTypedDict(TypedDict):
+    r"""Daily OHLC bars for all stocks on a given trading date, as returned by the upstream data provider."""
+
+    adjusted: NotRequired[bool]
+    r"""Whether or not the results are adjusted for splits"""
+    query_count: NotRequired[int]
+    r"""Number of results returned"""
+    request_id: NotRequired[str]
+    r"""Unique request ID"""
+    results: NotRequired[List[StockOhlcBarTypedDict]]
+    r"""Array of grouped daily bars"""
+    results_count: NotRequired[int]
+    r"""Total number of results"""
+    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 DailyMarketSummaryResponse(BaseModel):
+    r"""Daily OHLC bars for all stocks on a given trading date, as returned by the upstream data provider."""
+
+    adjusted: Optional[bool] = None
+    r"""Whether or not the results are adjusted for splits"""
+
+    query_count: Annotated[Optional[int], pydantic.Field(alias="queryCount")] = None
+    r"""Number of results returned"""
+
+    request_id: Annotated[Optional[str], pydantic.Field(alias="requestId")] = None
+    r"""Unique request ID"""
+
+    results: Optional[List[StockOhlcBar]] = None
+    r"""Array of grouped daily bars"""
+
+    results_count: Annotated[Optional[int], pydantic.Field(alias="resultsCount")] = None
+    r"""Total number of results"""
+
+    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(
+            ["adjusted", "queryCount", "requestId", "results", "resultsCount", "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:
+    DailyMarketSummaryResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/deleteconfigwatchlistbyidop.py

@@ -0,0 +1,53 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 5a30a5f5c252
+
+from __future__ import annotations
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .watchlist import Watchlist, WatchlistTypedDict
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from finance_dev.utils import FieldMetadata, PathParamMetadata
+import pydantic
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class DeleteConfigWatchlistByIDRequestTypedDict(TypedDict):
+    watchlist_id: int
+    r"""The numeric ID of the watchlist to delete. You can get this from a previous list/create/update response (the `id` field in the returned watchlist)."""
+
+
+class DeleteConfigWatchlistByIDRequest(BaseModel):
+    watchlist_id: Annotated[
+        int, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
+    ]
+    r"""The numeric ID of the watchlist to delete. You can get this from a previous list/create/update response (the `id` field in the returned watchlist)."""
+
+
+class DeleteConfigWatchlistByIDResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    watchlist: NotRequired[WatchlistTypedDict]
+    r"""Watchlist deleted, or reset to default when it was the user's only remaining watchlist. The response body contains the affected watchlist."""
+
+
+class DeleteConfigWatchlistByIDResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    watchlist: Optional[Watchlist] = None
+    r"""Watchlist deleted, or reset to default when it was the user's only remaining watchlist. The response body contains the affected watchlist."""
+
+    @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/dividenditem.py

@@ -0,0 +1,125 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 311c61390943
+
+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 DividendItemTypedDict(TypedDict):
+    r"""A single dividend event for a ticker."""
+
+    cash_amount: NotRequired[float]
+    r"""Original cash dividend amount per share."""
+    currency: NotRequired[str]
+    r"""Currency code for the cash amount, such as USD."""
+    declaration_date: NotRequired[str]
+    r"""Date when the dividend was announced."""
+    distribution_type: NotRequired[str]
+    r"""Distribution classification such as recurring, special, supplemental, irregular, or unknown."""
+    ex_dividend_date: NotRequired[str]
+    r"""Date when the stock begins trading without the dividend."""
+    frequency: NotRequired[int]
+    r"""Times per year the dividend is paid, such as 0, 1, 4, or 12."""
+    historical_adjustment_factor: NotRequired[float]
+    r"""Adjustment factor used for historical-price normalization."""
+    id: NotRequired[str]
+    r"""Unique identifier for the dividend event."""
+    pay_date: NotRequired[str]
+    r"""Date when the dividend payment is distributed."""
+    record_date: NotRequired[str]
+    r"""Record date used to determine shareholder eligibility."""
+    split_adjusted_cash_amount: NotRequired[float]
+    r"""Dividend cash amount adjusted for stock splits."""
+    ticker: NotRequired[str]
+    r"""Stock ticker symbol"""
+
+
+class DividendItem(BaseModel):
+    r"""A single dividend event for a ticker."""
+
+    cash_amount: Annotated[Optional[float], pydantic.Field(alias="cashAmount")] = None
+    r"""Original cash dividend amount per share."""
+
+    currency: Optional[str] = None
+    r"""Currency code for the cash amount, such as USD."""
+
+    declaration_date: Annotated[
+        Optional[str], pydantic.Field(alias="declarationDate")
+    ] = None
+    r"""Date when the dividend was announced."""
+
+    distribution_type: Annotated[
+        Optional[str], pydantic.Field(alias="distributionType")
+    ] = None
+    r"""Distribution classification such as recurring, special, supplemental, irregular, or unknown."""
+
+    ex_dividend_date: Annotated[
+        Optional[str], pydantic.Field(alias="exDividendDate")
+    ] = None
+    r"""Date when the stock begins trading without the dividend."""
+
+    frequency: Optional[int] = None
+    r"""Times per year the dividend is paid, such as 0, 1, 4, or 12."""
+
+    historical_adjustment_factor: Annotated[
+        Optional[float], pydantic.Field(alias="historicalAdjustmentFactor")
+    ] = None
+    r"""Adjustment factor used for historical-price normalization."""
+
+    id: Optional[str] = None
+    r"""Unique identifier for the dividend event."""
+
+    pay_date: Annotated[Optional[str], pydantic.Field(alias="payDate")] = None
+    r"""Date when the dividend payment is distributed."""
+
+    record_date: Annotated[Optional[str], pydantic.Field(alias="recordDate")] = None
+    r"""Record date used to determine shareholder eligibility."""
+
+    split_adjusted_cash_amount: Annotated[
+        Optional[float], pydantic.Field(alias="splitAdjustedCashAmount")
+    ] = None
+    r"""Dividend cash amount adjusted for stock splits."""
+
+    ticker: Optional[str] = None
+    r"""Stock ticker symbol"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "cashAmount",
+                "currency",
+                "declarationDate",
+                "distributionType",
+                "exDividendDate",
+                "frequency",
+                "historicalAdjustmentFactor",
+                "id",
+                "payDate",
+                "recordDate",
+                "splitAdjustedCashAmount",
+                "ticker",
+            ]
+        )
+        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:
+    DividendItem.model_rebuild()
+except NameError:
+    pass

finance_dev/models/dividendsresponse.py

@@ -0,0 +1,61 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 61bbd2d2cfe5
+
+from __future__ import annotations
+from .dividenditem import DividendItem, DividendItemTypedDict
+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 DividendsResponseTypedDict(TypedDict):
+    r"""Paginated response containing dividend events."""
+
+    next_url: NotRequired[str]
+    r"""Opaque pagination URL for the next page of results when more data is available."""
+    request_id: NotRequired[str]
+    r"""Provider request identifier for tracing and support."""
+    results: NotRequired[List[DividendItemTypedDict]]
+    r"""Array of dividend payment events."""
+    status: NotRequired[str]
+    r"""Provider response status."""
+
+
+class DividendsResponse(BaseModel):
+    r"""Paginated response containing dividend events."""
+
+    next_url: Annotated[Optional[str], pydantic.Field(alias="nextUrl")] = None
+    r"""Opaque pagination URL for the next page of results when more data is available."""
+
+    request_id: Annotated[Optional[str], pydantic.Field(alias="requestId")] = None
+    r"""Provider request identifier for tracing and support."""
+
+    results: Optional[List[DividendItem]] = None
+    r"""Array of dividend payment events."""
+
+    status: Optional[str] = None
+    r"""Provider response status."""
+
+    @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:
+    DividendsResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/earningrelease.py

@@ -0,0 +1,291 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 1d7af08fb01d
+
+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 AnalystRatingTypedDict(TypedDict):
+    r"""Analyst ratings summary"""
+
+    average_return: NotRequired[str]
+    r"""Average return based on analyst recommendations"""
+    current_rating: NotRequired[str]
+    r"""Current analyst rating (e.g., Buy, Sell, Hold)"""
+    price_target: NotRequired[float]
+    r"""Average price target"""
+    success_rate: NotRequired[str]
+    r"""Historical success rate of analysts"""
+    total_ratings: NotRequired[int]
+    r"""Total number of analyst ratings"""
+
+
+class AnalystRating(BaseModel):
+    r"""Analyst ratings summary"""
+
+    average_return: Annotated[Optional[str], pydantic.Field(alias="averageReturn")] = (
+        None
+    )
+    r"""Average return based on analyst recommendations"""
+
+    current_rating: Annotated[Optional[str], pydantic.Field(alias="currentRating")] = (
+        None
+    )
+    r"""Current analyst rating (e.g., Buy, Sell, Hold)"""
+
+    price_target: Annotated[Optional[float], pydantic.Field(alias="priceTarget")] = None
+    r"""Average price target"""
+
+    success_rate: Annotated[Optional[str], pydantic.Field(alias="successRate")] = None
+    r"""Historical success rate of analysts"""
+
+    total_ratings: Annotated[Optional[int], pydantic.Field(alias="totalRatings")] = None
+    r"""Total number of analyst ratings"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "averageReturn",
+                "currentRating",
+                "priceTarget",
+                "successRate",
+                "totalRatings",
+            ]
+        )
+        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 LogoTypedDict(TypedDict):
+    r"""Company logos for UI display"""
+
+    logo_dark: NotRequired[str]
+    r"""Logo URL for dark theme"""
+    logo_light: NotRequired[str]
+    r"""Logo URL for light theme"""
+
+
+class Logo(BaseModel):
+    r"""Company logos for UI display"""
+
+    logo_dark: Annotated[Optional[str], pydantic.Field(alias="logoDark")] = None
+    r"""Logo URL for dark theme"""
+
+    logo_light: Annotated[Optional[str], pydantic.Field(alias="logoLight")] = None
+    r"""Logo URL for light theme"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["logoDark", "logoLight"])
+        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 EarningReleaseTypedDict(TypedDict):
+    r"""Earnings calendar entry for a company's earnings release, with actual and estimated figures."""
+
+    analyst_rating: NotRequired[AnalystRatingTypedDict]
+    r"""Analyst ratings summary"""
+    date_: NotRequired[str]
+    r"""Earnings release date"""
+    eps_actual: NotRequired[Nullable[float]]
+    r"""Actual earnings per share"""
+    eps_estimate: NotRequired[Nullable[float]]
+    r"""Estimated earnings per share"""
+    eps_surprise: NotRequired[Nullable[float]]
+    r"""Difference between actual and estimated EPS"""
+    hour: NotRequired[str]
+    r"""Time of day for earnings release: 'bmo' (before market open), 'amc' (after market close), 'dmh' (during market hours)"""
+    importance: NotRequired[int]
+    r"""Earnings event importance level (1-3, where 3 is most important). Use this to filter and prioritize high-impact earnings releases."""
+    logo: NotRequired[LogoTypedDict]
+    r"""Company logos for UI display"""
+    market_cap: NotRequired[Nullable[float]]
+    r"""Market capitalization in millions. Calculated as: (1) cached value if available and > 0, or (2) lastPrice × sharesOutstanding. Only present if both inputs are available."""
+    name: NotRequired[str]
+    r"""Company name"""
+    quarter: NotRequired[int]
+    r"""Quarter number (1-4)"""
+    revenue_actual: NotRequired[Nullable[float]]
+    r"""Actual revenue"""
+    revenue_estimate: NotRequired[Nullable[float]]
+    r"""Estimated revenue"""
+    revenue_surprise: NotRequired[Nullable[float]]
+    r"""Difference between actual and estimated revenue"""
+    symbol: NotRequired[str]
+    r"""Stock ticker symbol, such as AAPL. Use the exact ticker for the company you want to research."""
+    time: NotRequired[str]
+    r"""Time of day for earnings release: '16:39:00' 24 hours format"""
+    year: NotRequired[int]
+    r"""Year of the earnings"""
+
+
+class EarningRelease(BaseModel):
+    r"""Earnings calendar entry for a company's earnings release, with actual and estimated figures."""
+
+    analyst_rating: Annotated[
+        Optional[AnalystRating], pydantic.Field(alias="analystRating")
+    ] = None
+    r"""Analyst ratings summary"""
+
+    date_: Annotated[Optional[str], pydantic.Field(alias="date")] = None
+    r"""Earnings release date"""
+
+    eps_actual: Annotated[
+        OptionalNullable[float], pydantic.Field(alias="epsActual")
+    ] = UNSET
+    r"""Actual earnings per share"""
+
+    eps_estimate: Annotated[
+        OptionalNullable[float], pydantic.Field(alias="epsEstimate")
+    ] = UNSET
+    r"""Estimated earnings per share"""
+
+    eps_surprise: Annotated[
+        OptionalNullable[float], pydantic.Field(alias="epsSurprise")
+    ] = UNSET
+    r"""Difference between actual and estimated EPS"""
+
+    hour: Optional[str] = None
+    r"""Time of day for earnings release: 'bmo' (before market open), 'amc' (after market close), 'dmh' (during market hours)"""
+
+    importance: Optional[int] = None
+    r"""Earnings event importance level (1-3, where 3 is most important). Use this to filter and prioritize high-impact earnings releases."""
+
+    logo: Optional[Logo] = None
+    r"""Company logos for UI display"""
+
+    market_cap: Annotated[
+        OptionalNullable[float], pydantic.Field(alias="marketCap")
+    ] = UNSET
+    r"""Market capitalization in millions. Calculated as: (1) cached value if available and > 0, or (2) lastPrice × sharesOutstanding. Only present if both inputs are available."""
+
+    name: Optional[str] = None
+    r"""Company name"""
+
+    quarter: Optional[int] = None
+    r"""Quarter number (1-4)"""
+
+    revenue_actual: Annotated[
+        OptionalNullable[float], pydantic.Field(alias="revenueActual")
+    ] = UNSET
+    r"""Actual revenue"""
+
+    revenue_estimate: Annotated[
+        OptionalNullable[float], pydantic.Field(alias="revenueEstimate")
+    ] = UNSET
+    r"""Estimated revenue"""
+
+    revenue_surprise: Annotated[
+        OptionalNullable[float], pydantic.Field(alias="revenueSurprise")
+    ] = UNSET
+    r"""Difference between actual and estimated revenue"""
+
+    symbol: Optional[str] = None
+    r"""Stock ticker symbol, such as AAPL. Use the exact ticker for the company you want to research."""
+
+    time: Optional[str] = None
+    r"""Time of day for earnings release: '16:39:00' 24 hours format"""
+
+    year: Optional[int] = None
+    r"""Year of the earnings"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "analystRating",
+                "date",
+                "epsActual",
+                "epsEstimate",
+                "epsSurprise",
+                "hour",
+                "importance",
+                "logo",
+                "marketCap",
+                "name",
+                "quarter",
+                "revenueActual",
+                "revenueEstimate",
+                "revenueSurprise",
+                "symbol",
+                "time",
+                "year",
+            ]
+        )
+        nullable_fields = set(
+            [
+                "epsActual",
+                "epsEstimate",
+                "epsSurprise",
+                "marketCap",
+                "revenueActual",
+                "revenueEstimate",
+                "revenueSurprise",
+            ]
+        )
+        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:
+    AnalystRating.model_rebuild()
+except NameError:
+    pass
+try:
+    Logo.model_rebuild()
+except NameError:
+    pass
+try:
+    EarningRelease.model_rebuild()
+except NameError:
+    pass