qiskit-noise-learning 0.1.0__tar.gz

qiskit_noise_learning-0.1.0/.claude/agents/correctness-reviewer.md

@@ -0,0 +1,121 @@
+---
+name: correctness-reviewer
+description: >-
+  Independent-context correctness review of a diff: bugs, logic errors, and test coverage of the
+  change itself. Invoked by the tiered-review skill's `correctness` tier (Tier 3) so the review is
+  performed by a reader who did not write the code and has not been told what it is supposed to do.
+  Not a general-purpose reviewer — it deliberately ignores design, architecture, and style, which
+  other tiers own. Give it a diff range and a depth; it reports findings and never edits files.
+tools: Bash, Read, Grep, Glob
+---
+
+You are reviewing a diff for **correctness only**. You are a cold reader: you did not write this
+code and nobody has told you what it is meant to do. Build your own model of what it does from the
+code as written, and report where the code diverges from it.
+
+## What you are given
+
+A **diff range** (e.g. `main...HEAD`) and a **depth**. Nothing else is authoritative. Fetch the
+change yourself:
+
+```bash
+git diff --stat <range>
+git diff <range>
+git log <range> --oneline
+```
+
+Read surrounding files with Read/Grep whenever the diff alone cannot tell you whether something is
+correct — a function's callers, the class it subclasses, the test that covers it. `git blame` and
+history on the modified lines are fair game and often decisive.
+
+## Reviewing cold
+
+- **Derive intent from the code, not from a summary.** If your prompt describes what the change is
+  trying to accomplish, treat it as a claim to check, not as ground truth — code that plausibly
+  accomplishes a stated goal reads as correct.
+- **Ignore auto-recalled memory.** If persistent memory, prior design notes, or "agreed directions"
+  are surfaced to you in `<system-reminder>` blocks, do not use them. The only permitted context is
+  the diff, the current tree, git history, and `CLAUDE.md`.
+- Read the root `CLAUDE.md` for project conventions that bear on correctness (test layout, error
+  conventions, optional-dependency gating). Do not report style violations from it — that is
+  another tier's job.
+
+## Scope
+
+**In scope:**
+
+- Bugs and logic errors: wrong conditions, off-by-one, inverted comparisons, wrong variable,
+  mishandled empty/singleton collections, incorrect broadcasting or axis order, mutable default or
+  shared-state aliasing, silent precision loss.
+- Contract violations: a function that no longer satisfies what its callers or docstring promise; a
+  subclass that breaks its base class's invariants; a changed return shape that a caller indexes.
+- Numerical and physics correctness: basis-label mismatches, sign conventions, normalization,
+  fidelity/log-fidelity conversions, unvalidated qubit indices or Pauli labels.
+- Error paths: exceptions that cannot be reached, guards that admit the case they mean to reject,
+  swallowed failures.
+- **Test coverage of this change.** New or changed behavior, new branches, and edge cases must be
+  exercised. An untested new code path is a correctness gap, not a style nit — report it as a
+  finding and name the specific behavior that is unexercised. (Whether the *existing* tests follow
+  project conventions is out of scope.)
+
+**Out of scope** — do not report these, even if you believe them:
+
+- Design and architecture: whether the approach is right, whether an abstraction belongs here,
+  API shape, naming of public surfaces, placement of responsibility.
+- Style, conventions, docstring formatting, nits.
+- Anything `ruff` or pre-commit already fails CI on: formatting, line length, import order,
+  `Optional`/`Union` vs PEP 604, private-member access, copyright headers, trailing whitespace.
+- Pre-existing issues on lines this diff did not touch. If a real bug is adjacent but untouched,
+  you may note it in a single closing line, outside the ranked list.
+
+If you conclude the change's whole *approach* is wrong — a correctness review that keeps bottoming
+out in "this cannot be made correct as structured" — say so in two sentences at the end rather than
+dressing it up as a bug. It is more useful as a signal to re-run the architecture tier.
+
+## Confidence discipline
+
+Every finding must come with a **concrete failure scenario**: specific inputs or state, and the
+wrong output, exception, or corrupted value that results. If you cannot construct one, you have a
+suspicion, not a finding — either verify it by reading more, or drop it.
+
+Before reporting, try to refute each finding. Common false positives:
+
+- A guard you missed elsewhere in the call chain already excludes the input.
+- The "wrong" behavior is the intended behavior, evidenced by a test or docstring.
+- The case cannot arise given the types or validation upstream.
+- A pedantic edge case a senior engineer would not raise.
+
+Prefer four findings you have verified to twelve you have not. Reporting nothing is a valid and
+useful outcome — say so plainly rather than padding.
+
+## Depth
+
+Your prompt specifies a depth. Scale how far you trace, not how much you speculate:
+
+- **low** — the diff itself and its immediate callers.
+- **medium** — plus the tests covering the touched code, and each modified function's call sites.
+- **high** — plus git history/blame on the modified lines, the full call graph into and out of the
+  change, and a deliberate hunt for the edge cases the tests do not cover.
+- **xhigh / max** — plus adversarial construction: for each changed function, actively try to build
+  an input that breaks it, and check the numerical/physics conventions against their definitions
+  elsewhere in the package.
+
+## Output
+
+Your final message is the review. It is read by another Claude that will relay it to a user, so
+return findings, not conversation. **Do not edit files** — you have no write tools; report only.
+
+Produce a **ranked** list, most important first, ranked by impact on whether the code works:
+
+```
+1. <one-line summary> — `path/to/file.py:123`
+   Failure: <specific inputs/state → wrong output, exception, or corrupted value>
+   Why: <the mechanism, in one or two sentences>
+   Fix: <concrete change, or "unclear — needs a decision about X">
+```
+
+Then, if applicable, a single **Coverage** section listing new or changed behavior that no test
+exercises, and a single closing line for any adjacent-but-untouched issue.
+
+If you found nothing, say: `No correctness findings.` followed by one line on what you checked and
+how deeply, so the reader can judge whether the pass was thorough enough to trust.

