usaspending-orm 0.9.0__tar.gz → 0.9.1__tar.gz

{usaspending_orm-0.9.0 → usaspending_orm-0.9.1}/.gitignore

@@ -4,6 +4,7 @@ __pycache__
 .*_cache
 repomix*
 dist/
+site/
 .claude/
 /~/
 .coverage

usaspending_orm-0.9.1/.readthedocs.yaml

@@ -0,0 +1,17 @@
+version: 2
+
+build:
+  os: ubuntu-24.04
+  tools:
+    python: "3.13"
+
+python:
+  install:
+    - method: uv
+      command: sync
+      groups:
+        - docs
+
+mkdocs:
+  configuration: mkdocs.yml
+  fail_on_warning: true

{usaspending_orm-0.9.0 → usaspending_orm-0.9.1}/CHANGELOG.md

@@ -4,6 +4,53 @@ All notable changes to the USASpending ORM library are documented here.
 The format loosely follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and the project adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.9.1] - 2026-08-27
+
+### Added
+
+- `client.references.def_codes()`: fetches the API's current Disaster Emergency
+  Fund Code reference data from `/api/v2/references/def_codes/` as `DefCode`
+  models. DEF codes change as legislation is enacted, so discover them at
+  runtime instead of maintaining a local list; the `def_codes(...)` search
+  filter itself remains network-free, and its docstring no longer carries a
+  hardcoded code list. `DefCode` moved to `usaspending/models/def_code.py` and
+  is exported from `usaspending.models`; the legacy
+  `usaspending.models.agency.DefCode` import path still resolves to the same
+  class.
+- Client-side validation of classification-filter complexity, mirroring the
+  API's hard-coded bounds as reviewed against upstream on 2026-08-25.
+  `naics_codes()` rejects more than 200 combined require/exclude codes.
+  `psc_codes()` rejects more than 200 simple codes, more than 100 hierarchical
+  paths per side, more than 200 combined paths after upstream's PSC Tier-1
+  group expansion, and paths deeper than 10 levels. `tas_codes()` enforces the
+  same per-side, combined, and depth bounds. Oversized filters now raise
+  `ValidationError` at construction instead of failing at the API.
+- MkDocs documentation site (getting-started guides, API reference, and the
+  upstream endpoint mapping) with Read the Docs configuration.
+
+### Changed
+
+- `client.agencies.search()` now follows the shared collection semantics.
+  `page_size(n)` maps to the endpoint's `limit` parameter (default 100, capped
+  at 500) instead of a fixed internal limit of 100; the upstream limit applies
+  independently to the toptier, subtier, and office buckets, so one request can
+  return up to `3n` rows. `limit(n)` bounds the flattened result consistently
+  across `all()`, `count()`, `len()`, indexing, and slicing, and indexing reads
+  the single flattened response rather than translating indices into pages the
+  endpoint does not have. Zero bounds (`limit(0)`, `max_pages(0)`) resolve
+  without a request.
+- `naics_codes()`, `psc_codes()`, and `tas_codes()` copy their inputs, so
+  mutating a caller-owned list after building a query no longer alters the
+  filter.
+
+### Documentation
+
+- Download failure text (`job.error_message`, `DownloadStatus.message`) is
+  documented as opaque server-provided text: it may be generic and can change
+  without notice, so application control flow should depend on `job.state`.
+  When a failed job carries no server message, `job.error_message` is
+  `"API reported failure."`.
+
 ## [0.9.0] - 2026-07-30
 
 Adds the global transaction search: `client.transactions.search()` covers the

{usaspending_orm-0.9.0 → usaspending_orm-0.9.1}/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2025 Casey Dreier
+Copyright 2025 Casey Dreier/The Planetary Society
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the “Software”), to deal

