finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/earningscallliveresponse.py

@@ -0,0 +1,103 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 9f7608fd8822
+
+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 EventTypedDict(TypedDict):
+    event: NotRequired[str]
+    r"""Title of the earnings call event."""
+    live_audio: NotRequired[str]
+    r"""URL of the live audio stream for the call."""
+    quarter: NotRequired[int]
+    r"""Fiscal quarter of the earnings call."""
+    recording: NotRequired[str]
+    r"""URL of the recorded audio of the call."""
+    symbol: NotRequired[str]
+    r"""Ticker symbol of the company."""
+    time: NotRequired[str]
+    r"""Timestamp of the earnings call as provided by the data vendor."""
+    year: NotRequired[int]
+    r"""Fiscal year of the earnings call."""
+
+
+class Event(BaseModel):
+    event: Optional[str] = None
+    r"""Title of the earnings call event."""
+
+    live_audio: Annotated[Optional[str], pydantic.Field(alias="liveAudio")] = None
+    r"""URL of the live audio stream for the call."""
+
+    quarter: Optional[int] = None
+    r"""Fiscal quarter of the earnings call."""
+
+    recording: Optional[str] = None
+    r"""URL of the recorded audio of the call."""
+
+    symbol: Optional[str] = None
+    r"""Ticker symbol of the company."""
+
+    time: Optional[str] = None
+    r"""Timestamp of the earnings call as provided by the data vendor."""
+
+    year: Optional[int] = None
+    r"""Fiscal year of the earnings call."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["event", "liveAudio", "quarter", "recording", "symbol", "time", "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 EarningsCallLiveResponseTypedDict(TypedDict):
+    r"""Live and recorded earnings call events for the requested range or symbol."""
+
+    event: NotRequired[List[EventTypedDict]]
+    r"""Earnings call events."""
+
+
+class EarningsCallLiveResponse(BaseModel):
+    r"""Live and recorded earnings call events for the requested range or symbol."""
+
+    event: Optional[List[Event]] = None
+    r"""Earnings call events."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["event"])
+        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:
+    Event.model_rebuild()
+except NameError:
+    pass

finance_dev/models/earningsqualityscoreresponse.py

@@ -0,0 +1,140 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: b0f437ec92b2
+
+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 EarningsQualityScoreResponseDataTypedDict(TypedDict):
+    cash_generation_capital_allocation: NotRequired[float]
+    r"""Cash generation and capital allocation component score."""
+    growth: NotRequired[float]
+    r"""Growth component score."""
+    letter_score: NotRequired[str]
+    r"""Letter grade equivalent of the total score."""
+    leverage: NotRequired[float]
+    r"""Leverage component score."""
+    period: NotRequired[str]
+    r"""Reporting period the score applies to."""
+    profitability: NotRequired[float]
+    r"""Profitability component score."""
+    score: NotRequired[float]
+    r"""Total earnings quality score."""
+
+
+class EarningsQualityScoreResponseData(BaseModel):
+    cash_generation_capital_allocation: Annotated[
+        Optional[float], pydantic.Field(alias="cashGenerationCapitalAllocation")
+    ] = None
+    r"""Cash generation and capital allocation component score."""
+
+    growth: Optional[float] = None
+    r"""Growth component score."""
+
+    letter_score: Annotated[Optional[str], pydantic.Field(alias="letterScore")] = None
+    r"""Letter grade equivalent of the total score."""
+
+    leverage: Optional[float] = None
+    r"""Leverage component score."""
+
+    period: Optional[str] = None
+    r"""Reporting period the score applies to."""
+
+    profitability: Optional[float] = None
+    r"""Profitability component score."""
+
+    score: Optional[float] = None
+    r"""Total earnings quality score."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "cashGenerationCapitalAllocation",
+                "growth",
+                "letterScore",
+                "leverage",
+                "period",
+                "profitability",
+                "score",
+            ]
+        )
+        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 EarningsQualityScoreResponseTypedDict(TypedDict):
+    r"""Earnings quality score history for a company, as provided by Finnhub."""
+
+    data: NotRequired[List[EarningsQualityScoreResponseDataTypedDict]]
+    r"""Earnings quality scores, one entry 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"""Company ticker symbol."""
+
+
+class EarningsQualityScoreResponse(BaseModel):
+    r"""Earnings quality score history for a company, as provided by Finnhub."""
+
+    data: Optional[List[EarningsQualityScoreResponseData]] = None
+    r"""Earnings quality scores, one entry 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"""Company 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
+
+
+try:
+    EarningsQualityScoreResponseData.model_rebuild()
+except NameError:
+    pass

finance_dev/models/earningssurprisesresponse.py

