finance_dev 0.9.0__py3-none-any.whl

finance_dev/models/aggregatetechnicalindicatorsresponse.py

@@ -0,0 +1,192 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 7d00058f41aa
+
+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 CountTypedDict(TypedDict):
+    r"""Number of indicators giving each signal."""
+
+    buy: NotRequired[int]
+    r"""Number of indicators giving a buy signal."""
+    neutral: NotRequired[int]
+    r"""Number of indicators giving a neutral signal."""
+    sell: NotRequired[int]
+    r"""Number of indicators giving a sell signal."""
+
+
+class Count(BaseModel):
+    r"""Number of indicators giving each signal."""
+
+    buy: Optional[int] = None
+    r"""Number of indicators giving a buy signal."""
+
+    neutral: Optional[int] = None
+    r"""Number of indicators giving a neutral signal."""
+
+    sell: Optional[int] = None
+    r"""Number of indicators giving a sell signal."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["buy", "neutral", "sell"])
+        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 TechnicalAnalysisTypedDict(TypedDict):
+    r"""Aggregate technical analysis summary."""
+
+    count: NotRequired[CountTypedDict]
+    r"""Number of indicators giving each signal."""
+    signal: NotRequired[str]
+    r"""Overall aggregate signal."""
+
+
+class TechnicalAnalysis(BaseModel):
+    r"""Aggregate technical analysis summary."""
+
+    count: Optional[Count] = None
+    r"""Number of indicators giving each signal."""
+
+    signal: Optional[str] = None
+    r"""Overall aggregate signal."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["count", "signal"])
+        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 TrendTypedDict(TypedDict):
+    r"""Trend strength information."""
+
+    adx: NotRequired[float]
+    r"""Average Directional Index (ADX) value."""
+    trending: NotRequired[bool]
+    r"""Whether the symbol is trending."""
+
+
+class Trend(BaseModel):
+    r"""Trend strength information."""
+
+    adx: Optional[float] = None
+    r"""Average Directional Index (ADX) value."""
+
+    trending: Optional[bool] = None
+    r"""Whether the symbol is trending."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["adx", "trending"])
+        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 AggregateTechnicalIndicatorsResponseDataTypedDict(TypedDict):
+    r"""Aggregate indicators payload."""
+
+    technical_analysis: NotRequired[TechnicalAnalysisTypedDict]
+    r"""Aggregate technical analysis summary."""
+    trend: NotRequired[TrendTypedDict]
+    r"""Trend strength information."""
+
+
+class AggregateTechnicalIndicatorsResponseData(BaseModel):
+    r"""Aggregate indicators payload."""
+
+    technical_analysis: Annotated[
+        Optional[TechnicalAnalysis], pydantic.Field(alias="technicalAnalysis")
+    ] = None
+    r"""Aggregate technical analysis summary."""
+
+    trend: Optional[Trend] = None
+    r"""Trend strength information."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["technicalAnalysis", "trend"])
+        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 AggregateTechnicalIndicatorsResponseTypedDict(TypedDict):
+    r"""Aggregate technical indicator signal and trend strength for a symbol and resolution from Finnhub."""
+
+    data: NotRequired[AggregateTechnicalIndicatorsResponseDataTypedDict]
+    r"""Aggregate indicators payload."""
+
+
+class AggregateTechnicalIndicatorsResponse(BaseModel):
+    r"""Aggregate technical indicator signal and trend strength for a symbol and resolution from Finnhub."""
+
+    data: Optional[AggregateTechnicalIndicatorsResponseData] = None
+    r"""Aggregate indicators 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:
+    AggregateTechnicalIndicatorsResponseData.model_rebuild()
+except NameError:
+    pass

finance_dev/models/analystinsightitem.py

@@ -0,0 +1,161 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: f69109ec7db3
+
+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 AnalystInsightItemSecurityTypedDict(TypedDict):
+    r"""Security metadata for the company or instrument this analyst insight covers."""
+
+    cik: NotRequired[str]
+    r"""SEC Central Index Key of the covered 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."""
+    isin: NotRequired[str]
+    r"""ISIN of the covered security."""
+    name: NotRequired[str]
+    r"""Name of the covered company or instrument."""
+    symbol: NotRequired[str]
+    r"""Ticker symbol of the covered security."""
+
+
+class AnalystInsightItemSecurity(BaseModel):
+    r"""Security metadata for the company or instrument this analyst insight covers."""
+
+    cik: Optional[str] = None
+    r"""SEC Central Index Key of the covered 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."""
+
+    isin: Optional[str] = None
+    r"""ISIN of the covered security."""
+
+    name: Optional[str] = None
+    r"""Name of the covered company or instrument."""
+
+    symbol: Optional[str] = None
+    r"""Ticker symbol of the covered security."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["cik", "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 AnalystInsightItemTypedDict(TypedDict):
+    r"""Single analyst insight (GET /v1/analytics/insights)."""
+
+    action: NotRequired[str]
+    r"""Analyst action such as upgrade, downgrade, initiation, or reiteration. Use it to explain what changed."""
+    analyst_insights: NotRequired[str]
+    r"""Plain-English analyst note or summary. Show this as the explanation behind the rating action."""
+    date_: NotRequired[str]
+    r"""Date the analyst insight was published. Use it to sort or filter recent analyst changes."""
+    firm: NotRequired[str]
+    r"""Research firm that published the insight. Show this so users know the source."""
+    firm_id: NotRequired[str]
+    r"""Provider identifier for the research firm. Use it for filtering or grouping by firm."""
+    id: NotRequired[str]
+    r"""Unique insight identifier. Use it for linking, deduping, or storing this analyst insight."""
+    pt: NotRequired[str]
+    r"""Analyst price target as a decimal string. Use it to show expected upside or downside versus the current price."""
+    rating: NotRequired[str]
+    r"""Analyst rating label such as Buy, Hold, or Sell. Use it as the business recommendation text."""
+    rating_id: NotRequired[str]
+    r"""Provider identifier for the rating record. Use it for deduping or linking insight data to rating data."""
+    security: NotRequired[AnalystInsightItemSecurityTypedDict]
+    r"""Security metadata for the company or instrument this analyst insight covers."""
+    updated: NotRequired[int]
+    r"""Last updated timestamp from the data provider. Use it to know whether a stored insight has changed."""
+
+
+class AnalystInsightItem(BaseModel):
+    r"""Single analyst insight (GET /v1/analytics/insights)."""
+
+    action: Optional[str] = None
+    r"""Analyst action such as upgrade, downgrade, initiation, or reiteration. Use it to explain what changed."""
+
+    analyst_insights: Annotated[
+        Optional[str], pydantic.Field(alias="analystInsights")
+    ] = None
+    r"""Plain-English analyst note or summary. Show this as the explanation behind the rating action."""
+
+    date_: Annotated[Optional[str], pydantic.Field(alias="date")] = None
+    r"""Date the analyst insight was published. Use it to sort or filter recent analyst changes."""
+
+    firm: Optional[str] = None
+    r"""Research firm that published the insight. Show this so users know the source."""
+
+    firm_id: Annotated[Optional[str], pydantic.Field(alias="firmId")] = None
+    r"""Provider identifier for the research firm. Use it for filtering or grouping by firm."""
+
+    id: Optional[str] = None
+    r"""Unique insight identifier. Use it for linking, deduping, or storing this analyst insight."""
+
+    pt: Optional[str] = None
+    r"""Analyst price target as a decimal string. Use it to show expected upside or downside versus the current price."""
+
+    rating: Optional[str] = None
+    r"""Analyst rating label such as Buy, Hold, or Sell. Use it as the business recommendation text."""
+
+    rating_id: Annotated[Optional[str], pydantic.Field(alias="ratingId")] = None
+    r"""Provider identifier for the rating record. Use it for deduping or linking insight data to rating data."""
+
+    security: Optional[AnalystInsightItemSecurity] = None
+    r"""Security metadata for the company or instrument this analyst insight covers."""
+
+    updated: Optional[int] = None
+    r"""Last updated timestamp from the data provider. Use it to know whether a stored insight has changed."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "action",
+                "analystInsights",
+                "date",
+                "firm",
+                "firmId",
+                "id",
+                "pt",
+                "rating",
+                "ratingId",
+                "security",
+                "updated",
+            ]
+        )
+        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:
+    AnalystInsightItem.model_rebuild()
+except NameError:
+    pass

finance_dev/models/analystinsightsresponse.py

@@ -0,0 +1,39 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: b808c7ded529
+
+from __future__ import annotations
+from .analystinsightitem import AnalystInsightItem, AnalystInsightItemTypedDict
+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 AnalystInsightsResponseTypedDict(TypedDict):
+    r"""Response containing analyst insights."""
+
+    insights: NotRequired[List[AnalystInsightItemTypedDict]]
+    r"""Array of analyst insights"""
+
+
+class AnalystInsightsResponse(BaseModel):
+    r"""Response containing analyst insights."""
+
+    insights: Optional[List[AnalystInsightItem]] = None
+    r"""Array of analyst insights"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["insights"])
+        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/apperror.py

