development-finance 0.1.0__py3-none-any.whl

development_finance-0.1.0.dist-info/METADATA

@@ -0,0 +1,307 @@
+Metadata-Version: 2.3
+Name: development-finance
+Version: 0.1.0
+Summary: Python client for the Development Finance Observatory APIs
+Keywords: development finance,ODA,aid,SDMX,Data Commons
+Author: ONE Campaign
+Author-email: ONE Campaign <data@one.org>
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: httpcore2>=2.15,<2.16 ; sys_platform != 'emscripten'
+Requires-Dist: httpx2>=2.15,<2.16
+Requires-Dist: pyarrow>=15
+Requires-Dist: typing-extensions>=4.12
+Requires-Dist: pandas>=2.2 ; extra == 'pandas'
+Requires-Dist: polars>=1.0 ; extra == 'polars'
+Requires-Dist: openpyxl>=3.1 ; extra == 'xlsx'
+Requires-Python: >=3.12
+Project-URL: Homepage, https://developmentfinance.org
+Project-URL: Repository, https://github.com/DevelopmentFinanceObservatory/sdk
+Project-URL: Issues, https://github.com/DevelopmentFinanceObservatory/sdk/issues
+Project-URL: Changelog, https://github.com/DevelopmentFinanceObservatory/sdk/blob/main/python/CHANGELOG.md
+Provides-Extra: pandas
+Provides-Extra: polars
+Provides-Extra: xlsx
+Description-Content-Type: text/markdown
+
+# development-finance
+
+Ask the Development Finance Observatory (DFO) a question about aid, debt, or development indicators in your own words, and get a versioned table back.
+
+```bash
+uv add "development-finance[pandas]"        # in a uv project
+pip install "development-finance[pandas]"   # with pip
+```
+
+```python
+import dfo
+
+answer = dfo.search("ODA from Germany to Nigeria")
+print(answer)
+data = answer.fetch()
+df = data.to_pandas()
+
+growth = dfo.analysis.growth(data, window=(2015, 2024))
+share = dfo.share(dfo.cards.line(data, title="German ODA to Nigeria"), latest=True)
+print(share.url)
+```
+
+```text
+Germany's gross disbursements to Nigeria for official development assistance, 1960 to 2024. Current US dollars · OECD DAC2a.
+  Fetch: answer.fetch()
+https://developmentfinance.org/s/k3Qx8vTa
+```
+
+`dfo.analysis.growth` computes the change from 2015 to 2024 on DFO, as a fraction where 0.25 is a 25% rise. `dfo.share` publishes a line chart of the data at a public URL that anyone with the link can open, and follows new data.
+
+The package imports as `dfo` and needs Python 3.12 or later. It works without a key, under a per-IP quota. The table arrives as Arrow. The `pandas` extra adds `to_pandas()`, `polars` adds `to_polars()`, and `xlsx` lets `dfo.load` open an XLSX bundle from the website.
+
+The code blocks on this page run in order, as cells of one notebook.
+
+## Ask a question and read the answer
+
+`dfo.search` returns an `Answer`, which says what DFO understood and holds no data yet. Printing it shows Search's sentence, naming the measure, places, years, unit, and source, and the line to type next. Read the sentence before you fetch. Search is model-driven, and a wrong reading gives a plausible table for the wrong question.
+
+`answer.fetch()` builds the table on the server, downloads it, and checks the file against its digest. Printing the dataset shows what it is, how big, and how to keep it:
+
+```text
+<Dataset Germany's gross disbursements to Nigeria for official development assistance, 1960 to 2024. Current US dollars · OECD DAC2a.
+  Source: OECD DAC2A
+  Version: cv_1145ade0abb33920fefaf5daaeb8f3a9 (exact), held until 24 November 2026, not pinned
+  Rows: 65
+  Keep: data.save(path) · newest later: dfo.fetch(data.ref, latest=True)>
+    time_period financingProvider_label financingRecipient_label        value
+60         2020                 Germany                  Nigeria  123608639.0
+61         2021                 Germany                  Nigeria  164254178.0
+62         2022                 Germany                  Nigeria  122707200.0
+63         2023                 Germany                  Nigeria  126863832.0
+64         2024                 Germany                  Nigeria  100707102.0
+```
+
+```python
+import dfo
+
+answer = dfo.search("ODA from Germany to Nigeria")
+data = answer.fetch()
+print(data)
+
+df = data.to_pandas()
+print(df.iloc[:, :4].tail())
+```
+
+The `_label` columns of names come first, covering the year, the parties, the value, and its unit. The other columns follow, codes included, with those that tell the rows apart before those that hold one value throughout, and `stat_var` last. The years of each series read in order. `len(data)` is the row count, `data.to_polars()` gives a polars frame, and `pyarrow.table(data)` gives an Arrow table. While a build runs on the server, `fetch` shows its progress in a terminal or notebook. [Long builds](docs/long-builds.md) covers waiting, timeouts, and Ctrl-C.
+
+## Choose a reading
+
+Some questions have more than one reading. "government education spending Kenya" can mean a share of the budget or a share of GDP, and the answer lists both with the line that settles it:
+
+```text
+Answered 0 of 1 part of your question.
+  missing  "government education spending": 2 readings
+    [0] Kenya's percent of total government expenditure on education, 1980 to 2025 · World Development Indicators
+    [1] Kenya's percent of nominal GDP spent on education, 1971 to 2024 · World Development Indicators
+  Choose: answer.choose(0).fetch()
+Kenya's percent of total government expenditure on education, 1980 to 2025. World Development Indicators.
+```
+
+```python
+answer = dfo.search("government education spending Kenya")
+print(answer)
+
+data = answer.choose(0).fetch()
+print(data.sentence)
+```
+
+`choose` takes the option's index or its full label, and makes one Search request. The new answer and its sentence are Search's. The order of readings can change between searches, so a script that runs again later keeps `data.ref` and fetches that. A place that matches several countries, such as "Congo", is settled the same way, with `answer.choose("Congo [DRC]")`. [Answers and choices](docs/answers.md) covers questions with several parts and answers that leave a part out.
+
+## Fetch other years or places
+
+The simplest way is to put the years and places in the question:
+
+```text
+Germany's gross disbursements to Ghana and Kenya for official development assistance, 2015 to 2022. Current US dollars · OECD DAC2a.
+  Fetch: answer.fetch()
+```
+
+```python
+answer = dfo.search("ODA from Germany to Kenya and Ghana, 2015 to 2022")
+print(answer)
+```
+
+To vary a reading you already have without a new search, pass its spec to `dfo.fetch` with `window` and `entities`. `window` takes `(start_year, end_year)` with years from 1000 to 2200, `"latest"`, or `"all"`. `entities` maps each role the spec names to place codes, keyed `place` for the place a measure is about and `origin` and `destination` for a flow, and `spec.roles` lists those roles with the places each binds, or None for a role left open. `answer.fetch` takes the same arguments and narrows every reading in the answer:
+
+```text
+<Dataset Germany's gross disbursements to Ghana and Kenya for official development assistance, 2015 to 2022. Current US dollars · OECD DAC2a.
+  Source: OECD DAC2A
+  Version: cv_6cdec57990a5712642ad97ab58d9ea21 (exact), held until 24 November 2026, not pinned
+  Rows: 16
+  Keep: data.save(path) · newest later: dfo.fetch(data.ref, latest=True)>
+```
+
+```python
+spec = dfo.search("ODA from Germany to Nigeria").specs[0]
+print(spec.roles)
+# {'destination': ('country/NGA',), 'origin': ('country/DEU',)}
+
+data = dfo.fetch(
+    spec,
+    window=(2015, 2022),
+    entities={"destination": ["country/KEN", "country/GHA"]},
+)
+print(data)
+```
+
+[Look up a place code](#look-up-a-place-code) finds the code for a name. [Datasets and versions](docs/datasets.md) covers `facets` and the frame layout.
+
+## Keep group and total rows
+
+A table of flows leaves out the rows for groups and totals, such as "DAC countries" or "official donors (DAC)", so a sum over it counts each donor once. Pass `party_totals=True` to keep them. For ODA to Ethiopia in 2022, the default table has 95 rows, one per donor, and the full one has 110:
+
+```python
+answer = dfo.search("ODA to Ethiopia in 2022 by donor")
+by_donor = answer.fetch()
+with_totals = answer.fetch(party_totals=True)
+
+print(len(by_donor), len(with_totals))  # 95 110
+print(with_totals.to_pandas()["financingProvider_kind"].value_counts())
+```
+
+```text
+financingProvider_kind
+official       72
+private        23
+total          13
+whole total     2
+Name: count, dtype: int64
+```
+
+`financingProvider_kind` tells the rows apart: `official` and `private` for one donor, `total` for a group, and `whole total` for the source's figure across every donor. Both fetches issue a `SearchWarning` that no donor was named, which is the reading wanted here. `dfo.fetch(spec, party_totals=True)` does the same for a spec.
+
+## Save the data and load it later
+
+`data.save(path)` writes one Parquet file that carries the table, the citation, and the ref. `dfo.load(path)` reads it back offline:
+
+```python
+data = dfo.search("Kenya's external debt service").fetch()
+data.save("kenya-debt.parquet")
+
+saved = dfo.load("kenya-debt.parquet")
+print(saved.ref == data.ref, len(saved))  # True 55
+print(saved.citation.text)
+```
+
+The file is the record of what you analysed. The Parquet file reads in any Arrow tool, and its provenance sits in the file's metadata under `dfo.*` keys.
+
+## Refresh later and tell if the data changed
+
+`data.ref` names the exact version a dataset holds. `dfo.fetch(ref)` returns those rows again, and `dfo.fetch(ref, latest=True)` builds the newest version of the same reading. Two refs are equal when they name the same versions:
+
+```python
+old = dfo.load("kenya-debt.parquet")
+new = dfo.fetch(old.ref, latest=True)
+
+if new.ref != old.ref:
+    print("DFO's data has changed since you saved it")
+    new.save("kenya-debt.parquet")
+```
+
+A version marked "held until" in the dataset's display can be fetched by its ref until that date, and one marked "pinned" is kept without a limit. The saved file keeps its rows either way. [Datasets and versions](docs/datasets.md) covers refs and retention.
+
+## Share an answer
+
+`answer.to_json()` writes the answer as JSON, and `dfo.Answer.from_json(text)` reads it back, ready to choose and fetch. A web app uses this to show the readings on one request and build the reader's choice on the next:
+
+```python
+answer = dfo.search("government education spending Kenya")
+text = answer.to_json()
+
+restored = dfo.Answer.from_json(text)
+data = restored.choose(1).fetch()
+print(data.sentence)
+```
+
+Answer JSON that comes back from a browser can carry any reading, and its build runs on your key. [Answers and choices](docs/answers.md) says how to keep a web app safe with it.
+
+## Look up a place code
+
+`dfo.lookup.resolve` turns names into the codes `entities` takes. It returns one `Match` per name, which prints what the name resolved to. A name that matches several places lists them, and a misspelt name names the nearest:
+
+```python
+for match in dfo.lookup.resolve("Nigeria", "Congo", "Germny"):
+    print(match)
+```
+
+```text
+Nigeria -> Nigeria  country/NGA  (country)
+Congo -> ambiguous: Congo [DRC]  country/COD | Congo [Republic]  country/COG
+Germny -> not found; nearest: Germany  country/DEU
+```
+
+`match.entity.dcid` holds the code of a resolved name, `match.candidates` the places an ambiguous one could mean, and `match.near_matches` the nearest spellings. `match.raw` keeps the server's result. `resolve` also takes `kinds`, such as `["country"]`, to limit the node kinds a name may match, `code_system` with `kinds=["code"]` to match one code system's codes, such as `CRSPurposeCodeEnum`, and `expand_members=True` to inline each group's members. `dfo.lookup.node("country/NGA")` returns one place, with the regions it belongs to in `node.raw`, and `as_of=` reads the graph on a past date. `dfo.lookup.code("spec_not_found")` explains a code from an error, and `dfo.lookup.catalogue()` lists what Search holds data on, with example questions. The result types live in `dfo.types`.
+
+## Settings, keys, and errors
+
+`dfo.search` and `dfo.fetch` use a default client that reads `DFO_BASE_URL` and your stored key. `dfo.Client` carries the same calls with its own settings, and closes its connections on exit:
+
+```python
+with dfo.Client(timeout=60.0, max_retries=3) as client:
+    data = client.search("Kenya's external debt service").fetch()
+    print(len(data))
+```
+
+`Client` takes `api_key`, `base_url`, `timeout` (one request attempt, 30 seconds by default), `max_retries` (0 to 10, default 2), `cache_dir`, `cache`, `headers`, and `header_provider`. `dfo.configure(...)` takes the same options and replaces the default client. `dfo.AsyncClient` has the same methods as coroutines. `client.lookup` holds the lookups. `client.with_options(timeout=..., max_retries=...)` returns a copy with other limits that shares the client's connections and cache.
+
+Run `dfo auth login` to store a key, and `dfo auth status` to see which key the client sends. [Keys and credentials](docs/keys.md) covers the lookup order.
+
+Every error derives from `dfo.errors.DfoError`, carries a `code`, and ends its message with `[code]`, or `[code · trace id]` when a response carried one. A refusal names the fix, such as the call that settles an incomplete answer. [Errors](docs/errors.md) lists every class by what you do next. The types answers and datasets contain live in `dfo.types`.
+
+## Limits the client enforces
+
+The Python and TypeScript clients both apply these limits. The constant names are those in the Python source.
+
+| Rule                | Value                                                                                                                                                                                                                                           |
+| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Retry-After` parse | ASCII digits (seconds) or an IMF-fixdate such as `Sun, 06 Nov 1994 08:49:37 GMT`. Any other value is ignored, and the client's own backoff applies. A date in the past means 0                                                                  |
+| `Retry-After` wait  | The client waits when the value is at most 60 s (`RETRY_AFTER_MAX_S`) and fits the time left before the call's deadline. Otherwise it raises the refusal's typed error at once with `retry_after` set                                           |
+| Poll interval       | The server's value, or a refused poll's `Retry-After`, clamped to 1 s (`POLL_INTERVAL_MIN_S`) to 60 s (`POLL_INTERVAL_MAX_S`), then to the time left before the deadline, where the client polls once more                                      |
+| Versions walk       | Pages of 100 versions, at most 20 pages (`VERSIONS_PAGE_BUDGET`). A page cursor seen before raises `contract_violation`. Over the budget, no newest version is reported                                                                         |
+| Body size           | Decoded bytes are counted while the body streams, and the read stops at the limit with `response_too_large`. A file's limit is its manifest's `bytes`, else 2 GiB (`DOWNLOAD_MAX_BYTES`). A JSON body's limit is 16 MiB (`JSON_BODY_MAX_BYTES`) |
+| Keys                | Visible ASCII only, 0x21 to 0x7E. The key-format check (prefix, base62, checksum) only warns                                                                                                                                                    |
+| Header values       | Visible ASCII, space, and tab. A control character, DEL, or a non-ASCII character raises `header_invalid`                                                                                                                                       |
+| `timeout`           | A finite number above 0. A call's own `timeout` bounds the whole call (60 seconds for `search`, and no limit for `fetch` unless you pass one)                                                                                                   |
+| `max_retries`       | An integer from 0 to 10. A bool is refused                                                                                                                                                                                                      |
+| Error messages      | Name the source and the position of the offending character, and leave the key or header value out                                                                                                                                              |
+
+A key travels only to an https base URL, or to a loopback one over http: `localhost`, a name under `.localhost`, an address in 127.0.0.0/8 written as four decimal numbers, or `[::1]`. Any other plain-http base URL with a key raises `insecure_transport`. In synchronous code, platform name resolution can run past a deadline, and the asynchronous client can cancel it.
+
+A process forked from a threaded parent keeps the default client and the proxy settings the parent resolved. A client the child builds for itself reads the platform's proxy settings in the child, which can crash a macOS child forked from a process with running threads. Build the client in the parent, or start workers with `spawn`.
+
+The TypeScript client follows the same contract. It spells "no limit" as `Infinity` where Python uses `None`, decodes a Parquet file's row values on first use where Python decodes them when `fetch` returns, and writes refs without spaces after separators. Each client reads the other's refs.
+
+## Documentation
+
+- [Answers and choices](docs/answers.md): parts, readings, `choose`, partial fetches, shared answers, and declined questions.
+- [Datasets and versions](docs/datasets.md): narrowing a fetch, layouts, conversions, refs, retention, `save`, and `load`.
+- [Long builds](docs/long-builds.md): progress, deadlines, and what Ctrl-C leaves running.
+- [Compute a figure on DFO](docs/compute.md): `dfo.analysis`, recipes, `latest_year`, recomputing on new data, and the series an operation leaves out.
+- [Cards and shares](docs/shares.md): charts, tables and headline numbers, public share links, write tokens, snapshots, and what a share showed on a date.
+- [Errors](docs/errors.md): every error class and code, by what you do next.
+- [Keys and credentials](docs/keys.md): the key lookup order, `dfo auth login`, and the credentials file.
+- [The cache](docs/cache.md): where downloads go, `DFO_OFFLINE`, and stale reads.
+
+[llms.txt](llms.txt) summarises the package for language models.
+
+## Development
+
+The repository root holds the contract, the pre-commit configuration, and the CI workflows, and [`CONTRIBUTING.md`](../CONTRIBUTING.md) there explains them. From this directory:
+
+```bash
+uv sync
+uv run pytest
+uv run ruff check
+uv run ruff format --check
+uv run ty check
+```

development_finance-0.1.0.dist-info/RECORD

@@ -0,0 +1,84 @@
+dfo/__init__.py,sha256=xiTGkieJVNyF_AZm9egUeZ1Zb0HKYBsk-1DUOzDtqac,1915
+dfo/_client/__init__.py,sha256=4y6ze-KTIo5CELNAbEY6hfxtqd3ykwJipP1CWwwLCCg,82
+dfo/_client/analysis.py,sha256=OtrKv8lgIwvkJm4HkG7pp1PvMi1-TjqC2_vTRB6myoo,7322
+dfo/_client/cards.py,sha256=hEdsR_yj6-7ku1VnHVLwGtOkZL5Y4jbldtMDgXXmrBQ,3139
+dfo/_client/cli.py,sha256=1RTp8Tna8Y2jNK49p0peKVsK3hoyO9ovtoZ0Si3at_w,5544
+dfo/_client/client.py,sha256=6kArseMwcjdrwdgrM8QnGzuA1e1dxuKRoFC8oW4Jl1I,23161
+dfo/_client/default.py,sha256=OLemOoXOaJ02Cf5e7G4nZoyF2hknCRpjQqDBi5zmxU0,13270
+dfo/_config/__init__.py,sha256=MZT7M0MAS6uXMoU8MWvJsEnnXiDjfZls_z3LjwoTlbk,87
+dfo/_config/credentials.py,sha256=2aswKYtutA0POIw45rA59YUYNWZTNDOlg_Gxz0bLS8w,5156
+dfo/_config/keys.py,sha256=XiVqmShZ5FcKoRySJP8ed9KA9HSKSKB7DxiAZSXdVuQ,11727
+dfo/_config/paths.py,sha256=pPqVoA1OIEwVhlSf05XS0D-Fk_0F9ZdzeIuxuYRf6iE,4269
+dfo/_core/__init__.py,sha256=bI2o2-lQxD8K76pvXmE9-ioeV-qoqT_YoLMYcNDsyDc,75
+dfo/_core/codes.py,sha256=a2dRFXvFOf49sIJBDNniZJcdPqi7gAJS3w9oEQKXd28,3454
+dfo/_core/errors.py,sha256=-HPCm4nDW5BdqJXP64wwY7iuqx56SdDG63L_xWhUlTw,15195
+dfo/_core/json_text.py,sha256=MVr5lxzVcOyV5r4w0m0j9lFbq7yIlkZYkSRe5nuUYAU,3075
+dfo/_core/lookup_results.py,sha256=R5AuMgqrxwJ9qPqTsGLq1gktqrEQFuFfNrd5zqcIosQ,10413
+dfo/_core/nearest.py,sha256=HgtlaYkz6lyukLYQFURjhCSufO5XNR7Vk1hJ39KHQdQ,1728
+dfo/_core/parse.py,sha256=SMFNGW6X57VHbhrBW773x8J6YBFgASLtCQDjoyIxA_s,17874
+dfo/_core/periods.py,sha256=6HE5m3TTGIES-OUkK1pkeNWItmpO2GWsytnmNxbdxBw,2748
+dfo/_core/refs.py,sha256=DlPoJvAfCLHAqEsC4Yb1gqK_AqFozZRB5tARtknAm10,28612
+dfo/_core/refusals.py,sha256=Cm0Tgyd9WSnhh3BwFfssgnLn9kKiDQKNxRR1s2BxxZk,13768
+dfo/_core/text.py,sha256=567hFrYqTOsbL8PK5anq4zElJ4m2kQmaoAp4i256uSg,12514
+dfo/_core/types.py,sha256=HS7aruh3xk35WKDCKC0LJLL2TpO4ecMxKIeHcn-JaPs,27309
+dfo/_datasets/__init__.py,sha256=Gv7B_IkXZ5DgjmcVw7hdkpVmpjAUCB6H1RFvhk-u5IU,80
+dfo/_datasets/analysis.py,sha256=8vTatXYfza2GxxzBU8elGCdUjJ7htgZS7rZHXCte9E8,24058
+dfo/_datasets/build.py,sha256=AHE2oeKpfSRk4GRDWGeJTMcQk27s8Vsx5EuJBNYckWQ,26911
+dfo/_datasets/bundle.py,sha256=THfmSguP38mpsXAcOovFxX4q1RYULSDxmsxUEEvlYas,30220
+dfo/_datasets/cache.py,sha256=zfCgks266PAvoksUTwTrXQhbKfhPkgTEOqeU_Qol-Qg,16706
+dfo/_datasets/cards.py,sha256=JuyjqX8Xu-duTQgEeJ6wkM9S0dwpLDv-aNJNVAKWgZA,12824
+dfo/_datasets/dataset.py,sha256=7mbIiHgmhWkGDMAfvZHTjctHwAO0C2GmiS7OXB7d1UM,66673
+dfo/_datasets/fetch.py,sha256=C2b2bwDvsz0QrBUsOYN2IHrtmG-9MCG_o8XJA58o0yk,28575
+dfo/_datasets/interrupt.py,sha256=FRsmAQw0sLNyoB5o1UFIVhGzcrK03ScDQkyvVrYK7S4,1063
+dfo/_datasets/operation.py,sha256=f_zACl0Ylp5YSdhHTkyv7hLsarT3IyTdtFWuAxNviSQ,21432
+dfo/_datasets/pin.py,sha256=PSnbGRhvjkrporE0KR5vsrmQHHYxsvNzPDynuLgiOYU,4701
+dfo/_datasets/progress.py,sha256=_FJgsKCABDw_moTOE2l173j5mcdCgJuTDa5k1sGeEBA,5425
+dfo/_datasets/publication.py,sha256=WQdSgGVegcK6XypP4VXhQwz_9CHKVadXFTS0JV55evU,24990
+dfo/_datasets/recipe.py,sha256=sff4wpNH93Do8_KXmFIE9pWafWPjb14arM7GpX9_mFw,23400
+dfo/_datasets/resolve.py,sha256=W213sa1V0e5WoAO1FnoI3SQeyu03ztTH6hNXOBsc7rY,44133
+dfo/_datasets/shares.py,sha256=327QiFsRj6sChfXzW2fAaeB3qHW3uCE8WM3eXQNvDHg,15381
+dfo/_generated/__init__.py,sha256=1WvrJoFlVaKv7LeNOws77l67IMjqz4oQGpQEBJqzprM,68
+dfo/_generated/error_map.py,sha256=dpLIbBTs4Qi3uNBwPj7Kck6VIhqfbFCTA_-nma59Lck,11173
+dfo/_generated/file_selector.py,sha256=CPjd5vXMgvVQNf4adoF1wsqaHANKHYzAqsNJNlDCYl8,329
+dfo/_generated/reading_order.py,sha256=pfOb7heS2bKf8dSQsEOp1OQ3C8vKki5XViqhR0WNVRM,787
+dfo/_generated/role_keys.py,sha256=WzszI43bqiBlOefISxHIfk8kOqxmwjvIRGcXi-ABnIw,571
+dfo/_generated/strict.py,sha256=mIvUEBkVfKW4tfKpVwfzCSq-z3SMIWRnT-_kMKza2dg,2526
+dfo/_generated/wire.py,sha256=sI_JIJItrBffRXB1YTC7_MQmajVdCRC__NApJqxH1ic,90007
+dfo/_http/__init__.py,sha256=ChYPgAGF1FWhS_EpCwacdS7mphtJ3QBTljl1lKEXbwM,89
+dfo/_http/hooks.py,sha256=Y2geHeKJpwmLp1YtQpobLGBFjzSw1x2JjvFjuU3adlo,6848
+dfo/_http/transport.py,sha256=oT8sXZg8ID7q2n75NsBKBHnFI-u2gMyQhEWBBqQR-_o,58071
+dfo/_search/__init__.py,sha256=lC9-yBM-DMK9uC4CSiawK6ZODe7O599QGJs5hFZlnmo,70
+dfo/_search/answer.py,sha256=AfpLdlw0YaWaOSGD_B3udSZ2DRGCmj5bOEhgwBMf-ek,33162
+dfo/_search/answer_json.py,sha256=YbQvF7U9wHZgq-VS4zs9lnv5KBd_AHcn1NJO0YRdhUY,4585
+dfo/_search/display.py,sha256=60zB4Rd6dLa4ux5iJWOB8WA3zr_1Xt_bu_raKJs0RDc,8944
+dfo/_search/lookups.py,sha256=0RfT9SI5gwJqRq7rx21OEjA5U2iIQEQ-Z8EnKrD7SXE,8027
+dfo/_search/search.py,sha256=c5yoch1iISjfKHEeRY5usVUEVR-epJG9Yzof-jLfNRg,1862
+dfo/_sync/__init__.py,sha256=ckMI6SeT8hJVJayuMAS16GpGnus_ymJOVpNpj_WNpzY,81
+dfo/_sync/_client/__init__.py,sha256=hey-bmgnNvgkTL4PazPsBT_PDFksWnUcZDwHuvhB8-w,72
+dfo/_sync/_client/client.py,sha256=fspew20svIw3uynx3xDzl8SopkkqAcPGpIVUwH0UA3I,23101
+dfo/_sync/_datasets/__init__.py,sha256=fMrijgwTWguIL0wM7rLk3m87kricCdiKjvIRSNcvtC4,74
+dfo/_sync/_datasets/analysis.py,sha256=9iQqolfgjcnb1mohA1xQ5ZStNXT42OlfWLPyic-q0wk,23808
+dfo/_sync/_datasets/cards.py,sha256=is1WvdweQHsY-yHSLlbuU3wRt6O2NkqhC8kF_YcK1kw,12798
+dfo/_sync/_datasets/fetch.py,sha256=3heitShZ8RntthvW0DSJLmF2XuQLLNFPrbPQszEpA88,28440
+dfo/_sync/_datasets/operation.py,sha256=WRG0SvWHIzhmZw2PlcxtZJCoyzVTMztv6EYp-MGS2o8,21374
+dfo/_sync/_datasets/pin.py,sha256=nyvPHNPZ1HaRGEvdEBTTxJQWEvjJMvB3roWAqHS7b8I,4754
+dfo/_sync/_datasets/resolve.py,sha256=UdQKu7AVygsO7jjHb3eocbn5KXYDhrBYKDyzA5Eu0XA,43861
+dfo/_sync/_datasets/shares.py,sha256=Ywl80IyOUT8L85zm_Ox42zvlrxi_amOvABzxstdGlA8,15265
+dfo/_sync/_http/__init__.py,sha256=bqIjGsfzAsTBwMCPwrEyMJyfEaV8ckspOFcbw56adkg,70
+dfo/_sync/_http/transport.py,sha256=WBNPLu-GOYHScRM4qWei4pGyoKZlo6Ga8lYMTvxkP30,57771
+dfo/_sync/_search/__init__.py,sha256=sTw8vVT6vhf9-wuo1Ue84cd62QUbAVaTCv-IQffomZo,72
+dfo/_sync/_search/answer.py,sha256=j5CIgW06OhgmRRtC6AJp-LlGeODLLDpTFoqI4sDM3jU,33183
+dfo/_sync/_search/lookups.py,sha256=typOtO27xoOwQbrIyWWkxYcI2_9jaS545oW2Pv7TtRU,8031
+dfo/_sync/_search/search.py,sha256=sTa9Gu3fSe0S5fhyO-CGxDYeEe4rUzb2i9fFXY_1e3A,1939
+dfo/_version.py,sha256=74uw1papg0T7vMpgmplAbDa-OUEP4roFGMsYDkd7bdQ,89
+dfo/analysis.py,sha256=Vvm31BC5LEfgpKX8oqp6iP0lQ0ThQTVSioLZXH6W1_E,1070
+dfo/auth.py,sha256=Z--rO7hCZlguLZ4JWFHPb4l7gpHkNKq4sbiYqWTK1iU,595
+dfo/cards.py,sha256=DwFFDIgABUrPs-pen3mKIWtZ7tGIWiBKLkwJiqKZXiM,626
+dfo/errors.py,sha256=8gId2Tqg46omOeG1FjMiMfgKl2e_050zlOdwNpSekLs,1848
+dfo/lookup.py,sha256=iWwDk5vNt9gskMfPNtA_9FUzp-0et5aNsgvmRCF6do0,564
+dfo/py.typed,sha256=2fYELBifmrW34-PPJa0CTNoeda-08ZmdmE8dw_OKb_U,71
+dfo/types.py,sha256=VmO8FNWp14raqnzT6OBRHMT8jcJMMOwLsQ309hkzqV8,3348
+development_finance-0.1.0.dist-info/WHEEL,sha256=3OmCxFA0ffBIsX4x0o8CdfSvZAOvO3mzEG8U_z5TvV4,80
+development_finance-0.1.0.dist-info/entry_points.txt,sha256=OTrrD_ZrrLW5Cs7LRKjpsbwgAZMdiXQrjpzn8y_i1Rg,46
+development_finance-0.1.0.dist-info/METADATA,sha256=Rlkuwc8j7XR7JeWiAbLQ2BxigrOr0wwQi2AxR1bK2yI,18989
+development_finance-0.1.0.dist-info/RECORD,,

development_finance-0.1.0.dist-info/WHEEL

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

development_finance-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+dfo = dfo._client.cli:main
+

dfo/__init__.py

@@ -0,0 +1,65 @@
+"""Python client for the Development Finance Observatory APIs.
+
+`dfo.search(question)` returns an `Answer` that says what DFO understood.
+`answer.fetch()` or `dfo.fetch(spec_or_ref)` returns a `Dataset`, which
+`data.save` writes to a Parquet file and `dfo.load` reads back. `Client` and
+`AsyncClient` carry the same calls for one configuration each.
+
+`dfo.pin(data)` keeps a Dataset's versions fetchable with no time limit, and
+`dfo.latest_year(offset)` names a year DFO settles each time an operation runs.
+`dfo.share(cards, latest=...)` publishes cards from `dfo.cards` as a link that
+follows new data or stays fixed; `dfo.snapshot`, `dfo.unshare` and
+`dfo.history` fix it, take it down and list what it served.
+
+The task modules hold the rest: `dfo.analysis` DFO's operations and recipes,
+`dfo.cards` the charts, tables and numbers DFO draws,
+`dfo.errors` the errors and warnings, `dfo.types` what answers and datasets
+contain, `dfo.lookup` names, nodes and codes, and `dfo.auth` keys and headers.
+"""
+
+from dfo import analysis, auth, cards, errors, lookup, types
+from dfo._client.client import AsyncClient
+from dfo._client.default import (
+    configure,
+    fetch,
+    history,
+    pin,
+    search,
+    share,
+    snapshot,
+    unshare,
+)
+from dfo._core.periods import latest_year
+from dfo._core.refs import DatasetRef
+from dfo._core.types import Spec
+from dfo._datasets.bundle import load
+from dfo._datasets.dataset import Dataset
+from dfo._sync._client.client import Client
+from dfo._sync._search.answer import Answer
+from dfo._version import __version__
+
+__all__ = [
+    "Answer",
+    "AsyncClient",
+    "Client",
+    "Dataset",
+    "DatasetRef",
+    "Spec",
+    "__version__",
+    "analysis",
+    "auth",
+    "cards",
+    "configure",
+    "errors",
+    "fetch",
+    "history",
+    "latest_year",
+    "load",
+    "lookup",
+    "pin",
+    "search",
+    "share",
+    "snapshot",
+    "types",
+    "unshare",
+]

dfo/_client/__init__.py

@@ -0,0 +1 @@
+"""Client layer: the clients, the module-level functions and the command line."""