parsimony-boc 0.0.1__tar.gz

parsimony_boc-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_boc-0.0.1/CHANGELOG.md

@@ -0,0 +1,57 @@
+# Changelog — parsimony-boc
+
+All notable changes to `parsimony-boc` 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-09
+
+Re-run through the full connector guidebook process and **live-verified** against
+the production Valet API and bulk list endpoints.
+
+### Added
+
+- **Observations URL-length guard.** Valet 302-redirects any `/observations`
+  request whose URL exceeds ~4096 bytes (a limit on URL length, not series
+  count). `boc_fetch` now rejects oversized requests pre-network with an
+  actionable `InvalidParameterError` (split the names, or fetch a whole panel
+  with `group:NAME`) instead of an opaque redirect surfacing as a `ParseError`.
+- **Retired-group pruning.** The per-group membership fan-out doubles as a
+  liveness probe: ~29 dated one-off panels that 404 on both `/groups/{name}` and
+  `/observations/group/{name}` are pruned from the catalog so it never offers an
+  unfetchable panel. A *transient* (5xx/network) failure keeps the group
+  best-effort — only a definitive 404 prunes.
+- A `failed/total` enumeration summary log (series + live groups + pruned +
+  transient failures), `catalog_tests/queries.yaml` (recall gate), and
+  `tests/test_public_surface.py`.
+
+### Changed
+
+- **Package restructured** into `_http` / `outputs` / `connectors/{fetch,
+  enumerate,__init__}` / `search` / `catalog_build`; the monolithic
+  `__init__.py` is now a thin facade. No change to the connector surface
+  (`boc_fetch`, `enumerate_boc`, `boc_search`) or the catalog schema.
+- Completeness re-verified live: `/lists/series/json` (15,638 series) is the
+  authoritative universe — a full fan-out over all 2,441 groups surfaces **0**
+  members absent from it; ~99.7% of listed series are fetchable (stale entries
+  return a clean `EmptyDataError`); every live group panel is fetchable.
+
+## [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_boc-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_boc-0.0.1/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: parsimony-boc
+Version: 0.0.1
+Summary: Bank of Canada connector for the parsimony framework
+Project-URL: Homepage, https://www.bankofcanada.ca
+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: boc,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: 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-boc
+
+Bank of Canada connector — Canadian exchange rates, interest/bond yields, money
+& credit aggregates, CPI, commodity price indices, and the data behind BoC
+publications, as numeric time series via the **Valet** API.
+
+Part of the [parsimony-connectors](https://github.com/ockham-sh/parsimony-connectors) monorepo. Distributed standalone on PyPI as `parsimony-boc`.
+
+## Connectors
+
+| Name | Kind | Description |
+|---|---|---|
+| `boc_fetch` | connector | Fetch one or more series by name (e.g. `FXUSDCAD,FXEURCAD`) or a whole panel by group (e.g. `group:FX_RATES_DAILY`). Reaches the **entire** universe by name. |
+| `enumerate_boc` | enumerator | Catalog feed: one row per series (~15.6k) and one per live group (~2.4k), from Valet's list endpoints plus a per-group membership fan-out. |
+| `boc_search` | connector | Search the published BoC catalog (lexical title or `code:`/structured). Pass returned codes to `boc_fetch(series_name=...)`. |
+
+## Discovery model
+
+The Valet API has **no native keyword search**, so discovery is a built catalog
+(archetype A — one live full-index call lists the whole universe):
+
+- `GET /lists/series/json` is the **authoritative enumeration path** (15,638
+  series, live 2026-06-09). It self-tracks BoC additions, so the catalog stays
+  current on each rebuild.
+- **Groups are first-class catalog entities.** Each named panel (e.g.
+  `FX_RATES_DAILY`) gets its own row keyed `group:NAME` — the exact string
+  `boc_fetch` accepts — because group descriptions carry retrieval signal no
+  individual series has ("Month-end, Millions of dollars"). A fetch on a
+  `group:` code returns the whole panel in one request.
+- The per-group membership fan-out doubles as a **liveness probe**: ~29 retired
+  one-off panels that 404 on every fetch path are pruned, so the catalog never
+  offers a panel you cannot fetch.
+
+Every series stays fetchable by name regardless of catalog coverage — the
+boundary is discovery, not access.
+
+## Install
+
+```bash
+pip install parsimony-boc
+```
+
+Pulls in a compatible `parsimony-core` automatically. Verify discovery:
+
+```bash
+python -c "from parsimony import discover; print([p.name for p in discover.iter_providers()])"
+```
+
+## Configuration
+
+No configuration required — the Valet API is open and unauthenticated.
+
+`boc_search` reads published catalog snapshots (default root
+`hf://parsimony-dev/boc`). Override with `PARSIMONY_BOC_CATALOG_URL` or
+`catalog_url=` at call time; a missing snapshot is built on demand from the live
+list endpoints and cached in an LRU.
+
+> **Observations request limit.** Valet caps the `/observations` request URL near
+> **4096 bytes** (roughly 100–160 comma-joined series, depending on name length).
+> `boc_fetch` guards this pre-call and asks you to split the request or fetch a
+> whole panel with `group:NAME`. The limit is on URL length, not series count.
+
+## Quick start
+
+```python
+from parsimony_boc import CONNECTORS
+
+# find a series (or a whole panel) in the catalog
+hits = CONNECTORS["boc_search"](query="US dollar Canadian dollar exchange rate")
+code = hits.data.iloc[0]["code"]            # e.g. "FXUSDCAD" or "group:FX_RATES_DAILY"
+# fetch observations
+result = CONNECTORS["boc_fetch"](series_name=code, start_date="2024-01-01")
+print(result.data.head())
+```
+
+For multi-plugin composition (autoloads everything installed):
+
+```python
+from parsimony import discover
+connectors = discover.load_all()
+```
+
+## Catalog building
+
+`scripts/build_catalog.py` builds the single `boc` catalog from the live list
+endpoints and saves/pushes a snapshot:
+
+```bash
+uv run python packages/boc/scripts/build_catalog.py \
+  --save file:///tmp/parsimony-catalogs/boc --push hf://parsimony-dev/boc
+```
+
+## Provider
+
+- Homepage: https://www.bankofcanada.ca
+- Valet API docs: https://www.bankofcanada.ca/valet/docs
+- Terms: https://www.bankofcanada.ca/terms/ — free reuse **with attribution to
+  the Bank of Canada**. Data is © Bank of Canada; this connector and its catalog
+  are a derived index of series identifiers and titles.
+
+## License
+
+See [LICENSE](./LICENSE).

parsimony_boc-0.0.1/README.md

@@ -0,0 +1,103 @@
+# parsimony-boc
+
+Bank of Canada connector — Canadian exchange rates, interest/bond yields, money
+& credit aggregates, CPI, commodity price indices, and the data behind BoC
+publications, as numeric time series via the **Valet** API.
+
+Part of the [parsimony-connectors](https://github.com/ockham-sh/parsimony-connectors) monorepo. Distributed standalone on PyPI as `parsimony-boc`.
+
+## Connectors
+
+| Name | Kind | Description |
+|---|---|---|
+| `boc_fetch` | connector | Fetch one or more series by name (e.g. `FXUSDCAD,FXEURCAD`) or a whole panel by group (e.g. `group:FX_RATES_DAILY`). Reaches the **entire** universe by name. |
+| `enumerate_boc` | enumerator | Catalog feed: one row per series (~15.6k) and one per live group (~2.4k), from Valet's list endpoints plus a per-group membership fan-out. |
+| `boc_search` | connector | Search the published BoC catalog (lexical title or `code:`/structured). Pass returned codes to `boc_fetch(series_name=...)`. |
+
+## Discovery model
+
+The Valet API has **no native keyword search**, so discovery is a built catalog
+(archetype A — one live full-index call lists the whole universe):
+
+- `GET /lists/series/json` is the **authoritative enumeration path** (15,638
+  series, live 2026-06-09). It self-tracks BoC additions, so the catalog stays
+  current on each rebuild.
+- **Groups are first-class catalog entities.** Each named panel (e.g.
+  `FX_RATES_DAILY`) gets its own row keyed `group:NAME` — the exact string
+  `boc_fetch` accepts — because group descriptions carry retrieval signal no
+  individual series has ("Month-end, Millions of dollars"). A fetch on a
+  `group:` code returns the whole panel in one request.
+- The per-group membership fan-out doubles as a **liveness probe**: ~29 retired
+  one-off panels that 404 on every fetch path are pruned, so the catalog never
+  offers a panel you cannot fetch.
+
+Every series stays fetchable by name regardless of catalog coverage — the
+boundary is discovery, not access.
+
+## Install
+
+```bash
+pip install parsimony-boc
+```
+
+Pulls in a compatible `parsimony-core` automatically. Verify discovery:
+
+```bash
+python -c "from parsimony import discover; print([p.name for p in discover.iter_providers()])"
+```
+
+## Configuration
+
+No configuration required — the Valet API is open and unauthenticated.
+
+`boc_search` reads published catalog snapshots (default root
+`hf://parsimony-dev/boc`). Override with `PARSIMONY_BOC_CATALOG_URL` or
+`catalog_url=` at call time; a missing snapshot is built on demand from the live
+list endpoints and cached in an LRU.
+
+> **Observations request limit.** Valet caps the `/observations` request URL near
+> **4096 bytes** (roughly 100–160 comma-joined series, depending on name length).
+> `boc_fetch` guards this pre-call and asks you to split the request or fetch a
+> whole panel with `group:NAME`. The limit is on URL length, not series count.
+
+## Quick start
+
+```python
+from parsimony_boc import CONNECTORS
+
+# find a series (or a whole panel) in the catalog
+hits = CONNECTORS["boc_search"](query="US dollar Canadian dollar exchange rate")
+code = hits.data.iloc[0]["code"]            # e.g. "FXUSDCAD" or "group:FX_RATES_DAILY"
+# fetch observations
+result = CONNECTORS["boc_fetch"](series_name=code, start_date="2024-01-01")
+print(result.data.head())
+```
+
+For multi-plugin composition (autoloads everything installed):
+
+```python
+from parsimony import discover
+connectors = discover.load_all()
+```
+
+## Catalog building
+
+`scripts/build_catalog.py` builds the single `boc` catalog from the live list
+endpoints and saves/pushes a snapshot:
+
+```bash
+uv run python packages/boc/scripts/build_catalog.py \
+  --save file:///tmp/parsimony-catalogs/boc --push hf://parsimony-dev/boc
+```
+
+## Provider
+
+- Homepage: https://www.bankofcanada.ca
+- Valet API docs: https://www.bankofcanada.ca/valet/docs
+- Terms: https://www.bankofcanada.ca/terms/ — free reuse **with attribution to
+  the Bank of Canada**. Data is © Bank of Canada; this connector and its catalog
+  are a derived index of series identifiers and titles.
+
+## License
+
+See [LICENSE](./LICENSE).

parsimony_boc-0.0.1/parsimony_boc/__init__.py

@@ -0,0 +1,32 @@
+"""Bank of Canada (BoC) connector: fetch + catalog enumeration + search.
+
+Valet API (``https://www.bankofcanada.ca/valet``) — keyless public JSON. Three
+connectors, discovered as the top-level ``CONNECTORS`` bundle:
+
+* ``boc_fetch`` — observations by series name(s) or ``group:NAME`` panel.
+* ``enumerate_boc`` — the catalog feed (archetype A: live ``/lists/series``).
+* ``boc_search`` — search over the published catalog snapshot.
+
+This module is a thin facade; the implementation lives in ``_http`` / ``outputs``
+/ ``connectors/{fetch,enumerate}`` / ``search`` / ``catalog_build``.
+"""
+
+from __future__ import annotations
+
+from parsimony_boc.connectors import CONNECTORS, load
+from parsimony_boc.connectors.enumerate import enumerate_boc
+from parsimony_boc.connectors.fetch import boc_fetch
+from parsimony_boc.outputs import BOC_ENUMERATE_OUTPUT, BOC_FETCH_OUTPUT
+from parsimony_boc.search import BOC_SEARCH_OUTPUT, PARSIMONY_BOC_CATALOG_URL_ENV, boc_search
+
+__all__ = [
+    "BOC_ENUMERATE_OUTPUT",
+    "BOC_FETCH_OUTPUT",
+    "BOC_SEARCH_OUTPUT",
+    "CONNECTORS",
+    "PARSIMONY_BOC_CATALOG_URL_ENV",
+    "boc_fetch",
+    "boc_search",
+    "enumerate_boc",
+    "load",
+]

parsimony_boc-0.0.1/parsimony_boc/_http.py

@@ -0,0 +1,91 @@
+"""Bank of Canada (BoC) Valet transport: constants + the canonical client.
+
+The Valet API is keyless JSON — there is no auth to resolve, so this module is
+thin: a base URL, timeouts, the group-fan-out concurrency cap, and the one
+non-obvious transport fact, the **observations request-URI limit**.
+
+``boc_fetch`` and the list endpoints all speak GET + JSON, so they go through
+the kernel's canonical ``make_http_client`` + ``fetch_json`` pair (GET +
+``raise_for_status`` + ``map_http_error`` / ``map_timeout_error`` + ``json()`` +
+``None``-param dropping). There is no provider-specific status semantics to
+intercept, so there is no per-package mapper chokepoint here.
+
+Endpoints (base ``https://www.bankofcanada.ca/valet``):
+
+* ``GET /lists/series/json`` (~15.6k) and ``GET /lists/groups/json`` (~2.4k) —
+  the catalog index.
+* ``GET /groups/{name}/json`` — per-group series membership (the fan-out); a
+  retired group returns 404.
+* ``GET /observations/{names}/json`` and
+  ``GET /observations/group/{name}/json`` — time-series observations.
+
+**Observations request-URI cap (~4096 bytes).** Valet redirects (HTTP 302, to an
+error page) any ``/observations`` request whose URL exceeds ~4 KB. The boundary
+is on the *URL length*, not the series count: a full URL of 4087 bytes returns
+200 while 4127 bytes 302s (measured live 2026-06-09). So a count cap is wrong
+(140 short names pass, 140 long names 302). We guard the assembled URL
+pre-network and raise a clear :class:`InvalidParameterError` instead of letting
+the agent hit an opaque redirect that ``fetch_json`` would surface as a
+``ParseError``.
+"""
+
+from __future__ import annotations
+
+from parsimony.errors import InvalidParameterError
+from parsimony.transport import HttpClient
+from parsimony.transport.helpers import make_http_client
+
+PROVIDER = "boc"
+
+BASE_URL = "https://www.bankofcanada.ca/valet"
+
+#: Per-call timeout for both the fetch and the (large) list endpoints. The
+#: series index is ~3.5 MB, so allow a long read.
+FETCH_TIMEOUT = 60.0
+
+#: Concurrency cap for the per-group fan-out that builds the series→group map.
+#: Valet is unauthenticated and tolerates moderate concurrency; 16 keeps the
+#: ~2,400-group sweep at ~70 s while staying well under any sensible limit.
+GROUP_FETCH_CONCURRENCY = 16
+
+#: Maximum assembled-URL length (host + path, query excluded) we will send to
+#: ``/observations``. The server caps the request URI at ~4096 bytes; we sit
+#: conservatively below that so the date query string still fits under the cap.
+OBSERVATIONS_MAX_URL_BYTES = 4000
+
+
+def make_valet_client(timeout: float = FETCH_TIMEOUT) -> HttpClient:
+    """Build the canonical keyless Valet client (GET + JSON via ``fetch_json``)."""
+    return make_http_client(BASE_URL, timeout=timeout)
+
+
+def guard_observations_path(path: str, *, series_name: str) -> None:
+    """Reject an ``/observations`` path whose URL would exceed the server cap.
+
+    Valet 302-redirects any observations request URL over ~4 KB. Caught
+    pre-network, this becomes an actionable :class:`InvalidParameterError`
+    (split the request or fetch a whole panel with ``group:NAME``) instead of an
+    opaque redirect that downstream parsing would report as a ``ParseError``.
+    """
+    url_len = len(BASE_URL) + 1 + len(path)
+    if url_len > OBSERVATIONS_MAX_URL_BYTES:
+        raise InvalidParameterError(
+            PROVIDER,
+            (
+                f"too many/long series names: the request URL is {url_len} bytes but the "
+                f"Bank of Canada observations endpoint caps it near {OBSERVATIONS_MAX_URL_BYTES + 96}. "
+                "Split the names across multiple boc_fetch calls, or fetch a whole panel in one "
+                "call with series_name='group:GROUP_NAME'."
+            ),
+        )
+
+
+__all__ = [
+    "BASE_URL",
+    "FETCH_TIMEOUT",
+    "GROUP_FETCH_CONCURRENCY",
+    "OBSERVATIONS_MAX_URL_BYTES",
+    "PROVIDER",
+    "guard_observations_path",
+    "make_valet_client",
+]

parsimony_boc-0.0.1/parsimony_boc/catalog_build.py

@@ -0,0 +1,24 @@
+"""Build the Bank of Canada catalog snapshot."""
+
+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_boc.connectors.enumerate import enumerate_boc
+from parsimony_boc.outputs import BOC_ENUMERATE_OUTPUT
+
+CATALOG_NAMESPACE = "boc"
+
+
+def build_boc_catalog() -> Catalog:
+    result = enumerate_boc()
+    entries = entities_from_raw(result, BOC_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_boc_catalog"]

parsimony_boc-0.0.1/parsimony_boc/connectors/__init__.py

@@ -0,0 +1,25 @@
+"""boc connector registry."""
+
+from __future__ import annotations
+
+from parsimony.connector import Connectors
+
+from parsimony_boc.connectors.enumerate import enumerate_boc
+from parsimony_boc.connectors.fetch import boc_fetch
+from parsimony_boc.search import boc_search
+
+CONNECTORS = Connectors([boc_fetch, enumerate_boc, boc_search])
+
+
+def load(*, catalog_url: str | None = None) -> Connectors:
+    """Return :data:`CONNECTORS` with the optional search catalog URL bound.
+
+    BoC is keyless — there is no API key to bind. ``catalog_url`` lets an
+    operator point ``boc_search`` at a specific catalog snapshot.
+    """
+    if catalog_url is None:
+        return CONNECTORS
+    return CONNECTORS.bind(catalog_url=catalog_url)
+
+
+__all__ = ["CONNECTORS", "load"]

parsimony_boc-0.0.1/parsimony_boc/connectors/enumerate.py

@@ -0,0 +1,220 @@
+"""BoC catalog enumerator (archetype A: the live ``/lists/series`` full index).
+
+Emits one row per series **and** one row per *live* group. The series index
+(``/lists/series/json``, ~15.6k) is the authoritative universe — verified
+complete: a full fan-out over every group surfaces zero members absent from it.
+
+The per-group fan-out (``/groups/{name}/json`` × ~2.4k) does double duty:
+
+1. **Membership** — annotates each series with its group (97.7% of series carry
+   a group; the first encountered wins for the rare multi-group series).
+2. **Liveness** — a group whose detail endpoint 404s is *retired* (BoC leaves
+   ~29 dated one-off panels in ``/lists/groups`` that 404 on both
+   ``/groups/{name}`` and ``/observations/group/{name}``). We use the 404 signal
+   to **prune** those group rows so the catalog never offers a panel that cannot
+   be fetched. A *transient* failure (5xx / network) is kept best-effort — only
+   a definitive 404 prunes.
+
+A ``failed/total`` summary is logged at the end so a quietly-shrunk crawl is
+visible (guidebook §7.2).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import httpx
+import pandas as pd
+from parsimony.connector import enumerator
+from parsimony.errors import ParseError
+from parsimony.transport import HttpClient, pooled_client
+from parsimony.transport.helpers import fetch_json
+
+from parsimony_boc._http import PROVIDER, make_valet_client
+from parsimony_boc.outputs import BOC_ENUMERATE_OUTPUT, ENUMERATE_COLUMNS
+
+logger = logging.getLogger(__name__)
+
+
+def _list_groups(client: HttpClient) -> dict[str, dict[str, Any]]:
+    """Return BoC's group index (~2.4k entries) from ``/lists/groups/json``.
+
+    This is the **bounding seam** for live tests: monkeypatch this module global
+    to a 2–3 group slice so the per-group fan-out fires a handful of requests,
+    never the full ~2,400-request crawl. ``enumerate_boc`` reads it as a module
+    global at call time so the monkeypatch takes.
+    """
+    payload = fetch_json(client, path="lists/groups/json", provider=PROVIDER, op_name="groups/list")
+    if not isinstance(payload, dict):
+        raise ParseError(PROVIDER, "unexpected /lists/groups/json shape (expected object)")
+    groups = payload.get("groups") or {}
+    return groups if isinstance(groups, dict) else {}
+
+
+def _fetch_group_membership(
+    client: HttpClient,
+    group_name: str,
+) -> tuple[str, list[str], bool]:
+    """Fetch one group's membership. Returns ``(name, members, alive)``.
+
+    ``alive`` is ``False`` **only** on a definitive 404 (a retired group): the
+    caller prunes those from the catalog. A transient transport error or a
+    200-with-non-JSON body keeps ``alive=True`` (best-effort) — the group is
+    still catalogued, it just loses its membership annotation this run, so a
+    network blip never silently shrinks the catalog.
+    """
+    try:
+        resp = client.request("GET", f"/groups/{group_name}/json")
+        resp.raise_for_status()
+        body = resp.json()
+    except httpx.HTTPStatusError as exc:
+        if exc.response.status_code == 404:
+            # Retired-but-indexed group: prune it.
+            return group_name, [], False
+        logger.warning("BoC group fetch failed for %r: HTTP %s", group_name, exc.response.status_code)
+        return group_name, [], True
+    except (httpx.HTTPError, ValueError) as exc:
+        # Transport failure OR a 200-with-non-JSON body (BoC sometimes serves
+        # an HTML stub) — keep the group, drop only its membership this run.
+        logger.warning("BoC group fetch failed for %r: %s", group_name, exc)
+        return group_name, [], True
+
+    if not isinstance(body, dict):
+        return group_name, [], True
+    details = body.get("groupDetails") or {}
+    members = details.get("groupSeries") or {}
+    if not isinstance(members, dict):
+        return group_name, [], True
+    return group_name, [s for s in members if s], True
+
+
+def _build_series_to_group_map(
+    client: HttpClient,
+    groups_index: dict[str, dict[str, Any]],
+) -> tuple[dict[str, tuple[str, str]], set[str], int]:
+    """Fan out over groups → ``(series_to_group, dead_groups, transient_failures)``.
+
+    ``series_to_group`` maps each series to its first ``(group_id, group_label)``.
+    ``dead_groups`` are the names that 404'd (retired) — the caller skips their
+    rows. ``transient_failures`` counts non-404 failures (kept, for the summary
+    log). Connections are pooled across the walk via :func:`pooled_client`.
+    """
+    with pooled_client(client) as shared:
+        results = [_fetch_group_membership(shared, name) for name in groups_index]
+
+    series_to_group: dict[str, tuple[str, str]] = {}
+    dead_groups: set[str] = set()
+    transient_failures = 0
+    for group_name, members, alive in results:
+        if not alive:
+            dead_groups.add(group_name)
+            continue
+        if not members:
+            # alive but no members → either an empty/transient result. We can't
+            # distinguish a live-but-empty group from a transient miss here, but
+            # live groups always carry members in practice, so a non-404 empty is
+            # a transient failure for summary purposes.
+            transient_failures += 1
+        info = groups_index.get(group_name) or {}
+        label = (info.get("label") if isinstance(info, dict) else "") or ""
+        for series_name in members:
+            if series_name not in series_to_group:
+                series_to_group[series_name] = (group_name, label)
+    return series_to_group, dead_groups, transient_failures
+
+
+@enumerator(output=BOC_ENUMERATE_OUTPUT, tags=["macro", "ca"])
+def enumerate_boc() -> pd.DataFrame:
+    """Enumerate every Bank of Canada series and live group via Valet.
+
+    Granularity is one row per series — Valet addresses observations per series,
+    so series-level keys are the right unit (~15.6k rows) — plus one row per live
+    group (keyed ``group:NAME``) so whole panels are discoverable.
+
+    Pipeline: ``/lists/series/json`` and ``/lists/groups/json``, then a
+    serial ``/groups/{name}/json`` fan-out for series→group membership and
+    group liveness (retired groups that 404 are pruned).
+    """
+    client = make_valet_client()
+
+    series_payload = fetch_json(client, path="lists/series/json", provider=PROVIDER, op_name="series/list")
+    if not isinstance(series_payload, dict):
+        raise ParseError(PROVIDER, "unexpected /lists/series/json shape (expected object)")
+
+    groups_index = _list_groups(client)
+    series_to_group, dead_groups, transient_failures = _build_series_to_group_map(client, groups_index)
+
+    series = series_payload.get("series") or {}
+    if not isinstance(series, dict):
+        series = {}
+
+    rows: list[dict[str, str]] = []
+    for series_name, info in series.items():
+        if not series_name:
+            continue
+        if isinstance(info, dict):
+            label = info.get("label") or series_name
+            desc = info.get("description") or ""
+        else:
+            label = str(info)
+            desc = ""
+
+        group_id, group_label = series_to_group.get(series_name, ("", ""))
+        rows.append(
+            {
+                "series_name": series_name,
+                "title": label,
+                "description": desc,
+                "source": "valet",
+                "entity_type": "series",
+                "group": group_id,
+                "group_label": group_label,
+            }
+        )
+
+    n_series = len(rows)
+
+    # One row per *live* group as a discoverable catalog entity. Groups are
+    # addressable via ``boc_fetch(series_name="group:NAME")``; cataloguing them
+    # lets agents search by the group-level description ("Month-end, Millions of
+    # dollars") and fetch a whole panel in one shot. Retired groups (404 on
+    # detail) are pruned so the catalog never offers an unfetchable panel.
+    n_groups = 0
+    for group_name, group_info in groups_index.items():
+        if not group_name or group_name in dead_groups:
+            continue
+        if isinstance(group_info, dict):
+            g_label = group_info.get("label") or group_name
+            g_desc = group_info.get("description") or ""
+        else:
+            g_label = str(group_info)
+            g_desc = ""
+        rows.append(
+            {
+                "series_name": f"group:{group_name}",
+                "title": g_label,
+                "description": g_desc,
+                "source": "valet",
+                "entity_type": "group",
+                "group": group_name,
+                "group_label": g_label,
+            }
+        )
+        n_groups += 1
+
+    logger.info(
+        "boc enumerate: %d series + %d live groups "
+        "(%d retired groups pruned, %d transient membership failures of %d groups)",
+        n_series,
+        n_groups,
+        len(dead_groups),
+        transient_failures,
+        len(groups_index),
+    )
+
+    columns = list(ENUMERATE_COLUMNS)
+    return pd.DataFrame(rows, columns=columns) if rows else pd.DataFrame(columns=columns)
+
+
+__all__ = ["enumerate_boc"]

parsimony_boc-0.0.1/parsimony_boc/connectors/fetch.py

@@ -0,0 +1,119 @@
+"""BoC observations fetch connector (Valet ``/observations`` endpoint).
+
+Fetches one or more series by name, or a whole named panel via ``group:NAME``.
+The observations payload is a wide, date-keyed array — ``{"d": ..., "FXUSDCAD":
+{"v": "1.38"}, ...}`` — which we melt into long ``(series_name, title, date,
+value)`` rows. Suppressed/missing observations (``""`` / ``"NaN"`` / absent) come
+back as a null ``value``.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+import pandas as pd
+from parsimony import Namespace
+from parsimony.connector import connector
+from parsimony.errors import EmptyDataError, InvalidParameterError, ParseError
+from parsimony.transport.helpers import fetch_json
+
+from parsimony_boc._http import PROVIDER, guard_observations_path, make_valet_client
+from parsimony_boc.outputs import BOC_FETCH_OUTPUT
+
+_FETCH_COLUMNS = ["series_name", "title", "date", "value"]
+
+
+def _parse_observations(
+    json_data: dict[str, Any],
+    series_details: dict[str, Any] | None = None,
+) -> pd.DataFrame:
+    """Melt the Valet observations array into long-format rows.
+
+    Each observation entry looks like
+    ``{"d": "2024-01-15", "FXUSDCAD": {"v": "1.3456"}, ...}`` — one date key
+    plus one nested ``{"v": ...}`` per series. Titles are resolved from the
+    payload's ``seriesDetail`` block when present, else fall back to the name.
+    """
+    observations = json_data.get("observations", [])
+    if not observations:
+        return pd.DataFrame(columns=_FETCH_COLUMNS)
+
+    sample = observations[0]
+    series_cols = [k for k in sample if k != "d"]
+
+    rows: list[dict[str, Any]] = []
+    for obs in observations:
+        date = obs.get("d", "")
+        for col in series_cols:
+            raw = obs.get(col)
+            if raw is None:
+                continue
+            raw_value = raw.get("v") if isinstance(raw, dict) else raw
+            try:
+                value = float(raw_value) if raw_value is not None and raw_value not in ("", "NaN") else None
+            except (ValueError, TypeError):
+                value = None
+
+            title = col
+            if series_details and col in series_details:
+                detail = series_details[col]
+                title = detail.get("label", detail.get("description", col))
+
+            rows.append({"series_name": col, "title": title, "date": date, "value": value})
+
+    return pd.DataFrame(rows, columns=_FETCH_COLUMNS) if rows else pd.DataFrame(columns=_FETCH_COLUMNS)
+
+
+@connector(output=BOC_FETCH_OUTPUT, tags=["macro", "ca"])
+def boc_fetch(
+    series_name: Annotated[str, Namespace("boc")],
+    start_date: str | None = None,
+    end_date: str | None = None,
+) -> pd.DataFrame:
+    """Fetch Bank of Canada time series by series name(s) or group name.
+
+    Use 'group:GROUP_NAME' syntax for a whole panel (e.g. group:FX_RATES_DAILY).
+    Otherwise pass one or more comma-separated series names (e.g.
+    FXUSDCAD,FXEURCAD). Discover names with boc_search or enumerate_boc.
+    Observations come back as long-format (series_name, title, date, value)
+    rows; optional start_date/end_date (YYYY-MM-DD) bound the window.
+    """
+    series_name = series_name.strip()
+    if not series_name:
+        raise InvalidParameterError(PROVIDER, "series_name must be non-empty")
+
+    if series_name.startswith("group:"):
+        group_name = series_name[6:].strip()
+        if not group_name:
+            raise InvalidParameterError(PROVIDER, "group name must be non-empty after 'group:'")
+        path = f"observations/group/{group_name}/json"
+    else:
+        path = f"observations/{series_name}/json"
+
+    # Valet 302-redirects observations requests whose URL exceeds ~4 KB; reject
+    # those pre-network with actionable guidance rather than a downstream parse
+    # failure. Only the multi-series path realistically trips this.
+    guard_observations_path(path, series_name=series_name)
+
+    json_data = fetch_json(
+        make_valet_client(),
+        path=path,
+        params={"start_date": start_date, "end_date": end_date},
+        provider=PROVIDER,
+        op_name="observations",
+    )
+    if not isinstance(json_data, dict):
+        raise ParseError(PROVIDER, f"unexpected observations response shape for: {series_name}")
+
+    df = _parse_observations(json_data, json_data.get("seriesDetail"))
+    if df.empty:
+        raise EmptyDataError(
+            PROVIDER,
+            message=f"No observations returned for: {series_name}",
+            query_params={"series_name": series_name, "start_date": start_date, "end_date": end_date},
+        )
+
+    return df
+
+
+__all__ = ["boc_fetch"]

parsimony_boc-0.0.1/parsimony_boc/outputs.py

@@ -0,0 +1,54 @@
+"""Output schemas for the Bank of Canada (BoC) connectors."""
+
+from __future__ import annotations
+
+from parsimony.result import Column, ColumnRole, OutputConfig
+
+BOC_FETCH_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="series_name", role=ColumnRole.KEY, namespace="boc"),
+        Column(name="title", role=ColumnRole.TITLE),
+        Column(name="date", dtype="datetime", role=ColumnRole.DATA),
+        Column(name="value", dtype="numeric", role=ColumnRole.DATA),
+    ]
+)
+
+BOC_ENUMERATE_OUTPUT = OutputConfig(
+    columns=[
+        # The KEY is either a series name (e.g. ``FXUSDCAD``) or a group entry
+        # prefixed with ``group:`` (e.g. ``group:FX_RATES_DAILY``). Groups are
+        # first-class addressable entities — ``boc_fetch`` accepts
+        # ``series_name="group:NAME"`` and Valet's
+        # ``/observations/group/{name}/json`` returns the full panel — so they
+        # get their own catalog rows for discovery alongside the per-series rows.
+        # The ``group:`` prefix is the exact string ``boc_fetch`` already
+        # expects, so a search hit routes straight to a fetch.
+        Column(name="series_name", role=ColumnRole.KEY, namespace="boc"),
+        Column(name="title", role=ColumnRole.TITLE),
+        # The upstream Valet ``description`` text. For group rows this carries
+        # the group's description (often the only place units/frequency live,
+        # e.g. "Month-end, Millions of dollars").
+        Column(name="description", role=ColumnRole.METADATA),
+        # ``source`` tells the agent which fetch connector to call. BoC has a
+        # single Valet source today; the column is future-proofing for a
+        # parallel source so dispatch is already wired (matches Treasury's
+        # ``fiscal_data``/``treasury_rates`` split).
+        Column(name="source", role=ColumnRole.METADATA),
+        # ``entity_type`` is ``"series"`` for individual series rows and
+        # ``"group"`` for group rows — lets agents filter or weight by
+        # entity granularity.
+        Column(name="entity_type", role=ColumnRole.METADATA),
+        # ``group`` carries the upstream group ID the series belongs to. A
+        # series can belong to several groups (rare); the first encountered
+        # group wins. Empty string when a series is in no catalogued group.
+        # For group rows this is the group's own ID.
+        Column(name="group", role=ColumnRole.METADATA),
+        Column(name="group_label", role=ColumnRole.METADATA),
+    ]
+)
+
+#: The exact column order the ``@enumerator`` must return (enumerators drop
+#: unmapped columns then require an exact match against the declared schema).
+ENUMERATE_COLUMNS: tuple[str, ...] = tuple(c.name for c in BOC_ENUMERATE_OUTPUT.columns)
+
+__all__ = ["BOC_ENUMERATE_OUTPUT", "BOC_FETCH_OUTPUT", "ENUMERATE_COLUMNS"]

