finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/reportedfiling.py

@@ -0,0 +1,110 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: d249172a8488
+
+from __future__ import annotations
+from .reportedreport import ReportedReport, ReportedReportTypedDict
+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 ReportedFilingTypedDict(TypedDict):
+    r"""SEC filing with its reporting period and reported financial data."""
+
+    accepted_date: NotRequired[str]
+    r"""Date and time when the SEC accepted the filing"""
+    access_number: NotRequired[str]
+    r"""SEC accession number uniquely identifying the filing"""
+    cik: NotRequired[str]
+    r"""Central Index Key assigned by the SEC to the company"""
+    end_date: NotRequired[str]
+    r"""End date of the reporting period in YYYY-MM-DD format"""
+    filed_date: NotRequired[str]
+    r"""Date when the filing was submitted to the SEC"""
+    form: NotRequired[str]
+    r"""Type of SEC form (e.g., 10-K, 10-Q, 8-K)"""
+    quarter: NotRequired[int]
+    r"""Fiscal quarter number (1-4)"""
+    report: NotRequired[ReportedReportTypedDict]
+    r"""Financial statements reported within a filing."""
+    start_date: NotRequired[str]
+    r"""Start date of the reporting period in YYYY-MM-DD format"""
+    symbol: NotRequired[str]
+    r"""Stock ticker symbol"""
+    year: NotRequired[int]
+    r"""Fiscal year of the report"""
+
+
+class ReportedFiling(BaseModel):
+    r"""SEC filing with its reporting period and reported financial data."""
+
+    accepted_date: Annotated[Optional[str], pydantic.Field(alias="acceptedDate")] = None
+    r"""Date and time when the SEC accepted the filing"""
+
+    access_number: Annotated[Optional[str], pydantic.Field(alias="accessNumber")] = None
+    r"""SEC accession number uniquely identifying the filing"""
+
+    cik: Optional[str] = None
+    r"""Central Index Key assigned by the SEC to the company"""
+
+    end_date: Annotated[Optional[str], pydantic.Field(alias="endDate")] = None
+    r"""End date of the reporting period in YYYY-MM-DD format"""
+
+    filed_date: Annotated[Optional[str], pydantic.Field(alias="filedDate")] = None
+    r"""Date when the filing was submitted to the SEC"""
+
+    form: Optional[str] = None
+    r"""Type of SEC form (e.g., 10-K, 10-Q, 8-K)"""
+
+    quarter: Optional[int] = None
+    r"""Fiscal quarter number (1-4)"""
+
+    report: Optional[ReportedReport] = None
+    r"""Financial statements reported within a filing."""
+
+    start_date: Annotated[Optional[str], pydantic.Field(alias="startDate")] = None
+    r"""Start date of the reporting period in YYYY-MM-DD format"""
+
+    symbol: Optional[str] = None
+    r"""Stock ticker symbol"""
+
+    year: Optional[int] = None
+    r"""Fiscal year of the report"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "acceptedDate",
+                "accessNumber",
+                "cik",
+                "endDate",
+                "filedDate",
+                "form",
+                "quarter",
+                "report",
+                "startDate",
+                "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
+
+
+try:
+    ReportedFiling.model_rebuild()
+except NameError:
+    pass

finance_dev/models/reportedreport.py

@@ -0,0 +1,39 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: ba11fb9e361e
+
+from __future__ import annotations
+from .reportedbsitem import ReportedBSItem, ReportedBSItemTypedDict
+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 ReportedReportTypedDict(TypedDict):
+    r"""Financial statements reported within a filing."""
+
+    bs: NotRequired[List[ReportedBSItemTypedDict]]
+    r"""Balance sheet line items from the reported financial statements"""
+
+
+class ReportedReport(BaseModel):
+    r"""Financial statements reported within a filing."""
+
+    bs: Optional[List[ReportedBSItem]] = None
+    r"""Balance sheet line items from the reported financial statements"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["bs"])
+        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/reportingfrequency.py

@@ -0,0 +1,16 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 1b7e145c88bb
+
+from __future__ import annotations
+from enum import Enum
+from finance_dev import utils
+
+
+class ReportingFrequency(str, Enum, metaclass=utils.OpenEnumMeta):
+    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).
+    """
+
+    ANNUAL = "annual"
+    QUARTERLY = "quarterly"

finance_dev/models/revenuebreakdownaxis.py

@@ -0,0 +1,52 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 9d558be82e79
+
+from __future__ import annotations
+from .revenuebreakdowndatapoint import (
+    RevenueBreakdownDataPoint,
+    RevenueBreakdownDataPointTypedDict,
+)
+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 RevenueBreakdownAxisTypedDict(TypedDict):
+    r"""Revenue breakdown along a single dimension such as product or geography."""
+
+    axis: NotRequired[str]
+    r"""XBRL axis identifier (e.g., product line, geography)"""
+    data: NotRequired[List[RevenueBreakdownDataPointTypedDict]]
+    r"""Array of revenue data points for this axis"""
+    label: NotRequired[str]
+    r"""Human-readable label for the axis"""
+
+
+class RevenueBreakdownAxis(BaseModel):
+    r"""Revenue breakdown along a single dimension such as product or geography."""
+
+    axis: Optional[str] = None
+    r"""XBRL axis identifier (e.g., product line, geography)"""
+
+    data: Optional[List[RevenueBreakdownDataPoint]] = None
+    r"""Array of revenue data points for this axis"""
+
+    label: Optional[str] = None
+    r"""Human-readable label for the axis"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["axis", "data", "label"])
+        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/revenuebreakdowndatapoint.py

