finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/indexchartbarsresponse.py

@@ -0,0 +1,213 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 873220b4dc51
+
+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 ChartBarTypedDict(TypedDict):
+    adjustment_ratio: NotRequired[int]
+    r"""Price adjustment ratio for corporate actions"""
+    close: NotRequired[float]
+    r"""Closing index value for the bar period"""
+    currency: NotRequired[str]
+    r"""Currency of the bar data"""
+    end_date: NotRequired[str]
+    r"""Bar end date in MM/DD/YYYY format"""
+    end_time: NotRequired[str]
+    r"""Bar end time in HH:MM:SS AM/PM format"""
+    high: NotRequired[float]
+    r"""Highest index value during the bar period"""
+    low: NotRequired[float]
+    r"""Lowest index value during the bar period"""
+    open: NotRequired[float]
+    r"""Opening index value for the bar period"""
+    session: NotRequired[str]
+    r"""Trading session type (Market, PreMarket, PostMarket)"""
+    start_date: NotRequired[str]
+    r"""Bar start date in MM/DD/YYYY format"""
+    start_time: NotRequired[str]
+    r"""Bar start time in HH:MM:SS AM/PM format"""
+    trades: NotRequired[int]
+    r"""Number of trades during the bar period"""
+    twap: NotRequired[float]
+    r"""Time-Weighted Average Price for the bar period"""
+    utc_offset: NotRequired[int]
+    r"""UTC time offset in hours"""
+    volume: NotRequired[int]
+    r"""Trading volume during the bar period"""
+    vwap: NotRequired[float]
+    r"""Volume-Weighted Average Price for the bar period"""
+
+
+class ChartBar(BaseModel):
+    adjustment_ratio: Annotated[
+        Optional[int], pydantic.Field(alias="adjustmentRatio")
+    ] = None
+    r"""Price adjustment ratio for corporate actions"""
+
+    close: Optional[float] = None
+    r"""Closing index value for the bar period"""
+
+    currency: Optional[str] = None
+    r"""Currency of the bar data"""
+
+    end_date: Annotated[Optional[str], pydantic.Field(alias="endDate")] = None
+    r"""Bar end date in MM/DD/YYYY format"""
+
+    end_time: Annotated[Optional[str], pydantic.Field(alias="endTime")] = None
+    r"""Bar end time in HH:MM:SS AM/PM format"""
+
+    high: Optional[float] = None
+    r"""Highest index value during the bar period"""
+
+    low: Optional[float] = None
+    r"""Lowest index value during the bar period"""
+
+    open: Optional[float] = None
+    r"""Opening index value for the bar period"""
+
+    session: Optional[str] = None
+    r"""Trading session type (Market, PreMarket, PostMarket)"""
+
+    start_date: Annotated[Optional[str], pydantic.Field(alias="startDate")] = None
+    r"""Bar start date in MM/DD/YYYY format"""
+
+    start_time: Annotated[Optional[str], pydantic.Field(alias="startTime")] = None
+    r"""Bar start time in HH:MM:SS AM/PM format"""
+
+    trades: Optional[int] = None
+    r"""Number of trades during the bar period"""
+
+    twap: Optional[float] = None
+    r"""Time-Weighted Average Price for the bar period"""
+
+    utc_offset: Annotated[Optional[int], pydantic.Field(alias="utcOffset")] = None
+    r"""UTC time offset in hours"""
+
+    volume: Optional[int] = None
+    r"""Trading volume during the bar period"""
+
+    vwap: Optional[float] = None
+    r"""Volume-Weighted Average Price for the bar period"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "adjustmentRatio",
+                "close",
+                "currency",
+                "endDate",
+                "endTime",
+                "high",
+                "low",
+                "open",
+                "session",
+                "startDate",
+                "startTime",
+                "trades",
+                "twap",
+                "utcOffset",
+                "volume",
+                "vwap",
+            ]
+        )
+        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 IndexChartBarsResponseTypedDict(TypedDict):
+    r"""Response containing chart bars for an index along with the index metadata."""
+
+    chart_bars: NotRequired[List[ChartBarTypedDict]]
+    r"""Array of historical chart bars"""
+    currency: NotRequired[str]
+    r"""Currency in which the index is quoted"""
+    index_group: NotRequired[str]
+    r"""Index group classification"""
+    index_name: NotRequired[str]
+    r"""Full name of the index"""
+    symbol: NotRequired[str]
+    r"""Index ticker symbol"""
+    timing: NotRequired[str]
+    r"""Data timing type (RealTime or Delayed)"""
+    valoren: NotRequired[str]
+    r"""Swiss securities identification number (Valoren)"""
+
+
+class IndexChartBarsResponse(BaseModel):
+    r"""Response containing chart bars for an index along with the index metadata."""
+
+    chart_bars: Annotated[
+        Optional[List[ChartBar]], pydantic.Field(alias="chartBars")
+    ] = None
+    r"""Array of historical chart bars"""
+
+    currency: Optional[str] = None
+    r"""Currency in which the index is quoted"""
+
+    index_group: Annotated[Optional[str], pydantic.Field(alias="indexGroup")] = None
+    r"""Index group classification"""
+
+    index_name: Annotated[Optional[str], pydantic.Field(alias="indexName")] = None
+    r"""Full name of the index"""
+
+    symbol: Optional[str] = None
+    r"""Index ticker symbol"""
+
+    timing: Optional[str] = None
+    r"""Data timing type (RealTime or Delayed)"""
+
+    valoren: Optional[str] = None
+    r"""Swiss securities identification number (Valoren)"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "chartBars",
+                "currency",
+                "indexGroup",
+                "indexName",
+                "symbol",
+                "timing",
+                "valoren",
+            ]
+        )
+        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:
+    ChartBar.model_rebuild()
+except NameError:
+    pass
+try:
+    IndexChartBarsResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/indexgroupsresponse.py

