finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/etbsearchrequest.py

@@ -0,0 +1,21 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: cbcc589f5d9c
+
+from __future__ import annotations
+from finance_dev.types import BaseModel
+from typing import List
+from typing_extensions import TypedDict
+
+
+class EtbSearchRequestTypedDict(TypedDict):
+    r"""Batch borrowability query. Symbols are uppercased and trimmed before the lookup, and duplicates that normalize to the same symbol collapse into a single entry in the response."""
+
+    symbols: List[str]
+    r"""Symbols to check. Case-insensitive and whitespace-trimmed, so `aapl`, ` AAPL `, and `AAPL` are the same symbol and return one entry. A request of only blank strings is rejected with 400 MISSING_SYMBOLS rather than answered with an empty result."""
+
+
+class EtbSearchRequest(BaseModel):
+    r"""Batch borrowability query. Symbols are uppercased and trimmed before the lookup, and duplicates that normalize to the same symbol collapse into a single entry in the response."""
+
+    symbols: List[str]
+    r"""Symbols to check. Case-insensitive and whitespace-trimmed, so `aapl`, ` AAPL `, and `AAPL` are the same symbol and return one entry. A request of only blank strings is rejected with 400 MISSING_SYMBOLS rather than answered with an empty result."""

finance_dev/models/etbsearchresponse.py

@@ -0,0 +1,43 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 4b8179ed10d8
+
+from __future__ import annotations
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Dict, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class EtbSearchResponseTypedDict(TypedDict):
+    r"""Borrowability answers keyed by normalized (uppercase) symbol."""
+
+    count: NotRequired[int]
+    r"""Number of entries in `results`. This can be lower than the number of symbols you sent, because duplicates collapse after normalization."""
+    results: NotRequired[Dict[str, bool]]
+    r"""One entry per distinct normalized symbol. `true` means easy to borrow (a short sale needs no extra step); `false` means hard to borrow (the symbol is not on today's list and needs a locate first). Read answers out of this object by uppercase key — do not match them against your request array by index, because normalization collapses duplicates."""
+
+
+class EtbSearchResponse(BaseModel):
+    r"""Borrowability answers keyed by normalized (uppercase) symbol."""
+
+    count: Optional[int] = None
+    r"""Number of entries in `results`. This can be lower than the number of symbols you sent, because duplicates collapse after normalization."""
+
+    results: Optional[Dict[str, bool]] = None
+    r"""One entry per distinct normalized symbol. `true` means easy to borrow (a short sale needs no extra step); `false` means hard to borrow (the symbol is not on today's list and needs a locate first). Read answers out of this object by uppercase key — do not match them against your request array by index, because normalization collapses duplicates."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["count", "results"])
+        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/etfcountryallocationresponse.py

@@ -0,0 +1,113 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 48fcc91d65ef
+
+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 CountryExposureTypedDict(TypedDict):
+    country: NotRequired[str]
+    r"""Name of the country."""
+    exposure: NotRequired[float]
+    r"""Exposure of the ETF to this country as reported by the provider."""
+
+
+class CountryExposure(BaseModel):
+    country: Optional[str] = None
+    r"""Name of the country."""
+
+    exposure: Optional[float] = None
+    r"""Exposure of the ETF to this country as reported by the provider."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["country", "exposure"])
+        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 EtfCountryAllocationResponseDataTypedDict(TypedDict):
+    r"""ETF country exposure payload."""
+
+    country_exposure: NotRequired[List[CountryExposureTypedDict]]
+    r"""List of country exposures for the ETF."""
+    symbol: NotRequired[str]
+    r"""ETF ticker symbol."""
+
+
+class EtfCountryAllocationResponseData(BaseModel):
+    r"""ETF country exposure payload."""
+
+    country_exposure: Annotated[
+        Optional[List[CountryExposure]], pydantic.Field(alias="countryExposure")
+    ] = None
+    r"""List of country exposures for the ETF."""
+
+    symbol: Optional[str] = None
+    r"""ETF ticker symbol."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["countryExposure", "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 EtfCountryAllocationResponseTypedDict(TypedDict):
+    r"""Country exposure breakdown of an ETF from Finnhub."""
+
+    data: NotRequired[EtfCountryAllocationResponseDataTypedDict]
+    r"""ETF country exposure payload."""
+
+
+class EtfCountryAllocationResponse(BaseModel):
+    r"""Country exposure breakdown of an ETF from Finnhub."""
+
+    data: Optional[EtfCountryAllocationResponseData] = None
+    r"""ETF country exposure 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:
+    EtfCountryAllocationResponseData.model_rebuild()
+except NameError:
+    pass

