masterly 0.4.0__tar.gz → 0.5.1__tar.gz

masterly-0.5.1/.github/dependency-review-config.yml

@@ -0,0 +1,23 @@
+# Licence allow-list for the dependency-review job (.github/workflows/dependency-review.yml).
+#
+# Source: the permissive licences that can be combined with this package's own Apache-2.0
+# licence and redistributed from PyPI -- Apache-2.0 itself, and the permissive families
+# (MIT, BSD, ISC, PSF, Zlib, Unlicense/CC0, MPL-2.0 as file-level copyleft that does not reach the
+# SDK's own code). Strong or network copyleft (GPL, AGPL, LGPL-3 static) and non-commercial or
+# source-available licences are deliberately absent: a dependency under one fails the check.
+# Identifiers are SPDX. Adding one is an owner decision.
+allow-licenses:
+  - Apache-2.0
+  - MIT
+  - MIT-0
+  - BSD-2-Clause
+  - BSD-3-Clause
+  - 0BSD
+  - ISC
+  - PSF-2.0
+  - Python-2.0
+  - Unlicense
+  - CC0-1.0
+  - Zlib
+  - MPL-2.0
+  - BlueOak-1.0.0

{masterly-0.4.0 → masterly-0.5.1}/.github/workflows/ci.yml

@@ -44,7 +44,7 @@ jobs:
       - uses: actions/checkout@v7
         with:
           persist-credentials: false
-      - uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7  # v10, pinned by digest
+      - uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884  # v10, pinned by digest
         with:
           python-version: ${{ matrix.python }}
       - run: uv sync

masterly-0.5.1/.github/workflows/dependency-review.yml

@@ -0,0 +1,41 @@
+# Fails a pull request that introduces a dependency with a known high-or-worse advisory, or one
+# whose licence is outside .github/dependency-review-config.yml (MAS-2155 is the backend twin).
+# This package ships to PyPI, so what it depends on reaches customers' environments.
+#
+# The required-status-check name for the ruleset is the job name: `dependency-review`. Adding it
+# to the ruleset is the owner's change.
+name: dependency-review
+
+# Quoted because bare `on` is a YAML 1.1 boolean.
+"on":
+  pull_request:
+  # The merge queue tests the speculative merge. Without this trigger a required check never
+  # reports for a queued entry and the queue stalls until it times out.
+  merge_group:
+
+# Deliberately no path filter. A required check that does not run on a pull request blocks it
+# forever; with no dependency change the action reports an empty diff and exits 0 in seconds.
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+permissions: {}
+
+jobs:
+  dependency-review:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read # actions/checkout, and the dependency-graph compare API
+    steps:
+      # persist-credentials: false -- nothing here pushes, so the token has no job after the checkout.
+      - uses: actions/checkout@v7
+        with:
+          persist-credentials: false
+      # Pinned by full commit SHA: MAS-2159 asks for it, which is stricter than the `actions/*`
+      # ref-pin policy in .github/zizmor.yml.
+      - uses: actions/dependency-review-action@5a2ce3f5b92ee19cbb1541a4984c76d921601d7c  # v4.3.4, pinned by digest
+        with:
+          fail-on-severity: high
+          config-file: ./.github/dependency-review-config.yml
+          comment-summary-in-pr: never

{masterly-0.4.0 → masterly-0.5.1}/.github/workflows/release.yml

@@ -75,7 +75,7 @@ jobs:
       # entry poisoned by any earlier job holding this repository's GITHUB_TOKEN would feed the
       # build backend straight into what ships. A cold cache costs seconds here; the wheel is
       # built from the tag alone, with everything fetched fresh from PyPI.
-      - uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7  # v10, pinned by digest
+      - uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884  # v10, pinned by digest
         with:
           enable-cache: false
       - run: uv build

masterly-0.5.1/AGENTS.md

@@ -0,0 +1 @@
+CLAUDE.md

masterly-0.5.1/CLAUDE.md

