exchangerate-dev 0.1.0__tar.gz

exchangerate_dev-0.1.0/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 0.1.0 — 2026-10-09
+
+- Synchronous and asynchronous clients for indicative FX reference rates.
+- Latest and historical rates, conversion, currencies, indices, and daily usage.
+- Exact decimals, typed errors, bounded retries, and response metadata.
+- Pagination iterators for rate ranges and rate and index timeseries.

exchangerate_dev-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nusantara Ventures, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

exchangerate_dev-0.1.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.5
+Name: exchangerate-dev
+Version: 0.1.0
+Summary: Typed clients for the exchangerate.dev API
+Project-URL: Homepage, https://exchangerate.dev/docs
+Author-email: "Nusantara Ventures, LLC" <hello@exchangerate.dev>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api,currency,decimal,exchange-rates,forex,fx,sdk
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx<1,>=0.27
+Description-Content-Type: text/markdown
+
+# Exchangerate for Python
+
+Python clients for indicative FX reference rates from exchangerate.dev. Read latest
+and historical rates, currency pairs, indices, and account usage, or convert an
+amount between currencies. These rates are not for settlement or trading.
+
+## Install
+
+Requires Python 3.10 or newer. The only dependency is httpx.
+
+```sh
+pip install exchangerate-dev
+```
+
+## Quickstart
+
+Set `EXCHANGERATE_API_KEY` in your environment, then run:
+
+```python
+from exchangerate_dev import Exchangerate
+
+with Exchangerate() as client:
+    latest = client.rates.latest(base="USD", symbols=["EUR", "IDR"])
+    print(latest.rates["EUR"])
+    print(latest.meta.request_id)
+    converted = client.convert.amount("USD", "IDR", amount="100")
+    print(converted)
+```
+
+The context manager closes the client. `AsyncExchangerate` provides asynchronous
+access. Supply `api_key=` to configure a key explicitly. The default base URL is
+`https://api.exchangerate.dev`; override it with `EXCHANGERATE_BASE_URL` or
+`base_url=`. Pass `symbols` as a list of currency codes.
+
+Use `currencies.list()` to read available currency codes and
+`account.usage_daily(days=...)` to inspect daily account usage.
+
+## Decimals
+
+Rates and amounts use exact `decimal.Decimal` values, never floats. The `rates`
+dictionary maps currency codes to decimals. Pass conversion amounts as strings
+to preserve decimal input. Every response carries `meta` with `request_id` and
+rate-limit values from headers.
+
+## Errors and retries
+
+`errors.Unauthorized`, `errors.RateLimited`, `errors.NotFound`, and
+`errors.BadRequest` extend `errors.ApiError`, which exposes `status`, `code`,
+`detail`, and `request_id`. `errors.RateLimited` also carries `retry_after`.
+All client errors derive from `errors.ExchangerateError`. Import `errors` from
+`exchangerate_dev` when handling these exceptions.
+
+Requests retry up to twice by default for short-window rate limits and temporary
+unavailability. Quota exhaustion is not retried.
+
+## Pagination iterators
+
+Use `rates.range_iter(...)`, `rates.timeseries_iter(...)`, and
+`indices.timeseries_iter(index_slug, ...)` to consume items across pages. Use
+`for` with `Exchangerate` and `async for` with `AsyncExchangerate`. Their
+corresponding methods without `_iter` return a single page.
+
+Links: [Documentation](https://exchangerate.dev/docs)
+
+MIT licensed

exchangerate_dev-0.1.0/README.md

@@ -0,0 +1,65 @@
+# Exchangerate for Python
+
+Python clients for indicative FX reference rates from exchangerate.dev. Read latest
+and historical rates, currency pairs, indices, and account usage, or convert an
+amount between currencies. These rates are not for settlement or trading.
+
+## Install
+
+Requires Python 3.10 or newer. The only dependency is httpx.
+
+```sh
+pip install exchangerate-dev
+```
+
+## Quickstart
+
+Set `EXCHANGERATE_API_KEY` in your environment, then run:
+
+```python
+from exchangerate_dev import Exchangerate
+
+with Exchangerate() as client:
+    latest = client.rates.latest(base="USD", symbols=["EUR", "IDR"])
+    print(latest.rates["EUR"])
+    print(latest.meta.request_id)
+    converted = client.convert.amount("USD", "IDR", amount="100")
+    print(converted)
+```
+
+The context manager closes the client. `AsyncExchangerate` provides asynchronous
+access. Supply `api_key=` to configure a key explicitly. The default base URL is
+`https://api.exchangerate.dev`; override it with `EXCHANGERATE_BASE_URL` or
+`base_url=`. Pass `symbols` as a list of currency codes.
+
+Use `currencies.list()` to read available currency codes and
+`account.usage_daily(days=...)` to inspect daily account usage.
+
+## Decimals
+
+Rates and amounts use exact `decimal.Decimal` values, never floats. The `rates`
+dictionary maps currency codes to decimals. Pass conversion amounts as strings
+to preserve decimal input. Every response carries `meta` with `request_id` and
+rate-limit values from headers.
+
+## Errors and retries
+
+`errors.Unauthorized`, `errors.RateLimited`, `errors.NotFound`, and
+`errors.BadRequest` extend `errors.ApiError`, which exposes `status`, `code`,
+`detail`, and `request_id`. `errors.RateLimited` also carries `retry_after`.
+All client errors derive from `errors.ExchangerateError`. Import `errors` from
+`exchangerate_dev` when handling these exceptions.
+
+Requests retry up to twice by default for short-window rate limits and temporary
+unavailability. Quota exhaustion is not retried.
+
+## Pagination iterators
+
+Use `rates.range_iter(...)`, `rates.timeseries_iter(...)`, and
+`indices.timeseries_iter(index_slug, ...)` to consume items across pages. Use
+`for` with `Exchangerate` and `async for` with `AsyncExchangerate`. Their
+corresponding methods without `_iter` return a single page.
+
+Links: [Documentation](https://exchangerate.dev/docs)
+
+MIT licensed

exchangerate_dev-0.1.0/hatch_build.py

@@ -0,0 +1,14 @@
+"""Keep repository ignore files out of the source distribution."""
+
+from pathlib import Path
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+
+class CustomBuildHook(BuildHookInterface):
+    def initialize(self, version, build_data):
+        if self.target_name == "sdist":
+            forced = build_data["force_include"]
+            for path in list(forced):
+                if Path(path).name in {".gitignore", ".hgignore"}:
+                    del forced[path]

exchangerate_dev-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "exchangerate-dev"
+version = "0.1.0"
+description = "Typed clients for the exchangerate.dev API"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "Nusantara Ventures, LLC", email = "hello@exchangerate.dev" }]
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = ["httpx>=0.27,<1"]
+keywords = ["api", "sdk", "fx", "exchange-rates", "currency", "forex", "decimal"]
+classifiers = [
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Topic :: Office/Business :: Financial",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "License :: OSI Approved :: MIT License",
+]
+
+[project.urls]
+Homepage = "https://exchangerate.dev/docs"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/exchangerate_dev"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/exchangerate_dev", "README.md", "CHANGELOG.md", "LICENSE", "pyproject.toml"]
+
+[tool.hatch.build.hooks.custom]