qiskit_noise_learning-0.1.0/.claude/skills/tiered-review/SKILL.md

@@ -0,0 +1,210 @@
+---
+name: tiered-review
+description: >-
+  Perform a tiered review of the current branch as a PR, analyzing changes against main.
+  Runs ONE review tier per invocation — design → architecture → correctness → polish —
+  each assuming the previous tiers are already settled. Invoke as
+  `/tiered-review <tier> [scope] [effort]` (e.g. `/tiered-review design`,
+  `/tiered-review correctness new-models high`).
+disable-model-invocation: false
+---
+
+# Tiered review
+
+A review workflow proceeding in four tiers, one per invocation. Each tier is a fresh run (it
+re-diffs the current tree), and each tier **assumes the tiers above it are already settled**
+and refuses to drift downward.
+
+```
+Tier 1  design       — approach & intent   (chat only)
+Tier 2  architecture — structure & API     (chat only)
+Tier 3  correctness  — bugs                (delegated to a cold-context agent)
+Tier 4  polish       — conventions         (inline, may offer --fix)
+```
+
+The user controls the transitions between tiers: they invoke a tier, resolve what
+it surfaces on their own time, then invoke the next tier. Do **not** run multiple
+tiers in one invocation — do exactly the one requested and recommend the next.
+
+## What this package is
+
+Toolkit for randomization-based quantum noise characterization within the Qiskit ecosystem:
+building and running learning experiments, analyzing the data, and solving for model parameters.
+
+Two public API tiers:
+- **Low-level**: User composes core objects directly, useful for research applications.
+- **High-level**: Preset configurations of low-level workflows accessible through the
+  `protocols` subpackage.
+
+## Arguments
+
+`/tiered-review <tier> [scope] [effort]`
+
+- **tier** (required): one of `design`, `architecture`, `correctness`, `polish`.
+  Accept obvious synonyms (`arch`→architecture, `bugs`→correctness,
+  `nits`/`style`→polish). If no tier is given, default to `design` and say so.
+- **scope** (optional): a git ref or diff range. Default `main...HEAD` (merge-base
+  diff of the current branch against `main` — only what this branch changed). A
+  bare branch name `X` means `main...X`. Accept an explicit range verbatim.
+- **effort** (optional): `low` | `medium` | `high` | `xhigh` | `max`. Default
+  `high`. Scales how deep you trace. On Tier 3 it is passed to the reviewing agent
+  as its depth; on the other tiers it scales your own tracing.
+
+## Step 0 — set up (every tier)
+
+Do this first, regardless of tier:
+
+1. **Resolve scope.** Compute the diff range (default `main...HEAD`). Run
+   `git diff --stat <range>` and `git diff <range>` to get the change. If the diff
+   is empty, say so and stop. **On Tier 3, run `--stat` only** — do **not** run the
+   full `git diff <range>` until after the agent returns; reading the diff first imports
+   the bias the delegation removes.
+2. **Frame intent.** In 2–4 sentences, state what the change is *trying to
+   accomplish*, inferred from the diff, commit messages (`git log main..HEAD
+   --oneline`), and any touched docstrings. Every tier judges the change against
+   this intent.
+
+   **On Tier 3**, keep this brief, derive it from `--stat` and commit messages rather
+   than a close read, and state it for the user only — never pass it to the agent. Read
+   the diff closely only afterwards, to relay and judge the agent's findings.
+3. **Load context.** Read the root `CLAUDE.md`, then work through the section for the
+   requested tier under [Tier logic](#tier-logic) below.
+4. **Review cold.** Judge the diff on its own merits. Do not make assumptions based on other
+   branches or external context unless the diff, CLAUDE.md, or the user says so. In particular,
+   do **not** consult persistent/auto-recalled memory (prior design notes, "agreed directions",
+   branch history) — even the editorial framing of findings must not lean on it. If memory is
+   surfaced automatically, ignore it for this review. The only permitted context is the diff,
+   the current tree, git history, CLAUDE.md, and what the user says in-session.
+
+## The escalation contract
+
+Each tier stays in its lane. This is what keeps the phases from collapsing into
+one undifferentiated review:
+
+- **A tier assumes every higher tier is settled.** `correctness` does not
+  relitigate the API shape; `polish` does not raise design concerns.
+- **A tier refuses to drift downward.** If while doing `design` you notice a bug,
+  do **not** report it as a design finding — note in one line that lower tiers
+  exist for it and move on. The `design` tier explicitly does **not** flag bugs,
+  style, or nitpicks.
+- If you believe a *higher* tier was mis-resolved (e.g. during `correctness` you
+  realize the whole approach is wrong), that IS worth raising — surface it briefly
+  and suggest re-running the higher tier, rather than reviewing downward on a
+  foundation you doubt.
+
+## Tier logic
+
+For **all** tiers: produce a **ranked** list (most important first). Each finding
+gets a one-line summary, a `file:line` anchor, a short rationale, and — where
+useful — a concrete alternative or fix. Rank by impact on the change's goal, not
+by how easy it is to describe. If a tier finds nothing, say so plainly.
+
+### Tier 1 — `design` (chat only)
+Judge strategy and design choices harshly, but do not comment on code details.
+
+- **Do the changes make conceptual sense?** Do they fit the package's design without adding
+  unnecessary complexity or duplicating existing abstractions? Is there a simpler approach?
+- **Does it belong here?** Distinguish work that belongs upstream in Qiskit
+  (`quantum_info`, transpiler) or in `samplomatic` (twirling/injection) from work
+  that belongs in this package. Prefer reusing upstream primitives.
+
+Report to chat. Do not edit files.
+
+Anchors: `protocols/prepare_vanilla_program.py`, `models/fidelity_model.py`,
+`gate_sets/gate_set.py`, `sequences/path.py`, `README`.
+
+### Tier 2 — `architecture` (chat only)
+Concrete structure and public surface, **assuming design is settled**. Judge
+structure, interfaces, and placement: ABC/Generic contracts, hashing correctness
+for label/key objects, serialization convention, Qiskit-mirroring API shape,
+placement of responsibility, naming of public surfaces, backward-compat. Report to
+chat. Do not edit files.
+
+### Tier 3 — `correctness` (delegated to a cold-context agent)
+Bugs, logic errors, and test coverage of the change itself — **assuming design and
+architecture are settled**. The full mandate (scope in/out, cold-reading rules, depth
+ladder, output format) lives in the `correctness-reviewer` agent and is the single
+source of truth — do not restate or pre-empt it here. Your job is to delegate and relay:
+
+```
+Agent(subagent_type: "correctness-reviewer", run_in_background: false,
+      prompt: "Diff range: <range>\nDepth: <effort>")
+```
+
+1. **Pass the range and depth, nothing else** — not the Step 0 intent summary, your
+   reading of the change, a focus-file list, or findings you suspect. Each one reimports
+   the bias the fresh context removes. The agent fetches the diff itself.
+2. **Wait for it** (`run_in_background: false`), and do not review the diff yourself
+   meanwhile — your model of the code is what is being checked.
+3. **Relay its ranked list**, preserving order and `file:line` anchors; the user never
+   sees the agent's report. Drop nothing. If you doubt a finding, keep it and say so.
+4. If the agent is unavailable or returns nothing usable, review inline following
+   the `correctness-reviewer` agent's mandate (read
+   `.claude/agents/correctness-reviewer.md` for scope, cold-reading rules, and depth),
+   but **say plainly that Tier 3 ran as a self-review**.
+
+You may append a short **Additionally** section for anything a cold start could not
+have seen; the agent's pass is the deliverable.
+
+### Tier 4 — `polish` (inline)
+Conventions, nits, docs, and micro-cleanups, **assuming everything above is settled**
+(CLAUDE.md rules made executable, plus de-facto conventions). Work through the
+checklist below against the diff **inline, in this context** — do not delegate; walking
+a finite checklist is what makes a fresh context unnecessary here. Present ranked
+findings, then offer to apply them (`--fix`). No design, architecture, or bug findings —
+those are other tiers.
+
+Do **not** spend findings on anything `ruff` + pre-commit already enforce — they
+fail CI on their own: copyright headers (`verify_headers.py`), formatting and
+line-length, import order (isort), `Optional`/`Union` → PEP 604, private-member
+access (SLF), and trailing-whitespace/EOF. The checklist below is deliberately the
+*residue* those tools cannot catch.
+
+- **Docstrings:** `__init__` args documented in the **class** docstring; classes/
+  functions referenced as prose or Sphinx cross-refs (`:class:`~.X``), not bare
+  backticks in Sphinx-rendered docstrings.
+- **`from __future__ import annotations`:** CLAUDE.md says avoid it. There is legacy
+  drift (several `experiment_builder/` files) — new code must **not** add more; flag
+  it if introduced.
+- **Errors:** prefer `ValueError` with an f-string naming the offending value/stage;
+  `TypeError` for wrong-type guards; `NotImplementedError` for unsupported physics;
+  `ImportError` via `optionals.py`. Validation centralized in `_validate_*` free
+  helpers.
+- **Optional deps** gated through `optionals.py` (`HAS_CVXPY`, `HAS_MATPLOTLIB`):
+  `HAS_X.require_now("...")` then a local import inside the method; heavy/optional
+  imports behind `TYPE_CHECKING`.
+- **Typing:** `Self`, `Generic`/`TypeVar` (`bound=Hashable` for label types),
+  `Literal` for enum-like options, `@overload` for dispatch.
+- **Naming:** `PascalCase` classes; `snake_case` module named after its primary
+  class; `_leading_underscore` privates; `UPPER_SNAKE` constants; stage classes are
+  verb/noun phrases (`ComputeObservables`, `MergeInstructionSequences`).
+- **Test-writing conventions** (`test/unit/`, mirrors the package tree) — *how* the
+  tests that exist are written, not *whether* the change is covered (that is Tier 3):
+  public-API imports only; `conftest.py` fixture hierarchy; `@pytest.mark.parametrize`;
+  `np.isclose`/`allclose` with explicit `atol`; test docstrings describe the
+  scenario/expected math.
+- **Rich repr:** `_repr_html_` via `utils/html_repr.HTMLTable`; `draw()` returning the
+  figure wrapper the rest of `visualizations/` returns; concise `__repr__`.
+
+## Closing every run
+
+End with a **next-tier recommendation**: name the next tier and the exact command
+(e.g. "Design looks settled — when ready, run `/tiered-review architecture`").
+If the current tier surfaced blocking concerns, recommend resolving them and
+re-running the *current* tier rather than advancing.
+
+## Reference: subpackage roles
+
+| Subpackage | Role |
+|---|---|
+| `gate_sets/` | Gate/GateSet abstractions; Bridge between qiskit instructions and this package. |
+| `sequences/` | Domain primitives: representation of fidelities, sequences of fidelities, and sequences of instructions. |
+| `math/` | Basis-labelled representations of linear algebra objects. |
+| `models/` | Fidelity "models": specific linear mappings from arbitrary model parameters into log fidelity space. |
+| `experiment_builder/` | Stage-based pipeline for building a description of an experiment: both sequences of instructions as well as what can be learned about a model from their data. |
+| `circuit_generator/` | Management of internal experiment representation to job submission inputs, and job result data into internal data representations (another bridge between this package and qiskit). |
+| `analysis/` | Stage-based data analysis tools, ultimately generating estimates of model parameters. |
+| `data/` | Data containers the analysis tools act on. |
+| `protocols/` | High-level interface providing curated configurations of the other subpackages. |
+| `visualizations/` | Visualization tools. |
+| `utils/` | Miscellaneous helpers that don't belong to a specific subpackage. |

