finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/basicfinancials.py

@@ -0,0 +1,243 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 4e7c827b3f40
+
+from __future__ import annotations
+from .metricseriespoint import MetricSeriesPoint, MetricSeriesPointTypedDict
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+import pydantic
+from pydantic import ConfigDict, model_serializer
+from typing import Dict, List, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class MetricTypedDict(TypedDict):
+    r"""Current financial metrics and ratios (dynamic object with various metric keys)"""
+
+    ten_day_average_trading_volume: NotRequired[float]
+    r"""Average daily trading volume over the last 10 days"""
+    fifty_two_week_high: NotRequired[float]
+    r"""Highest stock price in the last 52 weeks"""
+    fifty_two_week_high_date: NotRequired[str]
+    r"""Date when the 52-week high was reached"""
+    fifty_two_week_low: NotRequired[float]
+    r"""Lowest stock price in the last 52 weeks"""
+    fifty_two_week_low_date: NotRequired[str]
+    r"""Date when the 52-week low was reached"""
+    fifty_two_week_price_return_daily: NotRequired[float]
+    r"""Price return over the last 52 weeks (daily calculation)"""
+    beta: NotRequired[float]
+    r"""Stock's beta coefficient measuring volatility relative to the market"""
+
+
+class Metric(BaseModel):
+    r"""Current financial metrics and ratios (dynamic object with various metric keys)"""
+
+    model_config = ConfigDict(
+        populate_by_name=True, arbitrary_types_allowed=True, extra="allow"
+    )
+    __pydantic_extra__: Dict[str, Optional[Union[float, str]]] = pydantic.Field(init=False)
+
+    ten_day_average_trading_volume: Annotated[
+        Optional[float], pydantic.Field(alias="10DayAverageTradingVolume")
+    ] = None
+    r"""Average daily trading volume over the last 10 days"""
+
+    fifty_two_week_high: Annotated[
+        Optional[float], pydantic.Field(alias="52WeekHigh")
+    ] = None
+    r"""Highest stock price in the last 52 weeks"""
+
+    fifty_two_week_high_date: Annotated[
+        Optional[str], pydantic.Field(alias="52WeekHighDate")
+    ] = None
+    r"""Date when the 52-week high was reached"""
+
+    fifty_two_week_low: Annotated[
+        Optional[float], pydantic.Field(alias="52WeekLow")
+    ] = None
+    r"""Lowest stock price in the last 52 weeks"""
+
+    fifty_two_week_low_date: Annotated[
+        Optional[str], pydantic.Field(alias="52WeekLowDate")
+    ] = None
+    r"""Date when the 52-week low was reached"""
+
+    fifty_two_week_price_return_daily: Annotated[
+        Optional[float], pydantic.Field(alias="52WeekPriceReturnDaily")
+    ] = None
+    r"""Price return over the last 52 weeks (daily calculation)"""
+
+    beta: Optional[float] = None
+    r"""Stock's beta coefficient measuring volatility relative to the market"""
+
+    @property
+    def additional_properties(self):
+        return self.__pydantic_extra__
+
+    @additional_properties.setter
+    def additional_properties(self, value):
+        self.__pydantic_extra__ = value  # pyright: ignore[reportIncompatibleVariableOverride]
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "10DayAverageTradingVolume",
+                "52WeekHigh",
+                "52WeekHighDate",
+                "52WeekLow",
+                "52WeekLowDate",
+                "52WeekPriceReturnDaily",
+                "beta",
+            ]
+        )
+        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))
+            serialized.pop(k, serialized.pop(n, None))
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+        for k, v in serialized.items():
+            m[k] = v
+
+        return m
+
+
+class AnnualTypedDict(TypedDict):
+    r"""Annual financial metrics organized by type"""
+
+    current_ratio: NotRequired[List[MetricSeriesPointTypedDict]]
+    r"""Current ratio values over time (current assets / current liabilities)"""
+    net_margin: NotRequired[List[MetricSeriesPointTypedDict]]
+    r"""Net profit margin values over time"""
+    sales_per_share: NotRequired[List[MetricSeriesPointTypedDict]]
+    r"""Sales per share values over time"""
+
+
+class Annual(BaseModel):
+    r"""Annual financial metrics organized by type"""
+
+    current_ratio: Annotated[
+        Optional[List[MetricSeriesPoint]], pydantic.Field(alias="currentRatio")
+    ] = None
+    r"""Current ratio values over time (current assets / current liabilities)"""
+
+    net_margin: Annotated[
+        Optional[List[MetricSeriesPoint]], pydantic.Field(alias="netMargin")
+    ] = None
+    r"""Net profit margin values over time"""
+
+    sales_per_share: Annotated[
+        Optional[List[MetricSeriesPoint]], pydantic.Field(alias="salesPerShare")
+    ] = None
+    r"""Sales per share values over time"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["currentRatio", "netMargin", "salesPerShare"])
+        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 SeriesTypedDict(TypedDict):
+    r"""Time series data for various financial metrics"""
+
+    annual: NotRequired[AnnualTypedDict]
+    r"""Annual financial metrics organized by type"""
+
+
+class Series(BaseModel):
+    r"""Time series data for various financial metrics"""
+
+    annual: Optional[Annual] = None
+    r"""Annual financial metrics organized by type"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["annual"])
+        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 BasicFinancialsTypedDict(TypedDict):
+    r"""Basic financial metrics for company research. Use these values for valuation, profitability, and balance-sheet trend displays."""
+
+    metric: NotRequired[MetricTypedDict]
+    r"""Current financial metrics and ratios (dynamic object with various metric keys)"""
+    metric_type: NotRequired[str]
+    r"""Type of metrics returned (all, price, valuation, margin)"""
+    series: NotRequired[SeriesTypedDict]
+    r"""Time series data for various financial metrics"""
+    symbol: NotRequired[str]
+    r"""Stock ticker symbol these financial metrics belong to. Use it to match the metrics back to the requested company."""
+
+
+class BasicFinancials(BaseModel):
+    r"""Basic financial metrics for company research. Use these values for valuation, profitability, and balance-sheet trend displays."""
+
+    metric: Optional[Metric] = None
+    r"""Current financial metrics and ratios (dynamic object with various metric keys)"""
+
+    metric_type: Annotated[Optional[str], pydantic.Field(alias="metricType")] = None
+    r"""Type of metrics returned (all, price, valuation, margin)"""
+
+    series: Optional[Series] = None
+    r"""Time series data for various financial metrics"""
+
+    symbol: Optional[str] = None
+    r"""Stock ticker symbol these financial metrics belong to. Use it to match the metrics back to the requested company."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["metric", "metricType", "series", "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:
+    Metric.model_rebuild()
+except NameError:
+    pass
+try:
+    Annual.model_rebuild()
+except NameError:
+    pass
+try:
+    BasicFinancials.model_rebuild()
+except NameError:
+    pass

finance_dev/models/bullbearanalysisresponse.py

@@ -0,0 +1,150 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 0b163bccd680
+
+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 BullBearAnalysisResponseSecurityTypedDict(TypedDict):
+    cik: NotRequired[str]
+    r"""SEC Central Index Key"""
+    exchange: NotRequired[str]
+    r"""Exchange code where the data originates. Format depends on the upstream data source and may use MIC, ISO 10383, or a vendor-specific code."""
+    isin: NotRequired[str]
+    r"""International Securities Identification Number"""
+    name: NotRequired[str]
+    r"""Company name"""
+    symbol: NotRequired[str]
+    r"""Stock ticker symbol, such as AAPL. Use the exact ticker for the company you want to research."""
+
+
+class BullBearAnalysisResponseSecurity(BaseModel):
+    cik: Optional[str] = None
+    r"""SEC Central Index Key"""
+
+    exchange: Optional[str] = None
+    r"""Exchange code where the data originates. Format depends on the upstream data source and may use MIC, ISO 10383, or a vendor-specific code."""
+
+    isin: Optional[str] = None
+    r"""International Securities Identification Number"""
+
+    name: Optional[str] = None
+    r"""Company name"""
+
+    symbol: Optional[str] = None
+    r"""Stock ticker symbol, such as AAPL. Use the exact ticker for the company you want to research."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["cik", "exchange", "isin", "name", "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 BullBearCaseTypedDict(TypedDict):
+    bear_case: NotRequired[str]
+    r"""Bearish investment thesis describing risks and potential challenges"""
+    bull_case: NotRequired[str]
+    r"""Bullish investment thesis describing positive factors and growth opportunities"""
+    id: NotRequired[str]
+    r"""Unique identifier for the bull/bear case analysis"""
+    securities: NotRequired[List[BullBearAnalysisResponseSecurityTypedDict]]
+    r"""Array of securities associated with this ticker"""
+    ticker: NotRequired[str]
+    r"""Stock ticker symbol, such as AAPL. Use the exact ticker for the company you want to research."""
+    updated: NotRequired[int]
+    r"""Unix timestamp when the analysis was last updated"""
+
+
+class BullBearCase(BaseModel):
+    bear_case: Annotated[Optional[str], pydantic.Field(alias="bearCase")] = None
+    r"""Bearish investment thesis describing risks and potential challenges"""
+
+    bull_case: Annotated[Optional[str], pydantic.Field(alias="bullCase")] = None
+    r"""Bullish investment thesis describing positive factors and growth opportunities"""
+
+    id: Optional[str] = None
+    r"""Unique identifier for the bull/bear case analysis"""
+
+    securities: Optional[List[BullBearAnalysisResponseSecurity]] = None
+    r"""Array of securities associated with this ticker"""
+
+    ticker: Optional[str] = None
+    r"""Stock ticker symbol, such as AAPL. Use the exact ticker for the company you want to research."""
+
+    updated: Optional[int] = None
+    r"""Unix timestamp when the analysis was last updated"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["bearCase", "bullCase", "id", "securities", "ticker", "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 BullBearAnalysisResponseTypedDict(TypedDict):
+    r"""Bull and bear investment cases for securities."""
+
+    bull_bear_cases: NotRequired[List[BullBearCaseTypedDict]]
+    r"""Array of bull and bear investment cases for securities"""
+
+
+class BullBearAnalysisResponse(BaseModel):
+    r"""Bull and bear investment cases for securities."""
+
+    bull_bear_cases: Annotated[
+        Optional[List[BullBearCase]], pydantic.Field(alias="bullBearCases")
+    ] = None
+    r"""Array of bull and bear investment cases for securities"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["bullBearCases"])
+        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:
+    BullBearCase.model_rebuild()
+except NameError:
+    pass
+try:
+    BullBearAnalysisResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/cancelorderop.py

@@ -0,0 +1,40 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: efe1a013e7b1
+
+from __future__ import annotations
+from .cancelordresponse import CancelOrdResponse, CancelOrdResponseTypedDict
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+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 CancelOrderResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    cancel_ord_response: NotRequired[CancelOrdResponseTypedDict]
+    r"""Cancel request submitted successfully"""
+
+
+class CancelOrderResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    cancel_ord_response: Optional[CancelOrdResponse] = None
+    r"""Cancel request submitted successfully"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["CancelOrdResponse"])
+        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