exchangerate_dev-0.1.0/src/exchangerate_dev/__init__.py

@@ -0,0 +1,16 @@
+"""Typed clients for the exchangerate.dev API."""
+
+from . import errors, models
+from ._client import AsyncExchangerate, Exchangerate
+from ._meta import RateLimit, ResponseMeta
+from ._version import __version__
+
+__all__ = [
+    "AsyncExchangerate",
+    "Exchangerate",
+    "RateLimit",
+    "ResponseMeta",
+    "__version__",
+    "errors",
+    "models",
+]

exchangerate_dev-0.1.0/src/exchangerate_dev/_client.py

@@ -0,0 +1,122 @@
+"""Connection-owning synchronous and asynchronous clients."""
+
+import asyncio
+import random
+import time
+from collections.abc import Awaitable, Callable, Mapping
+from types import TracebackType
+from typing import TypeVar
+
+import httpx
+
+from ._generated.operations import (
+    LIVE_SPEC_SHA,
+    AsyncStableOperations,
+    StableOperations,
+)
+from ._transport import AsyncTransport, Settings, SyncTransport
+
+SyncClient = TypeVar("SyncClient", bound="Exchangerate")
+AsyncClient = TypeVar("AsyncClient", bound="AsyncExchangerate")
+
+
+class Exchangerate(StableOperations):
+    """Share one client across threads and close it when finished."""
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        base_url: str | None = None,
+        proxy: str | None = None,
+        timeout: float = 30,
+        max_retries: int = 2,
+        max_retry_wait: float = 30,
+        extra_headers: Mapping[str, str] | None = None,
+        transport: httpx.BaseTransport | None = None,
+        sleep: Callable[[float], None] = time.sleep,
+        clock: Callable[[], float] = time.monotonic,
+        random_fraction: Callable[[], float] = random.random,
+    ) -> None:
+        settings = Settings(
+            api_key=api_key,
+            base_url=base_url,
+            proxy=proxy,
+            timeout=timeout,
+            max_retries=max_retries,
+            max_retry_wait=max_retry_wait,
+            extra_headers=extra_headers,
+            clock=clock,
+            random_fraction=random_fraction,
+            spec_sha=LIVE_SPEC_SHA,
+        )
+        self._transport = SyncTransport(settings, transport=transport, sleep=sleep)
+        super().__init__(self._transport)
+
+    def __repr__(self) -> str:
+        return "Exchangerate(api_key=<redacted>)"
+
+    def close(self) -> None:
+        self._transport.http.close()
+
+    def __enter__(self: SyncClient) -> SyncClient:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        self.close()
+
+
+class AsyncExchangerate(AsyncStableOperations):
+    """Use one client per event loop and close it with async with."""
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        base_url: str | None = None,
+        proxy: str | None = None,
+        timeout: float = 30,
+        max_retries: int = 2,
+        max_retry_wait: float = 30,
+        extra_headers: Mapping[str, str] | None = None,
+        transport: httpx.AsyncBaseTransport | None = None,
+        sleep: Callable[[float], Awaitable[None]] = asyncio.sleep,
+        clock: Callable[[], float] = time.monotonic,
+        random_fraction: Callable[[], float] = random.random,
+    ) -> None:
+        settings = Settings(
+            api_key=api_key,
+            base_url=base_url,
+            proxy=proxy,
+            timeout=timeout,
+            max_retries=max_retries,
+            max_retry_wait=max_retry_wait,
+            extra_headers=extra_headers,
+            clock=clock,
+            random_fraction=random_fraction,
+            spec_sha=LIVE_SPEC_SHA,
+        )
+        self._transport = AsyncTransport(settings, transport=transport, sleep=sleep)
+        super().__init__(self._transport)
+
+    def __repr__(self) -> str:
+        return "AsyncExchangerate(api_key=<redacted>)"
+
+    async def aclose(self) -> None:
+        await self._transport.http.aclose()
+
+    async def __aenter__(self: AsyncClient) -> AsyncClient:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self.aclose()

