finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/lobbyingresponse.py

@@ -0,0 +1,166 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 56b2c0f57a20
+
+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 LobbyingResponseDataTypedDict(TypedDict):
+    client_id: NotRequired[str]
+    r"""Client identifier."""
+    country: NotRequired[str]
+    r"""Country."""
+    date_: NotRequired[str]
+    r"""Date of the filing, as returned by the provider."""
+    description: NotRequired[str]
+    r"""Description of the lobbying activity."""
+    document_url: NotRequired[str]
+    r"""URL of the source filing document."""
+    expenses: NotRequired[float]
+    r"""Expenses reported by the company."""
+    houseregistrant_id: NotRequired[str]
+    r"""House registrant identifier."""
+    income: NotRequired[float]
+    r"""Income reported by lobbying firms."""
+    name: NotRequired[str]
+    r"""Company name."""
+    period: NotRequired[str]
+    r"""Filing period."""
+    posted_name: NotRequired[str]
+    r"""Posted name on the filing."""
+    registrant_id: NotRequired[str]
+    r"""Registrant identifier."""
+    senate_id: NotRequired[str]
+    r"""Senate identifier."""
+    symbol: NotRequired[str]
+    r"""Company ticker symbol."""
+    year: NotRequired[int]
+    r"""Year of the filing."""
+
+
+class LobbyingResponseData(BaseModel):
+    client_id: Annotated[Optional[str], pydantic.Field(alias="clientId")] = None
+    r"""Client identifier."""
+
+    country: Optional[str] = None
+    r"""Country."""
+
+    date_: Annotated[Optional[str], pydantic.Field(alias="date")] = None
+    r"""Date of the filing, as returned by the provider."""
+
+    description: Optional[str] = None
+    r"""Description of the lobbying activity."""
+
+    document_url: Annotated[Optional[str], pydantic.Field(alias="documentUrl")] = None
+    r"""URL of the source filing document."""
+
+    expenses: Optional[float] = None
+    r"""Expenses reported by the company."""
+
+    houseregistrant_id: Annotated[
+        Optional[str], pydantic.Field(alias="houseregistrantId")
+    ] = None
+    r"""House registrant identifier."""
+
+    income: Optional[float] = None
+    r"""Income reported by lobbying firms."""
+
+    name: Optional[str] = None
+    r"""Company name."""
+
+    period: Optional[str] = None
+    r"""Filing period."""
+
+    posted_name: Annotated[Optional[str], pydantic.Field(alias="postedName")] = None
+    r"""Posted name on the filing."""
+
+    registrant_id: Annotated[Optional[str], pydantic.Field(alias="registrantId")] = None
+    r"""Registrant identifier."""
+
+    senate_id: Annotated[Optional[str], pydantic.Field(alias="senateId")] = None
+    r"""Senate identifier."""
+
+    symbol: Optional[str] = None
+    r"""Company ticker symbol."""
+
+    year: Optional[int] = None
+    r"""Year of the filing."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "clientId",
+                "country",
+                "date",
+                "description",
+                "documentUrl",
+                "expenses",
+                "houseregistrantId",
+                "income",
+                "name",
+                "period",
+                "postedName",
+                "registrantId",
+                "senateId",
+                "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 LobbyingResponseTypedDict(TypedDict):
+    r"""US Senate and House lobbying activity reported for a company, as provided by Finnhub."""
+
+    data: NotRequired[List[LobbyingResponseDataTypedDict]]
+    r"""Lobbying records for the symbol."""
+    symbol: NotRequired[str]
+    r"""Company ticker symbol."""
+
+
+class LobbyingResponse(BaseModel):
+    r"""US Senate and House lobbying activity reported for a company, as provided by Finnhub."""
+
+    data: Optional[List[LobbyingResponseData]] = None
+    r"""Lobbying records for the symbol."""
+
+    symbol: Optional[str] = None
+    r"""Company ticker symbol."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["data", "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:
+    LobbyingResponseData.model_rebuild()
+except NameError:
+    pass

finance_dev/models/logosearchresponse.py