usaspending_orm-0.9.1/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.5
+Name: usaspending-orm
+Version: 0.9.1
+Summary: A Python ORM wrapper for the USAspending.gov API with intuitive queries, automatic pagination, and smart caching
+Project-URL: Homepage, https://github.com/planetary-society/usaspending-orm
+Project-URL: Repository, https://github.com/planetary-society/usaspending-orm
+Project-URL: Issues, https://github.com/planetary-society/usaspending-orm/issues
+Project-URL: Documentation, https://github.com/planetary-society/usaspending-orm/blob/main/README.md
+Author-email: Casey Dreier <casey.dreier@planetary.org>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api-wrapper,contracts,federal-spending,government-data,grants,orm,usaspending
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: cachier<5.0.0,>=4.1.0
+Requires-Dist: pyyaml<7.0.0,>=6.0.2
+Requires-Dist: requests<3.0.0,>=2.32.4
+Requires-Dist: titlecase<3.0.0,>=2.4.1
+Description-Content-Type: text/markdown
+
+# USASpending ORM
+
+[![Tests](https://github.com/planetary-society/usaspending-orm/actions/workflows/test.yml/badge.svg)](https://github.com/planetary-society/usaspending-orm/actions/workflows/test.yml)
+[![PyPI](https://img.shields.io/pypi/v/usaspending-orm.svg)](https://pypi.org/project/usaspending-orm/)
+[![Python](https://img.shields.io/pypi/pyversions/usaspending-orm.svg)](https://pypi.org/project/usaspending-orm/)
+
+USASpending ORM is a typed, ORM-style Python interface to the
+[USAspending.gov API](https://api.usaspending.gov/). It provides fluent query
+builders and navigable models for federal awards, transactions, recipients,
+agencies, spending summaries, Treasury Account Symbols, and bulk downloads.
+
+The library is maintained by [The Planetary Society](https://www.planetary.org/).
+
+## Why use it?
+
+- Express complex USAspending searches through chainable Python methods.
+- Work with normalized models, `date` values, and exact `Decimal` amounts.
+- Navigate from awards to recipients, agencies, transactions, funding, accounts,
+  and subawards.
+- Retain the original API response through each model's `.raw` property.
+- Use built-in pagination, retries, rate limiting, optional caching, and result
+  safeguards.
+
+No API key is required.
+
+## Installation
+
+```console
+python -m pip install usaspending-orm
+```
+
+Requires Python 3.9 or newer.
+
+## Quickstart
+
+```python
+from usaspending import USASpendingClient
+
+with USASpendingClient() as client:
+    awards = (
+        client.awards.search()
+        .contracts()
+        .agency("National Aeronautics and Space Administration")
+        .recipient_search_text("Space Exploration Technologies")
+        .fiscal_year(2024)
+        .order_by("Award Amount", "desc")
+        .limit(5)
+    )
+
+    for award in awards:
+        amount = award.total_obligation or 0
+        print(f"{award.award_identifier}: {award.recipient.name} - ${amount:,.2f}")
+```
+
+Queries are lazy. Building the chain makes no request; iteration, `.first()`,
+`.all()`, `.count()`, `len(query)`, indexing, and truth-value testing execute
+the appropriate USAspending operation.
+
+## Documentation
+
+The full documentation covers:
+
+- [installation and core concepts](docs/getting-started/installation.md);
+- [award and transaction searches](docs/guides/search-awards.md);
+- [sessions, lazy loading, caching, and production use](docs/guides/production.md);
+- [generated Python API reference](docs/reference/client.md);
+- [mappings to canonical USAspending endpoints](docs/usaspending-api/endpoint-mapping.md);
+- [known upstream limits and contract differences](docs/usaspending-api/limitations.md).
+
+The repository includes Read the Docs configuration for the published site.
+
+## Development
+
+```console
+git clone https://github.com/planetary-society/usaspending-orm.git
+cd usaspending-orm
+uv sync --locked --group docs
+
+uv run pytest -q
+uv run ruff check src/ tests/
+uv run ruff format --check src/ tests/
+uv run --group docs mkdocs build --strict
+```
+
+Integration tests make live USAspending requests and run separately:
+
+```console
+uv run pytest -m integration -q
+```
+
+Preview the documentation site locally with `uv run --group docs mkdocs serve`.
+
+> **Note for contributors**
+>
+> Documentation examples are enforced, not just reviewed. `tests/test_documentation.py`
+> compiles every fenced `python` block under `docs/`, checks that method names cited in
+> prose exist on the public API, and executes most blocks against the live API under the
+> `integration` marker. Adding or removing an example changes the runnable count, so
+> update `_EXPECTED_RUNNABLE_BLOCKS` in the same change.
+>
+> The public API surface is snapshot-tested. When a deliberate change adds, removes, or
+> alters a public callable, regenerate the fixture and review the diff:
+>
+> ```console
+> USASPENDING_REGEN_API_SURFACE=1 uv run pytest tests/test_public_api_surface.py
+> ```
+>
+> The published site builds from `.readthedocs.yaml`. To activate hosting: import
+> `planetary-society/usaspending-orm` in Read the Docs, use `usaspending-orm` as the
+> project slug, and enable pull-request builds. Keep `latest` as the default until a
+> release tag contains the docs configuration, then make `stable` the default
+> user-facing version while retaining `latest` for `main`.
+
+## Project status
+
+The project is in beta. USAspending itself changes over time, and live federal
+data is revised as agencies submit corrections. Counts and values shown in
+examples should not be treated as permanent fixtures.
+
+See [CHANGELOG.md](CHANGELOG.md) for release history and compatibility notes.
+
+## License
+
+USASpending ORM is released under the [MIT License](LICENSE).

usaspending_orm-0.9.1/README.md

@@ -0,0 +1,124 @@
+# USASpending ORM
+
+[![Tests](https://github.com/planetary-society/usaspending-orm/actions/workflows/test.yml/badge.svg)](https://github.com/planetary-society/usaspending-orm/actions/workflows/test.yml)
+[![PyPI](https://img.shields.io/pypi/v/usaspending-orm.svg)](https://pypi.org/project/usaspending-orm/)
+[![Python](https://img.shields.io/pypi/pyversions/usaspending-orm.svg)](https://pypi.org/project/usaspending-orm/)
+
+USASpending ORM is a typed, ORM-style Python interface to the
+[USAspending.gov API](https://api.usaspending.gov/). It provides fluent query
+builders and navigable models for federal awards, transactions, recipients,
+agencies, spending summaries, Treasury Account Symbols, and bulk downloads.
+
+The library is maintained by [The Planetary Society](https://www.planetary.org/).
+
+## Why use it?
+
+- Express complex USAspending searches through chainable Python methods.
+- Work with normalized models, `date` values, and exact `Decimal` amounts.
+- Navigate from awards to recipients, agencies, transactions, funding, accounts,
+  and subawards.
+- Retain the original API response through each model's `.raw` property.
+- Use built-in pagination, retries, rate limiting, optional caching, and result
+  safeguards.
+
+No API key is required.
+
+## Installation
+
+```console
+python -m pip install usaspending-orm
+```
+
+Requires Python 3.9 or newer.
+
+## Quickstart
+
+```python
+from usaspending import USASpendingClient
+
+with USASpendingClient() as client:
+    awards = (
+        client.awards.search()
+        .contracts()
+        .agency("National Aeronautics and Space Administration")
+        .recipient_search_text("Space Exploration Technologies")
+        .fiscal_year(2024)
+        .order_by("Award Amount", "desc")
+        .limit(5)
+    )
+
+    for award in awards:
+        amount = award.total_obligation or 0
+        print(f"{award.award_identifier}: {award.recipient.name} - ${amount:,.2f}")
+```
+
+Queries are lazy. Building the chain makes no request; iteration, `.first()`,
+`.all()`, `.count()`, `len(query)`, indexing, and truth-value testing execute
+the appropriate USAspending operation.
+
+## Documentation
+
+The full documentation covers:
+
+- [installation and core concepts](docs/getting-started/installation.md);
+- [award and transaction searches](docs/guides/search-awards.md);
+- [sessions, lazy loading, caching, and production use](docs/guides/production.md);
+- [generated Python API reference](docs/reference/client.md);
+- [mappings to canonical USAspending endpoints](docs/usaspending-api/endpoint-mapping.md);
+- [known upstream limits and contract differences](docs/usaspending-api/limitations.md).
+
+The repository includes Read the Docs configuration for the published site.
+
+## Development
+
+```console
+git clone https://github.com/planetary-society/usaspending-orm.git
+cd usaspending-orm
+uv sync --locked --group docs
+
+uv run pytest -q
+uv run ruff check src/ tests/
+uv run ruff format --check src/ tests/
+uv run --group docs mkdocs build --strict
+```
+
+Integration tests make live USAspending requests and run separately:
+
+```console
+uv run pytest -m integration -q
+```
+
+Preview the documentation site locally with `uv run --group docs mkdocs serve`.
+
+> **Note for contributors**
+>
+> Documentation examples are enforced, not just reviewed. `tests/test_documentation.py`
+> compiles every fenced `python` block under `docs/`, checks that method names cited in
+> prose exist on the public API, and executes most blocks against the live API under the
+> `integration` marker. Adding or removing an example changes the runnable count, so
+> update `_EXPECTED_RUNNABLE_BLOCKS` in the same change.
+>
+> The public API surface is snapshot-tested. When a deliberate change adds, removes, or
+> alters a public callable, regenerate the fixture and review the diff:
+>
+> ```console
+> USASPENDING_REGEN_API_SURFACE=1 uv run pytest tests/test_public_api_surface.py
+> ```
+>
+> The published site builds from `.readthedocs.yaml`. To activate hosting: import
+> `planetary-society/usaspending-orm` in Read the Docs, use `usaspending-orm` as the
+> project slug, and enable pull-request builds. Keep `latest` as the default until a
+> release tag contains the docs configuration, then make `stable` the default
+> user-facing version while retaining `latest` for `main`.
+
+## Project status
+
+The project is in beta. USAspending itself changes over time, and live federal
+data is revised as agencies submit corrections. Counts and values shown in
+examples should not be treated as permanent fixtures.
+
+See [CHANGELOG.md](CHANGELOG.md) for release history and compatibility notes.
+
+## License
+
+USASpending ORM is released under the [MIT License](LICENSE).

usaspending_orm-0.9.1/docs/explanation/caching.md

@@ -0,0 +1,115 @@
+# Caching
+
+Caching is off by default. When enabled, the client stores successful API
+responses and serves repeat requests from the store instead of the network.
+
+```python
+from datetime import timedelta
+
+from usaspending import USASpendingClient, config
+
+config.configure(
+    cache_enabled=True,
+    cache_backend="file",
+    cache_ttl=timedelta(days=1),
+)
+
+with USASpendingClient() as client:
+    award = client.awards.find_by_award_id("80GSFC18C0008")
+```
+
+Configure caching before creating a client. Settings are applied through an
+observer, so a later `configure()` call rebuilds the cache wrapper rather than
+leaving clients on stale settings.
+
+## What gets cached
+
+The unit of caching is one HTTP request, not one query. A cache entry is keyed
+on the endpoint and the full request payload, so two searches that differ in any
+filter, sort, or page are separate entries, and a repeat of the identical
+request is a hit.
+
+Because the unit is the request, caching covers everything the library sends:
+search pages, count calls, award detail lookups, and the follow-up requests
+behind lazy relationships. A loop that reads `award.recipient.location` for many
+awards still issues one request per award the first time, but pays nothing on a
+second pass over the same awards.
+
+Two things are deliberately not stored:
+
+- **Failures.** Errors are never cached, so a transient outage does not poison
+  the store. The next call re-issues the request.
+- **Empty results.** A response the client could not interpret is not stored,
+  and the request falls back to the network.
+
+## Cache misses are never fatal
+
+Reading from the cache is best-effort. If the store is unreadable, locked, or
+corrupt, the client logs a warning and issues the request normally. A broken
+cache degrades performance, never correctness.
+
+API errors are the exception to that fallback: `APIError`, `HTTPError`,
+`RateLimitError`, and `ValidationError` propagate to the caller rather than
+being retried uncached, because they describe the request rather than the cache.
+
+## Backends
+
+`cache_backend="memory"` keeps entries in the process and discards them on exit.
+It suits tests and short scripts, and avoids writing anything to disk.
+
+`cache_backend="file"` is the default and writes pickled responses under
+`cache_dir`, which defaults to `$XDG_CACHE_HOME/usaspending` or
+`~/.cache/usaspending`. Entries survive the process, so a later run reuses what
+an earlier one fetched. That is what makes an interrupted batch job cheap to
+restart, and what lets a script re-run during development stop paying for the
+same pages.
+
+Reuse depends on the request serializing identically each time. The library
+sorts the values of match-any filters for that reason, so a filter built from a
+Python set produces the same request, and therefore the same cache entry, on
+every run.
+
+!!! warning "The file backend unpickles data it reads"
+
+    Unpickling executes code, so the cache directory is a trust boundary. The
+    library creates it with `0700` permissions and restores those permissions if
+    they have been widened, but do not point `cache_dir` at a shared,
+    world-writable, or otherwise untrusted location, and do not use a directory
+    another user can write to.
+
+## Expiry and namespaces
+
+`cache_ttl` sets how long an entry stays fresh; the default is one week. An
+entry older than the TTL is recomputed on next use. `configure()` accepts either
+a `timedelta` or a number of seconds.
+
+Federal spending data is revised after publication, so the TTL is a correctness
+decision as much as a performance one. A long TTL on a reporting job can serve
+figures that agencies have since corrected. Prefer hours or days for anything
+whose numbers get published, and reserve a week for exploratory work.
+
+`cache_namespace` is part of every key, so two projects sharing a `cache_dir` do
+not read each other's entries. Change it to isolate a workload, or to abandon an
+existing set of entries wholesale.
+
+`cache_timeout` bounds how long a caller waits for another worker that is
+already computing the same entry, which keeps concurrent callers from
+stampeding the same request.
+
+## Clearing the cache
+
+There is no public API for clearing the cache. With the file backend, delete the
+files under `cache_dir`; with the memory backend, ending the process is enough.
+Changing `cache_namespace` also abandons the previous entries without deleting
+them.
+
+## Choosing a TTL
+
+- Interactive analysis over a stable slice of history: hours to a day.
+- Repeatedly re-running the same broad query while developing: a day or more,
+  since the point is to stop paying for the same pages.
+- Anything producing published figures: short, or disabled, so a correction
+  upstream is not masked by a stale entry.
+
+See [Production use](../guides/production.md) for how caching interacts with
+rate limiting and long batch runs.

usaspending_orm-0.9.1/docs/explanation/data-model.md

@@ -0,0 +1,52 @@
+# USAspending data model
+
+The library presents several related grains of federal spending data.
+
+## Prime awards
+
+An award is the durable agreement between the federal government and a
+recipient: a contract, grant, loan, direct payment, other assistance, or
+Indefinite Delivery Vehicle. An award accumulates financial activity over its
+lifetime.
+
+`Award` and its subclasses normalize the details endpoint and expose
+relationships such as recipient, agencies, period of performance, place of
+performance, transactions, accounts, funding records, and subawards.
+
+## Transactions
+
+A transaction is an action that changes or reports an award. Examples include
+the initial obligation, a contract modification, an incremental funding
+action, or a deobligation.
+
+Transaction searches therefore have a different grain from award searches:
+
+- award search returns one row per matching award;
+- global transaction search returns one row per matching action;
+- `award.transactions` returns actions belonging to one award.
+
+Summing transaction amounts and reading an award's current total obligation are
+different analytical operations.
+
+## Subawards
+
+A subaward records funding passed from a prime recipient to another
+organization. Subawards are reported separately and do not share every field or
+filter available for prime awards.
+
+## Accounts and funding records
+
+Federal accounts and Treasury Account Symbols describe the appropriations
+accounts behind spending. Award funding records connect transactions to those
+accounts and agencies. These records are useful when the question concerns
+budget authority or the source of funds rather than only the recipient and
+award.
+
+## Aggregations
+
+Spending-by-category endpoints return grouped totals by dimensions such as
+recipient or geography. Their rows are summaries, not awards, and use dedicated
+models.
+
+See [Terminology](../usaspending-api/terminology.md) for links to canonical
+USAspending definitions.

usaspending_orm-0.9.1/docs/explanation/query-execution.md

@@ -0,0 +1,68 @@
+# Query execution
+
+Query builders separate request construction from execution.
+
+## Lazy construction
+
+Filter, sort, and limit calls modify the builder without making an HTTP
+request:
+
+```python
+query = (
+    client.awards.search()
+    .contracts()
+    .agency("National Aeronautics and Space Administration")
+    .fiscal_year(2024)
+    .limit(25)
+)
+```
+
+The request begins when code:
+
+- iterates over the query;
+- calls `.all()`, `.first()`, or `.count()`;
+- calls `len(query)`;
+- indexes or slices the query;
+- evaluates its truth value.
+
+## Pagination
+
+Iteration requests pages as needed and stops when the API is exhausted or a
+configured bound is reached. Query builders expose list-like operations, but
+they do not pre-load the entire result set.
+
+`.all()` materializes the bounded query into a list. Prefer iteration when
+streaming pages is sufficient.
+
+## Count consistency
+
+`count()` uses a companion endpoint when USAspending provides one. Library
+limits are applied to the reported value so these expressions agree for a
+bounded query:
+
+```python
+query = client.awards.search().contracts().fiscal_year(2024).limit(10)
+
+query.count()
+len(query)
+len(query.all())
+```
+
+Some upstream search and count endpoints accept different filters. When a
+correct count cannot be requested, the library raises `ValidationError` rather
+than returning a misleading number.
+
+## Immutable chaining
+
+Fluent methods return a clone with the new filter, sort, or bound. A partly
+built query can therefore be used as an immutable template:
+
+```python
+base = client.awards.search().contracts().fiscal_year(2024)
+california = base.place_of_performance_locations(
+    {"country_code": "USA", "state_code": "CA"}
+)
+```
+
+After this call, `base` remains unchanged and `california` carries the added
+location filter.

usaspending_orm-0.9.1/docs/getting-started/core-concepts.md

@@ -0,0 +1,77 @@
+# Core concepts
+
+## Client
+
+`USASpendingClient` owns the HTTP session, retry behavior, rate limiter, and
+resource entry points. Prefer a `with` block so the session closes reliably.
+
+```python
+from usaspending import USASpendingClient
+
+with USASpendingClient() as client:
+    award = client.awards.find_by_award_id("80GSFC18C0008")
+```
+
+## Resources
+
+Client properties group related upstream operations:
+
+| Resource              | Typical purpose                                    |
+| --------------------- | -------------------------------------------------- |
+| `client.awards`       | Find and search prime awards                       |
+| `client.transactions` | Search transactions globally or for one award      |
+| `client.subawards`    | Search subawards                                   |
+| `client.recipients`   | Find and search recipient organizations            |
+| `client.agencies`     | Agency summaries, subagencies, and office searches |
+| `client.references`   | Current API reference data, including DEF codes    |
+| `client.spending`     | Aggregated spending by recipient or geography      |
+| `client.tas`          | Treasury Account Symbol hierarchy                  |
+| `client.downloads`    | Queue server-side bulk exports                     |
+
+## Query builders
+
+Calling `.search()` returns a fluent builder. Filter methods clone it and return
+a new query, so a shared base query can safely feed consumers that need
+different filters.
+
+```python
+query = (
+    client.awards.search()
+    .contracts()
+    .agency("National Aeronautics and Space Administration")
+    .fiscal_year(2024)
+    .limit(25)
+)
+```
+
+Query builders handle pagination and expose a list-like interface, but they are
+not in-memory lists. Some operations make separate API requests; see
+[Query execution](../explanation/query-execution.md).
+
+## Models
+
+Results are model objects such as `Award`, `Transaction`, `Recipient`, and
+`Agency`. Models provide:
+
+- normalized snake-case properties;
+- parsed dates and decimal amounts;
+- `.raw` access to the original response;
+- related objects or query builders where the upstream data supports them.
+
+Optional fields return `None` when the API does not report a value. A real
+zero-dollar amount remains `Decimal("0.00")`.
+
+## Lazy loading and sessions
+
+Some relationships require another API request. Access them while the creating
+client is open. A model can be reattached to a new client when later lazy loads
+are required:
+
+```python
+with USASpendingClient() as client:
+    award = client.awards.find_by_award_id("80GSFC18C0008")
+
+with USASpendingClient() as new_client:
+    award.reattach(new_client, recursive=True)
+    print(award.transactions.count())
+```