finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/marketbreadthresponse.py

@@ -0,0 +1,44 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 42cd6345f01e
+
+from __future__ import annotations
+from .marketbreadth import MarketBreadth, MarketBreadthTypedDict
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class MarketBreadthResponseTypedDict(TypedDict):
+    r"""Response envelope for the market breadth endpoint."""
+
+    data: NotRequired[MarketBreadthTypedDict]
+    r"""Market breadth snapshot showing how many symbols are rising, falling, or unchanged. Use it to summarize overall market participation."""
+    success: NotRequired[bool]
+    r"""Always true on a successful response."""
+
+
+class MarketBreadthResponse(BaseModel):
+    r"""Response envelope for the market breadth endpoint."""
+
+    data: Optional[MarketBreadth] = None
+    r"""Market breadth snapshot showing how many symbols are rising, falling, or unchanged. Use it to summarize overall market participation."""
+
+    success: Optional[bool] = None
+    r"""Always true on a successful response."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["data", "success"])
+        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/marketholiday.py

@@ -0,0 +1,56 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: fe877285fa70
+
+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 Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class MarketHolidayTypedDict(TypedDict):
+    r"""Market holiday or special trading day."""
+
+    at_date: NotRequired[date]
+    r"""Date of the holiday in YYYY-MM-DD format"""
+    event_name: NotRequired[str]
+    r"""Name of the holiday or special market event"""
+    trading_hour: NotRequired[str]
+    r"""Trading hours for the day (e.g., 09:30-13:00 for early close, empty for full closure)"""
+
+
+class MarketHoliday(BaseModel):
+    r"""Market holiday or special trading day."""
+
+    at_date: Annotated[Optional[date], pydantic.Field(alias="atDate")] = None
+    r"""Date of the holiday in YYYY-MM-DD format"""
+
+    event_name: Annotated[Optional[str], pydantic.Field(alias="eventName")] = None
+    r"""Name of the holiday or special market event"""
+
+    trading_hour: Annotated[Optional[str], pydantic.Field(alias="tradingHour")] = None
+    r"""Trading hours for the day (e.g., 09:30-13:00 for early close, empty for full closure)"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["atDate", "eventName", "tradingHour"])
+        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:
+    MarketHoliday.model_rebuild()
+except NameError:
+    pass

finance_dev/models/marketholidayresponse.py

@@ -0,0 +1,39 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: b950ab8a825d
+
+from __future__ import annotations
+from .marketholiday import MarketHoliday, MarketHolidayTypedDict
+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 MarketHolidayResponseTypedDict(TypedDict):
+    r"""Market holidays and special trading days."""
+
+    holidays: NotRequired[List[MarketHolidayTypedDict]]
+    r"""List of market holidays and special trading days"""
+
+
+class MarketHolidayResponse(BaseModel):
+    r"""Market holidays and special trading days."""
+
+    holidays: Optional[List[MarketHoliday]] = None
+    r"""List of market holidays and special trading days"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["holidays"])
+        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/marketstatus.py

@@ -0,0 +1,67 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 082a87dffa48
+
+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 MarketStatusTypedDict(TypedDict):
+    r"""Current trading status of a market."""
+
+    exchange: NotRequired[str]
+    r"""Exchange code (e.g., US, TO, L)"""
+    is_open: NotRequired[bool]
+    r"""Whether the market is currently open for trading"""
+    session: NotRequired[str]
+    r"""Current trading session (pre-market, regular, after-hours, or empty if closed)"""
+    timestamp: NotRequired[int]
+    r"""Unix timestamp of the status data"""
+    timezone: NotRequired[str]
+    r"""Timezone of the exchange (e.g., America/New_York)"""
+
+
+class MarketStatus(BaseModel):
+    r"""Current trading status of a market."""
+
+    exchange: Optional[str] = None
+    r"""Exchange code (e.g., US, TO, L)"""
+
+    is_open: Annotated[Optional[bool], pydantic.Field(alias="isOpen")] = None
+    r"""Whether the market is currently open for trading"""
+
+    session: Optional[str] = None
+    r"""Current trading session (pre-market, regular, after-hours, or empty if closed)"""
+
+    timestamp: Optional[int] = None
+    r"""Unix timestamp of the status data"""
+
+    timezone: Optional[str] = None
+    r"""Timezone of the exchange (e.g., America/New_York)"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["exchange", "isOpen", "session", "timestamp", "timezone"]
+        )
+        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:
+    MarketStatus.model_rebuild()
+except NameError:
+    pass