@@ -0,0 +1,152 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 2ffdfe50f2e6
+
+from __future__ import annotations
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import Any, Dict, List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class LogoSearchResponseFilesTypedDict(TypedDict):
+    r"""Available logo file variants"""
+
+    logo_dark: NotRequired[str]
+    r"""URL to full logo optimized for dark backgrounds (PNG)"""
+    logo_light: NotRequired[str]
+    r"""URL to full logo optimized for light backgrounds (PNG)"""
+    mark_dark: NotRequired[str]
+    r"""URL to logo mark/icon optimized for dark backgrounds (PNG)"""
+    mark_light: NotRequired[str]
+    r"""URL to logo mark/icon optimized for light backgrounds (PNG)"""
+
+
+class LogoSearchResponseFiles(BaseModel):
+    r"""Available logo file variants"""
+
+    logo_dark: Annotated[Optional[str], pydantic.Field(alias="logoDark")] = None
+    r"""URL to full logo optimized for dark backgrounds (PNG)"""
+
+    logo_light: Annotated[Optional[str], pydantic.Field(alias="logoLight")] = None
+    r"""URL to full logo optimized for light backgrounds (PNG)"""
+
+    mark_dark: Annotated[Optional[str], pydantic.Field(alias="markDark")] = None
+    r"""URL to logo mark/icon optimized for dark backgrounds (PNG)"""
+
+    mark_light: Annotated[Optional[str], pydantic.Field(alias="markLight")] = None
+    r"""URL to logo mark/icon optimized for light backgrounds (PNG)"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["logoDark", "logoLight", "markDark", "markLight"])
+        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 LogoSearchResponseDataTypedDict(TypedDict):
+    colors: NotRequired[Dict[str, Any]]
+    r"""Brand color palette (if available)"""
+    created_at: NotRequired[str]
+    r"""Timestamp when the logo was first added (ISO 8601 format)"""
+    files: NotRequired[LogoSearchResponseFilesTypedDict]
+    r"""Available logo file variants"""
+    id: NotRequired[str]
+    r"""Unique identifier for the logo record"""
+    search_key: NotRequired[str]
+    r"""Search key used to identify the company (e.g., NASDAQ:TSLA)"""
+    updated_at: NotRequired[str]
+    r"""Timestamp when the logo was last updated (ISO 8601 format)"""
+
+
+class LogoSearchResponseData(BaseModel):
+    colors: Optional[Dict[str, Any]] = None
+    r"""Brand color palette (if available)"""
+
+    created_at: Annotated[Optional[str], pydantic.Field(alias="createdAt")] = None
+    r"""Timestamp when the logo was first added (ISO 8601 format)"""
+
+    files: Optional[LogoSearchResponseFiles] = None
+    r"""Available logo file variants"""
+
+    id: Optional[str] = None
+    r"""Unique identifier for the logo record"""
+
+    search_key: Annotated[Optional[str], pydantic.Field(alias="searchKey")] = None
+    r"""Search key used to identify the company (e.g., NASDAQ:TSLA)"""
+
+    updated_at: Annotated[Optional[str], pydantic.Field(alias="updatedAt")] = None
+    r"""Timestamp when the logo was last updated (ISO 8601 format)"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["colors", "createdAt", "files", "id", "searchKey", "updatedAt"]
+        )
+        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 LogoSearchResponseTypedDict(TypedDict):
+    r"""Response containing logo records that match a search query."""
+
+    data: NotRequired[List[LogoSearchResponseDataTypedDict]]
+    r"""Array of logo data matching the search query"""
+    ok: NotRequired[bool]
+    r"""Request success status"""
+
+
+class LogoSearchResponse(BaseModel):
+    r"""Response containing logo records that match a search query."""
+
+    data: Optional[List[LogoSearchResponseData]] = None
+    r"""Array of logo data matching the search query"""
+
+    ok: Optional[bool] = None
+    r"""Request success status"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["data", "ok"])
+        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:
+    LogoSearchResponseFiles.model_rebuild()
+except NameError:
+    pass
+try:
+    LogoSearchResponseData.model_rebuild()
+except NameError:
+    pass

finance_dev/models/logosyncresponse.py

@@ -0,0 +1,277 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: e81d48f73654
+
+from __future__ import annotations
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import Any, Dict, List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class LogoSyncResponseFilesTypedDict(TypedDict):
+    r"""Available logo file variants"""
+
+    logo_dark: NotRequired[str]
+    r"""URL to the full logo for dark backgrounds"""
+    logo_light: NotRequired[str]
+    r"""URL to the full logo for light backgrounds"""
+    logo_vector_dark: NotRequired[str]
+    r"""URL to the vector full logo for dark backgrounds"""
+    logo_vector_light: NotRequired[str]
+    r"""URL to the vector full logo for light backgrounds"""
+    mark_composite_dark: NotRequired[str]
+    r"""URL to the composite logo mark for dark backgrounds"""
+    mark_composite_light: NotRequired[str]
+    r"""URL to the composite logo mark for light backgrounds"""
+    mark_dark: NotRequired[str]
+    r"""URL to the logo mark for dark backgrounds"""
+    mark_light: NotRequired[str]
+    r"""URL to the logo mark for light backgrounds"""
+    mark_vector_dark: NotRequired[str]
+    r"""URL to the vector logo mark for dark backgrounds"""
+    mark_vector_light: NotRequired[str]
+    r"""URL to the vector logo mark for light backgrounds"""
+
+
+class LogoSyncResponseFiles(BaseModel):
+    r"""Available logo file variants"""
+
+    logo_dark: Annotated[Optional[str], pydantic.Field(alias="logoDark")] = None
+    r"""URL to the full logo for dark backgrounds"""
+
+    logo_light: Annotated[Optional[str], pydantic.Field(alias="logoLight")] = None
+    r"""URL to the full logo for light backgrounds"""
+
+    logo_vector_dark: Annotated[
+        Optional[str], pydantic.Field(alias="logoVectorDark")
+    ] = None
+    r"""URL to the vector full logo for dark backgrounds"""
+
+    logo_vector_light: Annotated[
+        Optional[str], pydantic.Field(alias="logoVectorLight")
+    ] = None
+    r"""URL to the vector full logo for light backgrounds"""
+
+    mark_composite_dark: Annotated[
+        Optional[str], pydantic.Field(alias="markCompositeDark")
+    ] = None
+    r"""URL to the composite logo mark for dark backgrounds"""
+
+    mark_composite_light: Annotated[
+        Optional[str], pydantic.Field(alias="markCompositeLight")
+    ] = None
+    r"""URL to the composite logo mark for light backgrounds"""
+
+    mark_dark: Annotated[Optional[str], pydantic.Field(alias="markDark")] = None
+    r"""URL to the logo mark for dark backgrounds"""
+
+    mark_light: Annotated[Optional[str], pydantic.Field(alias="markLight")] = None
+    r"""URL to the logo mark for light backgrounds"""
+
+    mark_vector_dark: Annotated[
+        Optional[str], pydantic.Field(alias="markVectorDark")
+    ] = None
+    r"""URL to the vector logo mark for dark backgrounds"""
+
+    mark_vector_light: Annotated[
+        Optional[str], pydantic.Field(alias="markVectorLight")
+    ] = None
+    r"""URL to the vector logo mark for light backgrounds"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "logoDark",
+                "logoLight",
+                "logoVectorDark",
+                "logoVectorLight",
+                "markCompositeDark",
+                "markCompositeLight",
+                "markDark",
+                "markLight",
+                "markVectorDark",
+                "markVectorLight",
+            ]
+        )
+        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 LogoSyncResponseSecurityTypedDict(TypedDict):
+    cik: NotRequired[str]
+    r"""Central Index Key assigned by the SEC"""
+    cusip: NotRequired[str]
+    r"""CUSIP identifier of the security"""
+    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"""ISIN identifier of the security"""
+    name: NotRequired[str]
+    r"""Name of the security"""
+    symbol: NotRequired[str]
+    r"""Ticker symbol of the security"""
+
+
+class LogoSyncResponseSecurity(BaseModel):
+    cik: Optional[str] = None
+    r"""Central Index Key assigned by the SEC"""
+
+    cusip: Optional[str] = None
+    r"""CUSIP identifier of the security"""
+
+    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"""ISIN identifier of the security"""
+
+    name: Optional[str] = None
+    r"""Name of the security"""
+
+    symbol: Optional[str] = None
+    r"""Ticker symbol of the security"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["cik", "cusip", "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 LogoSyncResponseDataTypedDict(TypedDict):
+    colors: NotRequired[Dict[str, Any]]
+    r"""Key-value map; may be empty. Keys vary by record."""
+    created_at: NotRequired[str]
+    r"""Timestamp when the logo record was created"""
+    files: NotRequired[LogoSyncResponseFilesTypedDict]
+    r"""Available logo file variants"""
+    id: NotRequired[str]
+    r"""Unique identifier for the logo record"""
+    securities: NotRequired[List[LogoSyncResponseSecurityTypedDict]]
+    r"""Securities associated with the logo record"""
+    updated_at: NotRequired[str]
+    r"""Timestamp when the logo record was last updated"""
+
+
+class LogoSyncResponseData(BaseModel):
+    colors: Optional[Dict[str, Any]] = None
+    r"""Key-value map; may be empty. Keys vary by record."""
+
+    created_at: Annotated[Optional[str], pydantic.Field(alias="createdAt")] = None
+    r"""Timestamp when the logo record was created"""
+
+    files: Optional[LogoSyncResponseFiles] = None
+    r"""Available logo file variants"""
+
+    id: Optional[str] = None
+    r"""Unique identifier for the logo record"""
+
+    securities: Optional[List[LogoSyncResponseSecurity]] = None
+    r"""Securities associated with the logo record"""
+
+    updated_at: Annotated[Optional[str], pydantic.Field(alias="updatedAt")] = None
+    r"""Timestamp when the logo record was last updated"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["colors", "createdAt", "files", "id", "securities", "updatedAt"]
+        )
+        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 LogoSyncResponseTypedDict(TypedDict):
+    r"""Paginated response containing logo records for bulk sync."""
+
+    data: NotRequired[List[LogoSyncResponseDataTypedDict]]
+    r"""Array of logo records"""
+    has_more: NotRequired[bool]
+    r"""Whether more pages are available"""
+    ok: NotRequired[bool]
+    r"""Request success status"""
+    page: NotRequired[int]
+    r"""Current page number"""
+    page_size: NotRequired[int]
+    r"""Number of records per page"""
+
+
+class LogoSyncResponse(BaseModel):
+    r"""Paginated response containing logo records for bulk sync."""
+
+    data: Optional[List[LogoSyncResponseData]] = None
+    r"""Array of logo records"""
+
+    has_more: Annotated[Optional[bool], pydantic.Field(alias="hasMore")] = None
+    r"""Whether more pages are available"""
+
+    ok: Optional[bool] = None
+    r"""Request success status"""
+
+    page: Optional[int] = None
+    r"""Current page number"""
+
+    page_size: Annotated[Optional[int], pydantic.Field(alias="pageSize")] = None
+    r"""Number of records per page"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["data", "hasMore", "ok", "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
+
+
+try:
+    LogoSyncResponseFiles.model_rebuild()
+except NameError:
+    pass
+try:
+    LogoSyncResponseData.model_rebuild()
+except NameError:
+    pass
+try:
+    LogoSyncResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/marketbreadth.py

@@ -0,0 +1,97 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: f33ef86271fe
+
+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 MarketBreadthTypedDict(TypedDict):
+    r"""Market breadth snapshot showing how many symbols are rising, falling, or unchanged. Use it to summarize overall market participation."""
+
+    advance_decline_ratio: NotRequired[float]
+    r"""Ratio of advancers to decliners"""
+    advancers: NotRequired[int]
+    r"""Number of advancing stocks"""
+    advancers_percent: NotRequired[float]
+    r"""Percentage of tracked symbols that are advancing. Use this to show how broad the market move is."""
+    decliners: NotRequired[int]
+    r"""Number of declining stocks"""
+    decliners_percent: NotRequired[float]
+    r"""Percentage of tracked symbols that are declining. Use this with advancers percent for market breadth displays."""
+    timestamp: NotRequired[str]
+    r"""Data timestamp in ISO 8601 format; fractional seconds may be present (for example microseconds)."""
+    total_symbols: NotRequired[int]
+    r"""Total number of symbols included in the breadth calculation."""
+    unchanged: NotRequired[int]
+    r"""Number of unchanged stocks"""
+
+
+class MarketBreadth(BaseModel):
+    r"""Market breadth snapshot showing how many symbols are rising, falling, or unchanged. Use it to summarize overall market participation."""
+
+    advance_decline_ratio: Annotated[
+        Optional[float], pydantic.Field(alias="advanceDeclineRatio")
+    ] = None
+    r"""Ratio of advancers to decliners"""
+
+    advancers: Optional[int] = None
+    r"""Number of advancing stocks"""
+
+    advancers_percent: Annotated[
+        Optional[float], pydantic.Field(alias="advancersPercent")
+    ] = None
+    r"""Percentage of tracked symbols that are advancing. Use this to show how broad the market move is."""
+
+    decliners: Optional[int] = None
+    r"""Number of declining stocks"""
+
+    decliners_percent: Annotated[
+        Optional[float], pydantic.Field(alias="declinersPercent")
+    ] = None
+    r"""Percentage of tracked symbols that are declining. Use this with advancers percent for market breadth displays."""
+
+    timestamp: Optional[str] = None
+    r"""Data timestamp in ISO 8601 format; fractional seconds may be present (for example microseconds)."""
+
+    total_symbols: Annotated[Optional[int], pydantic.Field(alias="totalSymbols")] = None
+    r"""Total number of symbols included in the breadth calculation."""
+
+    unchanged: Optional[int] = None
+    r"""Number of unchanged stocks"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "advanceDeclineRatio",
+                "advancers",
+                "advancersPercent",
+                "decliners",
+                "declinersPercent",
+                "timestamp",
+                "totalSymbols",
+                "unchanged",
+            ]
+        )
+        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:
+    MarketBreadth.model_rebuild()
+except NameError:
+    pass