finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/searchsymbolitem.py

@@ -0,0 +1,76 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 930408cb76d8
+
+from __future__ import annotations
+from enum import Enum
+from finance_dev import models, utils
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from pydantic import field_serializer, model_serializer
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class SearchSymbolItemType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Instrument class returned by symbol search."""
+
+    STOCK = "stock"
+    OPTION = "option"
+
+
+class SearchSymbolItemTypedDict(TypedDict):
+    r"""Symbol search result."""
+
+    description: NotRequired[str]
+    r"""Full description of the symbol/company"""
+    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."""
+    symbol: NotRequired[str]
+    r"""Symbol identifier"""
+    ticker: NotRequired[str]
+    r"""Symbol ticker"""
+    type: NotRequired[SearchSymbolItemType]
+    r"""Instrument class returned by symbol search."""
+
+
+class SearchSymbolItem(BaseModel):
+    r"""Symbol search result."""
+
+    description: Optional[str] = None
+    r"""Full description of the symbol/company"""
+
+    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."""
+
+    symbol: Optional[str] = None
+    r"""Symbol identifier"""
+
+    ticker: Optional[str] = None
+    r"""Symbol ticker"""
+
+    type: Optional[SearchSymbolItemType] = None
+    r"""Instrument class returned by symbol search."""
+
+    @field_serializer("type")
+    def serialize_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.SearchSymbolItemType(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["description", "exchange", "symbol", "ticker", "type"])
+        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/searchsymbolresponseitem.py

@@ -0,0 +1,71 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: ced83a40a9ad
+
+from __future__ import annotations
+from enum import Enum
+from finance_dev import models, utils
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from pydantic import field_serializer, model_serializer
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class SearchSymbolResponseItemType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Instrument class returned by symbol search."""
+
+    STOCK = "stock"
+    OPTION = "option"
+
+
+class SearchSymbolResponseItemTypedDict(TypedDict):
+    r"""One symbol search result. Use it to let users choose the exact instrument before fetching quotes, research data, or placing orders."""
+
+    description: NotRequired[str]
+    r"""Human-readable company or security name. Show this next to the symbol so users can confirm they selected the intended instrument."""
+    symbol: NotRequired[str]
+    r"""Symbol value to pass into quote, chart, research, or order endpoints. Use the exact case returned here."""
+    tag: NotRequired[str]
+    r"""Exchange or source tag, such as `XNAS` for Nasdaq or `OPRA` for options. Use it for display or filtering when multiple instruments share similar symbols."""
+    type: NotRequired[SearchSymbolResponseItemType]
+    r"""Instrument class returned by symbol search."""
+
+
+class SearchSymbolResponseItem(BaseModel):
+    r"""One symbol search result. Use it to let users choose the exact instrument before fetching quotes, research data, or placing orders."""
+
+    description: Optional[str] = None
+    r"""Human-readable company or security name. Show this next to the symbol so users can confirm they selected the intended instrument."""
+
+    symbol: Optional[str] = None
+    r"""Symbol value to pass into quote, chart, research, or order endpoints. Use the exact case returned here."""
+
+    tag: Optional[str] = None
+    r"""Exchange or source tag, such as `XNAS` for Nasdaq or `OPRA` for options. Use it for display or filtering when multiple instruments share similar symbols."""
+
+    type: Optional[SearchSymbolResponseItemType] = None
+    r"""Instrument class returned by symbol search."""
+
+    @field_serializer("type")
+    def serialize_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.SearchSymbolResponseItemType(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["description", "symbol", "tag", "type"])
+        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/searchsymbolsop.py

@@ -0,0 +1,77 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 74b284dc9311
+
+from __future__ import annotations
+from .httpmetadata import HTTPMetadata, HTTPMetadataTypedDict
+from .searchsymbolitem import SearchSymbolItem, SearchSymbolItemTypedDict
+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 List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class SearchSymbolsRequestTypedDict(TypedDict):
+    query: str
+    r"""Text to search. Use plain text for stocks and indices, `.` prefix for options such as `.AAPL`, and `/` prefix for futures such as `/ES`."""
+    limit: NotRequired[int]
+    r"""Maximum number of results to return. Use smaller values for autocomplete and larger values for search result pages. Default is 20; maximum is 100."""
+
+
+class SearchSymbolsRequest(BaseModel):
+    query: Annotated[
+        str, FieldMetadata(query=QueryParamMetadata(style="form", explode=True))
+    ]
+    r"""Text to search. Use plain text for stocks and indices, `.` prefix for options such as `.AAPL`, and `/` prefix for futures such as `/ES`."""
+
+    limit: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = 20
+    r"""Maximum number of results to return. Use smaller values for autocomplete and larger values for search result pages. Default is 20; maximum is 100."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["limit"])
+        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 SearchSymbolsResponseTypedDict(TypedDict):
+    http_meta: HTTPMetadataTypedDict
+    search_symbol_items: NotRequired[List[SearchSymbolItemTypedDict]]
+    r"""Symbol search results retrieved successfully"""
+
+
+class SearchSymbolsResponse(BaseModel):
+    http_meta: Annotated[Optional[HTTPMetadata], pydantic.Field(exclude=True)] = None
+
+    search_symbol_items: Optional[List[SearchSymbolItem]] = None
+    r"""Symbol search results retrieved successfully"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["SearchSymbolItems"])
+        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/secfiling.py

