finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/ebitestimatesresponse.py

@@ -0,0 +1,176 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 5aa0aea91bf4
+
+from __future__ import annotations
+from .reportingfrequency import ReportingFrequency
+from finance_dev import models
+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 EbitEstimatesResponseDataTypedDict(TypedDict):
+    ebit_avg: NotRequired[int]
+    r"""Average analyst EBIT estimate for the period"""
+    ebit_high: NotRequired[int]
+    r"""Highest analyst EBIT estimate for the period"""
+    ebit_low: NotRequired[int]
+    r"""Lowest analyst EBIT estimate for the period"""
+    number_analysts: NotRequired[int]
+    r"""Number of analysts contributing to the estimate"""
+    period: NotRequired[str]
+    r"""End date of the reporting period the estimate applies to"""
+    quarter: NotRequired[int]
+    r"""Fiscal quarter of the period; 0 for annual estimates"""
+    year: NotRequired[int]
+    r"""Fiscal year of the period"""
+
+
+class EbitEstimatesResponseData(BaseModel):
+    ebit_avg: Annotated[Optional[int], pydantic.Field(alias="ebitAvg")] = None
+    r"""Average analyst EBIT estimate for the period"""
+
+    ebit_high: Annotated[Optional[int], pydantic.Field(alias="ebitHigh")] = None
+    r"""Highest analyst EBIT estimate for the period"""
+
+    ebit_low: Annotated[Optional[int], pydantic.Field(alias="ebitLow")] = None
+    r"""Lowest analyst EBIT estimate for the period"""
+
+    number_analysts: Annotated[
+        Optional[int], pydantic.Field(alias="numberAnalysts")
+    ] = None
+    r"""Number of analysts contributing to the estimate"""
+
+    period: Optional[str] = None
+    r"""End date of the reporting period the estimate applies to"""
+
+    quarter: Optional[int] = None
+    r"""Fiscal quarter of the period; 0 for annual estimates"""
+
+    year: Optional[int] = None
+    r"""Fiscal year of the period"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "ebitAvg",
+                "ebitHigh",
+                "ebitLow",
+                "numberAnalysts",
+                "period",
+                "quarter",
+                "year",
+            ]
+        )
+        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 EbitEstimatesTypedDict(TypedDict):
+    r"""EBIT estimates container for the symbol"""
+
+    data: NotRequired[List[EbitEstimatesResponseDataTypedDict]]
+    r"""List of EBIT estimates, one per reporting period"""
+    freq: NotRequired[ReportingFrequency]
+    r"""How often the underlying data is reported:
+    - `annual` — once per fiscal year (10-K, full-year statements).
+    - `quarterly` — once per fiscal quarter (10-Q, quarterly statements).
+    """
+    symbol: NotRequired[str]
+    r"""Stock ticker symbol"""
+
+
+class EbitEstimates(BaseModel):
+    r"""EBIT estimates container for the symbol"""
+
+    data: Optional[List[EbitEstimatesResponseData]] = None
+    r"""List of EBIT estimates, one per reporting period"""
+
+    freq: Optional[ReportingFrequency] = None
+    r"""How often the underlying data is reported:
+    - `annual` — once per fiscal year (10-K, full-year statements).
+    - `quarterly` — once per fiscal quarter (10-Q, quarterly statements).
+    """
+
+    symbol: Optional[str] = None
+    r"""Stock ticker symbol"""
+
+    @field_serializer("freq")
+    def serialize_freq(self, value):
+        if isinstance(value, str):
+            try:
+                return models.ReportingFrequency(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["data", "freq", "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
+
+
+class EbitEstimatesResponseTypedDict(TypedDict):
+    r"""Analyst consensus EBIT estimates for a stock by reporting period, sourced from Finnhub."""
+
+    ebit_estimates: NotRequired[EbitEstimatesTypedDict]
+    r"""EBIT estimates container for the symbol"""
+
+
+class EbitEstimatesResponse(BaseModel):
+    r"""Analyst consensus EBIT estimates for a stock by reporting period, sourced from Finnhub."""
+
+    ebit_estimates: Annotated[
+        Optional[EbitEstimates], pydantic.Field(alias="ebitEstimates")
+    ] = None
+    r"""EBIT estimates container for the symbol"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["ebitEstimates"])
+        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:
+    EbitEstimatesResponseData.model_rebuild()
+except NameError:
+    pass
+try:
+    EbitEstimatesResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/economicscalendarevent.py