@@ -0,0 +1,125 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 4e76845e066a
+
+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 EarningSurpriseTypedDict(TypedDict):
+    actual: NotRequired[float]
+    r"""Reported actual earnings per share"""
+    estimate: NotRequired[float]
+    r"""Analyst consensus earnings per share estimate"""
+    period: NotRequired[str]
+    r"""End date of the reporting period"""
+    quarter: NotRequired[int]
+    r"""Fiscal quarter number"""
+    surprise: NotRequired[float]
+    r"""Difference between actual and estimate"""
+    surprise_percent: NotRequired[float]
+    r"""Surprise as a percentage of the estimate"""
+    symbol: NotRequired[str]
+    r"""Stock ticker symbol"""
+    year: NotRequired[int]
+    r"""Fiscal year"""
+
+
+class EarningSurprise(BaseModel):
+    actual: Optional[float] = None
+    r"""Reported actual earnings per share"""
+
+    estimate: Optional[float] = None
+    r"""Analyst consensus earnings per share estimate"""
+
+    period: Optional[str] = None
+    r"""End date of the reporting period"""
+
+    quarter: Optional[int] = None
+    r"""Fiscal quarter number"""
+
+    surprise: Optional[float] = None
+    r"""Difference between actual and estimate"""
+
+    surprise_percent: Annotated[
+        Optional[float], pydantic.Field(alias="surprisePercent")
+    ] = None
+    r"""Surprise as a percentage of the estimate"""
+
+    symbol: Optional[str] = None
+    r"""Stock ticker symbol"""
+
+    year: Optional[int] = None
+    r"""Fiscal year"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "actual",
+                "estimate",
+                "period",
+                "quarter",
+                "surprise",
+                "surprisePercent",
+                "symbol",
+                "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 EarningsSurprisesResponseTypedDict(TypedDict):
+    r"""Historical quarterly earnings results versus analyst estimates for a stock, sourced from Finnhub."""
+
+    earning_surprises: NotRequired[List[EarningSurpriseTypedDict]]
+    r"""List of quarterly earnings surprise records"""
+
+
+class EarningsSurprisesResponse(BaseModel):
+    r"""Historical quarterly earnings results versus analyst estimates for a stock, sourced from Finnhub."""
+
+    earning_surprises: Annotated[
+        Optional[List[EarningSurprise]], pydantic.Field(alias="earningSurprises")
+    ] = None
+    r"""List of quarterly earnings surprise records"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["earningSurprises"])
+        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:
+    EarningSurprise.model_rebuild()
+except NameError:
+    pass
+try:
+    EarningsSurprisesResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/ebitdaestimatesresponse.py

@@ -0,0 +1,176 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: cb94375cece9
+
+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 EbitdaEstimatesResponseDataTypedDict(TypedDict):
+    ebitda_avg: NotRequired[int]
+    r"""Average analyst EBITDA estimate for the period"""
+    ebitda_high: NotRequired[int]
+    r"""Highest analyst EBITDA estimate for the period"""
+    ebitda_low: NotRequired[int]
+    r"""Lowest analyst EBITDA 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 EbitdaEstimatesResponseData(BaseModel):
+    ebitda_avg: Annotated[Optional[int], pydantic.Field(alias="ebitdaAvg")] = None
+    r"""Average analyst EBITDA estimate for the period"""
+
+    ebitda_high: Annotated[Optional[int], pydantic.Field(alias="ebitdaHigh")] = None
+    r"""Highest analyst EBITDA estimate for the period"""
+
+    ebitda_low: Annotated[Optional[int], pydantic.Field(alias="ebitdaLow")] = None
+    r"""Lowest analyst EBITDA 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(
+            [
+                "ebitdaAvg",
+                "ebitdaHigh",
+                "ebitdaLow",
+                "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 EbitdaEstimatesTypedDict(TypedDict):
+    r"""EBITDA estimates container for the symbol"""
+
+    data: NotRequired[List[EbitdaEstimatesResponseDataTypedDict]]
+    r"""List of EBITDA 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 EbitdaEstimates(BaseModel):
+    r"""EBITDA estimates container for the symbol"""
+
+    data: Optional[List[EbitdaEstimatesResponseData]] = None
+    r"""List of EBITDA 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 EbitdaEstimatesResponseTypedDict(TypedDict):
+    r"""Analyst consensus EBITDA estimates for a stock by reporting period, sourced from Finnhub."""
+
+    ebitda_estimates: NotRequired[EbitdaEstimatesTypedDict]
+    r"""EBITDA estimates container for the symbol"""
+
+
+class EbitdaEstimatesResponse(BaseModel):
+    r"""Analyst consensus EBITDA estimates for a stock by reporting period, sourced from Finnhub."""
+
+    ebitda_estimates: Annotated[
+        Optional[EbitdaEstimates], pydantic.Field(alias="ebitdaEstimates")
+    ] = None
+    r"""EBITDA estimates container for the symbol"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["ebitdaEstimates"])
+        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:
+    EbitdaEstimatesResponseData.model_rebuild()
+except NameError:
+    pass
+try:
+    EbitdaEstimatesResponse.model_rebuild()
+except NameError:
+    pass