finance_dev/models/etfholdingsresponse.py

@@ -0,0 +1,163 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: e31fc139fbc5
+
+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 HoldingTypedDict(TypedDict):
+    asset_type: NotRequired[str]
+    r"""Asset type of the holding."""
+    cusip: NotRequired[str]
+    r"""CUSIP identifier of the holding."""
+    isin: NotRequired[str]
+    r"""ISIN identifier of the holding."""
+    name: NotRequired[str]
+    r"""Name of the holding."""
+    percent: NotRequired[float]
+    r"""Portfolio weight of the holding as reported by the provider."""
+    share: NotRequired[int]
+    r"""Number of shares held."""
+    symbol: NotRequired[str]
+    r"""Ticker symbol of the holding."""
+    value: NotRequired[int]
+    r"""Market value of the holding as reported by the provider."""
+
+
+class Holding(BaseModel):
+    asset_type: Annotated[Optional[str], pydantic.Field(alias="assetType")] = None
+    r"""Asset type of the holding."""
+
+    cusip: Optional[str] = None
+    r"""CUSIP identifier of the holding."""
+
+    isin: Optional[str] = None
+    r"""ISIN identifier of the holding."""
+
+    name: Optional[str] = None
+    r"""Name of the holding."""
+
+    percent: Optional[float] = None
+    r"""Portfolio weight of the holding as reported by the provider."""
+
+    share: Optional[int] = None
+    r"""Number of shares held."""
+
+    symbol: Optional[str] = None
+    r"""Ticker symbol of the holding."""
+
+    value: Optional[int] = None
+    r"""Market value of the holding as reported by the provider."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "assetType",
+                "cusip",
+                "isin",
+                "name",
+                "percent",
+                "share",
+                "symbol",
+                "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
+
+
+class EtfHoldingsResponseDataTypedDict(TypedDict):
+    r"""ETF holdings payload."""
+
+    holdings: NotRequired[List[HoldingTypedDict]]
+    r"""List of holdings in the ETF."""
+    number_of_holdings: NotRequired[int]
+    r"""Total number of holdings in the ETF."""
+    symbol: NotRequired[str]
+    r"""ETF ticker symbol."""
+
+
+class EtfHoldingsResponseData(BaseModel):
+    r"""ETF holdings payload."""
+
+    holdings: Optional[List[Holding]] = None
+    r"""List of holdings in the ETF."""
+
+    number_of_holdings: Annotated[
+        Optional[int], pydantic.Field(alias="numberOfHoldings")
+    ] = None
+    r"""Total number of holdings in the ETF."""
+
+    symbol: Optional[str] = None
+    r"""ETF ticker symbol."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["holdings", "numberOfHoldings", "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 EtfHoldingsResponseTypedDict(TypedDict):
+    r"""Constituent holdings of an ETF from Finnhub."""
+
+    data: NotRequired[EtfHoldingsResponseDataTypedDict]
+    r"""ETF holdings payload."""
+
+
+class EtfHoldingsResponse(BaseModel):
+    r"""Constituent holdings of an ETF from Finnhub."""
+
+    data: Optional[EtfHoldingsResponseData] = None
+    r"""ETF holdings 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:
+    Holding.model_rebuild()
+except NameError:
+    pass
+try:
+    EtfHoldingsResponseData.model_rebuild()
+except NameError:
+    pass

finance_dev/models/etfprofileresponse.py

@@ -0,0 +1,234 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: c0ee516eec91
+
+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 ProfileTypedDict(TypedDict):
+    r"""Descriptive and fundamental attributes of the ETF."""
+
+    asset_class: NotRequired[str]
+    r"""Asset class of the ETF."""
+    aum: NotRequired[int]
+    r"""Assets under management of the ETF."""
+    avg_volume: NotRequired[int]
+    r"""Average trading volume of the ETF."""
+    cusip: NotRequired[str]
+    r"""CUSIP identifier of the ETF."""
+    description: NotRequired[str]
+    r"""Text description of the ETF."""
+    domicile: NotRequired[str]
+    r"""Domicile of the ETF."""
+    etf_company: NotRequired[str]
+    r"""Company that manages or issues the ETF."""
+    expense_ratio: NotRequired[float]
+    r"""Expense ratio of the ETF."""
+    inception_date: NotRequired[str]
+    r"""Inception date of the ETF as a string from the provider."""
+    investment_segment: NotRequired[str]
+    r"""Investment segment of the ETF."""
+    isin: NotRequired[str]
+    r"""ISIN identifier of the ETF."""
+    logo: NotRequired[str]
+    r"""URL of the ETF logo image."""
+    name: NotRequired[str]
+    r"""Name of the ETF."""
+    nav: NotRequired[float]
+    r"""Net asset value of the ETF."""
+    nav_currency: NotRequired[str]
+    r"""Currency in which the net asset value is quoted."""
+    price_to_book: NotRequired[float]
+    r"""Price-to-book ratio of the ETF."""
+    price_to_earnings: NotRequired[float]
+    r"""Price-to-earnings ratio of the ETF."""
+    tracking_index: NotRequired[str]
+    r"""Index tracked by the ETF."""
+    website: NotRequired[str]
+    r"""URL of the ETF website."""
+
+
+class Profile(BaseModel):
+    r"""Descriptive and fundamental attributes of the ETF."""
+
+    asset_class: Annotated[Optional[str], pydantic.Field(alias="assetClass")] = None
+    r"""Asset class of the ETF."""
+
+    aum: Optional[int] = None
+    r"""Assets under management of the ETF."""
+
+    avg_volume: Annotated[Optional[int], pydantic.Field(alias="avgVolume")] = None
+    r"""Average trading volume of the ETF."""
+
+    cusip: Optional[str] = None
+    r"""CUSIP identifier of the ETF."""
+
+    description: Optional[str] = None
+    r"""Text description of the ETF."""
+
+    domicile: Optional[str] = None
+    r"""Domicile of the ETF."""
+
+    etf_company: Annotated[Optional[str], pydantic.Field(alias="etfCompany")] = None
+    r"""Company that manages or issues the ETF."""
+
+    expense_ratio: Annotated[Optional[float], pydantic.Field(alias="expenseRatio")] = (
+        None
+    )
+    r"""Expense ratio of the ETF."""
+
+    inception_date: Annotated[Optional[str], pydantic.Field(alias="inceptionDate")] = (
+        None
+    )
+    r"""Inception date of the ETF as a string from the provider."""
+
+    investment_segment: Annotated[
+        Optional[str], pydantic.Field(alias="investmentSegment")
+    ] = None
+    r"""Investment segment of the ETF."""
+
+    isin: Optional[str] = None
+    r"""ISIN identifier of the ETF."""
+
+    logo: Optional[str] = None
+    r"""URL of the ETF logo image."""
+
+    name: Optional[str] = None
+    r"""Name of the ETF."""
+
+    nav: Optional[float] = None
+    r"""Net asset value of the ETF."""
+
+    nav_currency: Annotated[Optional[str], pydantic.Field(alias="navCurrency")] = None
+    r"""Currency in which the net asset value is quoted."""
+
+    price_to_book: Annotated[Optional[float], pydantic.Field(alias="priceToBook")] = (
+        None
+    )
+    r"""Price-to-book ratio of the ETF."""
+
+    price_to_earnings: Annotated[
+        Optional[float], pydantic.Field(alias="priceToEarnings")
+    ] = None
+    r"""Price-to-earnings ratio of the ETF."""
+
+    tracking_index: Annotated[Optional[str], pydantic.Field(alias="trackingIndex")] = (
+        None
+    )
+    r"""Index tracked by the ETF."""
+
+    website: Optional[str] = None
+    r"""URL of the ETF website."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "assetClass",
+                "aum",
+                "avgVolume",
+                "cusip",
+                "description",
+                "domicile",
+                "etfCompany",
+                "expenseRatio",
+                "inceptionDate",
+                "investmentSegment",
+                "isin",
+                "logo",
+                "name",
+                "nav",
+                "navCurrency",
+                "priceToBook",
+                "priceToEarnings",
+                "trackingIndex",
+                "website",
+            ]
+        )
+        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 EtfProfileResponseDataTypedDict(TypedDict):
+    r"""ETF profile payload."""
+
+    profile: NotRequired[ProfileTypedDict]
+    r"""Descriptive and fundamental attributes of the ETF."""
+    symbol: NotRequired[str]
+    r"""ETF ticker symbol."""
+
+
+class EtfProfileResponseData(BaseModel):
+    r"""ETF profile payload."""
+
+    profile: Optional[Profile] = None
+    r"""Descriptive and fundamental attributes of the ETF."""
+
+    symbol: Optional[str] = None
+    r"""ETF ticker symbol."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["profile", "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 EtfProfileResponseTypedDict(TypedDict):
+    r"""Profile information for an ETF from Finnhub."""
+
+    data: NotRequired[EtfProfileResponseDataTypedDict]
+    r"""ETF profile payload."""
+
+
+class EtfProfileResponse(BaseModel):
+    r"""Profile information for an ETF from Finnhub."""
+
+    data: Optional[EtfProfileResponseData] = None
+    r"""ETF profile 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:
+    Profile.model_rebuild()
+except NameError:
+    pass

