econdash 0.1.0__py3-none-any.whl

econdash/__init__.py

@@ -0,0 +1,40 @@
+"""Python client for the EconDash macroeconomic data API (https://econdash.org)."""
+
+__version__ = "0.1.0"
+
+from ._client import DEFAULT_BASE_URL, AsyncEconDash, EconDash  # noqa: E402
+from .errors import (  # noqa: E402
+    EconDashAuthError,
+    EconDashError,
+    EconDashNotFound,
+    EconDashPaymentRequired,
+    EconDashRateLimitError,
+)
+from .models import (  # noqa: E402
+    Citation,
+    Country,
+    Indicator,
+    Point,
+    Series,
+    TopCountries,
+    TopCountry,
+)
+
+__all__ = [
+    "DEFAULT_BASE_URL",
+    "AsyncEconDash",
+    "Citation",
+    "Country",
+    "EconDash",
+    "EconDashAuthError",
+    "EconDashError",
+    "EconDashNotFound",
+    "EconDashPaymentRequired",
+    "EconDashRateLimitError",
+    "Indicator",
+    "Point",
+    "Series",
+    "TopCountries",
+    "TopCountry",
+    "__version__",
+]

econdash/_client.py

@@ -0,0 +1,349 @@
+from __future__ import annotations
+
+import base64
+import json
+import os
+from datetime import date
+from typing import Any, TypeVar
+
+import httpx
+from pydantic import BaseModel, TypeAdapter
+
+from . import __version__
+from .errors import (
+    EconDashAuthError,
+    EconDashError,
+    EconDashNotFound,
+    EconDashPaymentRequired,
+    EconDashRateLimitError,
+)
+from .models import Citation, Country, Indicator, Series, TopCountries
+
+DEFAULT_BASE_URL = "https://econdash.org/api/v1"
+M = TypeVar("M", bound=BaseModel)
+DateLike = str | int | date
+
+
+def _date(value: DateLike | None, *, end: bool) -> str | None:
+    """'2000' -> 2000-01-01 (start) / 2000-12-31 (end); '2000-06' -> month bounds."""
+    if value is None:
+        return None
+    if isinstance(value, date):
+        return value.isoformat()
+    s = str(value)
+    if len(s) == 4 and s.isdigit():
+        return f"{s}-12-31" if end else f"{s}-01-01"
+    if len(s) == 7:
+        if not end:
+            return f"{s}-01"
+        y, m = int(s[:4]), int(s[5:])
+        nxt = date(y + m // 12, m % 12 + 1, 1)
+        return date.fromordinal(nxt.toordinal() - 1).isoformat()
+    return date.fromisoformat(s).isoformat()
+
+
+def _is_code(indicator: str) -> bool:
+    # Codes look like "world_bank__gdp_nominal", slugs like "gdp-nominal".
+    return "__" in indicator
+
+
+def _search(indicators: list[Indicator], query: str, limit: int) -> list[Indicator]:
+    words = query.lower().split()
+    hits = []
+    for ind in indicators:
+        hay = " ".join(
+            x or ""
+            for x in (
+                ind.name_en,
+                ind.name_ru,
+                ind.slug,
+                ind.code,
+                ind.category,
+                ind.source,
+                ind.description,
+            )
+        ).lower()
+        if all(w in hay for w in words):
+            hits.append(ind)
+    q = query.lower()
+    hits.sort(key=lambda i: (q not in (i.name_en or "").lower(), -i.data_points))
+    return hits[:limit]
+
+
+def _payment_required(resp: httpx.Response, message: str) -> EconDashPaymentRequired:
+    challenge = None
+    raw = resp.headers.get("payment-required")
+    if raw:
+        try:
+            challenge = json.loads(base64.b64decode(raw))
+        except ValueError:
+            challenge = None
+    return EconDashPaymentRequired(
+        message,
+        challenge=challenge,
+        www_authenticate=resp.headers.get_list("www-authenticate"),
+        status_code=402,
+        body=_body(resp),
+    )
+
+
+def _body(resp: httpx.Response) -> Any:
+    try:
+        return resp.json()
+    except ValueError:
+        return resp.text
+
+
+def _check(resp: httpx.Response) -> Any:
+    if resp.is_success:
+        return resp.json()
+    body = _body(resp)
+    detail = body.get("detail") if isinstance(body, dict) else None
+    msg = f"{resp.status_code}: {detail or body}"
+    code = resp.status_code
+    if code == 402:
+        raise _payment_required(resp, msg)
+    if code in (401, 403):
+        raise EconDashAuthError(msg, status_code=code, body=body)
+    if code == 404:
+        raise EconDashNotFound(msg, status_code=code, body=body)
+    if code == 429:
+        ra = resp.headers.get("retry-after")
+        raise EconDashRateLimitError(
+            msg, retry_after=int(ra) if ra and ra.isdigit() else None, status_code=code, body=body
+        )
+    raise EconDashError(msg, status_code=code, body=body)
+
+
+def _x402_client(signer: Any, max_usd_per_call: float, sync: bool) -> Any:
+    try:
+        from x402 import x402Client, x402ClientSync
+        from x402.http import x402HTTPClient, x402HTTPClientSync
+        from x402.mechanisms.evm.exact import register_exact_evm_client
+    except ImportError as e:  # pragma: no cover
+        raise ImportError("x402 payments need the extra: pip install 'econdash[x402]'") from e
+    client: Any = x402ClientSync() if sync else x402Client()
+    register_exact_evm_client(client, signer)
+    # x402 refuses to sign anything above this cap; nothing is paid then.
+    client.set_spend_controls({"max_amount_per_payment": f"${max_usd_per_call}"})
+    return x402HTTPClientSync(client) if sync else x402HTTPClient(client)
+
+
+class _Base:
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        pay_with_x402: bool = False,
+        x402_signer: Any = None,
+        max_usd_per_call: float | None = None,
+    ) -> None:
+        self.api_key = api_key or os.environ.get("ECONDASH_API_KEY") or None
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.headers = {"User-Agent": f"econdash-python/{__version__}"}
+        if self.api_key:
+            self.headers["Authorization"] = f"Bearer {self.api_key}"
+        if pay_with_x402 and (x402_signer is None or not max_usd_per_call):
+            raise ValueError("pay_with_x402=True needs x402_signer and max_usd_per_call")
+        self.pay_with_x402 = pay_with_x402
+        self._x402_signer = x402_signer
+        self._max_usd = max_usd_per_call or 0.0
+        # Paid (x402) access lives under /m2m; plain /api/v1 answers trial limits, not 402.
+        self._data = self.base_url + ("/m2m" if pay_with_x402 else "")
+        self._indicators: list[Indicator] | None = None
+        self._codes: dict[str, str] = {}
+
+    def _x402_for(self, sync: bool) -> Any:
+        if not self.pay_with_x402:
+            return None
+        return _x402_client(self._x402_signer, self._max_usd, sync=sync)
+
+    def _remember(self, ind: Indicator) -> Indicator:
+        if ind.slug:
+            self._codes[ind.slug] = ind.code
+        return ind
+
+    @staticmethod
+    def _one(model: type[M], data: Any) -> M:
+        return model.model_validate(data)
+
+    @staticmethod
+    def _many(model: type[M], data: Any) -> list[M]:
+        return TypeAdapter(list[model]).validate_python(data)  # type: ignore[valid-type]
+
+    def _series_params(
+        self, country: str, start: DateLike | None, end: DateLike | None
+    ) -> dict[str, str]:
+        params = {"country": country.upper()}
+        if (s := _date(start, end=False)) is not None:
+            params["start_date"] = s
+        if (e := _date(end, end=True)) is not None:
+            params["end_date"] = e
+        return params
+
+
+class EconDash(_Base):
+    """Synchronous client.
+
+    >>> ed = EconDash()                      # trial, or ECONDASH_API_KEY from env
+    >>> ed.get_series("gdp-nominal", "USA", start=2000).data[-1].value
+    """
+
+    def __init__(self, api_key: str | None = None, **kw: Any) -> None:
+        super().__init__(api_key, **kw)
+        self._http = httpx.Client(headers=self.headers, timeout=self.timeout)
+        self._x402 = self._x402_for(sync=True)
+
+    def __enter__(self) -> EconDash:
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()
+
+    def close(self) -> None:
+        self._http.close()
+
+    def _get(self, url: str, params: dict[str, Any] | None = None) -> Any:
+        resp = self._http.get(url, params=params)
+        if resp.status_code == 402 and self._x402 is not None:
+            try:
+                pay, _ = self._x402.handle_402_response(
+                    dict(resp.headers), resp.content, str(resp.request.url)
+                )
+            except Exception as e:
+                raise _payment_required(resp, f"x402 payment not made: {e}") from e
+            resp = self._http.get(url, params=params, headers=pay)
+        return _check(resp)
+
+    def _code(self, indicator: str) -> str:
+        if _is_code(indicator):
+            return indicator
+        if indicator not in self._codes:
+            self.get_indicator(indicator)
+        return self._codes[indicator]
+
+    def list_indicators(self) -> list[Indicator]:
+        """All active indicators (cached per client)."""
+        if self._indicators is None:
+            data = self._get(f"{self._data}/indicators", {"limit": 1200})
+            self._indicators = [self._remember(i) for i in self._many(Indicator, data)]
+        return self._indicators
+
+    def search_indicators(self, query: str, *, limit: int = 20) -> list[Indicator]:
+        """Case-insensitive search over names, slugs, codes, categories and sources."""
+        return _search(self.list_indicators(), query, limit)
+
+    def get_indicator(self, indicator: str) -> Indicator:
+        """Metadata by slug ("gdp-nominal") or code ("world_bank__gdp_nominal")."""
+        path = indicator if _is_code(indicator) else f"by-slug/{indicator}"
+        return self._remember(self._one(Indicator, self._get(f"{self._data}/indicators/{path}")))
+
+    def get_series(
+        self,
+        indicator: str,
+        country: str,
+        *,
+        start: DateLike | None = None,
+        end: DateLike | None = None,
+    ) -> Series:
+        """Time series for one country. `start`/`end`: 2000, "2000-06" or "2000-06-30"."""
+        url = f"{self._data}/timeseries/{self._code(indicator)}"
+        return self._one(Series, self._get(url, self._series_params(country, start, end)))
+
+    def list_countries(self) -> list[Country]:
+        return self._many(Country, self._get(f"{self._data}/countries"))
+
+    def top_countries(
+        self, indicator: str, *, year: int | None = None, limit: int = 10
+    ) -> TopCountries:
+        """Ranking by the latest value (or by `year`). Includes aggregates like WLD."""
+        params: dict[str, Any] = {"limit": limit}
+        if year is not None:
+            params["year"] = year
+        url = f"{self._data}/timeseries/{self._code(indicator)}/top-countries"
+        return self._one(TopCountries, self._get(url, params))
+
+    def cite(self, indicator: str, country: str) -> Citation:
+        """Latest value with ready citation strings (text, short, markdown). Free endpoint."""
+        return self._one(Citation, self._get(f"{self.base_url}/cite/{country}/{indicator}"))
+
+
+class AsyncEconDash(_Base):
+    """Asynchronous client with the same methods as `EconDash`, all awaitable."""
+
+    def __init__(self, api_key: str | None = None, **kw: Any) -> None:
+        super().__init__(api_key, **kw)
+        self._http = httpx.AsyncClient(headers=self.headers, timeout=self.timeout)
+        self._x402 = self._x402_for(sync=False)
+
+    async def __aenter__(self) -> AsyncEconDash:
+        return self
+
+    async def __aexit__(self, *exc: object) -> None:
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        await self._http.aclose()
+
+    async def _get(self, url: str, params: dict[str, Any] | None = None) -> Any:
+        resp = await self._http.get(url, params=params)
+        if resp.status_code == 402 and self._x402 is not None:
+            try:
+                pay, _ = await self._x402.handle_402_response(
+                    dict(resp.headers), resp.content, str(resp.request.url)
+                )
+            except Exception as e:
+                raise _payment_required(resp, f"x402 payment not made: {e}") from e
+            resp = await self._http.get(url, params=params, headers=pay)
+        return _check(resp)
+
+    async def _code(self, indicator: str) -> str:
+        if _is_code(indicator):
+            return indicator
+        if indicator not in self._codes:
+            await self.get_indicator(indicator)
+        return self._codes[indicator]
+
+    async def list_indicators(self) -> list[Indicator]:
+        if self._indicators is None:
+            data = await self._get(f"{self._data}/indicators", {"limit": 1200})
+            self._indicators = [self._remember(i) for i in self._many(Indicator, data)]
+        return self._indicators
+
+    async def search_indicators(self, query: str, *, limit: int = 20) -> list[Indicator]:
+        return _search(await self.list_indicators(), query, limit)
+
+    async def get_indicator(self, indicator: str) -> Indicator:
+        path = indicator if _is_code(indicator) else f"by-slug/{indicator}"
+        data = await self._get(f"{self._data}/indicators/{path}")
+        return self._remember(self._one(Indicator, data))
+
+    async def get_series(
+        self,
+        indicator: str,
+        country: str,
+        *,
+        start: DateLike | None = None,
+        end: DateLike | None = None,
+    ) -> Series:
+        url = f"{self._data}/timeseries/{await self._code(indicator)}"
+        return self._one(Series, await self._get(url, self._series_params(country, start, end)))
+
+    async def list_countries(self) -> list[Country]:
+        return self._many(Country, await self._get(f"{self._data}/countries"))
+
+    async def top_countries(
+        self, indicator: str, *, year: int | None = None, limit: int = 10
+    ) -> TopCountries:
+        params: dict[str, Any] = {"limit": limit}
+        if year is not None:
+            params["year"] = year
+        url = f"{self._data}/timeseries/{await self._code(indicator)}/top-countries"
+        return self._one(TopCountries, await self._get(url, params))
+
+    async def cite(self, indicator: str, country: str) -> Citation:
+        data = await self._get(f"{self.base_url}/cite/{country}/{indicator}")
+        return self._one(Citation, data)