@@ -0,0 +1,160 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: cc90ede7b35c
+
+from __future__ import annotations
+from datetime import date, datetime
+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 EconomicsCalendarEventTypedDict(TypedDict):
+    r"""Economic calendar event with its schedule, reported and forecast values."""
+
+    actual: NotRequired[str]
+    r"""Actual reported value (present after release)"""
+    calendar_id: NotRequired[str]
+    r"""Unique identifier for the calendar event"""
+    category: NotRequired[str]
+    r"""Category label for the economic event/indicator (e.g. `GDP`, `Inflation`, `Employment`). Format depends on the upstream data source."""
+    country: NotRequired[str]
+    r"""Country name"""
+    date_: NotRequired[date]
+    r"""Event date (YYYY-MM-DD)"""
+    event: NotRequired[str]
+    r"""Event name"""
+    forecast: NotRequired[str]
+    r"""Market forecast value"""
+    importance: NotRequired[int]
+    r"""Event importance level"""
+    last_update: NotRequired[str]
+    r"""Last update timestamp supplied by the provider; timezone information may be absent."""
+    previous: NotRequired[str]
+    r"""Previous period value"""
+    reference: NotRequired[str]
+    r"""Reference period (e.g. Feb/21)"""
+    reference_date: NotRequired[datetime]
+    r"""Reference period date (ISO 8601)"""
+    source: NotRequired[str]
+    r"""Organization or agency that published the economic event."""
+    source_url: NotRequired[str]
+    r"""URL to the data source"""
+    symbol: NotRequired[str]
+    r"""Economic indicator symbol"""
+    te_forecast: NotRequired[str]
+    r"""Trading Economics forecast value"""
+    ticker: NotRequired[str]
+    r"""Economic indicator ticker symbol"""
+    time: NotRequired[str]
+    r"""Event time (HH:MM:SS)"""
+    unit: NotRequired[str]
+    r"""Unit of measure for the indicator"""
+
+
+class EconomicsCalendarEvent(BaseModel):
+    r"""Economic calendar event with its schedule, reported and forecast values."""
+
+    actual: Optional[str] = None
+    r"""Actual reported value (present after release)"""
+
+    calendar_id: Annotated[Optional[str], pydantic.Field(alias="calendarID")] = None
+    r"""Unique identifier for the calendar event"""
+
+    category: Optional[str] = None
+    r"""Category label for the economic event/indicator (e.g. `GDP`, `Inflation`, `Employment`). Format depends on the upstream data source."""
+
+    country: Optional[str] = None
+    r"""Country name"""
+
+    date_: Annotated[Optional[date], pydantic.Field(alias="date")] = None
+    r"""Event date (YYYY-MM-DD)"""
+
+    event: Optional[str] = None
+    r"""Event name"""
+
+    forecast: Optional[str] = None
+    r"""Market forecast value"""
+
+    importance: Optional[int] = None
+    r"""Event importance level"""
+
+    last_update: Annotated[Optional[str], pydantic.Field(alias="lastUpdate")] = None
+    r"""Last update timestamp supplied by the provider; timezone information may be absent."""
+
+    previous: Optional[str] = None
+    r"""Previous period value"""
+
+    reference: Optional[str] = None
+    r"""Reference period (e.g. Feb/21)"""
+
+    reference_date: Annotated[
+        Optional[datetime], pydantic.Field(alias="referenceDate")
+    ] = None
+    r"""Reference period date (ISO 8601)"""
+
+    source: Optional[str] = None
+    r"""Organization or agency that published the economic event."""
+
+    source_url: Annotated[Optional[str], pydantic.Field(alias="sourceUrl")] = None
+    r"""URL to the data source"""
+
+    symbol: Optional[str] = None
+    r"""Economic indicator symbol"""
+
+    te_forecast: Annotated[Optional[str], pydantic.Field(alias="teForecast")] = None
+    r"""Trading Economics forecast value"""
+
+    ticker: Optional[str] = None
+    r"""Economic indicator ticker symbol"""
+
+    time: Optional[str] = None
+    r"""Event time (HH:MM:SS)"""
+
+    unit: Optional[str] = None
+    r"""Unit of measure for the indicator"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "actual",
+                "calendarID",
+                "category",
+                "country",
+                "date",
+                "event",
+                "forecast",
+                "importance",
+                "lastUpdate",
+                "previous",
+                "reference",
+                "referenceDate",
+                "source",
+                "sourceUrl",
+                "symbol",
+                "teForecast",
+                "ticker",
+                "time",
+                "unit",
+            ]
+        )
+        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:
+    EconomicsCalendarEvent.model_rebuild()
+except NameError:
+    pass

finance_dev/models/economicsindicator.py

@@ -0,0 +1,87 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 9886cc670853
+
+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 EconomicsIndicatorTypedDict(TypedDict):
+    r"""Single historical data point for an economic indicator."""
+
+    category: NotRequired[str]
+    r"""Category label for the economic event/indicator (e.g. `GDP`, `Inflation`, `Employment`). Format depends on the upstream data source."""
+    country: NotRequired[str]
+    r"""Country code or name"""
+    date_time: NotRequired[str]
+    r"""Date and time of the data point"""
+    frequency: NotRequired[str]
+    r"""Data frequency (e.g., monthly, quarterly, yearly)"""
+    historical_data_symbol: NotRequired[str]
+    r"""Symbol identifier for the historical data"""
+    last_update: NotRequired[str]
+    r"""Last update timestamp"""
+    value: NotRequired[float]
+    r"""Indicator value"""
+
+
+class EconomicsIndicator(BaseModel):
+    r"""Single historical data point for an economic indicator."""
+
+    category: Optional[str] = None
+    r"""Category label for the economic event/indicator (e.g. `GDP`, `Inflation`, `Employment`). Format depends on the upstream data source."""
+
+    country: Optional[str] = None
+    r"""Country code or name"""
+
+    date_time: Annotated[Optional[str], pydantic.Field(alias="dateTime")] = None
+    r"""Date and time of the data point"""
+
+    frequency: Optional[str] = None
+    r"""Data frequency (e.g., monthly, quarterly, yearly)"""
+
+    historical_data_symbol: Annotated[
+        Optional[str], pydantic.Field(alias="historicalDataSymbol")
+    ] = None
+    r"""Symbol identifier for the historical data"""
+
+    last_update: Annotated[Optional[str], pydantic.Field(alias="lastUpdate")] = None
+    r"""Last update timestamp"""
+
+    value: Optional[float] = None
+    r"""Indicator value"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "category",
+                "country",
+                "dateTime",
+                "frequency",
+                "historicalDataSymbol",
+                "lastUpdate",
+                "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
+
+
+try:
+    EconomicsIndicator.model_rebuild()
+except NameError:
+    pass

