parsimony-bdf 0.0.1__tar.gz

parsimony_bdf-0.0.1/.gitignore

@@ -0,0 +1,40 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+.Python
+build/
+dist/
+*.egg-info/
+*.egg
+
+.venv/
+.env
+.env.*
+!.env.example
+
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+coverage.xml
+
+uv.lock
+
+.vscode/
+.council/
+PLAN-*.md
+.idea/
+*.swp
+.DS_Store
+
+outputs/
+logs/
+# Recorded HTTP cassettes must never be committed — respx mocks are hand-authored
+# from upstream API documentation. A pre-commit / CI regex scan is the belt; this
+# ignore is the braces. Override per-file via `!` if you need a hand-authored
+# fixture checked in.
+packages/*/tests/fixtures/**
+!packages/*/tests/fixtures/README.md

parsimony_bdf-0.0.1/CHANGELOG.md

@@ -0,0 +1,57 @@
+# Changelog — parsimony-bdf
+
+All notable changes to `parsimony-bdf` will be documented in this file. The
+format is based on [Keep a Changelog](https://keepachangelog.com/) and
+this project adheres to [Semantic Versioning](https://semver.org/).
+
+## [0.8.0] — 2026-06-08
+
+Ground-up refactor, run through the full connector guidebook process and
+**live-verified** against the production Webstat API (the connector previously
+shipped `UNVERIFIED-LIVE` because no key was on hand).
+
+### Changed
+
+- **Enumeration switched to archetype A (live full-index export).** The Webstat
+  `series` dataset is a single flat queryable table, so `enumerate_bdf` now
+  streams the entire ~41.6k-series universe in **one** `series/exports/json`
+  call (plus one `webstat-datasets` call for the 45 dataflow stubs), replacing
+  the previous 45-call per-dataset crawl. Completeness is self-tracking and
+  verifiable by diffing `len(catalog)` against the live `series` total_count.
+- **Bilingual, breadcrumb-rich catalog at no extra cost.** Series rows now carry
+  English + French titles and the `path_en`/`path_fr` topic breadcrumb folded
+  into the indexed `description`, improving cross-language and topical recall.
+  No separate enrichment pass is needed (the source already serves both
+  languages).
+- **Package restructured** into `_http` / `outputs` / `connectors/{fetch,
+  enumerate,_catalog}` / `search` / `catalog_build`, mirroring the `bde`
+  exemplar; the top-level surface stays `CONNECTORS` + `load`.
+- `bdf_fetch` validates `start_period` / `end_period` as ISO dates pre-network
+  (`InvalidParameterError`) and tolerates null `obs_value` (missing-status gaps).
+
+### Added
+
+- Live integration suite (now runnable with `BDF_API_KEY`): keyed fetch, a
+  dataset-bounded live enumerate, and a fixture-catalog search.
+- `catalog_tests/queries.yaml` recall gate (referenced by the catalog-validate
+  registry) and `tests/test_build_catalog.py` index-policy test.
+
+## [0.5.0] — 2026-05-06
+
+### Changed
+
+- Adapted to `parsimony-core==0.5`. Connector code no longer constructs `Provenance` directly; the framework authors all provenance fields in `Connector._wrap_result`. Source-specific extras (where present) move to `Result.with_properties(**kwargs)`. Drops the `provenance=` and `params=` kwargs from `OutputConfig.build_table_result` / `Result.from_dataframe` call sites.
+- Bump `parsimony-core` pin from `>=0.4.0,<0.5` to `>=0.5.0,<0.6` (and `[standard-onnx]` extra accordingly on catalog-publishing packages).
+## [0.4.0] — 2026-04-24
+
+Part of the first coordinated release of the
+[`parsimony-connectors`](https://github.com/ockham-sh/parsimony-connectors)
+monorepo under `parsimony-core==0.4`.
+
+### Changed
+
+- Connector rewritten against the kernel's `parsimony.discover` surface
+  (`iter_providers`, `load`, `load_all`) and the `@connector(env=...)`
+  decorator-level env-var declaration that replaced module-level
+  `ENV_VARS`.
+- Pin bumped to `parsimony-core>=0.4,<0.5`.

parsimony_bdf-0.0.1/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Ockham.sh
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

parsimony_bdf-0.0.1/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: parsimony-bdf
+Version: 0.0.1
+Summary: Banque de France connector for the parsimony framework
+Project-URL: Homepage, https://www.banque-france.fr
+Project-URL: Repository, https://github.com/ockham-sh/parsimony-connectors
+Project-URL: Issues, https://github.com/ockham-sh/parsimony-connectors/issues
+Author-email: "Ockham.sh" <team@ockham.sh>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: bdf,connectors,data,finance,parsimony
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+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 :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: pandas<3,>=2.3.0
+Requires-Dist: parsimony-core[catalog]>=0.0.1
+Requires-Dist: parsimony-shared>=0.0.1
+Requires-Dist: pydantic<3,>=2.11.1
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=9.0.3; extra == 'dev'
+Requires-Dist: respx>=0.22.0; extra == 'dev'
+Requires-Dist: ruff>=0.15.10; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# parsimony-bdf
+
+Banque de France connector — French macroeconomic, monetary, and financial time
+series via the Webstat (Opendatasoft) API.
+
+Part of the [parsimony-connectors](https://github.com/ockham-sh/parsimony-connectors) monorepo. Distributed standalone on PyPI as `parsimony-bdf`.
+
+## Connectors
+
+| Name | Kind | Description |
+|---|---|---|
+| `bdf_fetch` | connector | Fetch a Banque de France time series by SDMX key (e.g. `EXR.M.USD.EUR.SP00.E`), optionally bounded by `start_period`/`end_period`. |
+| `enumerate_bdf` | enumerator | Stream the full BdF series universe (~41.6k series across 45 dataflows) for catalog discovery. |
+| `bdf_search` | connector | Semantic-search the published BdF catalog snapshot; returns ranked series codes. |
+
+## Install
+
+```bash
+pip install parsimony-bdf
+```
+
+Pulls in `parsimony-core>=0.7,<0.8` automatically. Verify discovery:
+
+```bash
+python -c "from parsimony import discover; print([p.name for p in discover.iter_providers()])"
+```
+
+## Configuration
+
+The Webstat API requires a free API key. Register at
+https://developer.webstat.banque-france.fr/, then set:
+
+```bash
+export BDF_API_KEY="<your-key>"
+```
+
+The key is sent in the `Authorization: Apikey <KEY>` header (the literal word
+`Apikey`, **not** `Bearer`). It is declared as a secret (stripped from
+provenance) and never appears in request logs. Supply it via the env var above,
+or bind it explicitly:
+
+```python
+from parsimony_bdf import load
+connectors = load(api_key="<your-key>")   # binds the key across the bundle
+```
+
+A missing key fails fast with `UnauthorizedError` naming `BDF_API_KEY`.
+
+`bdf_search` reads a published catalog snapshot (default `hf://parsimony-dev/bdf`).
+Override the snapshot location with the `PARSIMONY_BDF_CATALOG_URL` environment
+variable, or pass `catalog_url=` at call time.
+
+## Quick start
+
+```python
+from parsimony_bdf import load
+
+connectors = load(api_key="<your-key>")
+result = connectors["bdf_fetch"](key="EXR.M.USD.EUR.SP00.E")
+print(result.data.head())
+```
+
+For multi-plugin composition (autoloads everything installed):
+
+```python
+from parsimony import discover
+connectors = discover.load_all()
+```
+
+## Catalogs
+
+The Webstat `series` dataset is a single flat queryable table, so `enumerate_bdf`
+discovers the **entire** universe in two requests: one `series/exports/json`
+export (~41.6k series) plus one `webstat-datasets` call for the 45 dataflow stub
+rows. Each series row carries English + French titles and a topic breadcrumb,
+folded into the catalog `description` for cross-language recall. Maintainers
+build a `Catalog` snapshot from it (`scripts/build_catalog.py`) and push it to
+the snapshot URL `bdf_search` reads — the build runs offline as a publish job,
+never at query time. Quota: 10,000 requests/day.
+
+## Provider
+
+- Homepage: https://www.banque-france.fr
+- Webstat portal: https://webstat.banque-france.fr
+- Developer portal: https://developer.webstat.banque-france.fr/
+
+## License
+
+See [LICENSE](./LICENSE).

parsimony_bdf-0.0.1/README.md

@@ -0,0 +1,89 @@
+# parsimony-bdf
+
+Banque de France connector — French macroeconomic, monetary, and financial time
+series via the Webstat (Opendatasoft) API.
+
+Part of the [parsimony-connectors](https://github.com/ockham-sh/parsimony-connectors) monorepo. Distributed standalone on PyPI as `parsimony-bdf`.
+
+## Connectors
+
+| Name | Kind | Description |
+|---|---|---|
+| `bdf_fetch` | connector | Fetch a Banque de France time series by SDMX key (e.g. `EXR.M.USD.EUR.SP00.E`), optionally bounded by `start_period`/`end_period`. |
+| `enumerate_bdf` | enumerator | Stream the full BdF series universe (~41.6k series across 45 dataflows) for catalog discovery. |
+| `bdf_search` | connector | Semantic-search the published BdF catalog snapshot; returns ranked series codes. |
+
+## Install
+
+```bash
+pip install parsimony-bdf
+```
+
+Pulls in `parsimony-core>=0.7,<0.8` automatically. Verify discovery:
+
+```bash
+python -c "from parsimony import discover; print([p.name for p in discover.iter_providers()])"
+```
+
+## Configuration
+
+The Webstat API requires a free API key. Register at
+https://developer.webstat.banque-france.fr/, then set:
+
+```bash
+export BDF_API_KEY="<your-key>"
+```
+
+The key is sent in the `Authorization: Apikey <KEY>` header (the literal word
+`Apikey`, **not** `Bearer`). It is declared as a secret (stripped from
+provenance) and never appears in request logs. Supply it via the env var above,
+or bind it explicitly:
+
+```python
+from parsimony_bdf import load
+connectors = load(api_key="<your-key>")   # binds the key across the bundle
+```
+
+A missing key fails fast with `UnauthorizedError` naming `BDF_API_KEY`.
+
+`bdf_search` reads a published catalog snapshot (default `hf://parsimony-dev/bdf`).
+Override the snapshot location with the `PARSIMONY_BDF_CATALOG_URL` environment
+variable, or pass `catalog_url=` at call time.
+
+## Quick start
+
+```python
+from parsimony_bdf import load
+
+connectors = load(api_key="<your-key>")
+result = connectors["bdf_fetch"](key="EXR.M.USD.EUR.SP00.E")
+print(result.data.head())
+```
+
+For multi-plugin composition (autoloads everything installed):
+
+```python
+from parsimony import discover
+connectors = discover.load_all()
+```
+
+## Catalogs
+
+The Webstat `series` dataset is a single flat queryable table, so `enumerate_bdf`
+discovers the **entire** universe in two requests: one `series/exports/json`
+export (~41.6k series) plus one `webstat-datasets` call for the 45 dataflow stub
+rows. Each series row carries English + French titles and a topic breadcrumb,
+folded into the catalog `description` for cross-language recall. Maintainers
+build a `Catalog` snapshot from it (`scripts/build_catalog.py`) and push it to
+the snapshot URL `bdf_search` reads — the build runs offline as a publish job,
+never at query time. Quota: 10,000 requests/day.
+
+## Provider
+
+- Homepage: https://www.banque-france.fr
+- Webstat portal: https://webstat.banque-france.fr
+- Developer portal: https://developer.webstat.banque-france.fr/
+
+## License
+
+See [LICENSE](./LICENSE).

parsimony_bdf-0.0.1/parsimony_bdf/__init__.py

@@ -0,0 +1,7 @@
+"""Banque de France (BdF): fetch + catalog enumeration."""
+
+from __future__ import annotations
+
+from parsimony_bdf.connectors import CONNECTORS, load
+
+__all__ = ["CONNECTORS", "load"]

parsimony_bdf-0.0.1/parsimony_bdf/_http.py

@@ -0,0 +1,112 @@
+"""Banque de France (BdF) Webstat transport: constants, auth, HTTP client.
+
+BdF publishes through an Opendatasoft Explore v2.1 API. A single Opendatasoft
+"catalog" hosts several system datasets; three of them carry everything this
+connector needs (all live-verified 2026-06-08):
+
+* ``webstat-datasets`` — 45 records, one per BdF dataflow (``EXR``, ``BSI``, …),
+  each with bilingual ``name``/``description`` and a ``series_count``.
+* ``series`` — the full series catalogue as one flat table (~41.6k records),
+  each row carrying ``series_key``, ``dataset_id``, bilingual titles, the
+  ``path_en``/``path_fr`` breadcrumb, frequency, reference area and source
+  agency. Because it is a single queryable table, the *entire* universe streams
+  from one ``/exports/json`` call — no per-dataset fan-out needed.
+* ``observations`` — observation rows, filtered by ``series_key`` for a fetch.
+
+Auth is an Opendatasoft API key sent in the ``Authorization: Apikey <KEY>``
+header (the literal word ``Apikey`` — *not* ``Bearer``; the wrong scheme returns
+a silent 401). The key rides the header, never a query param, so it never lands
+in a request log. Register at https://developer.webstat.banque-france.fr/ and
+export it as ``BDF_API_KEY``. Quota: 10,000 requests/day.
+"""
+
+from __future__ import annotations
+
+import os
+
+import httpx
+from parsimony.errors import UnauthorizedError
+from parsimony.transport import HttpClient
+from parsimony.transport.helpers import make_http_client
+from parsimony_shared.cb_enumerate import MetadataCrawlConfig
+
+PROVIDER = "bdf"
+ENV_VAR = "BDF_API_KEY"
+USER_AGENT = "parsimony-bdf/0.8"
+
+BASE_URL = "https://webstat.banque-france.fr/api/explore/v2.1/catalog/datasets"
+
+# Opendatasoft export endpoints (relative to BASE_URL). ``/exports/json`` streams
+# the whole (optionally filtered) dataset in one response — no pagination.
+DATASETS_PATH = "webstat-datasets/exports/json"
+SERIES_PATH = "series/exports/json"
+OBSERVATIONS_PATH = "observations/exports/json"
+
+# Lean column projections keep the streamed payloads small. The ``series`` table
+# is ~200 columns wide (a sparse SDMX flat table) — selecting only what the
+# catalog needs turns a multi-hundred-MB export into a few MB.
+DATASETS_SELECT = "dataset_id,name_en,name_fr,description_en,description_fr,series_count"
+SERIES_SELECT = (
+    "series_key,dataset_id,title_en,title_fr,title_long_en,title_long_fr,"
+    "freq,ref_area,source_agency,first_time_period_date,last_time_period_date,"
+    "path_en,path_fr"
+)
+OBSERVATIONS_SELECT = "series_key,title_en,title_fr,time_period_start,obs_value"
+
+# The enumerator issues only two requests (datasets + the full series export),
+# so concurrency is almost moot; a small cap with a courtesy delay is plenty.
+METADATA_CRAWL = MetadataCrawlConfig(inter_request_delay_s=0.25)
+
+# The full ``series`` export is large; allow a long read. Used by the enumerator.
+CRAWL_TIMEOUT = httpx.Timeout(connect=30.0, read=180.0, write=30.0, pool=30.0)
+
+
+def resolve_key(api_key: str) -> str:
+    """Resolve the API key (arg → ``BDF_API_KEY`` env fallback); fast-fail if absent.
+
+    A missing key raises :class:`UnauthorizedError` naming the env var so an agent
+    is told exactly which variable to set — *before* any network call is made.
+    ``env_var`` is keyword-only.
+    """
+    key = (api_key or os.environ.get(ENV_VAR, "")).strip()
+    if not key:
+        raise UnauthorizedError(PROVIDER, env_var=ENV_VAR)
+    return key
+
+
+def auth_headers(key: str) -> dict[str, str]:
+    """Build the Webstat auth + transport headers for an already-resolved key.
+
+    Note the literal ``Apikey`` token (not ``Bearer``) — Opendatasoft's auth
+    scheme is non-standard, and the wrong word yields a silent 401.
+    """
+    return {
+        "Authorization": f"Apikey {key}",
+        "Accept": "application/json",
+        "User-Agent": USER_AGENT,
+    }
+
+
+def make_fetch_client(api_key: str) -> HttpClient:
+    """Resolve the key (fast-fail) and build the canonical client for ``bdf_fetch``."""
+    key = resolve_key(api_key)
+    return make_http_client(BASE_URL, headers=auth_headers(key), timeout=60.0)
+
+
+__all__ = [
+    "BASE_URL",
+    "CRAWL_TIMEOUT",
+    "DATASETS_PATH",
+    "DATASETS_SELECT",
+    "ENV_VAR",
+    "METADATA_CRAWL",
+    "OBSERVATIONS_PATH",
+    "OBSERVATIONS_SELECT",
+    "PROVIDER",
+    "SERIES_PATH",
+    "SERIES_SELECT",
+    "USER_AGENT",
+    "auth_headers",
+    "make_fetch_client",
+    "resolve_key",
+]

parsimony_bdf-0.0.1/parsimony_bdf/catalog_build.py

@@ -0,0 +1,37 @@
+"""Build the Banque de France catalog snapshot.
+
+Maintainer tooling, not part of the plugin contract: ``enumerate_bdf`` streams
+the full ``series`` universe, the rows become catalog entities, and the catalog
+is indexed and built. Titles are already bilingual at the source (English short
+title with a French / breadcrumb fallback in ``description``), so — unlike BdE —
+no separate enrichment pass is needed.
+"""
+
+from __future__ import annotations
+
+from parsimony.catalog import Catalog
+from parsimony.catalog.policy import discovery_indexes
+from parsimony.catalog.source import entities_from_raw
+
+from parsimony_bdf.connectors.enumerate import enumerate_bdf
+from parsimony_bdf.outputs import BDF_ENUMERATE_OUTPUT
+
+CATALOG_NAMESPACE = "bdf"
+
+
+def build_bdf_catalog(*, api_key: str | None = None) -> Catalog:
+    """Enumerate the full BdF universe and build a searchable catalog snapshot.
+
+    ``api_key`` falls back to ``BDF_API_KEY`` inside ``enumerate_bdf`` (and
+    fast-fails with :class:`~parsimony.errors.UnauthorizedError` if neither is
+    set), so the snapshot can be built straight from the environment.
+    """
+    result = enumerate_bdf(api_key=(api_key or "").strip())
+    entries = entities_from_raw(result, BDF_ENUMERATE_OUTPUT)
+    catalog = Catalog(CATALOG_NAMESPACE, indexes=discovery_indexes(entries), default_field="title")
+    catalog.set_entities(entries)
+    catalog.build()
+    return catalog
+
+
+__all__ = ["CATALOG_NAMESPACE", "build_bdf_catalog"]

parsimony_bdf-0.0.1/parsimony_bdf/connectors/__init__.py

@@ -0,0 +1,19 @@
+"""bdf connector registry."""
+
+from __future__ import annotations
+
+from parsimony.connector import Connectors
+
+from parsimony_bdf.connectors.enumerate import enumerate_bdf
+from parsimony_bdf.connectors.fetch import bdf_fetch
+from parsimony_bdf.search import bdf_search
+
+CONNECTORS = Connectors([bdf_fetch, enumerate_bdf, bdf_search])
+
+
+def load(*, api_key: str) -> Connectors:
+    """Return :data:`CONNECTORS` with ``api_key`` bound on every keyed connector."""
+    return CONNECTORS.bind(api_key=api_key)
+
+
+__all__ = ["CONNECTORS", "load"]

parsimony_bdf-0.0.1/parsimony_bdf/connectors/_catalog.py

@@ -0,0 +1,184 @@
+"""Pure (network-free) helpers that turn raw Webstat rows into catalog rows.
+
+Kept separate from the enumerator so the row-shaping logic is unit-testable
+without any HTTP. Two builders — one per entity kind — plus the dedup/assembly
+entry point :func:`build_enumerate_rows`.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from parsimony_bdf.outputs import ENUMERATE_COLUMNS
+
+# A blank row with every declared column present — @enumerator requires an
+# EXACT column match, so every emitted row must carry all of them.
+_BLANK: dict[str, str] = {name: "" for name in ENUMERATE_COLUMNS}
+
+
+def _clean(value: Any) -> str:
+    """Coerce a raw field to a stripped string (``None`` → empty)."""
+    if value is None:
+        return ""
+    return str(value).strip()
+
+
+def _as_path(raw: Any) -> str:
+    """Flatten a Webstat ``path_*`` field into a single breadcrumb string.
+
+    The export returns ``path_en`` as a JSON array (e.g.
+    ``['Rates and prices/Market interest rates']``), occasionally a bare string.
+    Returns the unique non-empty segments joined by `` | ``.
+    """
+    if raw is None:
+        return ""
+    items = raw if isinstance(raw, (list, tuple)) else [raw]
+    seen: list[str] = []
+    for item in items:
+        text = _clean(item)
+        if text and text not in seen:
+            seen.append(text)
+    return " | ".join(seen)
+
+
+def _first_nonempty(*candidates: str) -> str:
+    for candidate in candidates:
+        if candidate:
+            return candidate
+    return ""
+
+
+def _dataset_description(*, name_en: str, name_fr: str, desc_en: str, desc_fr: str) -> str:
+    """Bilingual description for a dataset stub (deduping identical halves)."""
+    parts: list[str] = []
+    for value in (name_en, name_fr, desc_en, desc_fr):
+        if value and value.lower() not in {p.lower() for p in parts}:
+            parts.append(value)
+    return " | ".join(parts)
+
+
+def dataset_stub_row(dataset: dict[str, Any]) -> dict[str, str] | None:
+    """Build the synthetic ``dataset:{id}`` parent row, or ``None`` if unusable."""
+    dataset_id = _clean(dataset.get("dataset_id"))
+    if not dataset_id:
+        return None
+    name_en = _clean(dataset.get("name_en"))
+    name_fr = _clean(dataset.get("name_fr"))
+    desc_en = _clean(dataset.get("description_en"))
+    desc_fr = _clean(dataset.get("description_fr"))
+    return {
+        **_BLANK,
+        "code": f"dataset:{dataset_id}",
+        "title": _first_nonempty(name_en, name_fr, dataset_id),
+        "description": _dataset_description(name_en=name_en, name_fr=name_fr, desc_en=desc_en, desc_fr=desc_fr),
+        "entity_type": "dataset",
+        "dataset_id": dataset_id,
+    }
+
+
+def _series_description(
+    *,
+    title_en: str,
+    title_fr: str,
+    long_en: str,
+    long_fr: str,
+    path: str,
+    dataset_id: str,
+    dataset_name: str,
+    source_agency: str,
+) -> str:
+    """Fold bilingual titles, breadcrumb and dataset context into one string.
+
+    Both languages plus the hierarchy path land in ``description`` (which the
+    discovery index covers), so an agent searching in English or French — or by
+    topic breadcrumb — gets a lexical hit even though ``title`` is single-language.
+    """
+    bilingual_en = _first_nonempty(long_en, title_en)
+    bilingual_fr = _first_nonempty(long_fr, title_fr)
+    parts: list[str] = []
+    if bilingual_en:
+        parts.append(bilingual_en)
+    if bilingual_fr and bilingual_fr.lower() != bilingual_en.lower():
+        parts.append(bilingual_fr)
+    if path:
+        parts.append(path)
+    ds_ctx = dataset_name or dataset_id
+    if ds_ctx:
+        parts.append(f"Dataset: {ds_ctx}.")
+    if source_agency:
+        parts.append(f"Source: {source_agency}.")
+    return " | ".join(p for p in parts if p)
+
+
+def series_row(series: dict[str, Any], dataset_names: dict[str, str]) -> dict[str, str] | None:
+    """Build a catalog row for one series, or ``None`` if it has no usable key."""
+    series_key = _clean(series.get("series_key"))
+    if not series_key:
+        return None
+    dataset_id = _clean(series.get("dataset_id"))
+    title_en = _clean(series.get("title_en"))
+    title_fr = _clean(series.get("title_fr"))
+    long_en = _clean(series.get("title_long_en"))
+    long_fr = _clean(series.get("title_long_fr"))
+    path = _as_path(series.get("path_en")) or _as_path(series.get("path_fr"))
+    source_agency = _clean(series.get("source_agency"))
+    return {
+        **_BLANK,
+        "code": series_key,
+        "title": _first_nonempty(title_en, title_fr, long_en, long_fr, series_key),
+        "description": _series_description(
+            title_en=title_en,
+            title_fr=title_fr,
+            long_en=long_en,
+            long_fr=long_fr,
+            path=path,
+            dataset_id=dataset_id,
+            dataset_name=dataset_names.get(dataset_id, ""),
+            source_agency=source_agency,
+        ),
+        "entity_type": "series",
+        "dataset_id": dataset_id,
+        "frequency": _clean(series.get("freq")),
+        "ref_area": _clean(series.get("ref_area")),
+        "source_agency": source_agency,
+        "path": path,
+        "first_time_period": _clean(series.get("first_time_period_date")),
+        "last_time_period": _clean(series.get("last_time_period_date")),
+    }
+
+
+def build_enumerate_rows(
+    datasets: list[dict[str, Any]],
+    series: list[dict[str, Any]],
+) -> list[dict[str, str]]:
+    """Assemble catalog rows: dataset stubs first, then series, deduped by code.
+
+    Dataset stubs come first so that on the (defensive) chance a series key
+    collides with a stub code, the stub wins. Series keys are globally unique in
+    practice, so the dedup mainly guards against accidental repeats in the feed.
+    """
+    dataset_names = {
+        _clean(d.get("dataset_id")): _first_nonempty(_clean(d.get("name_en")), _clean(d.get("name_fr")))
+        for d in datasets
+        if _clean(d.get("dataset_id"))
+    }
+
+    rows: list[dict[str, str]] = []
+    seen: set[str] = set()
+
+    for dataset in datasets:
+        row = dataset_stub_row(dataset)
+        if row is not None and row["code"] not in seen:
+            seen.add(row["code"])
+            rows.append(row)
+
+    for item in series:
+        row = series_row(item, dataset_names)
+        if row is not None and row["code"] not in seen:
+            seen.add(row["code"])
+            rows.append(row)
+
+    return rows
+
+
+__all__ = ["build_enumerate_rows", "dataset_stub_row", "series_row"]

parsimony_bdf-0.0.1/parsimony_bdf/connectors/enumerate.py

@@ -0,0 +1,114 @@
+"""BdF catalog enumeration connector (archetype A: live full-index export).
+
+The Webstat ``series`` dataset is a single flat queryable table holding the
+*entire* BdF universe (~41.6k series), so one ``/series/exports/json`` call with
+a lean column projection streams every addressable unit — no per-dataset
+fan-out. A second call to ``webstat-datasets`` supplies the 45 dataflow stubs
+and the dataset names used as series context. Two requests, fully self-tracking:
+completeness is verifiable by diffing ``len(catalog)`` against the live
+``series`` ``total_count``.
+
+The two universe sources are exposed as module-level seams (:func:`_list_datasets`,
+:func:`_list_all_series`) so tests can monkeypatch them to a tiny slice and bound
+the crawl — never pulling the full table offline.
+
+Best-effort: a failed source is logged and skipped so a partial catalog still
+builds; the publish job checks ``len(df) == 0`` separately. The returned frame
+matches ``ENUMERATE_COLUMNS`` exactly, as the ``@enumerator`` contract requires.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import httpx
+import pandas as pd
+from parsimony.connector import enumerator
+from parsimony_shared.cb_enumerate import ThrottledJsonFetcher
+
+from parsimony_bdf._http import (
+    BASE_URL,
+    CRAWL_TIMEOUT,
+    DATASETS_PATH,
+    DATASETS_SELECT,
+    METADATA_CRAWL,
+    SERIES_PATH,
+    SERIES_SELECT,
+    auth_headers,
+    resolve_key,
+)
+from parsimony_bdf.connectors._catalog import build_enumerate_rows
+from parsimony_bdf.outputs import BDF_ENUMERATE_OUTPUT, ENUMERATE_COLUMNS
+
+logger = logging.getLogger(__name__)
+
+
+def _list_datasets(fetcher: ThrottledJsonFetcher) -> list[dict[str, Any]]:
+    """Return every BdF dataflow stub (45 rows) from the ``webstat-datasets`` export.
+
+    A crawl seam: tests monkeypatch this to a small slice to bound the fan-out.
+    """
+    url = f"{BASE_URL}/{DATASETS_PATH}"
+    payload = fetcher.get_json(
+        url, params={"select": DATASETS_SELECT, "order_by": "dataset_id"}, label="datasets"
+    )
+    if not isinstance(payload, list):
+        return []
+    return [d for d in payload if isinstance(d, dict)]
+
+
+def _list_all_series(fetcher: ThrottledJsonFetcher) -> list[dict[str, Any]] | None:
+    """Return every series row (~41.6k) from the flat ``series`` export in one call.
+
+    A crawl seam: the live integration test monkeypatches this to a single small
+    dataset so it verifies the real export shape without streaming the whole
+    table. Returns ``None`` on transport / parse failure so the caller can still
+    emit the dataset stubs.
+    """
+    url = f"{BASE_URL}/{SERIES_PATH}"
+    payload = fetcher.get_json(url, params={"select": SERIES_SELECT}, label="series")
+    if payload is None:
+        return None
+    if not isinstance(payload, list):
+        return []
+    return [s for s in payload if isinstance(s, dict)]
+
+
+@enumerator(output=BDF_ENUMERATE_OUTPUT, tags=["macro", "fr"], secrets=("api_key",))
+def enumerate_bdf(*, api_key: str = "") -> pd.DataFrame:
+    """Enumerate every Banque de France series with parent-dataset context.
+
+    Streams the full ``series`` table plus the 45 dataflow stubs (two requests),
+    emitting one row per series (KEY = ``series_key``) and one ``dataset:{id}``
+    stub per dataflow, with bilingual descriptions and breadcrumb paths.
+    """
+    key = resolve_key(api_key)
+
+    datasets: list[dict[str, Any]] = []
+    series: list[dict[str, Any]] | None = []
+
+    with httpx.Client(timeout=CRAWL_TIMEOUT, headers=auth_headers(key), follow_redirects=True) as client:
+        fetcher = ThrottledJsonFetcher(client, provider="bdf", config=METADATA_CRAWL, logger=logger)
+        datasets = _list_datasets(fetcher)
+        series = _list_all_series(fetcher)
+
+    if not datasets:
+        logger.warning("BdF enumerate: dataset list unavailable; emitting series only")
+    if series is None:
+        logger.warning("BdF enumerate: series export failed; emitting dataset stubs only")
+        series = []
+
+    rows = build_enumerate_rows(datasets, series)
+    n_series = sum(1 for r in rows if r["entity_type"] == "series")
+    logger.info(
+        "BdF enumerate: %d datasets, %d series, %d total catalog rows",
+        len(datasets),
+        n_series,
+        len(rows),
+    )
+
+    return pd.DataFrame(rows, columns=list(ENUMERATE_COLUMNS))
+
+
+__all__ = ["enumerate_bdf"]

parsimony_bdf-0.0.1/parsimony_bdf/connectors/fetch.py

@@ -0,0 +1,119 @@
+"""BdF series fetch connector (Webstat ``observations`` export).
+
+Pulls observation rows for a single SDMX ``series_key`` from the Opendatasoft
+``observations`` dataset, filtered server-side with an ODSQL ``where`` clause.
+``obs_value`` is null on missing-status rows (BdF marks gaps with ``OBS_STATUS=M``),
+so values may legitimately be ``None`` between real observations.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+import pandas as pd
+from parsimony.connector import connector
+from parsimony.errors import EmptyDataError, InvalidParameterError, ParseError
+from parsimony.transport.helpers import fetch_json
+
+from parsimony_bdf._http import OBSERVATIONS_PATH, OBSERVATIONS_SELECT, make_fetch_client
+from parsimony_bdf.outputs import BDF_FETCH_OUTPUT, FETCH_COLUMNS
+
+
+def _validate_period(value: str | None, name: str) -> str | None:
+    """Screen a ``YYYY-MM-DD`` period bound before it enters the ODSQL clause.
+
+    Returns the validated string, or ``None`` when unset. A malformed value is
+    rejected pre-network as :class:`InvalidParameterError` rather than being
+    embedded in ``date'…'`` for the server to reject with a generic 400.
+    """
+    if value is None:
+        return None
+    text = value.strip()
+    if not text:
+        return None
+    parts = text.split("-")
+    if len(parts) == 3 and parts[0].isdigit() and len(parts[0]) == 4 and all(p.isdigit() for p in parts[1:]):
+        return text
+    raise InvalidParameterError("bdf", f"{name} must be an ISO date 'YYYY-MM-DD' (got {value!r})")
+
+
+def _build_where(series_key: str, start: str | None, end: str | None) -> str:
+    where = f'series_key="{series_key}"'
+    if start:
+        where += f" and time_period_start>=date'{start}'"
+    if end:
+        where += f" and time_period_start<=date'{end}'"
+    return where
+
+
+def _parse_observations(payload: Any, series_key: str) -> pd.DataFrame:
+    """Reshape the flat observations array into ``key,title,date,value`` rows."""
+    if not isinstance(payload, list):
+        raise ParseError("bdf", f"unexpected response shape for key: {series_key}")
+    if not payload:
+        raise EmptyDataError("bdf", query_params={"key": series_key})
+
+    rows: list[dict[str, Any]] = []
+    for row in payload:
+        if not isinstance(row, dict):
+            continue
+        date_str = str(row.get("time_period_start") or "").strip()
+        if not date_str:
+            continue
+        raw_value = row.get("obs_value")
+        try:
+            value = float(raw_value) if raw_value is not None else None
+        except (ValueError, TypeError):
+            value = None
+        title = str(row.get("title_en") or row.get("title_fr") or row.get("series_key") or series_key)
+        rows.append(
+            {
+                "key": str(row.get("series_key") or series_key),
+                "title": title,
+                "date": date_str,
+                "value": value,
+            }
+        )
+
+    if not rows:
+        raise EmptyDataError("bdf", query_params={"key": series_key})
+    return pd.DataFrame(rows, columns=list(FETCH_COLUMNS))
+
+
+@connector(output=BDF_FETCH_OUTPUT, tags=["macro", "fr"], secrets=("api_key",))
+def bdf_fetch(
+    key: Annotated[str, "ns:bdf"],
+    start_period: str | None = None,
+    end_period: str | None = None,
+    api_key: str = "",
+) -> pd.DataFrame:
+    """Fetch Banque de France time series via the Webstat Opendatasoft API.
+
+    Pulls observation rows for a single dot-separated SDMX series ``key`` (e.g.
+    ``EXR.M.USD.EUR.SP00.E``) and returns ``(key, title, date, value)`` rows
+    ordered by date. Optional ``start_period`` / ``end_period`` (``YYYY-MM-DD``)
+    bound the result on ``time_period_start``. Discover keys with ``bdf_search``
+    or ``enumerate_bdf``. Missing-status gaps come back with a null ``value``.
+    """
+    series_key = key.strip()
+    if not series_key:
+        raise InvalidParameterError("bdf", "key must be non-empty")
+    start = _validate_period(start_period, "start_period")
+    end = _validate_period(end_period, "end_period")
+
+    http = make_fetch_client(api_key)
+    payload = fetch_json(
+        http,
+        path=OBSERVATIONS_PATH,
+        params={
+            "select": OBSERVATIONS_SELECT,
+            "where": _build_where(series_key, start, end),
+            "order_by": "time_period_start",
+        },
+        provider="bdf",
+        op_name="observations",
+    )
+    return _parse_observations(payload, series_key)
+
+
+__all__ = ["bdf_fetch"]

parsimony_bdf-0.0.1/parsimony_bdf/outputs.py

@@ -0,0 +1,53 @@
+"""BdF connector output schemas."""
+
+from __future__ import annotations
+
+from parsimony.result import Column, ColumnRole, OutputConfig
+
+# The enumerator emits two entity kinds, distinguished by ``entity_type``:
+#
+# * ``series``  — KEY is the bare ``series_key`` (already globally unique, e.g.
+#   ``EXR.M.USD.EUR.SP00.E`` — the dataflow prefix makes it unique, so no
+#   compound code is needed).
+# * ``dataset`` — a synthetic parent stub keyed ``dataset:{dataset_id}`` (45 of
+#   these), mirroring BoJ's ``db:`` / BdP's ``dataset:`` so a consumer can split
+#   entity kinds by KEY prefix alone (or by the ``entity_type`` column).
+#
+# ``title`` is the English short title (French / long / key fallback); the
+# bilingual long titles plus the breadcrumb ``path`` and dataset context are
+# folded into ``description`` so the discovery index (which also covers
+# ``description``) gives recall in both languages.
+BDF_ENUMERATE_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="code", role=ColumnRole.KEY, namespace="bdf"),
+        Column(name="title", role=ColumnRole.TITLE),
+        Column(name="description", role=ColumnRole.METADATA),
+        Column(name="entity_type", role=ColumnRole.METADATA),  # "dataset" | "series"
+        Column(name="dataset_id", role=ColumnRole.METADATA),
+        Column(name="frequency", role=ColumnRole.METADATA),
+        Column(name="ref_area", role=ColumnRole.METADATA),
+        Column(name="source_agency", role=ColumnRole.METADATA),
+        Column(name="path", role=ColumnRole.METADATA),  # EN breadcrumb hierarchy
+        Column(name="first_time_period", role=ColumnRole.METADATA),
+        Column(name="last_time_period", role=ColumnRole.METADATA),
+    ]
+)
+
+BDF_FETCH_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="key", role=ColumnRole.KEY, namespace="bdf"),
+        Column(name="title", role=ColumnRole.TITLE),
+        Column(name="date", dtype="datetime", role=ColumnRole.DATA),
+        Column(name="value", dtype="numeric", role=ColumnRole.DATA),
+    ]
+)
+
+ENUMERATE_COLUMNS: tuple[str, ...] = tuple(c.name for c in BDF_ENUMERATE_OUTPUT.columns)
+FETCH_COLUMNS: tuple[str, ...] = tuple(c.name for c in BDF_FETCH_OUTPUT.columns)
+
+__all__ = [
+    "BDF_ENUMERATE_OUTPUT",
+    "BDF_FETCH_OUTPUT",
+    "ENUMERATE_COLUMNS",
+    "FETCH_COLUMNS",
+]

parsimony_bdf-0.0.1/parsimony_bdf/search.py

@@ -0,0 +1,37 @@
+"""Semantic search over the published Banque de France (BdF) catalog."""
+
+from __future__ import annotations
+
+from parsimony.catalog.search import CatalogSearchParams, make_local_search_connector
+from parsimony.result import Column, ColumnRole, OutputConfig
+
+from parsimony_bdf.catalog_build import build_bdf_catalog
+
+BdfSearchParams = CatalogSearchParams
+
+PARSIMONY_BDF_CATALOG_URL_ENV = "PARSIMONY_BDF_CATALOG_URL"
+
+BDF_SEARCH_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="code", role=ColumnRole.KEY, namespace="bdf"),
+        Column(name="title", role=ColumnRole.TITLE),
+        Column(name="score", role=ColumnRole.DATA),
+    ]
+)
+
+bdf_search = make_local_search_connector(
+    provider="bdf",
+    default_url="hf://parsimony-dev/bdf",
+    catalog_url_env_var=PARSIMONY_BDF_CATALOG_URL_ENV,
+    build_catalog=build_bdf_catalog,
+    tags=["macro", "fr", "tool"],
+    description=(
+        "Semantic-search the Banque de France (BdF) Webstat catalog of French "
+        "macroeconomic, monetary and financial time series. Returns ranked SDMX "
+        "series codes (and dataset:<id> group rows); pass a series code to "
+        "bdf_fetch(key=...) to retrieve its observations."
+    ),
+    output_columns=BDF_SEARCH_OUTPUT.columns,
+)
+
+__all__ = ["PARSIMONY_BDF_CATALOG_URL_ENV", "BdfSearchParams", "bdf_search"]

parsimony_bdf-0.0.1/pyproject.toml

@@ -0,0 +1,80 @@
+[project]
+name = "parsimony-bdf"
+version = "0.0.1"
+description = "Banque de France connector for the parsimony framework"
+authors = [{ name = "Ockham.sh", email = "team@ockham.sh" }]
+license = "Apache-2.0"
+readme = "README.md"
+requires-python = ">=3.11"
+keywords = ["finance", "data", "connectors", "parsimony", "bdf"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Financial and Insurance Industry",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Office/Business :: Financial",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+dependencies = [
+    "parsimony-core[catalog]>=0.0.1",
+    "parsimony-shared>=0.0.1",
+    "pydantic>=2.11.1,<3",
+    "pandas>=2.3.0,<3",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=9.0.3",
+    "pytest-cov>=5.0",
+    "respx>=0.22.0",
+    "ruff>=0.15.10",
+    "mypy>=1.10",
+]
+
+[project.urls]
+Homepage = "https://www.banque-france.fr"
+Repository = "https://github.com/ockham-sh/parsimony-connectors"
+Issues = "https://github.com/ockham-sh/parsimony-connectors/issues"
+
+[project.entry-points."parsimony.providers"]
+bdf = "parsimony_bdf"
+
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["parsimony_bdf"]
+
+[tool.hatch.build.targets.sdist]
+include = ["parsimony_bdf", "README.md", "LICENSE", "CHANGELOG.md"]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]
+
+[tool.ruff.lint.per-file-ignores]
+# Publish scripts call logging.basicConfig() before importing parsimony so
+# the kernel's INFO logs surface during the long-running publish pipeline.
+"scripts/*" = ["E402"]
+
+[tool.mypy]
+python_version = "3.11"
+warn_return_any = true
+warn_unused_ignores = true
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+addopts = "--import-mode=importlib -m 'not integration'"
+markers = [
+    "integration: hits live APIs (may be slow, requires env vars)",
+]