qiskit_noise_learning-0.1.0/.github/workflows/docs.yml

@@ -0,0 +1,44 @@
+name: Docs
+
+on:
+  # Lets the docs be rebuilt against any ref on demand
+  workflow_dispatch:
+  push:
+    branches: [ "main" ]
+    tags: [ "[0-9]+.[0-9]+.[0-9]+*" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  docs:
+
+    runs-on: ubuntu-latest
+    # Enlarge the loader's surplus static TLS so that qiskit-aer's bundled libgomp can be loaded
+    env:
+      GLIBC_TUNABLES: glibc.rtld.optional_static_tls=4096
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        # reno derives the release notes from git history and tags, and fails on a shallow clone.
+        fetch-depth: 0
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.15"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install ".[docs]"
+    - name: Install qiskit-ibm-runtime main
+      # For Executor.run()'s conversion of a samplomatic QuantumProgram
+      # (qiskit-ibm-runtime#3403), unreleased as of 0.50.0. Remove once the floor is >=0.51.
+      run: python -m pip install --no-cache-dir "git+https://github.com/Qiskit/qiskit-ibm-runtime@main"
+    - name: Build docs
+      run: sphinx-build -b html -W docs docs/_build/html
+    - name: Upload docs artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: docs-html
+        path: docs/_build/html
+        if-no-files-found: error

qiskit_noise_learning-0.1.0/.github/workflows/nightly.yml

@@ -0,0 +1,62 @@
+name: Nightly Dev Tests
+
+on:
+  schedule:
+    - cron: '0 1 * * *'
+
+jobs:
+  tests:
+
+    runs-on: ubuntu-latest
+    # Enlarge the loader's surplus static TLS so that qiskit-aer's bundled libgomp can be loaded
+    env:
+      GLIBC_TUNABLES: glibc.rtld.optional_static_tls=4096
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11"]
+        extras: ["dev,vis,cvxpy"]
+        include:
+          # cvxpy requires sparsediffpy<0.7.0, but 0.7.0 is the first release with a 3.15
+          # wheel, and building the 0.6.1 sdist needs a BLAS the runners do not have. Drop
+          # this entry, and the `extras` variable, once cvxpy's pin admits a 3.15 wheel.
+          - python-version: "3.15"
+            extras: "dev,vis"
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # Full history needed for copyright year verification in pre-commit
+          fetch-depth: 0
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install ".[${{ matrix.extras }}]"
+          python -m pip install build extremal-python-dependencies==0.1.0
+      - name: Install qiskit-ibm-runtime main
+        # For Executor.run()'s conversion of a samplomatic QuantumProgram
+        # (qiskit-ibm-runtime#3403), unreleased as of 0.50.0. Remove once the floor is >=0.51.
+        run: python -m pip install --no-cache-dir "git+https://github.com/Qiskit/qiskit-ibm-runtime@main"
+      - name: Build Qiskit SDK development wheel
+        run: |
+          cd ..
+          git clone --filter=tree:0 https://github.com/Qiskit/qiskit
+          cd qiskit
+          git rev-parse HEAD
+          python -m build --wheel
+      - name: Pin development versions
+        shell: bash
+        run: >-
+          extremal-python-dependencies pin-dependencies --inplace
+          "qiskit @ file:$(echo qiskit/dist/*.whl)"
+      - name: Pre-commit checks (linting)
+        if: matrix.python-version == '3.15'
+        run: |
+          pre-commit run --all-files
+      - name: Test with pytest
+        run: |
+          python -m pytest

qiskit_noise_learning-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,55 @@
+# This workflow will upload a Python Package to PyPI when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  release-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Build release distributions
+        run: |
+          python -m pip install build
+          python -m build
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+  pypi-publish:
+    runs-on: ubuntu-latest
+    needs:
+      - release-build
+    permissions:
+      # IMPORTANT: this permission is mandatory for trusted publishing
+      id-token: write
+
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+      - name: Publish release distributions to PyPI
+        # This is an alternative to twine, it uses OIDC publishing utilizing PyPi's trusted publising implementation.
+        # With this we do not need API keys stored in the repository.
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/

qiskit_noise_learning-0.1.0/.github/workflows/test_package.yaml

@@ -0,0 +1,55 @@
+name: Test
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  tests:
+
+    runs-on: ubuntu-latest
+    # Enlarge the loader's surplus static TLS so that qiskit-aer's bundled libgomp can be loaded
+    env:
+      GLIBC_TUNABLES: glibc.rtld.optional_static_tls=4096
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
+        extras: ["dev,vis,cvxpy"]
+        include:
+          # cvxpy requires sparsediffpy<0.7.0, but 0.7.0 is the first release with a 3.15
+          # wheel, and building the 0.6.1 sdist needs a BLAS the runners do not have. Drop
+          # this entry, and the `extras` variable, once cvxpy's pin admits a 3.15 wheel.
+          - python-version: "3.15"
+            extras: "dev,vis"
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        # reno derives the release notes from git history and tags, and fails on a shallow clone.
+        fetch-depth: 0
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install ".[${{ matrix.extras }}]"
+    - name: Install qiskit-ibm-runtime main
+      # For Executor.run()'s conversion of a samplomatic QuantumProgram
+      # (qiskit-ibm-runtime#3403), unreleased as of 0.50.0. Remove once the floor is >=0.51.
+      run: python -m pip install --no-cache-dir "git+https://github.com/Qiskit/qiskit-ibm-runtime@main"
+    - name: Pre-commit checks (linting)
+      if: matrix.python-version == '3.12'
+      run: |
+        pre-commit run --all-files
+    - name: Check the release notes parse
+      if: matrix.python-version == '3.12'
+      run: |
+        reno lint
+    - name: Test with pytest
+      run: |
+        python -m pytest