@@ -0,0 +1,91 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: a8cb747c0f75
+
+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 SecFilingTypedDict(TypedDict):
+    r"""A single SEC filing with its accession number, form type, dates and document URLs."""
+
+    accepted_date: NotRequired[str]
+    r"""Date and time when the SEC accepted the filing"""
+    access_number: NotRequired[str]
+    r"""SEC accession number uniquely identifying the filing"""
+    cik: NotRequired[str]
+    r"""Central Index Key assigned by the SEC"""
+    filed_date: NotRequired[str]
+    r"""Date when the filing was submitted to the SEC"""
+    filing_url: NotRequired[str]
+    r"""URL to the complete filing on SEC EDGAR"""
+    form: NotRequired[str]
+    r"""Type of SEC form (e.g., 10-K, 10-Q, 8-K)"""
+    report_url: NotRequired[str]
+    r"""URL to the formatted report document"""
+    symbol: NotRequired[str]
+    r"""Stock ticker symbol"""
+
+
+class SecFiling(BaseModel):
+    r"""A single SEC filing with its accession number, form type, dates and document URLs."""
+
+    accepted_date: Annotated[Optional[str], pydantic.Field(alias="acceptedDate")] = None
+    r"""Date and time when the SEC accepted the filing"""
+
+    access_number: Annotated[Optional[str], pydantic.Field(alias="accessNumber")] = None
+    r"""SEC accession number uniquely identifying the filing"""
+
+    cik: Optional[str] = None
+    r"""Central Index Key assigned by the SEC"""
+
+    filed_date: Annotated[Optional[str], pydantic.Field(alias="filedDate")] = None
+    r"""Date when the filing was submitted to the SEC"""
+
+    filing_url: Annotated[Optional[str], pydantic.Field(alias="filingUrl")] = None
+    r"""URL to the complete filing on SEC EDGAR"""
+
+    form: Optional[str] = None
+    r"""Type of SEC form (e.g., 10-K, 10-Q, 8-K)"""
+
+    report_url: Annotated[Optional[str], pydantic.Field(alias="reportUrl")] = None
+    r"""URL to the formatted report document"""
+
+    symbol: Optional[str] = None
+    r"""Stock ticker symbol"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "acceptedDate",
+                "accessNumber",
+                "cik",
+                "filedDate",
+                "filingUrl",
+                "form",
+                "reportUrl",
+                "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:
+    SecFiling.model_rebuild()
+except NameError:
+    pass

finance_dev/models/secfilingsresponse.py

@@ -0,0 +1,39 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 0c818c49181e
+
+from __future__ import annotations
+from .secfiling import SecFiling, SecFilingTypedDict
+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 SecFilingsResponseTypedDict(TypedDict):
+    r"""Response containing SEC filings for a symbol."""
+
+    filings: NotRequired[List[SecFilingTypedDict]]
+    r"""Array of SEC filings"""
+
+
+class SecFilingsResponse(BaseModel):
+    r"""Response containing SEC filings for a symbol."""
+
+    filings: Optional[List[SecFiling]] = None
+    r"""Array of SEC filings"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["filings"])
+        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/sectoravgchange.py

