exchangerate-dev 0.1.0__py3-none-any.whl

exchangerate_dev/_generated/models.py

@@ -0,0 +1,617 @@
+# Generated from spec/exchangerate/live/openapi.json sha256 6062a9cab89641865dd0d1ce764c5f89e54b11901602b41231f8dae9987ba773. Do not edit.
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from decimal import Decimal
+from typing import Literal
+
+from .._decode import (
+    read_bool,
+    read_cursor,
+    read_decimal_number,
+    read_int,
+    read_list,
+    read_object,
+    read_str,
+)
+from .._meta import ResponseMeta
+
+
+class BarInterval:
+    """Known values; response fields also accept future strings."""
+
+    V15M: Literal["15m"] = "15m"
+    V1D: Literal["1d"] = "1d"
+    V1H: Literal["1h"] = "1h"
+    V1M: Literal["1m"] = "1m"
+    V4H: Literal["4h"] = "4h"
+    V5M: Literal["5m"] = "5m"
+
+
+class IndexSourceType:
+    """Known values; response fields also accept future strings."""
+
+    MARKET: Literal["market"] = "market"
+    REFERENCE: Literal["reference"] = "reference"
+
+
+class MarketSession:
+    """Known values; response fields also accept future strings."""
+
+    INTERBANK_CLOSED: Literal["interbank_closed"] = "interbank_closed"
+    OPEN: Literal["open"] = "open"
+    WEEKEND: Literal["weekend"] = "weekend"
+
+
+class RateSource:
+    """Known values; response fields also accept future strings."""
+
+    ECB_DAILY: Literal["ecb_daily"] = "ecb_daily"
+    LIVE: Literal["live"] = "live"
+    MARKET_DAILY: Literal["market_daily"] = "market_daily"
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ConvertResponse:
+    amount: Decimal
+    converted: Decimal
+    data_updated_at: str
+    derivation_bps_max: Decimal | None = None
+    derived: bool
+    from_: str
+    market_session: str
+    notice: str
+    rate: Decimal
+    result: str | None = None
+    source: str
+    sources: dict[str, str]
+    stale: bool
+    timestamp: str
+    to: str
+    meta: ResponseMeta = field(default_factory=ResponseMeta, compare=False)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CurrenciesResponse:
+    currencies: list[CurrencyInfo]
+    result: str | None = None
+    meta: ResponseMeta = field(default_factory=ResponseMeta, compare=False)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CurrencyInfo:
+    code: str
+    decimals: int
+    is_derived: bool
+    minor_units: int
+    name: str
+    type: str | None = None
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DailyUsageEntry:
+    count: int
+    date: str
+    rate_limited: int
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DailyUsageResponse:
+    active_streams: int | None = None
+    days: list[DailyUsageEntry]
+    limit: int
+    max_streams: int
+    month_to_date: int
+    rate_limited_total: int
+    result: str | None = None
+    tier: str
+    meta: ResponseMeta = field(default_factory=ResponseMeta, compare=False)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class HistoricalResponse:
+    base: str
+    data_updated_at: str
+    date: str
+    derived_symbols: list[str]
+    is_forward_filled: bool
+    market_session: str
+    notice: str
+    rates: dict[str, Decimal]
+    result: str | None = None
+    source: str
+    sources: dict[str, str]
+    timestamp: str
+    meta: ResponseMeta = field(default_factory=ResponseMeta, compare=False)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class IndexConstituent:
+    contribution: Decimal
+    currency: str
+    effective_at: str
+    rate: Decimal
+    weight: Decimal
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class IndexSnapshotResponse:
+    base_date: str | None = None
+    constituents: list[IndexConstituent]
+    data_updated_at: str
+    index: str
+    market_session: str
+    methodology_version: str
+    name: str
+    notice: str
+    result: str | None = None
+    source: str
+    source_type: str
+    stale: bool
+    timestamp: str
+    value: Decimal
+    weights: dict[str, Decimal]
+    meta: ResponseMeta = field(default_factory=ResponseMeta, compare=False)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class IndexTimeseriesResponse:
+    base_date: str | None = None
+    data: list[IndexTimeseriesRow]
+    from_: str
+    has_more: bool | None = None
+    index: str
+    interval: str
+    methodology_version: str
+    name: str
+    next_cursor: str | None = None
+    notice: str
+    result: str | None = None
+    to: str
+    weights: dict[str, Decimal]
+    meta: ResponseMeta = field(default_factory=ResponseMeta, compare=False)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class IndexTimeseriesRow:
+    data_updated_at: str
+    market_session: str
+    source: str
+    source_type: str
+    timestamp: str
+    value: Decimal
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class LatestResponse:
+    base: str
+    data_updated_at: str
+    derived_symbols: list[str]
+    effective_at: dict[str, str]
+    market_session: str
+    notice: str
+    rates: dict[str, Decimal]
+    result: str | None = None
+    source: str
+    sources: dict[str, str]
+    stale: dict[str, bool]
+    timestamp: str
+    meta: ResponseMeta = field(default_factory=ResponseMeta, compare=False)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class RangeResponse:
+    base: str
+    data: list[RangeRow]
+    end_date: str
+    has_more: bool | None = None
+    next_cursor: str | None = None
+    notice: str
+    result: str | None = None
+    start_date: str
+    meta: ResponseMeta = field(default_factory=ResponseMeta, compare=False)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class RangeRow:
+    date: str
+    derived_symbols: list[str]
+    is_forward_filled: bool
+    rates: dict[str, Decimal]
+    source: str
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class RateResponse:
+    base: str
+    data_updated_at: str
+    derivation_bps_max: Decimal | None = None
+    derived: bool
+    market_session: str
+    notice: str
+    pair: str
+    quote: str
+    rate: Decimal
+    result: str | None = None
+    source: str
+    sources: dict[str, str]
+    stale: bool
+    timestamp: str
+    meta: ResponseMeta = field(default_factory=ResponseMeta, compare=False)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class TimeseriesResponse:
+    base: str
+    data: list[TimeseriesRow]
+    from_: str
+    has_more: bool | None = None
+    interval: str
+    next_cursor: str | None = None
+    notice: str
+    result: str | None = None
+    symbols: list[str]
+    to: str
+    meta: ResponseMeta = field(default_factory=ResponseMeta, compare=False)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class TimeseriesRow:
+    derived_symbols: list[str]
+    effective_at: dict[str, str]
+    market_session: str
+    rates: dict[str, Decimal]
+    source: str
+    source_type: str
+    timestamp: str
+
+
+def decode_ConvertResponse(
+    value: object, meta: ResponseMeta | None = None, raw_body: bytes = b""
+) -> ConvertResponse:
+    data = read_object(value)
+    return ConvertResponse(
+        amount=read_decimal_number(data["amount"]),
+        converted=read_decimal_number(data["converted"]),
+        data_updated_at=read_str(data["data_updated_at"]),
+        derivation_bps_max=read_decimal_number(data["derivation_bps_max"])
+        if data.get("derivation_bps_max") is not None
+        else None,
+        derived=read_bool(data["derived"]),
+        from_=read_str(data["from"]),
+        market_session=read_str(data["market_session"]),
+        notice=read_str(data["notice"]),
+        rate=read_decimal_number(data["rate"]),
+        result=read_str(data["result"]) if data.get("result") is not None else None,
+        source=read_str(data["source"]),
+        sources={
+            key0: read_str(item0)
+            for key0, item0 in read_object(data["sources"]).items()
+        },
+        stale=read_bool(data["stale"]),
+        timestamp=read_str(data["timestamp"]),
+        to=read_str(data["to"]),
+        meta=meta if meta is not None else ResponseMeta(),
+    )
+
+
+def decode_CurrenciesResponse(
+    value: object, meta: ResponseMeta | None = None, raw_body: bytes = b""
+) -> CurrenciesResponse:
+    data = read_object(value)
+    return CurrenciesResponse(
+        currencies=[
+            decode_CurrencyInfo(item0) for item0 in read_list(data["currencies"])
+        ],
+        result=read_str(data["result"]) if data.get("result") is not None else None,
+        meta=meta if meta is not None else ResponseMeta(),
+    )
+
+
+def decode_CurrencyInfo(
+    value: object, meta: ResponseMeta | None = None, raw_body: bytes = b""
+) -> CurrencyInfo:
+    data = read_object(value)
+    return CurrencyInfo(
+        code=read_str(data["code"]),
+        decimals=read_int(data["decimals"]),
+        is_derived=read_bool(data["is_derived"]),
+        minor_units=read_int(data["minor_units"]),
+        name=read_str(data["name"]),
+        type=read_str(data["type"]) if data.get("type") is not None else None,
+    )
+
+
+def decode_DailyUsageEntry(
+    value: object, meta: ResponseMeta | None = None, raw_body: bytes = b""
+) -> DailyUsageEntry:
+    data = read_object(value)
+    return DailyUsageEntry(
+        count=read_int(data["count"]),
+        date=read_str(data["date"]),
+        rate_limited=read_int(data["rate_limited"]),
+    )
+
+
+def decode_DailyUsageResponse(
+    value: object, meta: ResponseMeta | None = None, raw_body: bytes = b""
+) -> DailyUsageResponse:
+    data = read_object(value)
+    return DailyUsageResponse(
+        active_streams=read_int(data["active_streams"])
+        if data.get("active_streams") is not None
+        else None,
+        days=[decode_DailyUsageEntry(item0) for item0 in read_list(data["days"])],
+        limit=read_int(data["limit"]),
+        max_streams=read_int(data["max_streams"]),
+        month_to_date=read_int(data["month_to_date"]),
+        rate_limited_total=read_int(data["rate_limited_total"]),
+        result=read_str(data["result"]) if data.get("result") is not None else None,
+        tier=read_str(data["tier"]),
+        meta=meta if meta is not None else ResponseMeta(),
+    )
+
+
+def decode_HistoricalResponse(
+    value: object, meta: ResponseMeta | None = None, raw_body: bytes = b""
+) -> HistoricalResponse:
+    data = read_object(value)
+    return HistoricalResponse(
+        base=read_str(data["base"]),
+        data_updated_at=read_str(data["data_updated_at"]),
+        date=read_str(data["date"]),
+        derived_symbols=[
+            read_str(item0) for item0 in read_list(data["derived_symbols"])
+        ],
+        is_forward_filled=read_bool(data["is_forward_filled"]),
+        market_session=read_str(data["market_session"]),
+        notice=read_str(data["notice"]),
+        rates={
+            key0: read_decimal_number(item0)
+            for key0, item0 in read_object(data["rates"]).items()
+        },
+        result=read_str(data["result"]) if data.get("result") is not None else None,
+        source=read_str(data["source"]),
+        sources={
+            key0: read_str(item0)
+            for key0, item0 in read_object(data["sources"]).items()
+        },
+        timestamp=read_str(data["timestamp"]),
+        meta=meta if meta is not None else ResponseMeta(),
+    )
+
+
+def decode_IndexConstituent(
+    value: object, meta: ResponseMeta | None = None, raw_body: bytes = b""
+) -> IndexConstituent:
+    data = read_object(value)
+    return IndexConstituent(
+        contribution=read_decimal_number(data["contribution"]),
+        currency=read_str(data["currency"]),
+        effective_at=read_str(data["effective_at"]),
+        rate=read_decimal_number(data["rate"]),
+        weight=read_decimal_number(data["weight"]),
+    )
+
+
+def decode_IndexSnapshotResponse(
+    value: object, meta: ResponseMeta | None = None, raw_body: bytes = b""
+) -> IndexSnapshotResponse:
+    data = read_object(value)
+    return IndexSnapshotResponse(
+        base_date=read_str(data["base_date"])
+        if data.get("base_date") is not None
+        else None,
+        constituents=[
+            decode_IndexConstituent(item0) for item0 in read_list(data["constituents"])
+        ],
+        data_updated_at=read_str(data["data_updated_at"]),
+        index=read_str(data["index"]),
+        market_session=read_str(data["market_session"]),
+        methodology_version=read_str(data["methodology_version"]),
+        name=read_str(data["name"]),
+        notice=read_str(data["notice"]),
+        result=read_str(data["result"]) if data.get("result") is not None else None,
+        source=read_str(data["source"]),
+        source_type=read_str(data["source_type"]),
+        stale=read_bool(data["stale"]),
+        timestamp=read_str(data["timestamp"]),
+        value=read_decimal_number(data["value"]),
+        weights={
+            key0: read_decimal_number(item0)
+            for key0, item0 in read_object(data["weights"]).items()
+        },
+        meta=meta if meta is not None else ResponseMeta(),
+    )
+
+
+def decode_IndexTimeseriesResponse(
+    value: object, meta: ResponseMeta | None = None, raw_body: bytes = b""
+) -> IndexTimeseriesResponse:
+    data = read_object(value)
+    return IndexTimeseriesResponse(
+        base_date=read_str(data["base_date"])
+        if data.get("base_date") is not None
+        else None,
+        data=[decode_IndexTimeseriesRow(item0) for item0 in read_list(data["data"])],
+        from_=read_str(data["from"]),
+        has_more=read_bool(data["has_more"])
+        if data.get("has_more") is not None
+        else None,
+        index=read_str(data["index"]),
+        interval=read_str(data["interval"]),
+        methodology_version=read_str(data["methodology_version"]),
+        name=read_str(data["name"]),
+        next_cursor=read_cursor(data["next_cursor"])
+        if data.get("next_cursor") is not None
+        else None,
+        notice=read_str(data["notice"]),
+        result=read_str(data["result"]) if data.get("result") is not None else None,
+        to=read_str(data["to"]),
+        weights={
+            key0: read_decimal_number(item0)
+            for key0, item0 in read_object(data["weights"]).items()
+        },
+        meta=meta if meta is not None else ResponseMeta(),
+    )
+
+
+def decode_IndexTimeseriesRow(
+    value: object, meta: ResponseMeta | None = None, raw_body: bytes = b""
+) -> IndexTimeseriesRow:
+    data = read_object(value)
+    return IndexTimeseriesRow(
+        data_updated_at=read_str(data["data_updated_at"]),
+        market_session=read_str(data["market_session"]),
+        source=read_str(data["source"]),
+        source_type=read_str(data["source_type"]),
+        timestamp=read_str(data["timestamp"]),
+        value=read_decimal_number(data["value"]),
+    )
+
+
+def decode_LatestResponse(
+    value: object, meta: ResponseMeta | None = None, raw_body: bytes = b""
+) -> LatestResponse:
+    data = read_object(value)
+    return LatestResponse(
+        base=read_str(data["base"]),
+        data_updated_at=read_str(data["data_updated_at"]),
+        derived_symbols=[
+            read_str(item0) for item0 in read_list(data["derived_symbols"])
+        ],
+        effective_at={
+            key0: read_str(item0)
+            for key0, item0 in read_object(data["effective_at"]).items()
+        },
+        market_session=read_str(data["market_session"]),
+        notice=read_str(data["notice"]),
+        rates={
+            key0: read_decimal_number(item0)
+            for key0, item0 in read_object(data["rates"]).items()
+        },
+        result=read_str(data["result"]) if data.get("result") is not None else None,
+        source=read_str(data["source"]),
+        sources={
+            key0: read_str(item0)
+            for key0, item0 in read_object(data["sources"]).items()
+        },
+        stale={
+            key0: read_bool(item0) for key0, item0 in read_object(data["stale"]).items()
+        },
+        timestamp=read_str(data["timestamp"]),
+        meta=meta if meta is not None else ResponseMeta(),
+    )
+
+
+def decode_RangeResponse(
+    value: object, meta: ResponseMeta | None = None, raw_body: bytes = b""
+) -> RangeResponse:
+    data = read_object(value)
+    return RangeResponse(
+        base=read_str(data["base"]),
+        data=[decode_RangeRow(item0) for item0 in read_list(data["data"])],
+        end_date=read_str(data["end_date"]),
+        has_more=read_bool(data["has_more"])
+        if data.get("has_more") is not None
+        else None,
+        next_cursor=read_cursor(data["next_cursor"])
+        if data.get("next_cursor") is not None
+        else None,
+        notice=read_str(data["notice"]),
+        result=read_str(data["result"]) if data.get("result") is not None else None,
+        start_date=read_str(data["start_date"]),
+        meta=meta if meta is not None else ResponseMeta(),
+    )
+
+
+def decode_RangeRow(
+    value: object, meta: ResponseMeta | None = None, raw_body: bytes = b""
+) -> RangeRow:
+    data = read_object(value)
+    return RangeRow(
+        date=read_str(data["date"]),
+        derived_symbols=[
+            read_str(item0) for item0 in read_list(data["derived_symbols"])
+        ],
+        is_forward_filled=read_bool(data["is_forward_filled"]),
+        rates={
+            key0: read_decimal_number(item0)
+            for key0, item0 in read_object(data["rates"]).items()
+        },
+        source=read_str(data["source"]),
+    )
+
+
+def decode_RateResponse(
+    value: object, meta: ResponseMeta | None = None, raw_body: bytes = b""
+) -> RateResponse:
+    data = read_object(value)
+    return RateResponse(
+        base=read_str(data["base"]),
+        data_updated_at=read_str(data["data_updated_at"]),
+        derivation_bps_max=read_decimal_number(data["derivation_bps_max"])
+        if data.get("derivation_bps_max") is not None
+        else None,
+        derived=read_bool(data["derived"]),
+        market_session=read_str(data["market_session"]),
+        notice=read_str(data["notice"]),
+        pair=read_str(data["pair"]),
+        quote=read_str(data["quote"]),
+        rate=read_decimal_number(data["rate"]),
+        result=read_str(data["result"]) if data.get("result") is not None else None,
+        source=read_str(data["source"]),
+        sources={
+            key0: read_str(item0)
+            for key0, item0 in read_object(data["sources"]).items()
+        },
+        stale=read_bool(data["stale"]),
+        timestamp=read_str(data["timestamp"]),
+        meta=meta if meta is not None else ResponseMeta(),
+    )
+
+
+def decode_TimeseriesResponse(
+    value: object, meta: ResponseMeta | None = None, raw_body: bytes = b""
+) -> TimeseriesResponse:
+    data = read_object(value)
+    return TimeseriesResponse(
+        base=read_str(data["base"]),
+        data=[decode_TimeseriesRow(item0) for item0 in read_list(data["data"])],
+        from_=read_str(data["from"]),
+        has_more=read_bool(data["has_more"])
+        if data.get("has_more") is not None
+        else None,
+        interval=read_str(data["interval"]),
+        next_cursor=read_cursor(data["next_cursor"])
+        if data.get("next_cursor") is not None
+        else None,
+        notice=read_str(data["notice"]),
+        result=read_str(data["result"]) if data.get("result") is not None else None,
+        symbols=[read_str(item0) for item0 in read_list(data["symbols"])],
+        to=read_str(data["to"]),
+        meta=meta if meta is not None else ResponseMeta(),
+    )
+
+
+def decode_TimeseriesRow(
+    value: object, meta: ResponseMeta | None = None, raw_body: bytes = b""
+) -> TimeseriesRow:
+    data = read_object(value)
+    return TimeseriesRow(
+        derived_symbols=[
+            read_str(item0) for item0 in read_list(data["derived_symbols"])
+        ],
+        effective_at={
+            key0: read_str(item0)
+            for key0, item0 in read_object(data["effective_at"]).items()
+        },
+        market_session=read_str(data["market_session"]),
+        rates={
+            key0: read_decimal_number(item0)
+            for key0, item0 in read_object(data["rates"]).items()
+        },
+        source=read_str(data["source"]),
+        source_type=read_str(data["source_type"]),
+        timestamp=read_str(data["timestamp"]),
+    )