finance_dev/models/mergersandacquisitionsresponse.py

@@ -0,0 +1,186 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 732b22b2c677
+
+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 MergersAcquisitionTypedDict(TypedDict):
+    acquirer_exchange: NotRequired[str]
+    r"""Exchange of the acquiring company"""
+    acquirer_name: NotRequired[str]
+    r"""Name of the acquiring company"""
+    acquirer_ticker: NotRequired[str]
+    r"""Ticker of the acquiring company"""
+    currency: NotRequired[str]
+    r"""Currency of the deal"""
+    date_: NotRequired[date]
+    r"""Date of the M&A event"""
+    date_expected: NotRequired[str]
+    r"""Expected closing date or period supplied by the provider, such as 2026-H2."""
+    deal_payment_type: NotRequired[str]
+    r"""Payment method (Cash, Stock, Mixed, etc.)"""
+    deal_size: NotRequired[str]
+    r"""Size of the deal in the specified currency"""
+    deal_status: NotRequired[str]
+    r"""Current status of the deal (Completed, Pending, etc.)"""
+    deal_type: NotRequired[str]
+    r"""Type of deal (Acquisition, Merger, etc.)"""
+    id: NotRequired[str]
+    r"""Unique identifier for the M&A event"""
+    importance: NotRequired[int]
+    r"""Importance rating of the event"""
+    notes: NotRequired[str]
+    r"""Additional notes"""
+    target_exchange: NotRequired[str]
+    r"""Stock exchange where target is traded"""
+    target_name: NotRequired[str]
+    r"""Name of the target company"""
+    target_ticker: NotRequired[str]
+    r"""Stock ticker symbol of the target company. Enter the exact ticker, such as AAPL."""
+    updated: NotRequired[int]
+    r"""Unix timestamp of last update"""
+
+
+class MergersAcquisition(BaseModel):
+    acquirer_exchange: Annotated[
+        Optional[str], pydantic.Field(alias="acquirerExchange")
+    ] = None
+    r"""Exchange of the acquiring company"""
+
+    acquirer_name: Annotated[Optional[str], pydantic.Field(alias="acquirerName")] = None
+    r"""Name of the acquiring company"""
+
+    acquirer_ticker: Annotated[
+        Optional[str], pydantic.Field(alias="acquirerTicker")
+    ] = None
+    r"""Ticker of the acquiring company"""
+
+    currency: Optional[str] = None
+    r"""Currency of the deal"""
+
+    date_: Annotated[Optional[date], pydantic.Field(alias="date")] = None
+    r"""Date of the M&A event"""
+
+    date_expected: Annotated[Optional[str], pydantic.Field(alias="dateExpected")] = None
+    r"""Expected closing date or period supplied by the provider, such as 2026-H2."""
+
+    deal_payment_type: Annotated[
+        Optional[str], pydantic.Field(alias="dealPaymentType")
+    ] = None
+    r"""Payment method (Cash, Stock, Mixed, etc.)"""
+
+    deal_size: Annotated[Optional[str], pydantic.Field(alias="dealSize")] = None
+    r"""Size of the deal in the specified currency"""
+
+    deal_status: Annotated[Optional[str], pydantic.Field(alias="dealStatus")] = None
+    r"""Current status of the deal (Completed, Pending, etc.)"""
+
+    deal_type: Annotated[Optional[str], pydantic.Field(alias="dealType")] = None
+    r"""Type of deal (Acquisition, Merger, etc.)"""
+
+    id: Optional[str] = None
+    r"""Unique identifier for the M&A event"""
+
+    importance: Optional[int] = None
+    r"""Importance rating of the event"""
+
+    notes: Optional[str] = None
+    r"""Additional notes"""
+
+    target_exchange: Annotated[
+        Optional[str], pydantic.Field(alias="targetExchange")
+    ] = None
+    r"""Stock exchange where target is traded"""
+
+    target_name: Annotated[Optional[str], pydantic.Field(alias="targetName")] = None
+    r"""Name of the target company"""
+
+    target_ticker: Annotated[Optional[str], pydantic.Field(alias="targetTicker")] = None
+    r"""Stock ticker symbol of the target company. Enter the exact ticker, such as AAPL."""
+
+    updated: Optional[int] = None
+    r"""Unix timestamp of last update"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "acquirerExchange",
+                "acquirerName",
+                "acquirerTicker",
+                "currency",
+                "date",
+                "dateExpected",
+                "dealPaymentType",
+                "dealSize",
+                "dealStatus",
+                "dealType",
+                "id",
+                "importance",
+                "notes",
+                "targetExchange",
+                "targetName",
+                "targetTicker",
+                "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 MergersAndAcquisitionsResponseTypedDict(TypedDict):
+    r"""Response containing mergers and acquisitions calendar events."""
+
+    mergers_acquisitions: NotRequired[List[MergersAcquisitionTypedDict]]
+    r"""Array of merger and acquisition events"""
+
+
+class MergersAndAcquisitionsResponse(BaseModel):
+    r"""Response containing mergers and acquisitions calendar events."""
+
+    mergers_acquisitions: Annotated[
+        Optional[List[MergersAcquisition]], pydantic.Field(alias="mergersAcquisitions")
+    ] = None
+    r"""Array of merger and acquisition events"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["mergersAcquisitions"])
+        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:
+    MergersAcquisition.model_rebuild()
+except NameError:
+    pass
+try:
+    MergersAndAcquisitionsResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/metricseriespoint.py