finance_dev/models/epsestimatesresponse.py

@@ -0,0 +1,176 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 9445723d127f
+
+from __future__ import annotations
+from .reportingfrequency import ReportingFrequency
+from finance_dev import models
+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 EpsEstimatesResponseDataTypedDict(TypedDict):
+    eps_avg: NotRequired[float]
+    r"""Average analyst EPS estimate for the period"""
+    eps_high: NotRequired[float]
+    r"""Highest analyst EPS estimate for the period"""
+    eps_low: NotRequired[float]
+    r"""Lowest analyst EPS estimate for the period"""
+    number_analysts: NotRequired[int]
+    r"""Number of analysts contributing to the estimate"""
+    period: NotRequired[str]
+    r"""End date of the reporting period the estimate applies to"""
+    quarter: NotRequired[int]
+    r"""Fiscal quarter of the period; 0 for annual estimates"""
+    year: NotRequired[int]
+    r"""Fiscal year of the period"""
+
+
+class EpsEstimatesResponseData(BaseModel):
+    eps_avg: Annotated[Optional[float], pydantic.Field(alias="epsAvg")] = None
+    r"""Average analyst EPS estimate for the period"""
+
+    eps_high: Annotated[Optional[float], pydantic.Field(alias="epsHigh")] = None
+    r"""Highest analyst EPS estimate for the period"""
+
+    eps_low: Annotated[Optional[float], pydantic.Field(alias="epsLow")] = None
+    r"""Lowest analyst EPS estimate for the period"""
+
+    number_analysts: Annotated[
+        Optional[int], pydantic.Field(alias="numberAnalysts")
+    ] = None
+    r"""Number of analysts contributing to the estimate"""
+
+    period: Optional[str] = None
+    r"""End date of the reporting period the estimate applies to"""
+
+    quarter: Optional[int] = None
+    r"""Fiscal quarter of the period; 0 for annual estimates"""
+
+    year: Optional[int] = None
+    r"""Fiscal year of the period"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "epsAvg",
+                "epsHigh",
+                "epsLow",
+                "numberAnalysts",
+                "period",
+                "quarter",
+                "year",
+            ]
+        )
+        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 EpsEstimatesTypedDict(TypedDict):
+    r"""EPS estimates container for the symbol"""
+
+    data: NotRequired[List[EpsEstimatesResponseDataTypedDict]]
+    r"""List of EPS estimates, one per reporting period"""
+    freq: NotRequired[ReportingFrequency]
+    r"""How often the underlying data is reported:
+    - `annual` — once per fiscal year (10-K, full-year statements).
+    - `quarterly` — once per fiscal quarter (10-Q, quarterly statements).
+    """
+    symbol: NotRequired[str]
+    r"""Stock ticker symbol"""
+
+
+class EpsEstimates(BaseModel):
+    r"""EPS estimates container for the symbol"""
+
+    data: Optional[List[EpsEstimatesResponseData]] = None
+    r"""List of EPS estimates, one per reporting period"""
+
+    freq: Optional[ReportingFrequency] = None
+    r"""How often the underlying data is reported:
+    - `annual` — once per fiscal year (10-K, full-year statements).
+    - `quarterly` — once per fiscal quarter (10-Q, quarterly statements).
+    """
+
+    symbol: Optional[str] = None
+    r"""Stock ticker symbol"""
+
+    @field_serializer("freq")
+    def serialize_freq(self, value):
+        if isinstance(value, str):
+            try:
+                return models.ReportingFrequency(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["data", "freq", "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
+
+
+class EpsEstimatesResponseTypedDict(TypedDict):
+    r"""Analyst consensus EPS estimates for a stock by reporting period, sourced from Finnhub."""
+
+    eps_estimates: NotRequired[EpsEstimatesTypedDict]
+    r"""EPS estimates container for the symbol"""
+
+
+class EpsEstimatesResponse(BaseModel):
+    r"""Analyst consensus EPS estimates for a stock by reporting period, sourced from Finnhub."""
+
+    eps_estimates: Annotated[
+        Optional[EpsEstimates], pydantic.Field(alias="epsEstimates")
+    ] = None
+    r"""EPS estimates container for the symbol"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["epsEstimates"])
+        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:
+    EpsEstimatesResponseData.model_rebuild()
+except NameError:
+    pass
+try:
+    EpsEstimatesResponse.model_rebuild()
+except NameError:
+    pass