@@ -0,0 +1,58 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 3f95ebfff4ce
+
+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 RevenueBreakdownDataPointTypedDict(TypedDict):
+    r"""Revenue for a single segment along a breakdown axis."""
+
+    label: NotRequired[str]
+    r"""Label for the revenue segment"""
+    member: NotRequired[str]
+    r"""XBRL member identifier for the segment"""
+    percentage: NotRequired[float]
+    r"""Percentage of total revenue from this segment"""
+    unit: NotRequired[str]
+    r"""Unit of measurement (e.g., USD)"""
+    value: NotRequired[float]
+    r"""Revenue value for this segment"""
+
+
+class RevenueBreakdownDataPoint(BaseModel):
+    r"""Revenue for a single segment along a breakdown axis."""
+
+    label: Optional[str] = None
+    r"""Label for the revenue segment"""
+
+    member: Optional[str] = None
+    r"""XBRL member identifier for the segment"""
+
+    percentage: Optional[float] = None
+    r"""Percentage of total revenue from this segment"""
+
+    unit: Optional[str] = None
+    r"""Unit of measurement (e.g., USD)"""
+
+    value: Optional[float] = None
+    r"""Revenue value for this segment"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["label", "member", "percentage", "unit", "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

finance_dev/models/revenuebreakdownentry.py

@@ -0,0 +1,51 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 402e9e7f78a7
+
+from __future__ import annotations
+from .revenuebreakdowninner import RevenueBreakdownInner, RevenueBreakdownInnerTypedDict
+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 RevenueBreakdownEntryTypedDict(TypedDict):
+    r"""Revenue breakdown for a single SEC filing."""
+
+    access_number: NotRequired[str]
+    r"""SEC accession number for the filing"""
+    breakdown: NotRequired[RevenueBreakdownInnerTypedDict]
+    r"""Total revenue for a reporting period with its breakdown by axis."""
+
+
+class RevenueBreakdownEntry(BaseModel):
+    r"""Revenue breakdown for a single SEC filing."""
+
+    access_number: Annotated[Optional[str], pydantic.Field(alias="accessNumber")] = None
+    r"""SEC accession number for the filing"""
+
+    breakdown: Optional[RevenueBreakdownInner] = None
+    r"""Total revenue for a reporting period with its breakdown by axis."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["accessNumber", "breakdown"])
+        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:
+    RevenueBreakdownEntry.model_rebuild()
+except NameError:
+    pass

finance_dev/models/revenuebreakdowninner.py