@@ -0,0 +1,78 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 46a89814376d
+
+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 IndexGroupTypedDict(TypedDict):
+    description: NotRequired[str]
+    r"""Human-readable description of the index group"""
+    name: NotRequired[str]
+    r"""Unique identifier for the index group"""
+
+
+class IndexGroup(BaseModel):
+    description: Optional[str] = None
+    r"""Human-readable description of the index group"""
+
+    name: Optional[str] = None
+    r"""Unique identifier for the index group"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["description", "name"])
+        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 IndexGroupsResponseTypedDict(TypedDict):
+    r"""Response containing the available index groups."""
+
+    index_groups: NotRequired[List[IndexGroupTypedDict]]
+    r"""Array of available index groups"""
+
+
+class IndexGroupsResponse(BaseModel):
+    r"""Response containing the available index groups."""
+
+    index_groups: Annotated[
+        Optional[List[IndexGroup]], pydantic.Field(alias="indexGroups")
+    ] = None
+    r"""Array of available index groups"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["indexGroups"])
+        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:
+    IndexGroupsResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/indexlistresponse.py

@@ -0,0 +1,95 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 4257ff262e13
+
+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 IndexListResponseIndexTypedDict(TypedDict):
+    currency: NotRequired[str]
+    r"""Currency of the index"""
+    index_group: NotRequired[str]
+    r"""Index group identifier"""
+    index_name: NotRequired[str]
+    r"""Index name"""
+    symbol: NotRequired[str]
+    r"""Index symbol identifier"""
+
+
+class IndexListResponseIndex(BaseModel):
+    currency: Optional[str] = None
+    r"""Currency of the index"""
+
+    index_group: Annotated[Optional[str], pydantic.Field(alias="indexGroup")] = None
+    r"""Index group identifier"""
+
+    index_name: Annotated[Optional[str], pydantic.Field(alias="indexName")] = None
+    r"""Index name"""
+
+    symbol: Optional[str] = None
+    r"""Index symbol identifier"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["currency", "indexGroup", "indexName", "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 IndexListResponseTypedDict(TypedDict):
+    r"""Response containing the indices in an index group."""
+
+    indices: NotRequired[List[IndexListResponseIndexTypedDict]]
+    r"""Array of indices in the specified index group"""
+    next_page: NotRequired[str]
+    r"""Token for the next page. Send it as `nextPage` on the next request. Omitted on the last page."""
+
+
+class IndexListResponse(BaseModel):
+    r"""Response containing the indices in an index group."""
+
+    indices: Optional[List[IndexListResponseIndex]] = None
+    r"""Array of indices in the specified index group"""
+
+    next_page: Annotated[Optional[str], pydantic.Field(alias="nextPage")] = None
+    r"""Token for the next page. Send it as `nextPage` on the next request. Omitted on the last page."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["indices", "nextPage"])
+        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:
+    IndexListResponseIndex.model_rebuild()
+except NameError:
+    pass
+try:
+    IndexListResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/indexsearchresponse.py

@@ -0,0 +1,93 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: da69c3c49c6a
+
+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 IndexSearchResponseIndexTypedDict(TypedDict):
+    currency: NotRequired[str]
+    r"""Currency in which the index is quoted"""
+    index_group: NotRequired[str]
+    r"""Index group classification identifier"""
+    index_name: NotRequired[str]
+    r"""Full name of the index"""
+    symbol: NotRequired[str]
+    r"""Index ticker symbol"""
+    valoren: NotRequired[str]
+    r"""Swiss securities identification number (Valoren)"""
+
+
+class IndexSearchResponseIndex(BaseModel):
+    currency: Optional[str] = None
+    r"""Currency in which the index is quoted"""
+
+    index_group: Annotated[Optional[str], pydantic.Field(alias="indexGroup")] = None
+    r"""Index group classification identifier"""
+
+    index_name: Annotated[Optional[str], pydantic.Field(alias="indexName")] = None
+    r"""Full name of the index"""
+
+    symbol: Optional[str] = None
+    r"""Index ticker symbol"""
+
+    valoren: Optional[str] = None
+    r"""Swiss securities identification number (Valoren)"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["currency", "indexGroup", "indexName", "symbol", "valoren"]
+        )
+        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 IndexSearchResponseTypedDict(TypedDict):
+    r"""Response containing indices that match a search query."""
+
+    indices: NotRequired[List[IndexSearchResponseIndexTypedDict]]
+    r"""Array of matching indices"""
+
+
+class IndexSearchResponse(BaseModel):
+    r"""Response containing indices that match a search query."""
+
+    indices: Optional[List[IndexSearchResponseIndex]] = None
+    r"""Array of matching indices"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["indices"])
+        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:
+    IndexSearchResponseIndex.model_rebuild()
+except NameError:
+    pass

