parsimony-treasury 0.4.0__tar.gz

parsimony_treasury-0.4.0/.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_treasury-0.4.0/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog — parsimony-treasury
+
+All notable changes to `parsimony-treasury` 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/).
+
+## [Unreleased]
+
+## [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_treasury-0.4.0/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_treasury-0.4.0/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: parsimony-treasury
+Version: 0.4.0
+Summary: U.S. Treasury connector for the parsimony framework
+Project-URL: Homepage, https://fiscaldata.treasury.gov
+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: connectors,data,finance,parsimony,treasury
+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<0.5,>=0.4.0
+Requires-Dist: pydantic<3,>=2.11.1
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=1.3.0; 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'
+Provides-Extra: publish
+Requires-Dist: parsimony-core[standard-onnx]<0.5,>=0.4.0; extra == 'publish'
+Description-Content-Type: text/markdown
+
+# parsimony-treasury
+
+US Treasury Fiscal Data connector plugin for parsimony — debt, revenue, spending, securities, and other federal fiscal datasets from the Bureau of the Fiscal Service.
+
+Part of the [parsimony-connectors](https://github.com/ockham-sh/parsimony-connectors) monorepo. Distributed standalone on PyPI as `parsimony-treasury`.
+
+## Connectors
+
+| Name | Kind | Description |
+|---|---|---|
+| `treasury_fetch` | connector | Fetch any Fiscal Data API endpoint as a tidy DataFrame, with optional `filter`, `sort`, and page size. |
+| `enumerate_treasury` | enumerator | Enumerate every Treasury Fiscal Data dataset and endpoint for catalog indexing (drives the `treasury` catalog). |
+
+## Install
+
+```bash
+pip install parsimony-treasury
+```
+
+Pulls in `parsimony-core>=0.4,<0.5` automatically. Verify discovery:
+
+```bash
+python -c "from parsimony import discover; print([p.name for p in discover.iter_providers()])"
+```
+
+## Quick start
+
+```python
+import asyncio
+from parsimony_treasury import CONNECTORS
+
+async def main():
+    connectors = CONNECTORS.bind_env()
+    result = await connectors["treasury_fetch"](
+        endpoint="v2/accounting/od/debt_to_penny",
+        sort="-record_date",
+        page_size=10,
+    )
+    print(result.data.head())
+
+asyncio.run(main())
+```
+
+For multi-plugin composition:
+
+```python
+from parsimony import discover
+connectors = discover.load_all().bind_env()
+```
+
+## Catalog publishing
+
+This plugin publishes a catalog under the `treasury` namespace, backed by `enumerate_treasury` (param-less; walks the Fiscal Data dataset metadata API).
+
+```bash
+parsimony publish --provider treasury --target "hf://<your-org>/parsimony-treasury"
+```
+
+The `{namespace}` placeholder in `--target` is substituted with `treasury` at publish time; targets support `file://`, `hf://`, and `s3://` schemes.
+
+## Provider
+
+- Homepage: <https://fiscaldata.treasury.gov>
+- API docs: <https://fiscaldata.treasury.gov/api-documentation/>
+
+## License
+
+See [LICENSE](./LICENSE).

parsimony_treasury-0.4.0/README.md

@@ -0,0 +1,68 @@
+# parsimony-treasury
+
+US Treasury Fiscal Data connector plugin for parsimony — debt, revenue, spending, securities, and other federal fiscal datasets from the Bureau of the Fiscal Service.
+
+Part of the [parsimony-connectors](https://github.com/ockham-sh/parsimony-connectors) monorepo. Distributed standalone on PyPI as `parsimony-treasury`.
+
+## Connectors
+
+| Name | Kind | Description |
+|---|---|---|
+| `treasury_fetch` | connector | Fetch any Fiscal Data API endpoint as a tidy DataFrame, with optional `filter`, `sort`, and page size. |
+| `enumerate_treasury` | enumerator | Enumerate every Treasury Fiscal Data dataset and endpoint for catalog indexing (drives the `treasury` catalog). |
+
+## Install
+
+```bash
+pip install parsimony-treasury
+```
+
+Pulls in `parsimony-core>=0.4,<0.5` automatically. Verify discovery:
+
+```bash
+python -c "from parsimony import discover; print([p.name for p in discover.iter_providers()])"
+```
+
+## Quick start
+
+```python
+import asyncio
+from parsimony_treasury import CONNECTORS
+
+async def main():
+    connectors = CONNECTORS.bind_env()
+    result = await connectors["treasury_fetch"](
+        endpoint="v2/accounting/od/debt_to_penny",
+        sort="-record_date",
+        page_size=10,
+    )
+    print(result.data.head())
+
+asyncio.run(main())
+```
+
+For multi-plugin composition:
+
+```python
+from parsimony import discover
+connectors = discover.load_all().bind_env()
+```
+
+## Catalog publishing
+
+This plugin publishes a catalog under the `treasury` namespace, backed by `enumerate_treasury` (param-less; walks the Fiscal Data dataset metadata API).
+
+```bash
+parsimony publish --provider treasury --target "hf://<your-org>/parsimony-treasury"
+```
+
+The `{namespace}` placeholder in `--target` is substituted with `treasury` at publish time; targets support `file://`, `hf://`, and `s3://` schemes.
+
+## Provider
+
+- Homepage: <https://fiscaldata.treasury.gov>
+- API docs: <https://fiscaldata.treasury.gov/api-documentation/>
+
+## License
+
+See [LICENSE](./LICENSE).

parsimony_treasury-0.4.0/parsimony_treasury/__init__.py

@@ -0,0 +1,634 @@
+"""US Treasury Fiscal Data: fetch + catalog enumeration.
+
+API docs: https://fiscaldata.treasury.gov/api-documentation/
+No authentication required.
+"""
+
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+from datetime import UTC, datetime
+from typing import Annotated, Any, Literal
+
+import httpx
+import pandas as pd
+from parsimony.connector import Connectors, connector, enumerator
+from parsimony.errors import EmptyDataError
+from parsimony.result import (
+    Column,
+    ColumnRole,
+    OutputConfig,
+    Provenance,
+    Result,
+)
+from parsimony.transport import HttpClient, map_http_error
+from pydantic import BaseModel, Field
+
+_BASE_URL = "https://api.fiscaldata.treasury.gov/services/api/fiscal_service"
+_METADATA_URL = "https://api.fiscaldata.treasury.gov/services/dtg/metadata/"
+_TREASURY_RATES_BASE_URL = "https://home.treasury.gov/resource-center/data-chart-center/interest-rates/pages/xml"
+
+# OData Atom XML namespaces used by the home.treasury.gov rate feeds.
+_ATOM_NS = "{http://www.w3.org/2005/Atom}"
+_ODATA_DATASERVICES_NS = "{http://schemas.microsoft.com/ado/2007/08/dataservices}"
+_ODATA_METADATA_NS = "{http://schemas.microsoft.com/ado/2007/08/dataservices/metadata}"
+
+TreasuryRateFeed = Literal[
+    "daily_treasury_yield_curve",
+    "daily_treasury_real_yield_curve",
+    "daily_treasury_bill_rates",
+    "daily_treasury_long_term_rate",
+    "daily_treasury_real_long_term",
+]
+
+
+# ---------------------------------------------------------------------------
+# Parameter models
+# ---------------------------------------------------------------------------
+
+
+class TreasuryFetchParams(BaseModel):
+    """Parameters for fetching US Treasury fiscal data."""
+
+    endpoint: Annotated[str, "ns:treasury"] = Field(
+        ..., description="API endpoint path (e.g. v2/accounting/od/debt_to_penny)"
+    )
+    filter: str | None = Field(
+        default=None,
+        description="Filter expression (e.g. record_date:gte:2024-01-01)",
+    )
+    sort: str | None = Field(
+        default=None,
+        description="Sort expression (e.g. -record_date for descending)",
+    )
+    page_size: int = Field(default=100, ge=1, le=10000, description="Records per page")
+
+
+class TreasuryEnumerateParams(BaseModel):
+    """No parameters needed — enumerates the full Treasury API catalog."""
+
+    pass
+
+
+class TreasuryRatesFetchParams(BaseModel):
+    """Parameters for fetching a Treasury Office of Debt Management rate feed.
+
+    The home.treasury.gov rate feeds — Daily Treasury Par Yield Curve,
+    Bill Rates, Real Yield Curve, Long-Term Rates, Real Long-Term — are
+    paginated by calendar year. ``feed`` is a closed enum so invalid
+    values are caught at param-validation time rather than as a 404 from
+    Treasury.
+    """
+
+    feed: Annotated[TreasuryRateFeed, "ns:treasury"] = Field(
+        ...,
+        description=(
+            "Treasury OBM rate feed name (one of: daily_treasury_yield_curve, "
+            "daily_treasury_real_yield_curve, daily_treasury_bill_rates, "
+            "daily_treasury_long_term_rate, daily_treasury_real_long_term)."
+        ),
+    )
+    year: int | None = Field(
+        default=None,
+        ge=1990,
+        le=2100,
+        description="Calendar year to retrieve. Defaults to the current UTC year.",
+    )
+
+
+# ---------------------------------------------------------------------------
+# Output configs
+# ---------------------------------------------------------------------------
+
+TREASURY_ENUMERATE_OUTPUT = OutputConfig(
+    columns=[
+        # Compound code ``{endpoint}#{field}`` so every addressable time-series
+        # measure has a unique catalog entry; agents split on ``#`` to recover
+        # the fetchable endpoint and the column to read off the row.
+        Column(name="code", role=ColumnRole.KEY, namespace="treasury"),
+        Column(name="title", role=ColumnRole.TITLE),
+        # ``definition`` is the Fiscal Data field's own descriptive text — the
+        # most useful semantic signal for retrieval. Routing it through
+        # DESCRIPTION (not METADATA) lifts it into ``semantic_text()`` so the
+        # embedder indexes it, in addition to BM25.
+        Column(name="definition", role=ColumnRole.DESCRIPTION),
+        # ``source`` tells the agent which fetch connector to call —
+        # ``"fiscal_data"`` → :func:`treasury_fetch`, ``"treasury_rates"`` →
+        # :func:`treasury_rates_fetch`. Without this, agents would have to
+        # sniff the ``code`` prefix.
+        Column(name="source", role=ColumnRole.METADATA),
+        Column(name="endpoint", role=ColumnRole.METADATA),
+        Column(name="field", role=ColumnRole.METADATA),
+        Column(name="data_type", role=ColumnRole.METADATA),
+        Column(name="dataset", role=ColumnRole.METADATA),
+        Column(name="category", role=ColumnRole.METADATA),
+        Column(name="frequency", role=ColumnRole.METADATA),
+        Column(name="earliest_date", role=ColumnRole.METADATA),
+        Column(name="latest_date", role=ColumnRole.METADATA),
+    ]
+)
+
+# Treasury field ``data_type`` values that denote a time-series measure (as
+# opposed to dates, identifiers, category labels, or row-scaffolding ints).
+# The prefix match captures precision-suffixed variants (``CURRENCY0``,
+# ``PERCENTAGE_PRECISE``, etc.) that Fiscal Data emits alongside the base
+# types.
+_MEASURE_TYPE_PREFIXES: tuple[str, ...] = (
+    "CURRENCY",
+    "NUMBER",
+    "PERCENTAGE",
+    "RATE",
+)
+
+
+def _is_measure_field(field: dict[str, Any]) -> bool:
+    """Whether *field* is an addressable time-series measure.
+
+    Most measures are typed ``CURRENCY``/``NUMBER``/``PERCENTAGE``/``RATE``
+    (or precision-suffixed variants) — caught by prefix match. Treasury's
+    Certified Interest Rates (TCIR) tables, however, store rate values as
+    ``STRING`` data — Treasury's data dictionary quirk, not real strings.
+    Recognise those by name: a STRING column whose name contains ``rate``
+    or ``yield`` is a rate value, except for purely descriptive
+    ``*_desc`` fields and Y/N-coded indicators.
+    """
+    data_type = (field.get("data_type") or "").strip()
+    if data_type.startswith(_MEASURE_TYPE_PREFIXES):
+        return True
+    if data_type == "STRING":
+        column_name = (field.get("column_name") or "").lower()
+        if "rate" not in column_name and "yield" not in column_name:
+            return False
+        if column_name.endswith("_desc"):
+            return False
+        definition = (field.get("definition") or "").strip()
+        # ``floating_rate`` is a Y/N flag describing the security, not a
+        # rate value; same for any other Y/N-prefixed indicator.
+        return not definition.startswith("Y/N")
+    return False
+
+
+# ---------------------------------------------------------------------------
+# Treasury Office of Debt Management rate feeds (home.treasury.gov XML)
+#
+# These famous series — Daily Treasury Par Yield Curve, Daily Treasury
+# Bill Rates, etc. — are NOT in Fiscal Data's ``/dtg/metadata/`` endpoint.
+# They live on a separate Treasury subdomain as XML/CSV feeds. Cataloguing
+# them under the same ``treasury`` namespace gives agents one search
+# surface; the ``endpoint`` metadata field carries a ``home/<feed>`` prefix
+# so the fetch path can route by source.
+# ---------------------------------------------------------------------------
+
+_TREASURY_RATE_DATASET_CATEGORY = "Office of Debt Management"
+
+
+def _rate_feed_source_url(feed: str) -> str:
+    return (
+        "https://home.treasury.gov/resource-center/data-chart-center/"
+        f"interest-rates/TextView?type={feed}"
+    )
+
+
+_TREASURY_RATE_FEEDS: tuple[dict[str, Any], ...] = (
+    {
+        "feed": "daily_treasury_yield_curve",
+        "dataset": "Daily Treasury Par Yield Curve Rates",
+        "frequency": "Daily",
+        "definition_template": (
+            "{tenor} constant-maturity Treasury par yield curve rate, published daily by the "
+            "U.S. Treasury Office of Debt Management. The par yield curve is derived from "
+            "indicative bid-side prices on the most actively traded Treasury securities and is "
+            "the canonical risk-free rate benchmark for that maturity."
+        ),
+        "fields": (
+            ("BC_1MONTH", "1 Month"),
+            ("BC_1_5MONTH", "1.5 Month"),
+            ("BC_2MONTH", "2 Month"),
+            ("BC_3MONTH", "3 Month"),
+            ("BC_4MONTH", "4 Month"),
+            ("BC_6MONTH", "6 Month"),
+            ("BC_1YEAR", "1 Year"),
+            ("BC_2YEAR", "2 Year"),
+            ("BC_3YEAR", "3 Year"),
+            ("BC_5YEAR", "5 Year"),
+            ("BC_7YEAR", "7 Year"),
+            ("BC_10YEAR", "10 Year"),
+            ("BC_20YEAR", "20 Year"),
+            ("BC_30YEAR", "30 Year"),
+        ),
+    },
+    {
+        "feed": "daily_treasury_real_yield_curve",
+        "dataset": "Daily Treasury Real Yield Curve Rates",
+        "frequency": "Daily",
+        "definition_template": (
+            "{tenor} real (TIPS-based) Treasury yield curve rate, published daily by the U.S. "
+            "Treasury Office of Debt Management. Reflects the inflation-adjusted yield on "
+            "Treasury Inflation-Protected Securities at the given constant maturity."
+        ),
+        "fields": (
+            ("TC_5YEAR", "5 Year"),
+            ("TC_7YEAR", "7 Year"),
+            ("TC_10YEAR", "10 Year"),
+            ("TC_20YEAR", "20 Year"),
+            ("TC_30YEAR", "30 Year"),
+        ),
+    },
+    {
+        "feed": "daily_treasury_bill_rates",
+        "dataset": "Daily Treasury Bill Rates",
+        "frequency": "Daily",
+        "definition_template": "{tenor} {kind}, published daily by the U.S. Treasury Office of Debt Management.",
+        "fields": (
+            ("ROUND_B1_CLOSE_4WK_2", "4-Week Treasury Bill — Closing Bank Discount Rate"),
+            ("ROUND_B1_YIELD_4WK_2", "4-Week Treasury Bill — Coupon Equivalent Yield"),
+            ("ROUND_B1_CLOSE_6WK_2", "6-Week Treasury Bill — Closing Bank Discount Rate"),
+            ("ROUND_B1_YIELD_6WK_2", "6-Week Treasury Bill — Coupon Equivalent Yield"),
+            ("ROUND_B1_CLOSE_8WK_2", "8-Week Treasury Bill — Closing Bank Discount Rate"),
+            ("ROUND_B1_YIELD_8WK_2", "8-Week Treasury Bill — Coupon Equivalent Yield"),
+            ("ROUND_B1_CLOSE_13WK_2", "13-Week Treasury Bill — Closing Bank Discount Rate"),
+            ("ROUND_B1_YIELD_13WK_2", "13-Week Treasury Bill — Coupon Equivalent Yield"),
+            ("ROUND_B1_CLOSE_17WK_2", "17-Week Treasury Bill — Closing Bank Discount Rate"),
+            ("ROUND_B1_YIELD_17WK_2", "17-Week Treasury Bill — Coupon Equivalent Yield"),
+            ("ROUND_B1_CLOSE_26WK_2", "26-Week Treasury Bill — Closing Bank Discount Rate"),
+            ("ROUND_B1_YIELD_26WK_2", "26-Week Treasury Bill — Coupon Equivalent Yield"),
+            ("ROUND_B1_CLOSE_52WK_2", "52-Week Treasury Bill — Closing Bank Discount Rate"),
+            ("ROUND_B1_YIELD_52WK_2", "52-Week Treasury Bill — Coupon Equivalent Yield"),
+        ),
+    },
+    {
+        "feed": "daily_treasury_long_term_rate",
+        "dataset": "Daily Treasury Long-Term Rates",
+        "frequency": "Daily",
+        # Long format — the actual rate is in column ``RATE`` parameterised
+        # by ``RATE_TYPE``. One catalog row pointing at the feed is the most
+        # useful surface; agents fetch and pivot on RATE_TYPE themselves.
+        "definition_template": (
+            "Daily Treasury long-term composite rates, published by the U.S. Treasury Office of "
+            "Debt Management. The feed is in long format: each row carries a ``RATE_TYPE`` "
+            "(e.g. LT, LT5, etc.) and a ``RATE`` value. Used to evaluate long-term Treasury "
+            "yields when bonds with maturities of 10+ years are not available."
+        ),
+        "fields": (("RATE", "Long-Term Composite Rate"),),
+    },
+    {
+        "feed": "daily_treasury_real_long_term",
+        "dataset": "Daily Treasury Real Long-Term Rate Averages",
+        "frequency": "Daily",
+        "definition_template": (
+            "Daily Treasury real long-term rate averages (TIPS-based), published by the U.S. "
+            "Treasury Office of Debt Management."
+        ),
+        "fields": (("RATE", "Real Long-Term Rate Average"),),
+    },
+)
+
+
+def _build_treasury_rate_rows() -> list[dict[str, str]]:
+    """One row per (rate-feed, column) entry from :data:`_TREASURY_RATE_FEEDS`.
+
+    Pure function — the registry is static so this involves no I/O. The
+    code is ``home/{feed}#{column}``; the ``home/`` prefix distinguishes
+    these entries from Fiscal Data codes (which are versioned paths like
+    ``v2/...``) so a future fetch dispatcher can route by source.
+    """
+    rows: list[dict[str, str]] = []
+    for spec in _TREASURY_RATE_FEEDS:
+        feed = spec["feed"]
+        endpoint = f"home/{feed}"
+        dataset = spec["dataset"]
+        frequency = spec["frequency"]
+        template: str = spec["definition_template"]
+        for column_name, tenor in spec["fields"]:
+            kind = "Closing Bank Discount Rate" if "_CLOSE_" in column_name else "Coupon Equivalent Yield"
+            definition = template.format(tenor=tenor, kind=kind)
+            rows.append(
+                {
+                    "code": f"{endpoint}#{column_name}",
+                    "title": f"{tenor} — {dataset}",
+                    "source": "treasury_rates",
+                    "endpoint": endpoint,
+                    "field": column_name,
+                    "definition": definition,
+                    "data_type": "PERCENTAGE",
+                    "dataset": dataset,
+                    "category": _TREASURY_RATE_DATASET_CATEGORY,
+                    "frequency": frequency,
+                    "earliest_date": "",
+                    "latest_date": "",
+                }
+            )
+    return rows
+
+# Treasury returns tabular datasets — the output is a DataFrame whose
+# columns depend on the endpoint.  We use a minimal schema with just
+# the identity key; actual data columns vary per endpoint.
+TREASURY_FETCH_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="endpoint", role=ColumnRole.KEY, param_key="endpoint", namespace="treasury"),
+        Column(name="title", role=ColumnRole.TITLE),
+        Column(name="record_date", dtype="datetime", role=ColumnRole.DATA),
+    ]
+)
+
+# Rates feeds return one row per business day; rate columns vary per feed
+# (e.g. ``BC_10YEAR`` for the par yield curve, ``ROUND_B1_YIELD_4WK_2`` for
+# bill rates). The schema names only the columns we always materialise; the
+# feed-specific rate columns ride along as additional DATA columns.
+TREASURY_RATES_FETCH_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="feed", role=ColumnRole.KEY, param_key="feed", namespace="treasury"),
+        Column(name="title", role=ColumnRole.TITLE),
+        Column(name="record_date", dtype="datetime", role=ColumnRole.DATA),
+    ]
+)
+
+
+# ---------------------------------------------------------------------------
+# Connectors
+# ---------------------------------------------------------------------------
+
+
+def _make_http() -> HttpClient:
+    return HttpClient(_BASE_URL, query_params={"format": "json"})
+
+
+@connector(output=TREASURY_FETCH_OUTPUT, tags=["macro", "us"])
+async def treasury_fetch(params: TreasuryFetchParams) -> Result:
+    """Fetch US Treasury fiscal data by endpoint.
+
+    Returns the dataset as-is with ``record_date`` parsed and numeric
+    columns converted.  Each row is one record from the Treasury API.
+    """
+    http = _make_http()
+    req_params: dict[str, Any] = {"page[size]": params.page_size}
+    if params.filter:
+        req_params["filter"] = params.filter
+    if params.sort:
+        req_params["sort"] = params.sort
+
+    response = await http.request("GET", f"/{params.endpoint}", params=req_params)
+    try:
+        response.raise_for_status()
+    except httpx.HTTPStatusError as exc:
+        map_http_error(exc, provider="treasury", op_name=params.endpoint)
+    body = response.json()
+
+    data = body.get("data", [])
+    if not data:
+        raise EmptyDataError(provider="treasury", message=f"No data returned for endpoint: {params.endpoint}")
+
+    meta = body.get("meta", {})
+    labels = meta.get("labels", {})
+    data_types = meta.get("dataTypes", {})
+
+    df = pd.DataFrame(data)
+
+    # Parse record_date
+    if "record_date" in df.columns:
+        df["record_date"] = pd.to_datetime(df["record_date"], errors="coerce")
+
+    # Convert numeric columns identified by API metadata
+    numeric_types = {"CURRENCY", "NUMBER", "PERCENTAGE", "RATE"}
+    for col, dtype in data_types.items():
+        if dtype in numeric_types and col in df.columns:
+            df[col] = pd.to_numeric(
+                df[col].astype(str).str.replace(",", "", regex=False),
+                errors="coerce",
+            )
+
+    # Add identity columns
+    table_name = labels.get("record_date", params.endpoint)
+    df["endpoint"] = params.endpoint
+    df["title"] = table_name
+
+    return Result.from_dataframe(
+        df,
+        Provenance(
+            source="treasury",
+            params={"endpoint": params.endpoint},
+            properties={
+                "total_records": meta.get("total-count"),
+                "source_url": f"https://fiscaldata.treasury.gov/datasets/{params.endpoint}",
+            },
+        ),
+    )
+
+
+_RATES_DATE_COLUMNS: tuple[str, ...] = ("NEW_DATE", "INDEX_DATE", "QUOTE_DATE")
+_RATES_NUMERIC_TYPES: frozenset[str] = frozenset(
+    {"Edm.Double", "Edm.Decimal", "Edm.Single", "Edm.Int32", "Edm.Int64"}
+)
+_RATES_DATETIME_TYPES: frozenset[str] = frozenset({"Edm.DateTime"})
+
+
+def _parse_treasury_rates_xml(xml_text: str) -> pd.DataFrame:
+    """Parse a home.treasury.gov OData Atom rate-feed payload into a DataFrame.
+
+    Each ``<entry>`` carries an ``m:properties`` block whose ``d:NAME``
+    children are the row's columns. ``Edm.DateTime`` values become
+    pandas datetimes, ``Edm.Double``/``Edm.Decimal`` become floats, and
+    everything else stays as a string. The first ``Edm.DateTime`` column
+    encountered (Treasury uses ``NEW_DATE``, ``INDEX_DATE``, or
+    ``QUOTE_DATE`` depending on the feed) is duplicated as
+    ``record_date`` to give every feed a uniform time axis.
+    """
+    root = ET.fromstring(xml_text)
+    rows: list[dict[str, Any]] = []
+    for entry in root.findall(f"{_ATOM_NS}entry"):
+        props = entry.find(f"{_ATOM_NS}content/{_ODATA_METADATA_NS}properties")
+        if props is None:
+            continue
+        row: dict[str, Any] = {}
+        for prop in props:
+            tag = prop.tag.removeprefix(_ODATA_DATASERVICES_NS)
+            edm_type = prop.attrib.get(f"{_ODATA_METADATA_NS}type", "Edm.String")
+            text = prop.text
+            if text is None or text == "":
+                row[tag] = None
+                continue
+            if edm_type in _RATES_DATETIME_TYPES:
+                row[tag] = pd.to_datetime(text, errors="coerce")
+            elif edm_type in _RATES_NUMERIC_TYPES:
+                try:
+                    row[tag] = float(text)
+                except (TypeError, ValueError):
+                    row[tag] = None
+            else:
+                row[tag] = text
+        if row:
+            rows.append(row)
+
+    df = pd.DataFrame(rows)
+    if df.empty:
+        return df
+    for date_col in _RATES_DATE_COLUMNS:
+        if date_col in df.columns:
+            df["record_date"] = df[date_col]
+            break
+    if "record_date" in df.columns:
+        df = df.sort_values("record_date").reset_index(drop=True)
+    return df
+
+
+@connector(output=TREASURY_RATES_FETCH_OUTPUT, tags=["macro", "us"])
+async def treasury_rates_fetch(params: TreasuryRatesFetchParams) -> Result:
+    """Fetch a Treasury Office of Debt Management rate feed for one calendar year.
+
+    The home.treasury.gov XML feed is paginated by year via the
+    ``field_tdr_date_value`` query parameter. ``year=None`` defaults to
+    the current UTC year. Returns a DataFrame whose columns are the
+    feed's native rate columns (e.g. ``BC_10YEAR`` for the par yield
+    curve) plus a normalised ``record_date``.
+    """
+    year = params.year if params.year is not None else datetime.now(tz=UTC).year
+    op_name = f"rates/{params.feed}/{year}"
+    async with httpx.AsyncClient(timeout=30.0, follow_redirects=True) as client:
+        try:
+            response = await client.get(
+                _TREASURY_RATES_BASE_URL,
+                params={"data": params.feed, "field_tdr_date_value": str(year)},
+            )
+            response.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            map_http_error(exc, provider="treasury", op_name=op_name)
+        xml_text = response.text
+
+    df = _parse_treasury_rates_xml(xml_text)
+    if df.empty:
+        raise EmptyDataError(
+            provider="treasury",
+            message=f"No rows returned for rate feed {params.feed!r} year={year}",
+        )
+
+    df["feed"] = params.feed
+    df["title"] = params.feed.replace("_", " ").title()
+
+    return Result.from_dataframe(
+        df,
+        Provenance(
+            source="treasury",
+            params={"feed": params.feed, "year": year},
+            properties={
+                "row_count": len(df),
+                "source_url": (
+                    f"{_TREASURY_RATES_BASE_URL}?data={params.feed}&field_tdr_date_value={year}"
+                ),
+            },
+        ),
+    )
+
+
+@enumerator(
+    output=TREASURY_ENUMERATE_OUTPUT,
+    tags=["macro", "us"],
+)
+async def enumerate_treasury(params: TreasuryEnumerateParams) -> pd.DataFrame:
+    """Enumerate every addressable Treasury time series across two sources.
+
+    1. **Fiscal Data API** (``/dtg/metadata/``) — yields one row per
+       (endpoint, measure-field) pair. ``data_type`` typed as
+       ``CURRENCY``/``NUMBER``/``PERCENTAGE``/``RATE`` (or precision-suffixed
+       variants) is a measure; STRING fields whose names contain
+       ``rate``/``yield`` are also recognised so the Treasury Certified
+       Interest Rates (TCIR) tables — which Treasury stores as STRING — are
+       included. Dates, identifiers, and category labels are excluded.
+    2. **Office of Debt Management rate feeds** (home.treasury.gov XML) —
+       static registry covering the daily par yield curve, real yield curve,
+       bill rates, and long-term composite rates. These are the canonical
+       benchmark series and are not in the Fiscal Data metadata.
+    """
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        resp = await client.get(_METADATA_URL)
+        try:
+            resp.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            map_http_error(exc, provider="treasury", op_name="datasets/metadata")
+        raw = resp.json()
+
+    datasets: list[dict] = []
+    if isinstance(raw, list):
+        datasets = raw
+    elif isinstance(raw, dict):
+        for key in ("datasets", "data", "result"):
+            if key in raw and isinstance(raw[key], list):
+                datasets = raw[key]
+                break
+
+    prefix = "/services/api/fiscal_service/"
+    rows: list[dict[str, str]] = []
+
+    for ds in datasets:
+        dataset_title = ds.get("title") or ds.get("dataset_name", "")
+        category = ds.get("publisher", "")
+        ds_frequency = ds.get("update_frequency", "")
+        for api in ds.get("apis", []):
+            endpoint = api.get("endpoint_txt") or ""
+            if endpoint.startswith(prefix):
+                endpoint = endpoint[len(prefix) :]
+            if not endpoint:
+                endpoint = api.get("api_id", "")
+            if not endpoint:
+                continue
+            table_name = api.get("table_name") or dataset_title
+            frequency = api.get("update_frequency") or ds_frequency
+            earliest_date = api.get("earliest_date", "") or ""
+            latest_date = api.get("latest_date", "") or ""
+            for field in api.get("fields", []):
+                if not _is_measure_field(field):
+                    continue
+                column_name = field.get("column_name", "") or ""
+                if not column_name:
+                    continue
+                pretty_name = field.get("pretty_name") or column_name
+                definition = field.get("definition", "") or ""
+                rows.append(
+                    {
+                        "code": f"{endpoint}#{column_name}",
+                        "title": f"{pretty_name} — {table_name}",
+                        "source": "fiscal_data",
+                        "endpoint": endpoint,
+                        "field": column_name,
+                        "definition": definition,
+                        "data_type": field.get("data_type", "") or "",
+                        "dataset": dataset_title,
+                        "category": category,
+                        "frequency": frequency,
+                        "earliest_date": earliest_date,
+                        "latest_date": latest_date,
+                    }
+                )
+
+    rows.extend(_build_treasury_rate_rows())
+
+    columns = [
+        "code",
+        "title",
+        "source",
+        "endpoint",
+        "field",
+        "definition",
+        "data_type",
+        "dataset",
+        "category",
+        "frequency",
+        "earliest_date",
+        "latest_date",
+    ]
+    return pd.DataFrame(rows, columns=columns) if rows else pd.DataFrame(columns=columns)
+
+
+# ---------------------------------------------------------------------------
+# Exports
+# ---------------------------------------------------------------------------
+
+from parsimony_treasury.search import (  # noqa: E402, F401  (after public decorators; re-exported)
+    PARSIMONY_TREASURY_CATALOG_URL_ENV,
+    TREASURY_SEARCH_OUTPUT,
+    TreasurySearchParams,
+    treasury_search,
+)
+
+CATALOGS: list[tuple[str, object]] = [("treasury", enumerate_treasury)]
+
+CONNECTORS = Connectors([treasury_fetch, treasury_rates_fetch, enumerate_treasury, treasury_search])