finance_dev/models/etfsectorallocationresponse.py

@@ -0,0 +1,113 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: dc63bb7562f9
+
+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 SectorExposureTypedDict(TypedDict):
+    exposure: NotRequired[float]
+    r"""Exposure of the ETF to this sector as reported by the provider."""
+    industry: NotRequired[str]
+    r"""Name of the sector or industry."""
+
+
+class SectorExposure(BaseModel):
+    exposure: Optional[float] = None
+    r"""Exposure of the ETF to this sector as reported by the provider."""
+
+    industry: Optional[str] = None
+    r"""Name of the sector or industry."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["exposure", "industry"])
+        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 EtfSectorAllocationResponseDataTypedDict(TypedDict):
+    r"""ETF sector exposure payload."""
+
+    sector_exposure: NotRequired[List[SectorExposureTypedDict]]
+    r"""List of sector exposures for the ETF."""
+    symbol: NotRequired[str]
+    r"""ETF ticker symbol."""
+
+
+class EtfSectorAllocationResponseData(BaseModel):
+    r"""ETF sector exposure payload."""
+
+    sector_exposure: Annotated[
+        Optional[List[SectorExposure]], pydantic.Field(alias="sectorExposure")
+    ] = None
+    r"""List of sector exposures for the ETF."""
+
+    symbol: Optional[str] = None
+    r"""ETF ticker symbol."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["sectorExposure", "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 EtfSectorAllocationResponseTypedDict(TypedDict):
+    r"""Sector exposure breakdown of an ETF from Finnhub."""
+
+    data: NotRequired[EtfSectorAllocationResponseDataTypedDict]
+    r"""ETF sector exposure payload."""
+
+
+class EtfSectorAllocationResponse(BaseModel):
+    r"""Sector exposure breakdown of an ETF from Finnhub."""
+
+    data: Optional[EtfSectorAllocationResponseData] = None
+    r"""ETF sector exposure 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:
+    EtfSectorAllocationResponseData.model_rebuild()
+except NameError:
+    pass