econdash/errors.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class EconDashError(Exception):
+    """Base class. `status_code` and `body` carry the raw API answer."""
+
+    def __init__(self, message: str, *, status_code: int | None = None, body: Any = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.body = body
+
+
+class EconDashAuthError(EconDashError):
+    """401/403: bad API key, inactive subscription, or data outside the free trial."""
+
+
+class EconDashNotFound(EconDashError):
+    """404: unknown indicator, country or series."""
+
+
+class EconDashRateLimitError(EconDashError):
+    """429: trial or key quota exhausted. `retry_after` is in seconds."""
+
+    def __init__(self, message: str, *, retry_after: int | None = None, **kw: Any) -> None:
+        super().__init__(message, **kw)
+        self.retry_after = retry_after
+
+
+class EconDashPaymentRequired(EconDashError):
+    """402: the call needs payment. `challenge` is the decoded x402 PAYMENT-REQUIRED
+    object, `www_authenticate` the raw MPP challenges. Nothing was paid."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        challenge: dict[str, Any] | None = None,
+        www_authenticate: list[str] | None = None,
+        **kw: Any,
+    ) -> None:
+        super().__init__(message, **kw)
+        self.challenge = challenge
+        self.www_authenticate = www_authenticate or []

econdash/models.py

@@ -0,0 +1,132 @@
+"""Response models. Field names and types follow the EconDash API schema
+(`IndicatorResponse`, `TimeSeriesResponse`, `CountryResponse`, ... in the backend OpenAPI).
+Unknown fields are ignored, so new API fields never break old clients."""
+
+from __future__ import annotations
+
+from datetime import date
+
+from pydantic import BaseModel
+
+
+class Indicator(BaseModel):
+    code: str
+    slug: str | None
+    name_ru: str
+    name_en: str | None
+    category: str | None
+    source: str | None
+    unit: str | None
+    fetch_method: str | None
+    data_points: int = 0
+    description: str | None = None
+    updated_at: str | None = None
+    frequency: str | None = None
+    first_observation: str | None = None
+    last_observation: str | None = None
+    data_changed_at: str | None = None
+    data_checked_at: str | None = None
+    source_series_id: str | None = None
+    source_url: str | None = None
+    source_url_template: str | None = None
+    source_publisher: str | None = None
+    license_name: str | None = None
+    license_url: str | None = None
+    attribution_text: str | None = None
+    is_based_on: list[str] | None = None
+
+    @property
+    def name(self) -> str:
+        return self.name_en or self.name_ru
+
+    @property
+    def url(self) -> str | None:
+        """Chart hub page on econdash.org."""
+        return f"https://econdash.org/chart/{self.slug}" if self.slug else None
+
+
+class Point(BaseModel):
+    date: date
+    value: float
+    country: str
+    country_name: str | None = None
+    is_projection: bool | None = None
+
+
+class Series(BaseModel):
+    indicator_code: str
+    indicator_name_ru: str
+    indicator_name_en: str | None
+    unit: str | None
+    frequency: str | None = None
+    first_observation: str | None = None
+    last_observation: str | None = None
+    data_points: int | None = None
+    data_changed_at: str | None = None
+    data_checked_at: str | None = None
+    data: list[Point]
+
+
+class Country(BaseModel):
+    iso3_code: str
+    iso2_code: str | None
+    name: str
+    region: str | None
+    income_level: str | None
+    data_points: int = 0
+
+
+class TopCountry(BaseModel):
+    iso3_code: str
+    country_name: str | None
+    value: float
+    date: date
+    yoy_change_pct: float | None = None
+
+
+class TopCountries(BaseModel):
+    indicator_code: str
+    unit: str | None
+    data: list[TopCountry]
+
+
+class CiteSource(BaseModel):
+    name: str
+    acronym: str | None = None
+    url: str | None = None
+    release_date: str | None = None
+
+
+class CitationStrings(BaseModel):
+    text: str
+    short: str
+    markdown: str
+
+
+class CiteMeta(BaseModel):
+    updated_at: str
+    next_update: str | None = None
+    frequency: str | None = None
+    canonical_url: str
+
+
+class Citation(BaseModel):
+    type: str = "economic_indicator"
+    indicator: str
+    indicator_name: str
+    country: str
+    country_name: str
+    value: float
+    unit: str
+    change: str | None = None
+    period: str
+    previous_value: float | None = None
+    previous_period: str | None = None
+    trend: str | None = None
+    trend_magnitude: float | None = None
+    definition: str | None = None
+    source: CiteSource
+    citation: CitationStrings
+    meta: CiteMeta
+    is_projection: bool = False
+    projection_label: str | None = None

econdash-0.1.0.dist-info/METADATA

@@ -0,0 +1,162 @@
+Metadata-Version: 2.5
+Name: econdash
+Version: 0.1.0
+Summary: Python client for the EconDash macroeconomic data API: 750+ indicators, 290+ countries, sources and licences.
+Project-URL: Homepage, https://econdash.org
+Project-URL: Documentation, https://econdash.org/docs/python
+Project-URL: Repository, https://github.com/econdash/econdash-python
+Project-URL: Issues, https://github.com/econdash/econdash-python/issues
+Project-URL: Changelog, https://github.com/econdash/econdash-python/blob/main/CHANGELOG.md
+Author-email: EconDash <noderguru@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api,economics,gdp,imf,inflation,macroeconomics,time-series,world-bank,x402
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Office/Business :: Financial
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.5
+Provides-Extra: x402
+Requires-Dist: x402[evm]<3,>=2.25; extra == 'x402'
+Description-Content-Type: text/markdown
+
+# econdash
+
+[![PyPI](https://img.shields.io/pypi/v/econdash)](https://pypi.org/project/econdash/)
+[![CI](https://github.com/econdash/econdash-python/actions/workflows/ci.yml/badge.svg)](https://github.com/econdash/econdash-python/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/pypi/pyversions/econdash)](https://pypi.org/project/econdash/)
+
+Python client for the [EconDash](https://econdash.org) macroeconomic data API: 750+ indicators
+(GDP, inflation, debt, trade, labour, money supply, …) for 290+ countries and regions, with
+source, licence and freshness metadata for every series.
+
+```bash
+pip install econdash
+```
+
+```python
+from econdash import EconDash
+
+ed = EconDash()  # free trial, no key needed
+
+ed.search_indicators("inflation")[:3]  # -> list[Indicator]
+ed.get_indicator("gdp-nominal")  # metadata, source, licence, freshness
+s = ed.get_series("gdp-nominal", "USA", start=2000)
+s.data[-1]  # Point(date=2025-01-01, value=3.07e13, ...)
+ed.list_countries()  # -> list[Country]
+ed.top_countries("gdp-nominal", year=2024, limit=10)
+ed.cite(
+    "gdp-nominal", "USA"
+).citation.text  # 'United States GDP nominal was $30.77 tn in 2025 (World Bank, ...)'
+```
+
+Indicators can be addressed by slug (`gdp-nominal`, as in
+`econdash.org/chart/gdp-nominal/USA`) or by code (`world_bank__gdp_nominal`).
+`start`/`end` accept `2000`, `"2000-06"`, `"2000-06-30"` or a `date`.
+
+## Free trial vs API key
+
+Without a key the client works on the **free trial**:
+
+| Limit | Trial |
+|---|---|
+| Requests | 300 per day, 30 per minute (per IP) |
+| Countries | 10: USA, CHN, DEU, JPN, GBR, FRA, IND, BRA, RUS, KOR |
+| Indicators | 50 core series (GDP, CPI, money supply, debt, trade, …) |
+
+Outside the trial the API answers `403` and the client raises `EconDashAuthError`
+("Country ZWE not available in trial"). That is the trial limit, not a bug.
+
+For full access create a key at [econdash.org/dashboard/api-keys](https://econdash.org/dashboard/api-keys)
+([plans](https://econdash.org/api-access)) and pass it:
+
+```python
+ed = EconDash(api_key="ed_...")  # or set ECONDASH_API_KEY
+```
+
+## Async
+
+```python
+from econdash import AsyncEconDash
+
+async with AsyncEconDash() as ed:
+    series = await ed.get_series("cpi-inflation-rate-percent", "DEU", start=2010)
+```
+
+## Errors
+
+| Exception | When |
+|---|---|
+| `EconDashAuthError` | 401/403: bad key, inactive subscription, data outside the trial |
+| `EconDashNotFound` | 404: unknown indicator or country |
+| `EconDashRateLimitError` | 429, `retry_after` in seconds |
+| `EconDashPaymentRequired` | 402, `challenge` holds the x402 payment requirements |
+| `EconDashError` | base class, anything else |
+
+## Pay per call with x402 (for AI agents)
+
+Agents without an account can pay each call in USDC on Base via
+[x402](https://www.x402.org) ($0.02 per call at the time of writing). It is **off by
+default**: the client never spends money unless you turn it on and set a cap.
+
+```bash
+pip install "econdash[x402]"
+```
+
+```python
+import os
+
+from eth_account import Account
+from econdash import EconDash
+
+ed = EconDash(
+    pay_with_x402=True,
+    x402_signer=Account.from_key(os.environ["AGENT_PRIVATE_KEY"]),
+    max_usd_per_call=0.05,  # x402 refuses to sign anything more expensive
+)
+ed.get_series("gdp-nominal", "ZWE")
+```
+
+If the price is above `max_usd_per_call`, nothing is signed and `EconDashPaymentRequired`
+is raised. Keep agent wallets funded with small amounts only.
+
+## Examples
+
+Notebooks in [`examples/`](examples/): search → series → pandas chart, comparing countries,
+a LangChain agent, an agent paying with x402.
+
+## Data and licences
+
+Every `Indicator` carries `source`, `source_url`, `license_name`, `license_url` and
+`attribution_text`. Source licences differ (World Bank CC BY 4.0, IMF, OECD, FRED, …);
+see [econdash.org/data-license](https://econdash.org/data-license). Please keep the
+attribution when you publish charts or numbers.
+
+## Links
+
+- Website: <https://econdash.org>
+- API docs: <https://econdash.org/docs>, OpenAPI: <https://econdash.org/openapi.json>
+- Python docs: <https://econdash.org/docs/python>
+
+## Development
+
+```bash
+uv sync --all-extras
+uv run pytest            # offline tests on recorded API answers
+uv run pytest -m live    # contract tests against the real API
+uv run ruff check . && uv run mypy
+```
+
+Releases are published to PyPI from GitHub Actions on a GitHub Release (trusted publishing).
+
+MIT licence. The data itself is licensed by its original sources.

econdash-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+econdash/__init__.py,sha256=TW5KfoN0_RmanupFibPEuiQ1_AhEaHu9h-P3NFvJ_JE,820
+econdash/_client.py,sha256=kldWLfaBIiDc4hWA1sjsXWt2vf5phuQUwwQGG_ufxh0,13060
+econdash/errors.py,sha256=vih-ycvwhGCrptrczKFKLfdJRzvIM53bJ7rd-cuaxrc,1419
+econdash/models.py,sha256=B_DJVBBX48Ci_RL0LJwgEp5-h1_s3DsSBrc0-I94HsE,3258
+econdash/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+econdash-0.1.0.dist-info/METADATA,sha256=c3DqwiRHwDe-wMEMkCBDK8HewkffIpPLBotFilU-sXs,5925
+econdash-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+econdash-0.1.0.dist-info/licenses/LICENSE,sha256=OupCmP07CGvR28W_kudL9YPyrT_gBW09XduaA9eEkJc,1065
+econdash-0.1.0.dist-info/RECORD,,

econdash-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

econdash-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 EconDash
+
+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.