finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/shortvolumeresponse.py

@@ -0,0 +1,198 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 112bec940b11
+
+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 ShortVolumeResponseResultTypedDict(TypedDict):
+    adf_short_volume: NotRequired[int]
+    r"""Short volume reported through the FINRA Alternative Display Facility (ADF)"""
+    adf_short_volume_exempt: NotRequired[int]
+    r"""Short-sale-exempt portion of the ADF short volume"""
+    date_: NotRequired[str]
+    r"""Trading date the short volume applies to (YYYY-MM-DD)"""
+    exempt_volume: NotRequired[int]
+    r"""Short volume that was marked short-sale exempt"""
+    nasdaq_carteret_short_volume: NotRequired[int]
+    r"""Short volume reported through the Nasdaq Carteret facility"""
+    nasdaq_carteret_short_volume_exempt: NotRequired[int]
+    r"""Short-sale-exempt portion of the Nasdaq Carteret short volume"""
+    nasdaq_chicago_short_volume: NotRequired[int]
+    r"""Short volume reported through the Nasdaq Chicago facility"""
+    nasdaq_chicago_short_volume_exempt: NotRequired[int]
+    r"""Short-sale-exempt portion of the Nasdaq Chicago short volume"""
+    non_exempt_volume: NotRequired[int]
+    r"""Short volume that was not marked short-sale exempt"""
+    nyse_short_volume: NotRequired[int]
+    r"""Short volume reported through the NYSE facility"""
+    nyse_short_volume_exempt: NotRequired[int]
+    r"""Short-sale-exempt portion of the NYSE short volume"""
+    short_volume: NotRequired[int]
+    r"""Total number of shares sold short during the trading date"""
+    short_volume_ratio: NotRequired[float]
+    r"""Short volume as a proportion of total volume, as computed by the upstream provider"""
+    ticker: NotRequired[str]
+    r"""Stock ticker symbol"""
+    total_volume: NotRequired[int]
+    r"""Total shares traded during the trading date"""
+
+
+class ShortVolumeResponseResult(BaseModel):
+    adf_short_volume: Annotated[
+        Optional[int], pydantic.Field(alias="adfShortVolume")
+    ] = None
+    r"""Short volume reported through the FINRA Alternative Display Facility (ADF)"""
+
+    adf_short_volume_exempt: Annotated[
+        Optional[int], pydantic.Field(alias="adfShortVolumeExempt")
+    ] = None
+    r"""Short-sale-exempt portion of the ADF short volume"""
+
+    date_: Annotated[Optional[str], pydantic.Field(alias="date")] = None
+    r"""Trading date the short volume applies to (YYYY-MM-DD)"""
+
+    exempt_volume: Annotated[Optional[int], pydantic.Field(alias="exemptVolume")] = None
+    r"""Short volume that was marked short-sale exempt"""
+
+    nasdaq_carteret_short_volume: Annotated[
+        Optional[int], pydantic.Field(alias="nasdaqCarteretShortVolume")
+    ] = None
+    r"""Short volume reported through the Nasdaq Carteret facility"""
+
+    nasdaq_carteret_short_volume_exempt: Annotated[
+        Optional[int], pydantic.Field(alias="nasdaqCarteretShortVolumeExempt")
+    ] = None
+    r"""Short-sale-exempt portion of the Nasdaq Carteret short volume"""
+
+    nasdaq_chicago_short_volume: Annotated[
+        Optional[int], pydantic.Field(alias="nasdaqChicagoShortVolume")
+    ] = None
+    r"""Short volume reported through the Nasdaq Chicago facility"""
+
+    nasdaq_chicago_short_volume_exempt: Annotated[
+        Optional[int], pydantic.Field(alias="nasdaqChicagoShortVolumeExempt")
+    ] = None
+    r"""Short-sale-exempt portion of the Nasdaq Chicago short volume"""
+
+    non_exempt_volume: Annotated[
+        Optional[int], pydantic.Field(alias="nonExemptVolume")
+    ] = None
+    r"""Short volume that was not marked short-sale exempt"""
+
+    nyse_short_volume: Annotated[
+        Optional[int], pydantic.Field(alias="nyseShortVolume")
+    ] = None
+    r"""Short volume reported through the NYSE facility"""
+
+    nyse_short_volume_exempt: Annotated[
+        Optional[int], pydantic.Field(alias="nyseShortVolumeExempt")
+    ] = None
+    r"""Short-sale-exempt portion of the NYSE short volume"""
+
+    short_volume: Annotated[Optional[int], pydantic.Field(alias="shortVolume")] = None
+    r"""Total number of shares sold short during the trading date"""
+
+    short_volume_ratio: Annotated[
+        Optional[float], pydantic.Field(alias="shortVolumeRatio")
+    ] = None
+    r"""Short volume as a proportion of total volume, as computed by the upstream provider"""
+
+    ticker: Optional[str] = None
+    r"""Stock ticker symbol"""
+
+    total_volume: Annotated[Optional[int], pydantic.Field(alias="totalVolume")] = None
+    r"""Total shares traded during the trading date"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "adfShortVolume",
+                "adfShortVolumeExempt",
+                "date",
+                "exemptVolume",
+                "nasdaqCarteretShortVolume",
+                "nasdaqCarteretShortVolumeExempt",
+                "nasdaqChicagoShortVolume",
+                "nasdaqChicagoShortVolumeExempt",
+                "nonExemptVolume",
+                "nyseShortVolume",
+                "nyseShortVolumeExempt",
+                "shortVolume",
+                "shortVolumeRatio",
+                "ticker",
+                "totalVolume",
+            ]
+        )
+        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 ShortVolumeResponseTypedDict(TypedDict):
+    r"""Daily short sale volume per ticker, including a breakdown by reporting venue, sourced from Polygon."""
+
+    next_url: NotRequired[str]
+    r"""URL for the next page of results, omitted when there are no more pages"""
+    request_id: NotRequired[str]
+    r"""Request identifier returned by the upstream data provider"""
+    results: NotRequired[List[ShortVolumeResponseResultTypedDict]]
+    r"""Daily short sale volume records"""
+    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 ShortVolumeResponse(BaseModel):
+    r"""Daily short sale volume per ticker, including a breakdown by reporting venue, sourced from Polygon."""
+
+    next_url: Annotated[Optional[str], pydantic.Field(alias="nextUrl")] = None
+    r"""URL for the next page of results, omitted when there are no more pages"""
+
+    request_id: Annotated[Optional[str], pydantic.Field(alias="requestId")] = None
+    r"""Request identifier returned by the upstream data provider"""
+
+    results: Optional[List[ShortVolumeResponseResult]] = None
+    r"""Daily short sale volume records"""
+
+    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:
+    ShortVolumeResponseResult.model_rebuild()
+except NameError:
+    pass
+try:
+    ShortVolumeResponse.model_rebuild()
+except NameError:
+    pass

finance_dev/models/socialsentimentresponse.py

@@ -0,0 +1,124 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: cffb31885ace
+
+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 SocialSentimentResponseDataTypedDict(TypedDict):
+    at_time: NotRequired[str]
+    r"""Timestamp of the data point as provided by the data vendor."""
+    mention: NotRequired[int]
+    r"""Total number of mentions."""
+    negative_mention: NotRequired[int]
+    r"""Number of negative mentions."""
+    negative_score: NotRequired[float]
+    r"""Negative sentiment score."""
+    positive_mention: NotRequired[int]
+    r"""Number of positive mentions."""
+    positive_score: NotRequired[float]
+    r"""Positive sentiment score."""
+    score: NotRequired[float]
+    r"""Overall sentiment score."""
+
+
+class SocialSentimentResponseData(BaseModel):
+    at_time: Annotated[Optional[str], pydantic.Field(alias="atTime")] = None
+    r"""Timestamp of the data point as provided by the data vendor."""
+
+    mention: Optional[int] = None
+    r"""Total number of mentions."""
+
+    negative_mention: Annotated[
+        Optional[int], pydantic.Field(alias="negativeMention")
+    ] = None
+    r"""Number of negative mentions."""
+
+    negative_score: Annotated[
+        Optional[float], pydantic.Field(alias="negativeScore")
+    ] = None
+    r"""Negative sentiment score."""
+
+    positive_mention: Annotated[
+        Optional[int], pydantic.Field(alias="positiveMention")
+    ] = None
+    r"""Number of positive mentions."""
+
+    positive_score: Annotated[
+        Optional[float], pydantic.Field(alias="positiveScore")
+    ] = None
+    r"""Positive sentiment score."""
+
+    score: Optional[float] = None
+    r"""Overall sentiment score."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "atTime",
+                "mention",
+                "negativeMention",
+                "negativeScore",
+                "positiveMention",
+                "positiveScore",
+                "score",
+            ]
+        )
+        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 SocialSentimentResponseTypedDict(TypedDict):
+    r"""Social media sentiment time series for a symbol."""
+
+    data: NotRequired[List[SocialSentimentResponseDataTypedDict]]
+    r"""Sentiment data points."""
+    symbol: NotRequired[str]
+    r"""Ticker symbol of the company."""
+
+
+class SocialSentimentResponse(BaseModel):
+    r"""Social media sentiment time series for a symbol."""
+
+    data: Optional[List[SocialSentimentResponseData]] = None
+    r"""Sentiment data points."""
+
+    symbol: Optional[str] = None
+    r"""Ticker symbol of the company."""
+
+    @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:
+    SocialSentimentResponseData.model_rebuild()
+except NameError:
+    pass