@@ -0,0 +1,123 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 714f616ab5cf
+
+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 Any, Dict, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class AppErrorType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Categorical error type. Use this for branching error-handling logic; the values are stable across endpoints:
+    - `VALIDATION` — request body or query parameters failed validation.
+    - `AUTHENTICATION` — missing, invalid, or expired token.
+    - `AUTHORIZATION` — token is valid but lacks the required scope/permission.
+    - `NOT_FOUND` — the requested resource does not exist.
+    - `CONFLICT` — request conflicts with current state (e.g. duplicate).
+    - `INTERNAL` — server-side error; retry or contact support.
+    - `TIMEOUT` — operation took too long.
+    - `UNKNOWN` — uncategorized error; check `message`.
+    (Additional categorical values may appear in service-specific responses.)
+    """
+
+    UNKNOWN = "UNKNOWN"
+    VALIDATION = "VALIDATION"
+    AUTHENTICATION = "AUTHENTICATION"
+    AUTHORIZATION = "AUTHORIZATION"
+    NOT_FOUND = "NOT_FOUND"
+    CONFLICT = "CONFLICT"
+    INTERNAL = "INTERNAL"
+    TIMEOUT = "TIMEOUT"
+    RATE_LIMIT = "RATE_LIMIT"
+    BAD_REQUEST = "BAD_REQUEST"
+    DATABASE = "DATABASE"
+    EXTERNAL_SERVICE = "EXTERNAL_SERVICE"
+    PRECONDITION_FAILED = "PRECONDITION_FAILED"
+    SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE"
+    GRPC = "GRPC"
+    QUEUE = "QUEUE"
+    JSON_PARSING = "JSON_PARSING"
+
+
+class AppErrorTypedDict(TypedDict):
+    r"""Structured application error returned inside an `ErrorEnvelope`."""
+
+    code: str
+    r"""Machine-readable code, e.g. `SYMBOL_REQUIRED`, `EVENT_NOT_FOUND`."""
+    message: str
+    r"""Error detail as a string. Exact message content is not fixed and should not be hard-coded."""
+    type: AppErrorType
+    r"""Categorical error type. Use this for branching error-handling logic; the values are stable across endpoints:
+    - `VALIDATION` — request body or query parameters failed validation.
+    - `AUTHENTICATION` — missing, invalid, or expired token.
+    - `AUTHORIZATION` — token is valid but lacks the required scope/permission.
+    - `NOT_FOUND` — the requested resource does not exist.
+    - `CONFLICT` — request conflicts with current state (e.g. duplicate).
+    - `INTERNAL` — server-side error; retry or contact support.
+    - `TIMEOUT` — operation took too long.
+    - `UNKNOWN` — uncategorized error; check `message`.
+    (Additional categorical values may appear in service-specific responses.)
+    """
+    details: NotRequired[Dict[str, Any]]
+    operation: NotRequired[str]
+    request_id: NotRequired[str]
+    service: NotRequired[str]
+
+
+class AppError(BaseModel):
+    r"""Structured application error returned inside an `ErrorEnvelope`."""
+
+    code: str
+    r"""Machine-readable code, e.g. `SYMBOL_REQUIRED`, `EVENT_NOT_FOUND`."""
+
+    message: str
+    r"""Error detail as a string. Exact message content is not fixed and should not be hard-coded."""
+
+    type: AppErrorType
+    r"""Categorical error type. Use this for branching error-handling logic; the values are stable across endpoints:
+    - `VALIDATION` — request body or query parameters failed validation.
+    - `AUTHENTICATION` — missing, invalid, or expired token.
+    - `AUTHORIZATION` — token is valid but lacks the required scope/permission.
+    - `NOT_FOUND` — the requested resource does not exist.
+    - `CONFLICT` — request conflicts with current state (e.g. duplicate).
+    - `INTERNAL` — server-side error; retry or contact support.
+    - `TIMEOUT` — operation took too long.
+    - `UNKNOWN` — uncategorized error; check `message`.
+    (Additional categorical values may appear in service-specific responses.)
+    """
+
+    details: Optional[Dict[str, Any]] = None
+
+    operation: Optional[str] = None
+
+    request_id: Optional[str] = None
+
+    service: Optional[str] = None
+
+    @field_serializer("type")
+    def serialize_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.AppErrorType(value)
+            except ValueError:
+                return value
+        return value
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["details", "operation", "request_id", "service"])
+        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/authenticationerrordetail.py

@@ -0,0 +1,58 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 5969d9208386
+
+from __future__ import annotations
+from finance_dev.types import BaseModel, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Any, Dict, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class AuthenticationErrorDetailTypedDict(TypedDict):
+    r"""Structured payload for the nested `error` object. Services using the shared Go error writer emit uppercase `type` values aligned with error categories (for example `VALIDATION`, `BAD_REQUEST`, `AUTHENTICATION`, `AUTHORIZATION`, `NOT_FOUND`, `RATE_LIMIT`, `INTERNAL`)."""
+
+    code: NotRequired[str]
+    r"""Machine-readable code"""
+    details: NotRequired[Dict[str, Any]]
+    r"""Optional extra context"""
+    message: NotRequired[str]
+    r"""Error detail as a string. Exact message content is not fixed and should not be hard-coded."""
+    request_id: NotRequired[str]
+    r"""Request correlation id when provided"""
+    type: NotRequired[str]
+    r"""Error category emitted by the shared error writer, such as VALIDATION, BAD_REQUEST, AUTHENTICATION, AUTHORIZATION, NOT_FOUND, RATE_LIMIT, or INTERNAL."""
+
+
+class AuthenticationErrorDetail(BaseModel):
+    r"""Structured payload for the nested `error` object. Services using the shared Go error writer emit uppercase `type` values aligned with error categories (for example `VALIDATION`, `BAD_REQUEST`, `AUTHENTICATION`, `AUTHORIZATION`, `NOT_FOUND`, `RATE_LIMIT`, `INTERNAL`)."""
+
+    code: Optional[str] = None
+    r"""Machine-readable code"""
+
+    details: Optional[Dict[str, Any]] = None
+    r"""Optional extra context"""
+
+    message: Optional[str] = None
+    r"""Error detail as a string. Exact message content is not fixed and should not be hard-coded."""
+
+    request_id: Optional[str] = None
+    r"""Request correlation id when provided"""
+
+    type: Optional[str] = None
+    r"""Error category emitted by the shared error writer, such as VALIDATION, BAD_REQUEST, AUTHENTICATION, AUTHORIZATION, NOT_FOUND, RATE_LIMIT, or INTERNAL."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["code", "details", "message", "request_id", "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/bankbranchesresponse.py