parsimony_treasury-0.4.0/parsimony_treasury/search.py

@@ -0,0 +1,103 @@
+"""Semantic search over the published US Treasury catalog.
+
+Wraps the parquet+FAISS catalog at ``hf://parsimony-dev/treasury`` (override
+with ``PARSIMONY_TREASURY_CATALOG_URL`` for local testing) as an MCP tool.
+
+Codes returned dispatch to one of two fetch connectors:
+
+* ``v<n>/<endpoint>#<field>`` (Fiscal Data) → :func:`treasury_fetch` via
+  ``endpoint`` (use the part before ``#``); the field name guides which
+  measure to read.
+* ``home/<feed>`` (Treasury rate XML feeds) → :func:`treasury_rates_fetch`
+  via ``feed`` (use the part after ``home/``).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+from typing import Annotated
+
+import pandas as pd
+from parsimony.catalog import Catalog
+from parsimony.connector import connector
+from parsimony.result import Column, ColumnRole, OutputConfig
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger(__name__)
+
+PARSIMONY_TREASURY_CATALOG_URL_ENV = "PARSIMONY_TREASURY_CATALOG_URL"
+_DEFAULT_CATALOG_URL = "hf://parsimony-dev/treasury"
+
+_catalog: Catalog | None = None
+_catalog_lock = asyncio.Lock()
+
+
+async def _get_catalog() -> Catalog:
+    global _catalog
+    if _catalog is not None:
+        return _catalog
+    async with _catalog_lock:
+        if _catalog is None:
+            url = os.environ.get(PARSIMONY_TREASURY_CATALOG_URL_ENV, _DEFAULT_CATALOG_URL)
+            logger.info("loading US Treasury catalog from %s", url)
+            _catalog = await Catalog.from_url(url)
+    return _catalog
+
+
+TREASURY_SEARCH_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="code", role=ColumnRole.KEY, namespace="treasury"),
+        Column(name="title", role=ColumnRole.TITLE),
+        Column(name="similarity", role=ColumnRole.METADATA),
+    ]
+)
+
+
+class TreasurySearchParams(BaseModel):
+    """Parameters for :func:`treasury_search`."""
+
+    query: Annotated[
+        str,
+        Field(
+            min_length=1,
+            max_length=512,
+            description=(
+                "Natural-language description of the Treasury series you "
+                "want (e.g. 'US public debt to the penny', 'daily Treasury "
+                "yield curve 10-year', 'monthly Treasury statement receipts')."
+            ),
+        ),
+    ]
+    limit: int = Field(default=10, ge=1, le=50, description="Top-N results.")
+
+
+@connector(
+    output=TREASURY_SEARCH_OUTPUT,
+    tags=["macro", "us", "tool"],
+)
+async def treasury_search(params: TreasurySearchParams) -> pd.DataFrame:
+    """Semantic-search the US Treasury catalog (Fiscal Data + ODM rate feeds).
+
+    Covers ~884 Fiscal Data measure fields across debt, federal accounts,
+    monthly Treasury statements, etc., plus ~35 entries from the 5
+    daily Treasury rate feeds (yield curve, real yield curve, bill rates,
+    long-term rate, real long-term rate).
+
+    Dispatch by code prefix: ``home/<feed>`` →
+    ``treasury_rates_fetch(feed=...)``; ``v<n>/<endpoint>#<field>`` →
+    ``treasury_fetch(endpoint=...)``.
+    """
+    catalog = await _get_catalog()
+    matches = await catalog.search(params.query, limit=params.limit)
+    return pd.DataFrame(
+        [
+            {
+                "code": m.code,
+                "title": m.title,
+                "similarity": round(m.similarity, 6),
+            }
+            for m in matches
+        ]
+    )

parsimony_treasury-0.4.0/pyproject.toml

@@ -0,0 +1,83 @@
+[project]
+name = "parsimony-treasury"
+version = "0.4.0"
+description = "U.S. Treasury 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", "treasury"]
+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>=0.4.0,<0.5",
+    "pydantic>=2.11.1,<3",
+    "pandas>=2.3.0,<3",
+]
+
+[project.optional-dependencies]
+# Heavy deps for running the HF catalog publisher under scripts/. Kept
+# behind an extra so `pip install parsimony-treasury` stays lean — only
+# catalog maintainers ever need parsimony-core[standard-onnx] (faiss +
+# onnxruntime + sentence-transformers).
+publish = [
+    "parsimony-core[standard-onnx]>=0.4.0,<0.5",
+]
+dev = [
+    "pytest>=9.0.3",
+    "pytest-asyncio>=1.3.0",
+    "pytest-cov>=5.0",
+    "respx>=0.22.0",
+    "ruff>=0.15.10",
+    "mypy>=1.10",
+]
+
+[project.urls]
+Homepage = "https://fiscaldata.treasury.gov"
+Repository = "https://github.com/ockham-sh/parsimony-connectors"
+Issues = "https://github.com/ockham-sh/parsimony-connectors/issues"
+
+[project.entry-points."parsimony.providers"]
+treasury = "parsimony_treasury"
+
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["parsimony_treasury"]
+
+[tool.hatch.build.targets.sdist]
+include = ["parsimony_treasury", "README.md", "LICENSE", "CHANGELOG.md"]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]
+
+[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'"
+asyncio_mode = "auto"
+markers = [
+    "integration: hits live APIs (may be slow, requires env vars)",
+]