@@ -0,0 +1,43 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: ba34893a9005
+
+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 MetricSeriesPointTypedDict(TypedDict):
+    r"""Single data point of a company metric time series."""
+
+    period: NotRequired[str]
+    r"""Time period for the metric value (e.g., 2023-12-31)"""
+    v: NotRequired[float]
+    r"""Metric value for the period"""
+
+
+class MetricSeriesPoint(BaseModel):
+    r"""Single data point of a company metric time series."""
+
+    period: Optional[str] = None
+    r"""Time period for the metric value (e.g., 2023-12-31)"""
+
+    v: Optional[float] = None
+    r"""Metric value for the period"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["period", "v"])
+        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/netinflow.py

@@ -0,0 +1,81 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 801476f8859f
+
+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 NetInflowTypedDict(TypedDict):
+    r"""Net market inflow snapshot for Nasdaq and NYSE. Use it to show whether reported flow is net buying or net selling."""
+
+    nasdaq_net_inflow: NotRequired[float]
+    r"""Net inflow value for Nasdaq activity. Positive values indicate net buying flow; negative values indicate net selling flow."""
+    nasdaq_trade_count: NotRequired[int]
+    r"""Number of Nasdaq trades included in the inflow calculation."""
+    nyse_net_inflow: NotRequired[float]
+    r"""Net inflow value for NYSE activity. Positive values indicate net buying flow; negative values indicate net selling flow."""
+    nyse_trade_count: NotRequired[int]
+    r"""Number of NYSE trades included in the inflow calculation."""
+    timestamp: NotRequired[str]
+    r"""Data timestamp in ISO 8601 format; fractional seconds may be present (for example microseconds)."""
+
+
+class NetInflow(BaseModel):
+    r"""Net market inflow snapshot for Nasdaq and NYSE. Use it to show whether reported flow is net buying or net selling."""
+
+    nasdaq_net_inflow: Annotated[
+        Optional[float], pydantic.Field(alias="nasdaqNetInflow")
+    ] = None
+    r"""Net inflow value for Nasdaq activity. Positive values indicate net buying flow; negative values indicate net selling flow."""
+
+    nasdaq_trade_count: Annotated[
+        Optional[int], pydantic.Field(alias="nasdaqTradeCount")
+    ] = None
+    r"""Number of Nasdaq trades included in the inflow calculation."""
+
+    nyse_net_inflow: Annotated[
+        Optional[float], pydantic.Field(alias="nyseNetInflow")
+    ] = None
+    r"""Net inflow value for NYSE activity. Positive values indicate net buying flow; negative values indicate net selling flow."""
+
+    nyse_trade_count: Annotated[
+        Optional[int], pydantic.Field(alias="nyseTradeCount")
+    ] = None
+    r"""Number of NYSE trades included in the inflow calculation."""
+
+    timestamp: Optional[str] = None
+    r"""Data timestamp in ISO 8601 format; fractional seconds may be present (for example microseconds)."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "nasdaqNetInflow",
+                "nasdaqTradeCount",
+                "nyseNetInflow",
+                "nyseTradeCount",
+                "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
+
+
+try:
+    NetInflow.model_rebuild()
+except NameError:
+    pass