parsimony_boc-0.0.1/parsimony_boc/search.py

@@ -0,0 +1,35 @@
+"""Semantic search over the published Bank of Canada (BoC) catalog."""
+
+from __future__ import annotations
+
+from parsimony.catalog.search import CatalogSearchParams, make_local_search_connector
+from parsimony.result import Column, ColumnRole, OutputConfig
+
+from parsimony_boc.catalog_build import build_boc_catalog
+
+PARSIMONY_BOC_CATALOG_URL_ENV = "PARSIMONY_BOC_CATALOG_URL"
+
+BocSearchParams = CatalogSearchParams
+
+BOC_SEARCH_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="code", role=ColumnRole.KEY, namespace="boc"),
+        Column(name="title", role=ColumnRole.TITLE),
+        Column(name="score", role=ColumnRole.DATA),
+    ]
+)
+
+
+boc_search = make_local_search_connector(
+    provider="boc",
+    default_url="hf://parsimony-dev/boc",
+    catalog_url_env_var=PARSIMONY_BOC_CATALOG_URL_ENV,
+    build_catalog=build_boc_catalog,
+    tags=["macro", "ca", "tool"],
+    description=(
+        "Search the Bank of Canada (BoC) Valet catalog. "
+        "Preferred: structured queries such as 'code: FXUSDCAD'. "
+        "Pass returned codes to boc_fetch(series_name=...)."
+    ),
+    output_columns=BOC_SEARCH_OUTPUT.columns,
+)

parsimony_boc-0.0.1/pyproject.toml

@@ -0,0 +1,79 @@
+[project]
+name = "parsimony-boc"
+version = "0.0.1"
+description = "Bank of Canada 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", "boc"]
+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",
+    "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.bankofcanada.ca"
+Repository = "https://github.com/ockham-sh/parsimony-connectors"
+Issues = "https://github.com/ockham-sh/parsimony-connectors/issues"
+
+[project.entry-points."parsimony.providers"]
+boc = "parsimony_boc"
+
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["parsimony_boc"]
+
+[tool.hatch.build.targets.sdist]
+include = ["parsimony_boc", "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)",
+]