exchangerate_dev-0.1.0/src/exchangerate_dev/_deadline.py

@@ -0,0 +1,180 @@
+"""Per-attempt synchronous I/O deadlines, without threads or event loops."""
+
+from collections.abc import Callable, Iterable
+from contextvars import ContextVar
+from ssl import SSLContext
+from typing import Protocol, cast
+
+import httpx
+
+RESPONSE_STARTED = "exchangerate_dev.response_started"
+SocketOption = tuple[int, int, int | bytes] | tuple[int, int, None, int]
+
+
+class Deadline:
+    def __init__(self, timeout: float, clock: Callable[[], float]) -> None:
+        self.clock = clock
+        self.expires = clock() + timeout
+
+    def remaining(self) -> float:
+        return max(0.0, self.expires - self.clock())
+
+
+active_deadline: ContextVar[Deadline | None] = ContextVar(
+    "exchangerate_dev_deadline", default=None
+)
+
+
+def io_timeout(timeout: float | None) -> float | None:
+    deadline = active_deadline.get()
+    if deadline is None:
+        return timeout
+    remaining = deadline.remaining()
+    if remaining <= 0:
+        raise httpx.ReadTimeout("Attempt deadline exceeded")
+    return remaining if timeout is None else min(timeout, remaining)
+
+
+class NetworkStream(Protocol):
+    def read(self, max_bytes: int, timeout: float | None = None) -> bytes: ...
+    def write(self, buffer: bytes, timeout: float | None = None) -> None: ...
+    def close(self) -> None: ...
+    def start_tls(
+        self,
+        ssl_context: SSLContext,
+        server_hostname: str | None = None,
+        timeout: float | None = None,
+    ) -> "NetworkStream": ...
+    def get_extra_info(self, info: str) -> object: ...
+
+
+class NetworkBackend(Protocol):
+    def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: float | None = None,
+        local_address: str | None = None,
+        socket_options: Iterable[SocketOption] | None = None,
+    ) -> NetworkStream: ...
+    def connect_unix_socket(
+        self,
+        path: str,
+        timeout: float | None = None,
+        socket_options: Iterable[SocketOption] | None = None,
+    ) -> NetworkStream: ...
+    def sleep(self, seconds: float) -> None: ...
+
+
+class _Stream:
+    def __init__(self, inner: NetworkStream) -> None:
+        self.inner = inner
+
+    def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
+        return self.inner.read(max_bytes, timeout=io_timeout(timeout))
+
+    def write(self, buffer: bytes, timeout: float | None = None) -> None:
+        self.inner.write(buffer, timeout=io_timeout(timeout))
+
+    def close(self) -> None:
+        self.inner.close()
+
+    def start_tls(
+        self,
+        ssl_context: SSLContext,
+        server_hostname: str | None = None,
+        timeout: float | None = None,
+    ) -> "_Stream":
+        return _Stream(
+            self.inner.start_tls(
+                ssl_context,
+                server_hostname=server_hostname,
+                timeout=io_timeout(timeout),
+            )
+        )
+
+    def get_extra_info(self, info: str) -> object:
+        return self.inner.get_extra_info(info)
+
+
+class _Backend:
+    def __init__(self, inner: NetworkBackend) -> None:
+        self.inner = inner
+
+    def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: float | None = None,
+        local_address: str | None = None,
+        socket_options: Iterable[SocketOption] | None = None,
+    ) -> NetworkStream:
+        return _Stream(
+            self.inner.connect_tcp(
+                host,
+                port,
+                timeout=io_timeout(timeout),
+                local_address=local_address,
+                socket_options=socket_options,
+            )
+        )
+
+    def connect_unix_socket(
+        self,
+        path: str,
+        timeout: float | None = None,
+        socket_options: Iterable[SocketOption] | None = None,
+    ) -> NetworkStream:
+        return _Stream(
+            self.inner.connect_unix_socket(
+                path, timeout=io_timeout(timeout), socket_options=socket_options
+            )
+        )
+
+    def sleep(self, seconds: float) -> None:
+        self.inner.sleep(seconds)
+
+
+class _Pool(Protocol):
+    _network_backend: NetworkBackend
+
+
+class _ClientTransports(Protocol):
+    _transport: httpx.BaseTransport
+    _mounts: dict[object, httpx.BaseTransport | None]
+
+
+def install_deadlines(client: httpx.Client) -> None:
+    """Adapt native pools, including environment and explicit proxy pools.
+
+    This is the sole boundary using transport internals. The underlying HTTP codec
+    caches the body timeout, so mutating the request timeout between chunks alone
+    does not bound slow responses. Native-codec tests verify this adapter against
+    the locked dependency. Injected transports can read request timeout extensions.
+    """
+    transports = cast(_ClientTransports, client)
+    for transport in (transports._transport, *transports._mounts.values()):
+        if isinstance(transport, httpx.HTTPTransport):
+            pool = cast(_Pool, transport._pool)
+            if not isinstance(pool._network_backend, _Backend):
+                pool._network_backend = _Backend(pool._network_backend)
+
+
+def read_response(
+    response: httpx.Response, request: httpx.Request, deadline: Deadline
+) -> httpx.Response:
+    if response.is_stream_consumed:
+        return response
+    timeouts = cast(dict[str, float | None], request.extensions["timeout"])
+    chunks = []
+    for chunk in response.iter_raw():
+        chunks.append(chunk)
+        # Do not raise after a received chunk: it may be the last one. A next
+        # network read is where expiry becomes a transport failure.
+        timeouts["read"] = deadline.remaining()
+    return httpx.Response(
+        response.status_code,
+        headers=response.headers,
+        content=b"".join(chunks),
+        request=request,
+    )

