finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/symbolinfo.py

@@ -0,0 +1,183 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: ec5daac4efb8
+
+from __future__ import annotations
+from finance_dev.types import BaseModel, Nullable, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import List
+from typing_extensions import Annotated, TypedDict
+
+
+class SubsessionTypedDict(TypedDict):
+    description: str
+    r"""Description of the subsession."""
+    id: str
+    r"""Identifier of the subsession."""
+    session: str
+    r"""Trading hours of the subsession."""
+
+
+class Subsession(BaseModel):
+    description: str
+    r"""Description of the subsession."""
+
+    id: str
+    r"""Identifier of the subsession."""
+
+    session: str
+    r"""Trading hours of the subsession."""
+
+
+class SymbolInfoTypedDict(TypedDict):
+    r"""Chart symbol metadata, including supported resolutions, trading session and price scale."""
+
+    daily_multipliers: List[str]
+    r"""Available daily time multipliers"""
+    description: str
+    r"""Full description of the symbol/company"""
+    exchange: 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."""
+    format_: str
+    r"""Price format (usually 'price')"""
+    has_daily: bool
+    r"""Whether daily data is available"""
+    has_intraday: bool
+    r"""Whether intraday data is available"""
+    has_seconds: bool
+    r"""Whether seconds resolution is available"""
+    has_ticks: bool
+    r"""Whether tick data is available"""
+    has_weekly_and_monthly: bool
+    r"""Whether weekly and monthly data is available"""
+    intraday_multipliers: List[str]
+    r"""Available intraday time multipliers"""
+    listed_exchange: str
+    r"""Primary exchange where the symbol is listed"""
+    minmov: float
+    r"""Minimum price movement"""
+    monthly_multipliers: List[str]
+    r"""Available monthly time multipliers"""
+    name: str
+    r"""Symbol name"""
+    pricescale: int
+    r"""Price scale (e.g., 100 means divide price by 100)"""
+    session: str
+    r"""Trading session hours (e.g., '0930-1600')"""
+    subsession_id: str
+    r"""Identifier of the active subsession. Empty string when the symbol has no subsessions."""
+    subsessions: Nullable[List[SubsessionTypedDict]]
+    r"""Subsession definitions for the symbol. Null when the symbol has no subsessions."""
+    supported_resolutions: List[str]
+    r"""Resolutions supported for this symbol"""
+    ticker: str
+    r"""Symbol ticker"""
+    timezone: str
+    r"""Timezone of the exchange (e.g., 'America/New_York')"""
+    type: str
+    r"""Instrument class or provider category returned by the market data service. This value is not the trading order type."""
+    visible_plots_set: str
+    r"""Visible plots (e.g., 'ohlcv' for OHLC + Volume)"""
+    volume_precision: float
+    r"""Volume precision (decimal places)"""
+    weekly_multipliers: List[str]
+    r"""Available weekly time multipliers"""
+
+
+class SymbolInfo(BaseModel):
+    r"""Chart symbol metadata, including supported resolutions, trading session and price scale."""
+
+    daily_multipliers: List[str]
+    r"""Available daily time multipliers"""
+
+    description: str
+    r"""Full description of the symbol/company"""
+
+    exchange: 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."""
+
+    format_: Annotated[str, pydantic.Field(alias="format")]
+    r"""Price format (usually 'price')"""
+
+    has_daily: bool
+    r"""Whether daily data is available"""
+
+    has_intraday: bool
+    r"""Whether intraday data is available"""
+
+    has_seconds: bool
+    r"""Whether seconds resolution is available"""
+
+    has_ticks: bool
+    r"""Whether tick data is available"""
+
+    has_weekly_and_monthly: bool
+    r"""Whether weekly and monthly data is available"""
+
+    intraday_multipliers: List[str]
+    r"""Available intraday time multipliers"""
+
+    listed_exchange: str
+    r"""Primary exchange where the symbol is listed"""
+
+    minmov: float
+    r"""Minimum price movement"""
+
+    monthly_multipliers: List[str]
+    r"""Available monthly time multipliers"""
+
+    name: str
+    r"""Symbol name"""
+
+    pricescale: int
+    r"""Price scale (e.g., 100 means divide price by 100)"""
+
+    session: str
+    r"""Trading session hours (e.g., '0930-1600')"""
+
+    subsession_id: str
+    r"""Identifier of the active subsession. Empty string when the symbol has no subsessions."""
+
+    subsessions: Nullable[List[Subsession]]
+    r"""Subsession definitions for the symbol. Null when the symbol has no subsessions."""
+
+    supported_resolutions: List[str]
+    r"""Resolutions supported for this symbol"""
+
+    ticker: str
+    r"""Symbol ticker"""
+
+    timezone: str
+    r"""Timezone of the exchange (e.g., 'America/New_York')"""
+
+    type: str
+    r"""Instrument class or provider category returned by the market data service. This value is not the trading order type."""
+
+    visible_plots_set: str
+    r"""Visible plots (e.g., 'ohlcv' for OHLC + Volume)"""
+
+    volume_precision: float
+    r"""Volume precision (decimal places)"""
+
+    weekly_multipliers: List[str]
+    r"""Available weekly time multipliers"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        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:
+                m[k] = val
+
+        return m
+
+
+try:
+    SymbolInfo.model_rebuild()
+except NameError:
+    pass

finance_dev/models/synclogosop.py

@@ -0,0 +1,146 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 49cb8840cf95
+
+from __future__ import annotations
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .logosyncresponse import LogoSyncResponse, LogoSyncResponseTypedDict
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from finance_dev.utils import FieldMetadata, QueryParamMetadata
+import pydantic
+from pydantic import model_serializer
+from typing import Callable, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class SyncLogosRequestTypedDict(TypedDict):
+    fields: str
+    r"""Comma-separated list of logo asset fields to return. Common values:
+    - `logo_light` — full logo for light backgrounds.
+    - `logo_dark` — full logo for dark backgrounds.
+    - `mark_light` — square/icon mark for light backgrounds.
+    - `mark_dark` — square/icon mark for dark backgrounds.
+
+    Other provider-defined fields may also be supported — pass any field name the upstream image catalog exposes.
+    """
+    updated_since: NotRequired[int]
+    r"""Only return logos updated since this Unix timestamp"""
+    composite_auto: NotRequired[bool]
+    r"""Whether to auto-generate composite logo marks. Use true when you need fallback visuals for symbols without a standard logo."""
+    composite_radius: NotRequired[int]
+    r"""Corner radius for generated composite logos. Enter a value from 0 to 50 to match your UI style."""
+    scale: NotRequired[str]
+    r"""Image scale for returned logo URLs. Use higher scale values for high-density displays."""
+    page: NotRequired[int]
+    r"""Zero-based page offset. Enter 0 for the first page of results."""
+    page_size: NotRequired[int]
+    r"""Number of results per page. Use this to control pagination size in list views. (1-1000)"""
+
+
+class SyncLogosRequest(BaseModel):
+    fields: Annotated[
+        str, FieldMetadata(query=QueryParamMetadata(style="form", explode=True))
+    ]
+    r"""Comma-separated list of logo asset fields to return. Common values:
+    - `logo_light` — full logo for light backgrounds.
+    - `logo_dark` — full logo for dark backgrounds.
+    - `mark_light` — square/icon mark for light backgrounds.
+    - `mark_dark` — square/icon mark for dark backgrounds.
+
+    Other provider-defined fields may also be supported — pass any field name the upstream image catalog exposes.
+    """
+
+    updated_since: Annotated[
+        Optional[int],
+        pydantic.Field(alias="updatedSince"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Only return logos updated since this Unix timestamp"""
+
+    composite_auto: Annotated[
+        Optional[bool],
+        pydantic.Field(alias="compositeAuto"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = False
+    r"""Whether to auto-generate composite logo marks. Use true when you need fallback visuals for symbols without a standard logo."""
+
+    composite_radius: Annotated[
+        Optional[int],
+        pydantic.Field(alias="compositeRadius"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Corner radius for generated composite logos. Enter a value from 0 to 50 to match your UI style."""
+
+    scale: Annotated[
+        Optional[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Image scale for returned logo URLs. Use higher scale values for high-density displays."""
+
+    page: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Zero-based page offset. Enter 0 for the first page of results."""
+
+    page_size: Annotated[
+        Optional[int],
+        pydantic.Field(alias="pageSize"),
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Number of results per page. Use this to control pagination size in list views. (1-1000)"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "updatedSince",
+                "compositeAuto",
+                "compositeRadius",
+                "scale",
+                "page",
+                "pageSize",
+            ]
+        )
+        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 SyncLogosResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    logo_sync_response: NotRequired[LogoSyncResponseTypedDict]
+    r"""Successful response"""
+
+
+class SyncLogosResponse(BaseModel):
+    next: Callable[[], Optional[SyncLogosResponse]]
+
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    logo_sync_response: Optional[LogoSyncResponse] = None
+    r"""Successful response"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["LogoSyncResponse"])
+        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/technicalindicatorresponse.py

@@ -0,0 +1,43 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: d5c653e302da
+
+from __future__ import annotations
+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 TechnicalIndicatorResponseTypedDict(TypedDict):
+    r"""Technical indicator values for a symbol over a time range, as returned by Finnhub; the keys present depend on the requested indicator."""
+
+    sma: NotRequired[List[float]]
+    r"""Simple moving average values, one per timestamp in t."""
+    t: NotRequired[List[int]]
+    r"""Timestamps corresponding to each indicator value."""
+
+
+class TechnicalIndicatorResponse(BaseModel):
+    r"""Technical indicator values for a symbol over a time range, as returned by Finnhub; the keys present depend on the requested indicator."""
+
+    sma: Optional[List[float]] = None
+    r"""Simple moving average values, one per timestamp in t."""
+
+    t: Optional[List[int]] = None
+    r"""Timestamps corresponding to each indicator value."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["sma", "t"])
+        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/technicalindicatortype.py

@@ -0,0 +1,21 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 246217a13ad1
+
+from __future__ import annotations
+from enum import Enum
+from finance_dev import utils
+
+
+class TechnicalIndicatorType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Technical indicator slug (e.g. `sma`, `ema`, `rsi`, `macd`, `bbands`). Pass this with the indicator endpoint to compute that indicator over the requested bars."""
+
+    SMA = "sma"
+    EMA = "ema"
+    RSI = "rsi"
+    MACD = "macd"
+    BBANDS = "bbands"
+    STOCH = "stoch"
+    ADX = "adx"
+    CCI = "cci"
+    WILLR = "willr"
+    MFI = "mfi"

finance_dev/models/technicalpatternsresponse.py

@@ -0,0 +1,249 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 0d3cf537973f
+
+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 PointTypedDict(TypedDict):
+    aprice: NotRequired[float]
+    r"""Price at pattern point A."""
+    atime: NotRequired[int]
+    r"""Timestamp of pattern point A as an integer from the provider."""
+    bprice: NotRequired[int]
+    r"""Price at pattern point B."""
+    btime: NotRequired[int]
+    r"""Timestamp of pattern point B as an integer from the provider."""
+    cprice: NotRequired[int]
+    r"""Price at pattern point C."""
+    ctime: NotRequired[int]
+    r"""Timestamp of pattern point C as an integer from the provider."""
+    dprice: NotRequired[float]
+    r"""Price at pattern point D."""
+    dtime: NotRequired[int]
+    r"""Timestamp of pattern point D as an integer from the provider."""
+    end_price: NotRequired[int]
+    r"""Price at the end of the pattern."""
+    end_time: NotRequired[int]
+    r"""Timestamp of the end of the pattern as an integer from the provider."""
+    entry: NotRequired[int]
+    r"""Suggested entry price for the pattern."""
+    eprice: NotRequired[int]
+    r"""Price at pattern point E."""
+    etime: NotRequired[int]
+    r"""Timestamp of pattern point E as an integer from the provider."""
+    mature: NotRequired[int]
+    r"""Provider flag indicating whether the pattern is mature."""
+    patternname: NotRequired[str]
+    r"""Name of the detected pattern."""
+    patterntype: NotRequired[str]
+    r"""Type of the detected pattern."""
+    profit1: NotRequired[int]
+    r"""First profit target price for the pattern."""
+    profit2: NotRequired[int]
+    r"""Second profit target price for the pattern."""
+    sort_time: NotRequired[int]
+    r"""Provider timestamp used for sorting patterns."""
+    start_price: NotRequired[int]
+    r"""Price at the start of the pattern."""
+    start_time: NotRequired[int]
+    r"""Timestamp of the start of the pattern as an integer from the provider."""
+    status: NotRequired[str]
+    r"""Status string from the upstream data provider — typically `OK` for a successful response. Treat any other value as an error indicator alongside the HTTP status code."""
+    stoploss: NotRequired[int]
+    r"""Suggested stop-loss price for the pattern."""
+    symbol: NotRequired[str]
+    r"""Ticker symbol the pattern was detected for."""
+    terminal: NotRequired[int]
+    r"""Provider flag indicating whether the pattern is terminal."""
+
+
+class Point(BaseModel):
+    aprice: Optional[float] = None
+    r"""Price at pattern point A."""
+
+    atime: Optional[int] = None
+    r"""Timestamp of pattern point A as an integer from the provider."""
+
+    bprice: Optional[int] = None
+    r"""Price at pattern point B."""
+
+    btime: Optional[int] = None
+    r"""Timestamp of pattern point B as an integer from the provider."""
+
+    cprice: Optional[int] = None
+    r"""Price at pattern point C."""
+
+    ctime: Optional[int] = None
+    r"""Timestamp of pattern point C as an integer from the provider."""
+
+    dprice: Optional[float] = None
+    r"""Price at pattern point D."""
+
+    dtime: Optional[int] = None
+    r"""Timestamp of pattern point D as an integer from the provider."""
+
+    end_price: Optional[int] = None
+    r"""Price at the end of the pattern."""
+
+    end_time: Optional[int] = None
+    r"""Timestamp of the end of the pattern as an integer from the provider."""
+
+    entry: Optional[int] = None
+    r"""Suggested entry price for the pattern."""
+
+    eprice: Optional[int] = None
+    r"""Price at pattern point E."""
+
+    etime: Optional[int] = None
+    r"""Timestamp of pattern point E as an integer from the provider."""
+
+    mature: Optional[int] = None
+    r"""Provider flag indicating whether the pattern is mature."""
+
+    patternname: Optional[str] = None
+    r"""Name of the detected pattern."""
+
+    patterntype: Optional[str] = None
+    r"""Type of the detected pattern."""
+
+    profit1: Optional[int] = None
+    r"""First profit target price for the pattern."""
+
+    profit2: Optional[int] = None
+    r"""Second profit target price for the pattern."""
+
+    sort_time: Annotated[Optional[int], pydantic.Field(alias="sortTime")] = None
+    r"""Provider timestamp used for sorting patterns."""
+
+    start_price: Optional[int] = None
+    r"""Price at the start of the pattern."""
+
+    start_time: Optional[int] = None
+    r"""Timestamp of the start of the pattern as an integer from the provider."""
+
+    status: Optional[str] = None
+    r"""Status string from the upstream data provider — typically `OK` for a successful response. Treat any other value as an error indicator alongside the HTTP status code."""
+
+    stoploss: Optional[int] = None
+    r"""Suggested stop-loss price for the pattern."""
+
+    symbol: Optional[str] = None
+    r"""Ticker symbol the pattern was detected for."""
+
+    terminal: Optional[int] = None
+    r"""Provider flag indicating whether the pattern is terminal."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "aprice",
+                "atime",
+                "bprice",
+                "btime",
+                "cprice",
+                "ctime",
+                "dprice",
+                "dtime",
+                "end_price",
+                "end_time",
+                "entry",
+                "eprice",
+                "etime",
+                "mature",
+                "patternname",
+                "patterntype",
+                "profit1",
+                "profit2",
+                "sortTime",
+                "start_price",
+                "start_time",
+                "status",
+                "stoploss",
+                "symbol",
+                "terminal",
+            ]
+        )
+        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 TechnicalPatternsResponseDataTypedDict(TypedDict):
+    r"""Pattern recognition payload."""
+
+    points: NotRequired[List[PointTypedDict]]
+    r"""List of detected pattern points."""
+
+
+class TechnicalPatternsResponseData(BaseModel):
+    r"""Pattern recognition payload."""
+
+    points: Optional[List[Point]] = None
+    r"""List of detected pattern points."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["points"])
+        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 TechnicalPatternsResponseTypedDict(TypedDict):
+    r"""Chart patterns detected by Finnhub pattern recognition for a symbol and resolution."""
+
+    data: NotRequired[TechnicalPatternsResponseDataTypedDict]
+    r"""Pattern recognition payload."""
+
+
+class TechnicalPatternsResponse(BaseModel):
+    r"""Chart patterns detected by Finnhub pattern recognition for a symbol and resolution."""
+
+    data: Optional[TechnicalPatternsResponseData] = None
+    r"""Pattern recognition payload."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["data"])
+        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:
+    Point.model_rebuild()
+except NameError:
+    pass

finance_dev/models/tenderofferidentifiertype.py

@@ -0,0 +1,26 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 9a857d7cfa6e
+
+from __future__ import annotations
+from enum import Enum
+from finance_dev import utils
+
+
+class TenderOfferIdentifierType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Which kind of identifier you are filtering by. Provide the matching value in the identifier field:
+    - `Symbol` — exchange ticker (e.g. `AAPL`).
+    - `CUSIP` — 9-character U.S./Canadian security identifier.
+    - `ISIN` — 12-character international identifier.
+    - `SEDOL` — 7-character UK identifier.
+    - `Valoren` — Swiss identifier.
+    - `FIGI` — Bloomberg Financial Instrument Global Identifier.
+    - `CompositeFIGI` — country-level composite FIGI.
+    """
+
+    SYMBOL = "Symbol"
+    CUSIP = "CUSIP"
+    ISIN = "ISIN"
+    SEDOL = "SEDOL"
+    VALOREN = "Valoren"
+    FIGI = "FIGI"
+    COMPOSITE_FIGI = "CompositeFIGI"