@@ -0,0 +1,50 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 5e4f1e9ca5a0
+
+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 SectorAvgChangeTypedDict(TypedDict):
+    r"""Average percentage move by sector. Use it to compare which sectors are leading or lagging the market."""
+
+    avg_change: NotRequired[float]
+    r"""Average percentage change for the sector"""
+    sector: NotRequired[str]
+    r"""Sector name, such as Technology or Financials. Use it as the label in sector performance views."""
+
+
+class SectorAvgChange(BaseModel):
+    r"""Average percentage move by sector. Use it to compare which sectors are leading or lagging the market."""
+
+    avg_change: Annotated[Optional[float], pydantic.Field(alias="avgChange")] = None
+    r"""Average percentage change for the sector"""
+
+    sector: Optional[str] = None
+    r"""Sector name, such as Technology or Financials. Use it as the label in sector performance views."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["avgChange", "sector"])
+        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:
+    SectorAvgChange.model_rebuild()
+except NameError:
+    pass

finance_dev/models/security.py

@@ -0,0 +1,59 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 52fa621c8b19
+
+from __future__ import annotations
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from finance_dev.utils import FieldMetadata, SecurityMetadata
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class SecurityTypedDict(TypedDict):
+    client_id: NotRequired[str]
+    client_secret: NotRequired[str]
+    token_url: NotRequired[str]
+
+
+class Security(BaseModel):
+    client_id: Annotated[
+        Optional[str],
+        FieldMetadata(
+            security=SecurityMetadata(
+                scheme=True,
+                scheme_type="oauth2",
+                sub_type="client_credentials",
+                field_name="clientID",
+            )
+        ),
+    ] = None
+
+    client_secret: Annotated[
+        Optional[str],
+        FieldMetadata(
+            security=SecurityMetadata(
+                scheme=True,
+                scheme_type="oauth2",
+                sub_type="client_credentials",
+                field_name="clientSecret",
+            )
+        ),
+    ] = None
+
+    token_url: Optional[str] = "https://api.aries.com/v1/oauth2/token"
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["ClientID", "ClientSecret", "TokenURL"])
+        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/securitytypeenum.py

@@ -0,0 +1,16 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 4be879933929
+
+from __future__ import annotations
+from enum import Enum
+from finance_dev import utils
+
+
+class SecurityTypeEnum(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""What kind of instrument the order is for. Pick one:
+    - `CS` — Common Stock (equity / ETF).
+    - `OPT` — Option contract (call or put).
+    """
+
+    CS = "CS"
+    OPT = "OPT"

finance_dev/models/shortinterestresponse.py

@@ -0,0 +1,126 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 499d5a6020e4
+
+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 ShortInterestResponseResultTypedDict(TypedDict):
+    avg_daily_volume: NotRequired[int]
+    r"""Average daily trading volume in shares used for the days-to-cover calculation"""
+    days_to_cover: NotRequired[float]
+    r"""Number of days of average volume needed to cover the short interest"""
+    settlement_date: NotRequired[str]
+    r"""Settlement date of the short interest report (YYYY-MM-DD)"""
+    short_interest: NotRequired[int]
+    r"""Total number of shares sold short and not yet covered as of the settlement date"""
+    ticker: NotRequired[str]
+    r"""Stock ticker symbol"""
+
+
+class ShortInterestResponseResult(BaseModel):
+    avg_daily_volume: Annotated[
+        Optional[int], pydantic.Field(alias="avgDailyVolume")
+    ] = None
+    r"""Average daily trading volume in shares used for the days-to-cover calculation"""
+
+    days_to_cover: Annotated[Optional[float], pydantic.Field(alias="daysToCover")] = (
+        None
+    )
+    r"""Number of days of average volume needed to cover the short interest"""
+
+    settlement_date: Annotated[
+        Optional[str], pydantic.Field(alias="settlementDate")
+    ] = None
+    r"""Settlement date of the short interest report (YYYY-MM-DD)"""
+
+    short_interest: Annotated[Optional[int], pydantic.Field(alias="shortInterest")] = (
+        None
+    )
+    r"""Total number of shares sold short and not yet covered as of the settlement date"""
+
+    ticker: Optional[str] = None
+    r"""Stock ticker symbol"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "avgDailyVolume",
+                "daysToCover",
+                "settlementDate",
+                "shortInterest",
+                "ticker",
+            ]
+        )
+        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 ShortInterestResponseTypedDict(TypedDict):
+    r"""Short interest records per ticker, including shares sold short, average daily volume and days to cover, sourced from Polygon."""
+
+    next_url: NotRequired[str]
+    r"""URL for next page of results"""
+    request_id: NotRequired[str]
+    r"""Request identifier returned by the upstream data provider"""
+    results: NotRequired[List[ShortInterestResponseResultTypedDict]]
+    r"""Short interest records, one per ticker and settlement date"""
+    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."""
+
+
+class ShortInterestResponse(BaseModel):
+    r"""Short interest records per ticker, including shares sold short, average daily volume and days to cover, sourced from Polygon."""
+
+    next_url: Annotated[Optional[str], pydantic.Field(alias="nextUrl")] = None
+    r"""URL for next page of results"""
+
+    request_id: Annotated[Optional[str], pydantic.Field(alias="requestId")] = None
+    r"""Request identifier returned by the upstream data provider"""
+
+    results: Optional[List[ShortInterestResponseResult]] = None
+    r"""Short interest records, one per ticker and settlement date"""
+
+    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."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["nextUrl", "requestId", "results", "status"])
+        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:
+    ShortInterestResponseResult.model_rebuild()
+except NameError:
+    pass
+try:
+    ShortInterestResponse.model_rebuild()
+except NameError:
+    pass