exchangerate_dev-0.1.0/src/exchangerate_dev/_decode.py

@@ -0,0 +1,67 @@
+"""Strict wire primitives used by generated decoders."""
+
+import json
+import re
+from decimal import Decimal
+from typing import cast
+
+
+def read_object(value: object) -> dict[str, object]:
+    if not isinstance(value, dict) or any(not isinstance(k, str) for k in value):
+        raise ValueError("expected an object")
+    return cast(dict[str, object], value)
+
+
+def read_list(value: object) -> list[object]:
+    if not isinstance(value, list):
+        raise TypeError("expected an array")
+    return cast(list[object], value)
+
+
+def read_str(value: object) -> str:
+    if not isinstance(value, str):
+        raise TypeError("expected a string")
+    return value
+
+
+def read_int(value: object) -> int:
+    if type(value) is not int:
+        raise ValueError("expected an integer")
+    return value
+
+
+def read_bool(value: object) -> bool:
+    if not isinstance(value, bool):
+        raise TypeError("expected a boolean")
+    return value
+
+
+def read_decimal(value: object) -> Decimal:
+    text = read_str(value)
+    if re.fullmatch(r"-?\d+(\.\d+)?", text, re.ASCII) is None:
+        raise ValueError("expected a decimal wire string")
+    return Decimal(text)
+
+
+def read_decimal_number(value: object) -> Decimal:
+    """A decimal sent as a JSON number; `read_json` keeps its literal as a Decimal."""
+    if isinstance(value, bool) or not isinstance(value, (int, Decimal)):
+        raise TypeError("expected a JSON number")
+    if isinstance(value, Decimal) and not value.is_finite():
+        raise ValueError("expected a finite JSON number")
+    return Decimal(value)
+
+
+def reject_number(value: str) -> object:
+    raise ValueError("unexpected non-finite JSON number")
+
+
+def read_json(raw: bytes) -> object:
+    return json.loads(raw, parse_float=Decimal, parse_constant=reject_number)
+
+
+def read_cursor(value: object) -> str:
+    cursor = read_str(value)
+    if not cursor:
+        raise ValueError("next_cursor must not be empty")
+    return cursor

exchangerate_dev-0.1.0/src/exchangerate_dev/_generated/__init__.py

@@ -0,0 +1,2 @@
+# Generated from spec/exchangerate/live/openapi.json sha256 6062a9cab89641865dd0d1ce764c5f89e54b11901602b41231f8dae9987ba773. Do not edit.
+"""Generated contract surface."""