@@ -0,0 +1,72 @@
+# masterly-python-sdk
+
+The public (Apache-2.0) Python client for Masterly, published to PyPI as `masterly`
+(`pyproject.toml`). It is a hand-written client over the stable `/v1` REST API, not generated
+code and not a second contract: it adds ergonomics to endpoints the server already
+publishes (ADR 0068). Sync `httpx`, Python >= 3.10, typed (`src/masterly/py.typed`).
+
+This repository is public. Write everything in it — code, comments, commit messages, PR
+text — as something a customer will read.
+
+## Layout
+
+- `src/masterly/` — the package; public names are listed in `__all__` in `__init__.py`
+- `src/masterly/cli/` — the `masterly` console script (`masterly config migrate`)
+- `tests/` — pytest suite; `examples/demo_data.py` — demo master-data generator
+- `scripts/check_release_record.py` — the release-record check (see `RELEASING.md`)
+
+## Commands
+
+Run from the repository root; `uv` manages the environment (`uv.lock` is committed).
+
+```bash
+uv sync                                          # install, dev group included
+uv run pytest -q                                 # tests
+uv run ruff check                                # lint (rules and line length in pyproject.toml)
+uv run mypy src                                  # types; strict, on the package only
+uv build                                         # sdist and wheel, built with hatchling
+python3 scripts/check_release_record.py --selftest && python3 scripts/check_release_record.py
+```
+
+`.github/workflows/ci.yml` runs ruff, mypy and pytest on Python 3.10 and 3.13, plus the
+release-record check. A change is gated on all of it.
+
+## Versioning and release
+
+- Semver. The version is set in two places that must agree: `pyproject.toml` (`version`)
+  and `src/masterly/__init__.py` (`__version__`, sent in the `User-Agent` header).
+- The SDK's version tracks the `/v1` contract and is independent of the application's (ADR 0068).
+- A release is a version-bump PR to `main`, then an annotated `vX.Y.Z` tag on the merged
+  commit. Pushing the tag starts `.github/workflows/release.yml`, which publishes to PyPI by
+  trusted publishing (OIDC, no tokens) through the `pypi` environment.
+- PyPI versions are immutable, and the workflow refuses a tag that does not match
+  `pyproject.toml`, is not on the default branch, or claims 0.1.1 or 0.2.0. Never tag,
+  publish or re-use a version without being asked to. Details: `RELEASING.md`.
+
+## Documentation
+
+- The SDK reference on masterlydata.com (`Documentation` URL in `pyproject.toml`) documents
+  the **released** SDK. Do not describe unreleased behaviour there; `README.md` is what
+  PyPI shows, so it must also be true of the released package.
+- There is no `CHANGELOG.md` in this repository. The changelog is the docs "What's new"
+  page (`Changelog` URL in `pyproject.toml`), which lives outside this repository.
+
+## Don't
+
+- Don't make a breaking change to the public API (anything in `__all__`, method signatures,
+  exception types, the `masterly` console script) without a major version.
+- Don't add a runtime dependency beyond `httpx` without a stated reason. Optional features
+  go in an extra (`pandas`, `cli` in `pyproject.toml`), never in `dependencies`.
+- Don't call endpoints outside stable `/v1` paths.
+- Don't edit `uv.lock` by hand; change `pyproject.toml` and re-lock.
+- Don't weaken a test, a ruff rule or a strict mypy setting to get a change through.
+- Don't put credentials, tokens or customer data in code, tests, examples or comments.
+
+## Done means
+
+- `ruff check`, `mypy src` and `pytest -q` pass.
+- New behaviour has a test; the existing tests were not weakened.
+- `examples/demo_data.py` still runs: `uv run examples/demo_data.py --dry-run --customers 5`
+  (`examples/README.md`); `tests/test_demo_data.py` covers the generator.
+- A user-visible change is noted for the changelog and `README.md` is updated if it is wrong.
+- `REVIEW.md` is the checklist a reviewer applies.