@@ -0,0 +1,75 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 70924930526b
+
+from __future__ import annotations
+from .revenuebreakdownaxis import RevenueBreakdownAxis, RevenueBreakdownAxisTypedDict
+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 RevenueBreakdownInnerTypedDict(TypedDict):
+    r"""Total revenue for a reporting period with its breakdown by axis."""
+
+    concept: NotRequired[str]
+    r"""XBRL concept tag for revenue"""
+    end_date: NotRequired[str]
+    r"""End date of the reporting period in YYYY-MM-DD format"""
+    revenue_breakdown: NotRequired[List[RevenueBreakdownAxisTypedDict]]
+    r"""Array of revenue breakdown axes (by product, geography, etc.)"""
+    start_date: NotRequired[str]
+    r"""Start date of the reporting period in YYYY-MM-DD format"""
+    unit: NotRequired[str]
+    r"""Unit of measurement (e.g., USD)"""
+    value: NotRequired[float]
+    r"""Total revenue value"""
+
+
+class RevenueBreakdownInner(BaseModel):
+    r"""Total revenue for a reporting period with its breakdown by axis."""
+
+    concept: Optional[str] = None
+    r"""XBRL concept tag for revenue"""
+
+    end_date: Annotated[Optional[str], pydantic.Field(alias="endDate")] = None
+    r"""End date of the reporting period in YYYY-MM-DD format"""
+
+    revenue_breakdown: Annotated[
+        Optional[List[RevenueBreakdownAxis]], pydantic.Field(alias="revenueBreakdown")
+    ] = None
+    r"""Array of revenue breakdown axes (by product, geography, etc.)"""
+
+    start_date: Annotated[Optional[str], pydantic.Field(alias="startDate")] = None
+    r"""Start date of the reporting period in YYYY-MM-DD format"""
+
+    unit: Optional[str] = None
+    r"""Unit of measurement (e.g., USD)"""
+
+    value: Optional[float] = None
+    r"""Total revenue value"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["concept", "endDate", "revenueBreakdown", "startDate", "unit", "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:
+    RevenueBreakdownInner.model_rebuild()
+except NameError:
+    pass

finance_dev/models/revenueestimatesresponse.py

@@ -0,0 +1,176 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: b2bb53e9cf51
+
+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 RevenueEstimatesResponseDataTypedDict(TypedDict):
+    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"""
+    revenue_avg: NotRequired[int]
+    r"""Average analyst revenue estimate for the period"""
+    revenue_high: NotRequired[int]
+    r"""Highest analyst revenue estimate for the period"""
+    revenue_low: NotRequired[int]
+    r"""Lowest analyst revenue estimate for the period"""
+    year: NotRequired[int]
+    r"""Fiscal year of the period"""
+
+
+class RevenueEstimatesResponseData(BaseModel):
+    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"""
+
+    revenue_avg: Annotated[Optional[int], pydantic.Field(alias="revenueAvg")] = None
+    r"""Average analyst revenue estimate for the period"""
+
+    revenue_high: Annotated[Optional[int], pydantic.Field(alias="revenueHigh")] = None
+    r"""Highest analyst revenue estimate for the period"""
+
+    revenue_low: Annotated[Optional[int], pydantic.Field(alias="revenueLow")] = None
+    r"""Lowest analyst revenue estimate for the period"""
+
+    year: Optional[int] = None
+    r"""Fiscal year of the period"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "numberAnalysts",
+                "period",
+                "quarter",
+                "revenueAvg",
+                "revenueHigh",
+                "revenueLow",
+                "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 RevenueEstimatesTypedDict(TypedDict):
+    r"""revenue estimates container for the symbol"""
+
+    data: NotRequired[List[RevenueEstimatesResponseDataTypedDict]]
+    r"""List of revenue 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 RevenueEstimates(BaseModel):
+    r"""revenue estimates container for the symbol"""
+
+    data: Optional[List[RevenueEstimatesResponseData]] = None
+    r"""List of revenue 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 RevenueEstimatesResponseTypedDict(TypedDict):
+    r"""Analyst consensus revenue estimates for a stock by reporting period, sourced from Finnhub."""
+
+    revenue_estimates: NotRequired[RevenueEstimatesTypedDict]
+    r"""revenue estimates container for the symbol"""
+
+
+class RevenueEstimatesResponse(BaseModel):
+    r"""Analyst consensus revenue estimates for a stock by reporting period, sourced from Finnhub."""
+
+    revenue_estimates: Annotated[
+        Optional[RevenueEstimates], pydantic.Field(alias="revenueEstimates")
+    ] = None
+    r"""revenue estimates container for the symbol"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["revenueEstimates"])
+        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:
+    RevenueEstimatesResponseData.model_rebuild()
+except NameError:
+    pass
+try:
+    RevenueEstimatesResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/screenclause.py

@@ -0,0 +1,70 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 900ed6dcc198
+
+from __future__ import annotations
+from enum import Enum
+from finance_dev import models, utils
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from pydantic import field_serializer, model_serializer
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class ScreenClauseOperator(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Comparison: eq, gt, gte, lt, lte, contains"""
+
+    EQ = "eq"
+    GT = "gt"
+    GTE = "gte"
+    LT = "lt"
+    LTE = "lte"
+    CONTAINS = "contains"
+
+
+class ScreenClauseTypedDict(TypedDict):
+    r"""One filter condition: field name, comparison operator, and value (string)."""
+
+    field: NotRequired[str]
+    r"""Screener field name (e.g. marketcap, pricetoearnings, roe, volume, open_price, dilutedeps, cashandequivalents)"""
+    operator: NotRequired[ScreenClauseOperator]
+    r"""Comparison: eq, gt, gte, lt, lte, contains"""
+    value: NotRequired[str]
+    r"""Value to compare against (e.g. 1000000000, 0.15)"""
+
+
+class ScreenClause(BaseModel):
+    r"""One filter condition: field name, comparison operator, and value (string)."""
+
+    field: Optional[str] = None
+    r"""Screener field name (e.g. marketcap, pricetoearnings, roe, volume, open_price, dilutedeps, cashandequivalents)"""
+
+    operator: Optional[ScreenClauseOperator] = None
+    r"""Comparison: eq, gt, gte, lt, lte, contains"""
+
+    value: Optional[str] = None
+    r"""Value to compare against (e.g. 1000000000, 0.15)"""
+
+    @field_serializer("operator")
+    def serialize_operator(self, value):
+        if isinstance(value, str):
+            try:
+                return models.ScreenClauseOperator(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["field", "operator", "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