finance_dev/models/netinflowresponse.py

@@ -0,0 +1,44 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: f9b91864decc
+
+from __future__ import annotations
+from .netinflow import NetInflow, NetInflowTypedDict
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class NetInflowResponseTypedDict(TypedDict):
+    r"""Response envelope for the net inflow endpoint."""
+
+    data: NotRequired[NetInflowTypedDict]
+    r"""Net market inflow snapshot for Nasdaq and NYSE. Use it to show whether reported flow is net buying or net selling."""
+    success: NotRequired[bool]
+    r"""Always true on a successful response."""
+
+
+class NetInflowResponse(BaseModel):
+    r"""Response envelope for the net inflow endpoint."""
+
+    data: Optional[NetInflow] = None
+    r"""Net market inflow snapshot for Nasdaq and NYSE. Use it to show whether reported flow is net buying or net selling."""
+
+    success: Optional[bool] = None
+    r"""Always true on a successful response."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["data", "success"])
+        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/newsitem.py

@@ -0,0 +1,102 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 47372de7118c
+
+from __future__ import annotations
+from .newstypeenum import NewsTypeEnum
+from datetime import datetime
+from finance_dev import models
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from pydantic import field_serializer, model_serializer
+from typing import List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class NewsItemTypedDict(TypedDict):
+    r"""A single news item or press release."""
+
+    action: NotRequired[str]
+    r"""News action type (typically empty)"""
+    authors: NotRequired[List[str]]
+    r"""Authors of the news item"""
+    body: NotRequired[str]
+    r"""Full body of the news article"""
+    id: NotRequired[int]
+    r"""Unique news item ID"""
+    news_type: NotRequired[NewsTypeEnum]
+    r"""Source category of the news item. Pick one:
+    - `news` — Editorial news articles from journalists and news services.
+    - `press_release` — Official press releases issued directly by companies.
+    """
+    symbols: NotRequired[List[str]]
+    r"""Related stock symbols"""
+    timestamp: NotRequired[datetime]
+    r"""Publication timestamp in ISO 8601 format"""
+    title: NotRequired[str]
+    r"""News headline"""
+
+
+class NewsItem(BaseModel):
+    r"""A single news item or press release."""
+
+    action: Optional[str] = None
+    r"""News action type (typically empty)"""
+
+    authors: Optional[List[str]] = None
+    r"""Authors of the news item"""
+
+    body: Optional[str] = None
+    r"""Full body of the news article"""
+
+    id: Optional[int] = None
+    r"""Unique news item ID"""
+
+    news_type: Optional[NewsTypeEnum] = None
+    r"""Source category of the news item. Pick one:
+    - `news` — Editorial news articles from journalists and news services.
+    - `press_release` — Official press releases issued directly by companies.
+    """
+
+    symbols: Optional[List[str]] = None
+    r"""Related stock symbols"""
+
+    timestamp: Optional[datetime] = None
+    r"""Publication timestamp in ISO 8601 format"""
+
+    title: Optional[str] = None
+    r"""News headline"""
+
+    @field_serializer("news_type")
+    def serialize_news_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.NewsTypeEnum(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "action",
+                "authors",
+                "body",
+                "id",
+                "news_type",
+                "symbols",
+                "timestamp",
+                "title",
+            ]
+        )
+        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