{masterly-0.4.0 → masterly-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: masterly
-Version: 0.4.0
+Version: 0.5.1
 Summary: Python client for Masterly — extract governed data products and ingest records from your lakehouse
 Project-URL: Homepage, https://masterlydata.com
 Project-URL: Documentation, https://masterlydata.com/docs/reference/python-sdk/
@@ -222,7 +222,9 @@ recomputes without it, and its history stays readable. A delete for a key the so
 hold does nothing.
 
 When a system can only hand over everything it has, send it as a **full snapshot**: every live
-record of the Source that the snapshot does not carry is deleted after the upserts.
+record of the target that the snapshot does not carry is deleted after the upserts (a source
+that [feeds several models](#a-source-that-feeds-several-models) names the target with
+`model=`; its other targets are untouched).
 
 ```python
 client.sources.ingest("crm", every_customer, mode="full", batch_size=5000)
@@ -413,10 +415,84 @@ source = client.sources.get("erp")
 client.sources.update("erp", display_name="SAP ERP (Sweden)", if_match=source["version"])
 ```
 
+A field the field map does not name passes through under its own name, so a field named like a
+model attribute lands on it. When such a field is not meant for the model, name it in
+`ignored_fields=` (on `create`, `SourceTarget` and `targets.add`): it is dropped before the field
+map, lands on no attribute and is not reported as schema drift. It comes back as
+`mapping["ignored_fields"]`; to change it later, edit the mapping you read and pass it to
+`update` (or `targets.update`). An install on an API release before this field existed drops
+`ignored_fields` without an error and returns no such key, so read the mapping back to confirm it
+was kept.
+
 Everything takes an id or an exact name, so a script reads the way the domain is discussed.
 A model's `definition` carries its attributes, keys and constraints — ingest validates every
 record against them, so widening or tightening one changes what the pipeline accepts.
 
+### A source that feeds several models
+
+A source feeds one or more models — its **targets** — and each target has its own source
+key and field map. A CRM export that carries customers and their addresses is one source
+with two targets, registered with `targets=` instead of `target_model=`:
+
+```python
+from masterly import SourceTarget
+
+client.sources.create(
+    "crm",
+    display_name="Salesforce CRM",
+    targets=[
+        SourceTarget("Customer", source_key="customer_number"),
+        SourceTarget("Address", source_key="address_id", field_map={"ADDR_ID": "address_id"}),
+    ],
+)
+```
+
+A batch lands in **one** target, so a push to such a source names it with `model=` — one call
+per model. On a source with one target `model` may be left out, and the call sends exactly
+what it always sent; on a source with several, an unnamed batch is refused with
+`SOURCE_TARGET_REQUIRED` before anything is queued, `error.details["targets"]` listing them:
+
+```python
+client.sources.ingest("crm", customers, model="Customer")
+client.sources.ingest("crm", addresses, model="Address")
+client.sources.upload_csv("crm", open("addresses.csv").read(), model="Address", delimiter=";")
+
+with client.sources.full_load("crm", model="Address") as load:   # one target's snapshot
+    load.send(every_address)
+```
+
+Records, quarantine and counts are per target too — a source key names one record within a
+target, so the same key under two targets is two records:
+
+```python
+for row in client.sources.quarantine("crm", model="Address", status="open"):
+    print(row["model_name"], row["reason_code"], row["payload"])
+
+stats = client.sources.stats("crm")           # the whole source, plus `targets[]` per model
+stats = client.sources.stats("crm", model="Address")
+```
+
+`client.sources.targets` lists, adds, reads, edits and removes a source's targets. A target
+has a revision of its own, stated on its governed writes; adding one needs a model with a
+published version, and only a target that holds no records — deleted ones included — can be
+removed, never the last one:
+
+```python
+client.sources.targets.add("crm", "Address", source_key="address_id")
+target = client.sources.targets.get("crm", "Address")
+target["mapping"]["field_map"]["STREET"] = "street"
+client.sources.targets.update("crm", "Address", mapping=target["mapping"], if_match=target["version"])
+client.sources.targets.remove("crm", "Address", if_match=target["version"])   # only while empty
+```
+
+On what `client.sources.get` returns, `targets[]` carries every target; the top-level
+`target_model`, `mapping`, `profile` and `drift` are **deprecated** and describe the first
+target — on a one-target source, exactly what they always did. The same goes for `target_model=`
+and `mapping=` on `client.sources.update`, which write the first target; edit any target through
+`client.sources.targets.update`. These calls talk to routes that are not in a published release
+of the API yet; an install on an earlier release answers them `404 NOT_FOUND`, and sends every
+batch to its one target.
+
 Editing a model or a source is a **governed write**: more than one person edits them, and the
 edit is derived from a read, so `update` states the revision it replaces (ADR 0070) and a stale
 one is refused rather than silently overwriting:
@@ -433,6 +509,45 @@ A refused write raises `ApiError`; `error.conflict` names the fields that moved.
 without a typed method is reached through `client.request(...)`, which takes the same
 `if_match`.
 
+### Deactivate, reactivate or delete a source
+
+A source has a `status`: `active`, or `inactive` once deactivated. An **inactive** source admits
+nothing — a pushed batch, a CSV upload, a full load's next batch and a quarantine retry are all
+refused with `409 SOURCE_INACTIVE` and nothing is queued. Everything it already landed stays,
+and **its records keep contributing to golden records**: nothing is recomputed, in either
+direction. Reactivating admits records again with nothing lost. Both are governed writes, so
+they take the source's `version` as `if_match`:
+
+```python
+source = client.sources.get("erp")
+client.sources.deactivate("erp", if_match=source["version"])   # status: "inactive"
+
+source = client.sources.get("erp")
+client.sources.reactivate("erp", if_match=source["version"])   # status: "active"
+```
+
+A **delete** removes the source and everything it landed — its records in every target and
+their history, quarantine, profile, drift, run history, schedule and sealed connection — and
+recomputes the golden records it contributed to without it; an entity left with no live
+record clears. It is heavy work, so it runs as a job: the source is marked `deleting` at once,
+the answer is the job receipt, and `client.jobs.wait` follows the removal to its end. Read
+what it would touch first, and ask a person to type the source's `name` before you send it:
+
+```python
+impact = client.sources.deletion_impact("erp")
+print(impact["targets"], impact["golden"]["would_change"], impact["golden"]["would_clear"])
+if impact["deletable"] and typed_name == impact["name"]:
+    source = client.sources.get("erp")
+    receipt = client.sources.delete("erp", if_match=source["version"])
+    client.jobs.wait(receipt["job_id"])
+```
+
+The delete is refused with `409 SOURCE_IN_USE` while a data product reads the source through a
+raw relation — `error.details["dependents"]` names each one; change or delete the product
+first — and the model's built-in manual source can be neither deactivated nor deleted
+(`409 SOURCE_BUILT_IN`). The four calls are session routes. They talk to routes that are not
+in a published release yet; an install on an earlier release answers them `404 NOT_FOUND`.
+
 ## Command line: `masterly config migrate`
 
 The configuration files in a GitOps repository follow a schema that Masterly versions. A

{masterly-0.4.0 → masterly-0.5.1}/README.md

@@ -193,7 +193,9 @@ recomputes without it, and its history stays readable. A delete for a key the so
 hold does nothing.
 
 When a system can only hand over everything it has, send it as a **full snapshot**: every live
-record of the Source that the snapshot does not carry is deleted after the upserts.
+record of the target that the snapshot does not carry is deleted after the upserts (a source
+that [feeds several models](#a-source-that-feeds-several-models) names the target with
+`model=`; its other targets are untouched).
 
 ```python
 client.sources.ingest("crm", every_customer, mode="full", batch_size=5000)
@@ -384,10 +386,84 @@ source = client.sources.get("erp")
 client.sources.update("erp", display_name="SAP ERP (Sweden)", if_match=source["version"])
 ```
 
+A field the field map does not name passes through under its own name, so a field named like a
+model attribute lands on it. When such a field is not meant for the model, name it in
+`ignored_fields=` (on `create`, `SourceTarget` and `targets.add`): it is dropped before the field
+map, lands on no attribute and is not reported as schema drift. It comes back as
+`mapping["ignored_fields"]`; to change it later, edit the mapping you read and pass it to
+`update` (or `targets.update`). An install on an API release before this field existed drops
+`ignored_fields` without an error and returns no such key, so read the mapping back to confirm it
+was kept.
+
 Everything takes an id or an exact name, so a script reads the way the domain is discussed.
 A model's `definition` carries its attributes, keys and constraints — ingest validates every
 record against them, so widening or tightening one changes what the pipeline accepts.
 
+### A source that feeds several models
+
+A source feeds one or more models — its **targets** — and each target has its own source
+key and field map. A CRM export that carries customers and their addresses is one source
+with two targets, registered with `targets=` instead of `target_model=`:
+
+```python
+from masterly import SourceTarget
+
+client.sources.create(
+    "crm",
+    display_name="Salesforce CRM",
+    targets=[
+        SourceTarget("Customer", source_key="customer_number"),
+        SourceTarget("Address", source_key="address_id", field_map={"ADDR_ID": "address_id"}),
+    ],
+)
+```
+
+A batch lands in **one** target, so a push to such a source names it with `model=` — one call
+per model. On a source with one target `model` may be left out, and the call sends exactly
+what it always sent; on a source with several, an unnamed batch is refused with
+`SOURCE_TARGET_REQUIRED` before anything is queued, `error.details["targets"]` listing them:
+
+```python
+client.sources.ingest("crm", customers, model="Customer")
+client.sources.ingest("crm", addresses, model="Address")
+client.sources.upload_csv("crm", open("addresses.csv").read(), model="Address", delimiter=";")
+
+with client.sources.full_load("crm", model="Address") as load:   # one target's snapshot
+    load.send(every_address)
+```
+
+Records, quarantine and counts are per target too — a source key names one record within a
+target, so the same key under two targets is two records:
+
+```python
+for row in client.sources.quarantine("crm", model="Address", status="open"):
+    print(row["model_name"], row["reason_code"], row["payload"])
+
+stats = client.sources.stats("crm")           # the whole source, plus `targets[]` per model
+stats = client.sources.stats("crm", model="Address")
+```
+
+`client.sources.targets` lists, adds, reads, edits and removes a source's targets. A target
+has a revision of its own, stated on its governed writes; adding one needs a model with a
+published version, and only a target that holds no records — deleted ones included — can be
+removed, never the last one:
+
+```python
+client.sources.targets.add("crm", "Address", source_key="address_id")
+target = client.sources.targets.get("crm", "Address")
+target["mapping"]["field_map"]["STREET"] = "street"
+client.sources.targets.update("crm", "Address", mapping=target["mapping"], if_match=target["version"])
+client.sources.targets.remove("crm", "Address", if_match=target["version"])   # only while empty
+```
+
+On what `client.sources.get` returns, `targets[]` carries every target; the top-level
+`target_model`, `mapping`, `profile` and `drift` are **deprecated** and describe the first
+target — on a one-target source, exactly what they always did. The same goes for `target_model=`
+and `mapping=` on `client.sources.update`, which write the first target; edit any target through
+`client.sources.targets.update`. These calls talk to routes that are not in a published release
+of the API yet; an install on an earlier release answers them `404 NOT_FOUND`, and sends every
+batch to its one target.
+
 Editing a model or a source is a **governed write**: more than one person edits them, and the
 edit is derived from a read, so `update` states the revision it replaces (ADR 0070) and a stale
 one is refused rather than silently overwriting:
@@ -404,6 +480,45 @@ A refused write raises `ApiError`; `error.conflict` names the fields that moved.
 without a typed method is reached through `client.request(...)`, which takes the same
 `if_match`.
 
+### Deactivate, reactivate or delete a source
+
+A source has a `status`: `active`, or `inactive` once deactivated. An **inactive** source admits
+nothing — a pushed batch, a CSV upload, a full load's next batch and a quarantine retry are all
+refused with `409 SOURCE_INACTIVE` and nothing is queued. Everything it already landed stays,
+and **its records keep contributing to golden records**: nothing is recomputed, in either
+direction. Reactivating admits records again with nothing lost. Both are governed writes, so
+they take the source's `version` as `if_match`:
+
+```python
+source = client.sources.get("erp")
+client.sources.deactivate("erp", if_match=source["version"])   # status: "inactive"
+
+source = client.sources.get("erp")
+client.sources.reactivate("erp", if_match=source["version"])   # status: "active"
+```
+
+A **delete** removes the source and everything it landed — its records in every target and
+their history, quarantine, profile, drift, run history, schedule and sealed connection — and
+recomputes the golden records it contributed to without it; an entity left with no live
+record clears. It is heavy work, so it runs as a job: the source is marked `deleting` at once,
+the answer is the job receipt, and `client.jobs.wait` follows the removal to its end. Read
+what it would touch first, and ask a person to type the source's `name` before you send it:
+
+```python
+impact = client.sources.deletion_impact("erp")
+print(impact["targets"], impact["golden"]["would_change"], impact["golden"]["would_clear"])
+if impact["deletable"] and typed_name == impact["name"]:
+    source = client.sources.get("erp")
+    receipt = client.sources.delete("erp", if_match=source["version"])
+    client.jobs.wait(receipt["job_id"])
+```
+
+The delete is refused with `409 SOURCE_IN_USE` while a data product reads the source through a
+raw relation — `error.details["dependents"]` names each one; change or delete the product
+first — and the model's built-in manual source can be neither deactivated nor deleted
+(`409 SOURCE_BUILT_IN`). The four calls are session routes. They talk to routes that are not
+in a published release yet; an install on an earlier release answers them `404 NOT_FOUND`.
+
 ## Command line: `masterly config migrate`
 
 The configuration files in a GitOps repository follow a schema that Masterly versions. A

masterly-0.5.1/REVIEW.md

@@ -0,0 +1,47 @@
+# Reviewing a change to masterly-python-sdk
+
+`CLAUDE.md` says how to work in this repository; this file says what a review blocks on.
+
+## What blocks
+
+- **The change's stated acceptance criteria are not met.** Check the change against the stated acceptance
+  criteria, not against what the diff happens to do.
+- **A public API break without a major version.** Removed or renamed names in `__all__`
+  (`src/masterly/__init__.py`), changed signatures or defaults, a new required argument, a
+  changed exception type, or a changed `masterly` console script. PyPI versions are
+  immutable, so a break cannot be taken back.
+- **A new runtime dependency.** Any change to `dependencies` in `pyproject.toml` beyond
+  `httpx`. Optional features belong in an extra.
+- **A missing changelog entry** for a user-visible change. The changelog is the docs
+  "What's new" page (`Changelog` URL in `pyproject.toml`), not a file here, so look for the
+  entry in the PR description or the linked docs change.
+- **A weakened check:** a skipped or loosened test, a new ruff ignore, a relaxed strict
+  mypy setting.
+- **A release that breaks the record:** a version bump that differs between
+  `pyproject.toml` and `src/masterly/__init__.py`, or one that reuses 0.1.1 or 0.2.0
+  (`RELEASING.md`, `scripts/check_release_record.py`).
+- **Secrets or customer data** anywhere in the diff. The repository is public.
+
+## What does not block
+
+- Style, formatting and import order that ruff owns (`uv run ruff check`). If the linter
+  accepts it, do not comment on it.
+- Typing details mypy accepts under its strict configuration.
+- Dependabot bumps of dev tools and actions that CI passes (`.github/dependabot.yml`).
+- Wording preferences in comments and docs that are accurate.
+
+## Known traps
+
+- **The version lives in two places**, `pyproject.toml` and `src/masterly/__init__.py`.
+  Updating one passes CI's checks but ships a wrong `User-Agent` and `--version`.
+- **`README.md` ships to PyPI** as the project page, so a README edit is a published change
+  once released, and must describe the released package only.
+- **Two published versions have no tag here** (0.1.1, 0.2.0). Do not "fix" that by tagging
+  an unrelated commit; `RELEASING.md` explains why.
+- **mypy runs on `src` only.** Tests and `examples/` are not type-checked, so a typing
+  problem there will not fail CI.
+- **`examples/` is not covered by `pytest`** except through `tests/test_demo_data.py`;
+  run the example with `--dry-run` when a change touches the client surface it uses.
+- **Governed writes need a revision.** `data_models.update` requires the precondition
+  version; do not make it optional to simplify a call site.
+- **`uv.lock` is regenerated, not edited.** A hand-edited lockfile is a review finding.

{masterly-0.4.0 → masterly-0.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "masterly"
-version = "0.4.0"
+version = "0.5.1"
 description = "Python client for Masterly — extract governed data products and ingest records from your lakehouse"
 readme = "README.md"
 requires-python = ">=3.10"

{masterly-0.4.0 → masterly-0.5.1}/src/masterly/__init__.py

@@ -20,10 +20,10 @@ personas" says how to get either one.
 
 from masterly._client import ApiError, Client, Persona
 from masterly._extract import ChangeFeed, RowPages
-from masterly._ingest import FullLoad, IngestMode, IngestReceipt, IngestReport
+from masterly._ingest import FullLoad, IngestMode, IngestReceipt, IngestReport, SourceTarget
 from masterly._precondition import Conflict, Precondition
 
-__version__ = "0.4.0"
+__version__ = "0.5.1"
 
 __all__ = [
     "ApiError",
@@ -37,5 +37,6 @@ __all__ = [
     "Persona",
     "Precondition",
     "RowPages",
+    "SourceTarget",
     "__version__",
 ]

{masterly-0.4.0 → masterly-0.5.1}/src/masterly/_client.py

@@ -283,7 +283,16 @@ class Client:
         response = self._http.request(method, path, params=params, json=json, headers=sent or None)
         return self._answer(response)
 
-    def _keyed_request(self, method: str, path: str, *, json: Any) -> Any:
+    def _keyed_request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Any = None,
+        params: dict[str, Any] | None = None,
+        content: bytes | None = None,
+        headers: Mapping[str, str] | None = None,
+    ) -> Any:
         """Send a write the server de-duplicates by ``Idempotency-Key``, retrying it with the
         same key when the connection fails before an answer arrives.
 
@@ -291,12 +300,15 @@ class Client:
         reached us is indistinguishable, here, from one that never got through. Re-sending with
         the same key makes that ambiguity harmless: the server replays the answer it already
         gave instead of applying the write a second time. An answer — any status — is never
-        retried; it raises or returns as usual.
+        retried; it raises or returns as usual. The body is ``json``, or raw ``content`` (a
+        CSV file) with its own ``Content-Type`` in ``headers``.
         """
-        headers = {_IDEMPOTENCY_KEY: str(uuid.uuid4())}
+        sent = {**(headers or {}), _IDEMPOTENCY_KEY: str(uuid.uuid4())}
         for backoff in (*_KEYED_RETRY_BACKOFF, None):
             try:
-                response = self._http.request(method, path, json=json, headers=headers)
+                response = self._http.request(
+                    method, path, params=params, json=json, content=content, headers=sent
+                )
             except httpx.TransportError:
                 if backoff is None:
                     raise