finance_dev/models/sortorderenum.py

@@ -0,0 +1,13 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: c5ce248a2664
+
+from __future__ import annotations
+from enum import Enum
+from finance_dev import utils
+
+
+class SortOrderEnum(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Sort direction for results. Use ascending for oldest or smallest first, descending for newest or largest first."""
+
+    ASC = "asc"
+    DESC = "desc"

finance_dev/models/spinoffsresponse.py

@@ -0,0 +1,136 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: bdcdccecf852
+
+from __future__ import annotations
+from datetime import date
+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 SpinoffTypedDict(TypedDict):
+    declared_date: NotRequired[date]
+    r"""Date when the spinoff was announced (YYYY-MM-DD format)"""
+    description: NotRequired[str]
+    r"""Description of the spinoff transaction"""
+    ex_date: NotRequired[date]
+    r"""Ex-date when the stock trades without spinoff rights (YYYY-MM-DD format)"""
+    from_company_name: NotRequired[str]
+    r"""Name of the parent company"""
+    from_symbol: NotRequired[str]
+    r"""Ticker symbol of the parent company"""
+    payment_date: NotRequired[date]
+    r"""Date when spun-off shares are distributed to shareholders (YYYY-MM-DD format)"""
+    ratio: NotRequired[str]
+    r"""Distribution ratio (e.g., 1:1 means one share of new company for each share of parent)"""
+    record_date: NotRequired[date]
+    r"""Date determining which shareholders receive the spinoff (YYYY-MM-DD format)"""
+    to_company_name: NotRequired[str]
+    r"""Name of the spun-off company"""
+    to_symbol: NotRequired[str]
+    r"""Ticker symbol of the spun-off company"""
+
+
+class Spinoff(BaseModel):
+    declared_date: Annotated[Optional[date], pydantic.Field(alias="declaredDate")] = (
+        None
+    )
+    r"""Date when the spinoff was announced (YYYY-MM-DD format)"""
+
+    description: Optional[str] = None
+    r"""Description of the spinoff transaction"""
+
+    ex_date: Annotated[Optional[date], pydantic.Field(alias="exDate")] = None
+    r"""Ex-date when the stock trades without spinoff rights (YYYY-MM-DD format)"""
+
+    from_company_name: Annotated[
+        Optional[str], pydantic.Field(alias="fromCompanyName")
+    ] = None
+    r"""Name of the parent company"""
+
+    from_symbol: Annotated[Optional[str], pydantic.Field(alias="fromSymbol")] = None
+    r"""Ticker symbol of the parent company"""
+
+    payment_date: Annotated[Optional[date], pydantic.Field(alias="paymentDate")] = None
+    r"""Date when spun-off shares are distributed to shareholders (YYYY-MM-DD format)"""
+
+    ratio: Optional[str] = None
+    r"""Distribution ratio (e.g., 1:1 means one share of new company for each share of parent)"""
+
+    record_date: Annotated[Optional[date], pydantic.Field(alias="recordDate")] = None
+    r"""Date determining which shareholders receive the spinoff (YYYY-MM-DD format)"""
+
+    to_company_name: Annotated[Optional[str], pydantic.Field(alias="toCompanyName")] = (
+        None
+    )
+    r"""Name of the spun-off company"""
+
+    to_symbol: Annotated[Optional[str], pydantic.Field(alias="toSymbol")] = None
+    r"""Ticker symbol of the spun-off company"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "declaredDate",
+                "description",
+                "exDate",
+                "fromCompanyName",
+                "fromSymbol",
+                "paymentDate",
+                "ratio",
+                "recordDate",
+                "toCompanyName",
+                "toSymbol",
+            ]
+        )
+        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 SpinoffsResponseTypedDict(TypedDict):
+    r"""Response containing corporate spinoff events."""
+
+    spinoffs: NotRequired[List[SpinoffTypedDict]]
+    r"""Array of corporate spinoff events"""
+
+
+class SpinoffsResponse(BaseModel):
+    r"""Response containing corporate spinoff events."""
+
+    spinoffs: Optional[List[Spinoff]] = None
+    r"""Array of corporate spinoff events"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["spinoffs"])
+        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:
+    Spinoff.model_rebuild()
+except NameError:
+    pass

finance_dev/models/stockaggregatesresponse.py

@@ -0,0 +1,92 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 8ae670ac8237
+
+from __future__ import annotations
+from .stockohlcbar import StockOhlcBar, StockOhlcBarTypedDict
+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 StockAggregatesResponseTypedDict(TypedDict):
+    r"""Aggregate OHLC bars for a stock over a requested range and timespan, as returned by the upstream data provider."""
+
+    adjusted: NotRequired[bool]
+    r"""Whether or not the results are adjusted for splits"""
+    next_url: NotRequired[str]
+    r"""URL for next page of results"""
+    query_count: NotRequired[int]
+    r"""Number of results returned"""
+    request_id: NotRequired[str]
+    r"""Unique request ID"""
+    results: NotRequired[List[StockOhlcBarTypedDict]]
+    r"""Array of aggregate bars"""
+    results_count: NotRequired[int]
+    r"""Total number of results"""
+    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."""
+    ticker: NotRequired[str]
+    r"""Stock ticker symbol, such as AAPL. Use the exact ticker for the company you want to research."""
+
+
+class StockAggregatesResponse(BaseModel):
+    r"""Aggregate OHLC bars for a stock over a requested range and timespan, as returned by the upstream data provider."""
+
+    adjusted: Optional[bool] = None
+    r"""Whether or not the results are adjusted for splits"""
+
+    next_url: Annotated[Optional[str], pydantic.Field(alias="nextUrl")] = None
+    r"""URL for next page of results"""
+
+    query_count: Annotated[Optional[int], pydantic.Field(alias="queryCount")] = None
+    r"""Number of results returned"""
+
+    request_id: Annotated[Optional[str], pydantic.Field(alias="requestId")] = None
+    r"""Unique request ID"""
+
+    results: Optional[List[StockOhlcBar]] = None
+    r"""Array of aggregate bars"""
+
+    results_count: Annotated[Optional[int], pydantic.Field(alias="resultsCount")] = None
+    r"""Total number of results"""
+
+    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."""
+
+    ticker: Optional[str] = None
+    r"""Stock ticker symbol, such as AAPL. Use the exact ticker for the company you want to research."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "adjusted",
+                "nextUrl",
+                "queryCount",
+                "requestId",
+                "results",
+                "resultsCount",
+                "status",
+                "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
+
+
+try:
+    StockAggregatesResponse.model_rebuild()
+except NameError:
+    pass