@@ -0,0 +1,96 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: d06e04024df2
+
+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 BankBranchesResponseDataTypedDict(TypedDict):
+    address: NotRequired[str]
+    r"""Branch address."""
+    branch_id: NotRequired[str]
+    r"""Branch identifier."""
+    date_: NotRequired[str]
+    r"""Date the branch was opened, as returned by the provider."""
+    state: NotRequired[str]
+    r"""Branch state."""
+    zip_code: NotRequired[str]
+    r"""Branch zip code."""
+
+
+class BankBranchesResponseData(BaseModel):
+    address: Optional[str] = None
+    r"""Branch address."""
+
+    branch_id: Annotated[Optional[str], pydantic.Field(alias="branchId")] = None
+    r"""Branch identifier."""
+
+    date_: Annotated[Optional[str], pydantic.Field(alias="date")] = None
+    r"""Date the branch was opened, as returned by the provider."""
+
+    state: Optional[str] = None
+    r"""Branch state."""
+
+    zip_code: Annotated[Optional[str], pydantic.Field(alias="zipCode")] = None
+    r"""Branch zip code."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["address", "branchId", "date", "state", "zipCode"])
+        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 BankBranchesResponseTypedDict(TypedDict):
+    r"""List of US bank branches for a company, as provided by Finnhub."""
+
+    data: NotRequired[List[BankBranchesResponseDataTypedDict]]
+    r"""Bank branches for the symbol."""
+    symbol: NotRequired[str]
+    r"""Company ticker symbol."""
+
+
+class BankBranchesResponse(BaseModel):
+    r"""List of US bank branches for a company, as provided by Finnhub."""
+
+    data: Optional[List[BankBranchesResponseData]] = None
+    r"""Bank branches 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:
+    BankBranchesResponseData.model_rebuild()
+except NameError:
+    pass