finance_dev/models/indicesbygroupresponse.py

@@ -0,0 +1,93 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 66113231b617
+
+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 IndicesByGroupResponseIndexTypedDict(TypedDict):
+    currency: NotRequired[str]
+    r"""Currency code"""
+    index_group: NotRequired[str]
+    r"""Index group identifier"""
+    index_name: NotRequired[str]
+    r"""Full name of the index"""
+    symbol: NotRequired[str]
+    r"""Index symbol"""
+    valoren: NotRequired[str]
+    r"""Swiss securities identification number (Valoren)"""
+
+
+class IndicesByGroupResponseIndex(BaseModel):
+    currency: Optional[str] = None
+    r"""Currency code"""
+
+    index_group: Annotated[Optional[str], pydantic.Field(alias="indexGroup")] = None
+    r"""Index group identifier"""
+
+    index_name: Annotated[Optional[str], pydantic.Field(alias="indexName")] = None
+    r"""Full name of the index"""
+
+    symbol: Optional[str] = None
+    r"""Index symbol"""
+
+    valoren: Optional[str] = None
+    r"""Swiss securities identification number (Valoren)"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["currency", "indexGroup", "indexName", "symbol", "valoren"]
+        )
+        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 IndicesByGroupResponseTypedDict(TypedDict):
+    r"""Response containing the indices that belong to an index group."""
+
+    indices: NotRequired[List[IndicesByGroupResponseIndexTypedDict]]
+    r"""Array of indices in the index group"""
+
+
+class IndicesByGroupResponse(BaseModel):
+    r"""Response containing the indices that belong to an index group."""
+
+    indices: Optional[List[IndicesByGroupResponseIndex]] = None
+    r"""Array of indices in the index group"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["indices"])
+        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:
+    IndicesByGroupResponseIndex.model_rebuild()
+except NameError:
+    pass

finance_dev/models/indicesidentifiertype.py

@@ -0,0 +1,28 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: fef5d94461b0
+
+from __future__ import annotations
+from enum import Enum
+from finance_dev import utils
+
+
+class IndicesIdentifierType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Which kind of identifier you are sending in `identifier` / `identifiers`. Provide the matching value:
+    - `Symbol` — index ticker (e.g. `SPX.IND_CBOM`). Default.
+    - `CIK` — SEC Central Index Key.
+    - `CUSIP` — 9-character U.S./Canadian security identifier.
+    - `ISIN` — 12-character international identifier.
+    - `Valoren` — Swiss security identifier.
+    - `SEDOL` — 7-character UK identifier.
+    - `FIGI` — Bloomberg Financial Instrument Global Identifier.
+    - `CompositeFIGI` — country-level composite FIGI.
+    """
+
+    SYMBOL = "Symbol"
+    CIK = "CIK"
+    CUSIP = "CUSIP"
+    ISIN = "ISIN"
+    VALOREN = "Valoren"
+    SEDOL = "SEDOL"
+    FIGI = "FIGI"
+    COMPOSITE_FIGI = "CompositeFIGI"

finance_dev/models/indicesrealtimeindexinfo.py

@@ -0,0 +1,67 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: c4173e34f6de
+
+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 IndicesRealtimeIndexInfoTypedDict(TypedDict):
+    r"""Index metadata for a realtime quote item."""
+
+    currency: NotRequired[str]
+    r"""Quote currency"""
+    index_group: NotRequired[str]
+    r"""Index group or venue code (e.g. IND_CBOM)"""
+    index_name: NotRequired[str]
+    r"""Display name of the index"""
+    symbol: NotRequired[str]
+    r"""Index symbol (e.g. SPX)"""
+    valoren: NotRequired[str]
+    r"""Valoren / internal identifier"""
+
+
+class IndicesRealtimeIndexInfo(BaseModel):
+    r"""Index metadata for a realtime quote item."""
+
+    currency: Optional[str] = None
+    r"""Quote currency"""
+
+    index_group: Annotated[Optional[str], pydantic.Field(alias="indexGroup")] = None
+    r"""Index group or venue code (e.g. IND_CBOM)"""
+
+    index_name: Annotated[Optional[str], pydantic.Field(alias="indexName")] = None
+    r"""Display name of the index"""
+
+    symbol: Optional[str] = None
+    r"""Index symbol (e.g. SPX)"""
+
+    valoren: Optional[str] = None
+    r"""Valoren / internal identifier"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["currency", "indexGroup", "indexName", "symbol", "valoren"]
+        )
+        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:
+    IndicesRealtimeIndexInfo.model_rebuild()
+except NameError:
+    pass