sbmlsim 0.8.2__tar.gz → 0.8.3__tar.gz

{sbmlsim-0.8.2 → sbmlsim-0.8.3}/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.8.2"
+current_version = "0.8.3"
 commit = true
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]

sbmlsim-0.8.3/.github/actions/setup/action.yml

@@ -0,0 +1,43 @@
+name: Set up the environment
+description: >-
+  Install uv with its cache, set the python version of the job, put the
+  libpython of the interpreter on the library search path and sync the
+  environment of the project
+inputs:
+  python-version:
+    description: the python version, e.g. 3.14
+    required: true
+  sync:
+    description: >-
+      the arguments of `uv sync`, e.g. `--extra dev`; empty does not sync
+    required: false
+    default: ""
+runs:
+  using: composite
+  steps:
+    - name: Install uv and set the python version
+      # astral-sh/setup-uv publishes no floating major tag beyond v7
+      uses: astral-sh/setup-uv@v10.2.0
+      with:
+        python-version: ${{ inputs.python-version }}
+        enable-cache: true
+    - name: Put libpython on the library search path (linux only)
+      # the extension of libroadrunner links against libpython. The standalone
+      # interpreters uv installs link it statically and ship it in their `lib`,
+      # where the loader does not look; without it the import of roadrunner
+      # fails with `libpython3.14.so.1.0: cannot open shared object file`
+      if: runner.os == 'Linux'
+      shell: bash
+      env:
+        PYTHON_VERSION: ${{ inputs.python-version }}
+      run: |
+        prefix=$(uv run --no-project --python "$PYTHON_VERSION" python -c "import sys; print(sys.base_prefix)")
+        echo "LD_LIBRARY_PATH=$prefix/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}" >> "$GITHUB_ENV"
+        echo "libpython: $(ls "$prefix"/lib/libpython*.so.1.0)"
+    - name: Sync the environment
+      if: inputs.sync != ''
+      shell: bash
+      env:
+        SYNC: ${{ inputs.sync }}
+      # word splitting of the arguments is intended
+      run: uv sync $SYNC

{sbmlsim-0.8.2 → sbmlsim-0.8.3}/.github/pull_request_template.md

@@ -6,7 +6,7 @@
 
 - [ ] the pull request targets `develop`
 - [ ] tests were added or updated for the change
-- [ ] `tox run-parallel` passes locally (tests and `ty`)
+- [ ] `pytest` and `ty check` pass locally, `tox run-parallel` runs the tests on every supported python
 - [ ] `ruff check` and `ruff format` are clean, e.g., via `pre-commit run --all-files`
 - [ ] public functions and classes have type annotations and a docstring
 - [ ] user visible changes are in `release-notes/` and, if needed, in `docs/`

sbmlsim-0.8.3/.github/workflows/ci-cd.yml

@@ -0,0 +1,266 @@
+name: CI-CD
+
+on:
+  push:
+    # feature branches are tested through their pull request, tags release
+    branches: [develop, main]
+    tags: ['*']
+  pull_request:
+    branches: [develop, main]
+  workflow_dispatch:
+
+# least privilege by default, the release job raises what it needs
+permissions:
+  contents: read
+
+concurrency:
+  # a superseded run of a pull request is cancelled. A push is a group of its
+  # own: a release waits for the run of its commit on develop (see the job
+  # `tested`), and a group keeps one run waiting and cancels it for the next
+  # one even without `cancel-in-progress`, so two merges in a row would leave
+  # the first commit untested
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || format('{0}-{1}', github.ref, github.sha) }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  test:
+    # a tag is not tested again, see the job `tested`
+    if: ${{ !startsWith(github.ref, 'refs/tags/') }}
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 45
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ["3.13", "3.14"]
+        # linux covers the full range, windows and macos only the newest version
+        exclude:
+          - os: windows-latest
+            python-version: "3.13"
+          - os: macos-latest
+            python-version: "3.13"
+
+    steps:
+    - uses: actions/checkout@v7
+      with:
+        persist-credentials: false
+    - name: Set up the environment
+      # the package is installed as a wheel and not editable, so the tests run
+      # against what is published
+      uses: ./.github/actions/setup
+      with:
+        python-version: ${{ matrix.python-version }}
+        sync: --extra dev --no-editable
+    - name: Test
+      # the slowest tests are listed at the end of the log
+      run: uv run --no-sync pytest --durations=20
+
+  tests:
+    # the one check the branch protection requires; the names of the matrix
+    # jobs change with the matrix, this name does not, see .github/rulesets/
+    name: tests
+    needs: test
+    if: ${{ always() && !startsWith(github.ref, 'refs/tags/') }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+    - name: Check the result of the test matrix
+      env:
+        RESULT: ${{ needs.test.result }}
+      run: |
+        echo "test matrix: $RESULT"
+        test "$RESULT" = "success"
+
+  tested:
+    # a release does not run the test matrix again. The tag is on a commit of
+    # develop, and the push of that commit ran the matrix on exactly this
+    # tree; the job waits for that run and fails unless it succeeded, so the
+    # tag can be pushed right after the merge of the release
+    name: tested on develop
+    if: startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    permissions:
+      actions: read  # the runs of this workflow
+      contents: read
+    steps:
+    - uses: actions/checkout@v7
+      with:
+        fetch-depth: 0
+        persist-credentials: false
+    - name: Check that the tag is on develop
+      run: |
+        if ! git merge-base --is-ancestor "$GITHUB_SHA" origin/develop; then
+          echo "::error::$GITHUB_REF_NAME is not on develop, a release is tagged on develop"
+          exit 1
+        fi
+    - name: Wait for the run of the commit on develop
+      env:
+        GH_TOKEN: ${{ github.token }}
+      run: |
+        api="repos/$GITHUB_REPOSITORY/actions"
+        # the run starts with the merge, a tag pushed right after it may be first
+        run_id=""
+        for attempt in $(seq 1 20); do
+          run_id=$(gh api "$api/workflows/ci-cd.yml/runs?branch=develop&event=push&head_sha=$GITHUB_SHA" \
+            --jq '.workflow_runs[0].id // empty' || true)
+          [ -n "$run_id" ] && break
+          sleep 15
+        done
+        if [ -z "$run_id" ]; then
+          echo "::error::no CI-CD run of the push of $GITHUB_SHA to develop"
+          exit 1
+        fi
+        url="$GITHUB_SERVER_URL/$GITHUB_REPOSITORY/actions/runs/$run_id"
+        echo "waiting for $url"
+        # a failed request answers nothing, which is not `completed` either
+        until [ "$(gh api "$api/runs/$run_id" --jq .status || true)" = "completed" ]; do
+          sleep 30
+        done
+        conclusion=$(gh api "$api/runs/$run_id" --jq .conclusion)
+        echo "$url: $conclusion"
+        if [ "$conclusion" != "success" ]; then
+          echo "::error::the tests of $GITHUB_SHA on develop did not pass ($url); once they do, re-run the failed jobs of this release"
+          exit 1
+        fi
+
+  testsuite:
+    # the semantic cases of the SBML Test Suite against the pinned release and
+    # the cases of the PEtab SciML test suite against the pinned commit, which
+    # the baselines record, as two jobs which run next to each other. A normal
+    # run of the tests deselects them: they answer what libroadrunner and the
+    # networks support, which a change to sbmlsim rarely moves, and they take
+    # longer than the rest together. A release does not go out without them
+    name: sbml test suite
+    if: startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+    - uses: actions/checkout@v7
+      with:
+        persist-credentials: false
+    - name: Set up the environment
+      uses: ./.github/actions/setup
+      with:
+        python-version: "3.14"
+        sync: --extra dev --no-editable
+    - name: Download the pinned release
+      run: uv run --no-sync python scripts/testsuite.py download
+    - name: Run the semantic cases against the pinned release
+      run: uv run --no-sync pytest -m testsuite
+
+  sciml:
+    # see the job `testsuite`; a job of its own and not a matrix, the check of
+    # a matrix job which is skipped is named by the unevaluated expression
+    name: petab sciml test suite
+    if: startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+    - uses: actions/checkout@v7
+      with:
+        persist-credentials: false
+    - name: Set up the environment
+      uses: ./.github/actions/setup
+      with:
+        python-version: "3.14"
+        sync: --extra dev --no-editable
+    - name: Download the pinned commit
+      run: uv run --no-sync python scripts/sciml_testsuite.py download
+    - name: Run the cases of the PEtab SciML test suite against the pinned commit
+      run: uv run --no-sync pytest -m sciml_testsuite tests/sciml
+
+  submission:
+    # the results a submission to the SBML Test Suite Database is made of. A
+    # release submits against the newest suite, not against the pinned one.
+    # The archive is an attachment of the release and never blocks it
+    name: sbml test suite submission
+    if: startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    continue-on-error: true
+    steps:
+    - uses: actions/checkout@v7
+      with:
+        persist-credentials: false
+    - name: Set up the environment
+      uses: ./.github/actions/setup
+      with:
+        python-version: "3.14"
+        sync: --no-editable
+    - name: Run the SBML Test Suite against its newest release
+      # the cases run in one process per core
+      run: uv run --no-sync python scripts/testsuite.py submission --version latest --output submission
+    - name: Upload the submission
+      uses: actions/upload-artifact@v7
+      with:
+        name: submission
+        path: submission/*.zip
+        if-no-files-found: error
+
+  release:
+    needs: [tested, testsuite, sciml, submission]
+    # the submission is an attachment, the release goes out without it
+    if: >-
+      ${{ !cancelled() && startsWith(github.ref, 'refs/tags/')
+      && needs.tested.result == 'success'
+      && needs.testsuite.result == 'success'
+      && needs.sciml.result == 'success' }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    environment:
+      name: pypi
+      url: https://pypi.org/p/sbmlsim
+    permissions:
+      id-token: write  # trusted publishing to PyPI
+      contents: write  # create the GitHub release
+    steps:
+    - uses: actions/checkout@v7
+      with:
+        persist-credentials: false
+    - name: Set up uv
+      uses: ./.github/actions/setup
+      with:
+        python-version: "3.14"
+    - name: Build package
+      run: uvx hatch build
+    - name: Check the package
+      run: uvx twine check dist/*
+    - name: Publish to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        packages-dir: dist
+    - name: Download the submission
+      # missing when the submission failed, which is no reason to stop here:
+      # the package is on PyPI by this point
+      continue-on-error: true
+      uses: actions/download-artifact@v8
+      with:
+        name: submission
+        path: submission
+    - name: Create GitHub release
+      uses: softprops/action-gh-release@v3
+      with:
+        body_path: "release-notes/${{ github.ref_name }}.md"
+        files: submission/*.zip
+        # the submission may be missing, the notes are the release
+        fail_on_unmatched_files: false
+        draft: false
+        prerelease: false
+
+  sync-main:
+    # main tracks the latest published release, see docs/development.md
+    needs: release
+    if: startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    permissions:
+      contents: write  # fast-forward main to the released commit
+    steps:
+    - uses: actions/checkout@v7
+      with:
+        # a shallow clone cannot be pushed to another branch
+        fetch-depth: 0
+    - name: Fast-forward main to the release
+      # no --force: the push fails loudly if it would not be a fast-forward
+      run: git push origin HEAD:main

{sbmlsim-0.8.2 → sbmlsim-0.8.3}/.github/workflows/docs.yml

@@ -29,34 +29,25 @@ jobs:
           persist-credentials: false
       - name: Configure GitHub Pages
         uses: actions/configure-pages@v6
-      - name: Install the python dev files
-        # the extension of libroadrunner links against libpython, which the
-        # standalone interpreters do not put on the library search path
-        run: |
-          sudo add-apt-repository -y ppa:deadsnakes/ppa
-          sudo apt-get update
-          sudo apt-get install -y python3.14-dev
-      - name: Install uv and set the python version
-        uses: astral-sh/setup-uv@v10.2.0
+      - name: Set up the environment
+        uses: ./.github/actions/setup
         with:
           python-version: "3.14"
-          enable-cache: true
-      - name: Install dependencies
-        run: uv sync --extra dev
+          sync: --extra dev
       - name: Build the documentation
         # the API reference is rendered from the docstrings by mkdocstrings,
         # so the package has to be importable
-        run: uv run zensical build --clean
+        run: uv run --no-sync zensical build --clean
       - name: Generate the agent facing files
         # llms.txt, llms-full.txt and the markdown of every page
-        run: uv run python scripts/llms_txt.py
+        run: uv run --no-sync python scripts/llms_txt.py
       - name: Run the SBML Test Suite and write its report
         # the interactive report is generated into the site and not committed,
         # so the published one always describes the code it was built from.
         # Only a build which can be published pays the three minutes: a pull
         # request builds the site to check that it builds, it does not deploy
         if: github.event_name != 'pull_request'
-        run: uv run python scripts/testsuite.py report --output site/testsuite/report
+        run: uv run --no-sync python scripts/testsuite.py report --output site/testsuite/report
       - name: Upload the site
         uses: actions/upload-pages-artifact@v5
         with:

sbmlsim-0.8.3/.github/workflows/lint.yml

@@ -0,0 +1,58 @@
+name: lint
+
+on:
+  push:
+    # feature branches are checked through their pull request
+    branches: [develop, main]
+  pull_request:
+    branches: [develop, main]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  # a superseded run of a pull request is cancelled, a push is checked on its own
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  ruff:
+    # the names of the jobs are the checks the branch protection requires,
+    # see .github/rulesets/develop.json
+    name: ruff
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          persist-credentials: false
+      # the ruff version is read from the dev dependencies in pyproject.toml
+      - name: Lint
+        # astral-sh/ruff-action publishes no floating major tag beyond v3
+        uses: astral-sh/ruff-action@v4.1.0
+        with:
+          args: check --output-format=github
+      - name: Format
+        uses: astral-sh/ruff-action@v4.1.0
+        with:
+          args: format --check --diff
+
+  ty:
+    name: ty
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          persist-credentials: false
+      - name: Set up the environment
+        # ty resolves the imports of `src`, `tests`, `examples` and `scripts`
+        # in the environment, the dev extra has all of them; there is no ty
+        # action, and an environment is what it would need as well
+        uses: ./.github/actions/setup
+        with:
+          python-version: "3.14"
+          sync: --extra dev
+      - name: Type check
+        run: uv run --no-sync ty check --output-format github

{sbmlsim-0.8.2 → sbmlsim-0.8.3}/.github/workflows/testsuite-pin.yml

@@ -27,25 +27,16 @@ jobs:
       pull-requests: write  # open the pull request
     steps:
       - uses: actions/checkout@v7
-      - name: Install the python dev files
-        # the extension of libroadrunner links against libpython, which the
-        # standalone interpreters do not put on the library search path
-        run: |
-          sudo add-apt-repository -y ppa:deadsnakes/ppa
-          sudo apt-get update
-          sudo apt-get install -y python3.14-dev
-      - name: Install uv and set the python version
-        uses: astral-sh/setup-uv@v10.2.0
+      - name: Set up the environment
+        uses: ./.github/actions/setup
         with:
           python-version: "3.14"
-          enable-cache: true
-      - name: Install dependencies
-        run: uv sync --extra dev
+          sync: --extra dev
       - name: Compare the pinned release with the newest one
         id: versions
         run: |
-          PINNED=$(uv run python -c "from sbmlsim.testsuite.cases import SUITE_VERSION; print(SUITE_VERSION)")
-          LATEST=$(uv run python -c "from sbmlsim.testsuite import SemanticSuite; print(SemanticSuite.latest_version())")
+          PINNED=$(uv run --no-sync python -c "from sbmlsim.testsuite.cases import SUITE_VERSION; print(SUITE_VERSION)")
+          LATEST=$(uv run --no-sync python -c "from sbmlsim.testsuite import SemanticSuite; print(SemanticSuite.latest_version())")
           echo "pinned=$PINNED" >> "$GITHUB_OUTPUT"
           echo "latest=$LATEST" >> "$GITHUB_OUTPUT"
           echo "The pinned release is '$PINNED', the newest is '$LATEST'"
@@ -65,7 +56,7 @@ jobs:
           PY
           # the baseline records the outcome of every case, so it is recorded
           # again for the release which is adopted
-          uv run python scripts/testsuite.py baseline
+          uv run --no-sync python scripts/testsuite.py baseline
       - name: Open the pull request
         if: steps.versions.outputs.pinned != steps.versions.outputs.latest
         uses: peter-evans/create-pull-request@v8

{sbmlsim-0.8.2 → sbmlsim-0.8.3}/.pre-commit-config.yaml

@@ -56,7 +56,7 @@ repos:
 
 - repo: https://github.com/astral-sh/ty-pre-commit
   # ty version.
-  rev: v0.0.84
+  rev: v0.0.85
   hooks:
     # Run the type checker on the whole project (see `[tool.ty]` in pyproject.toml).
     # `--extra dev` syncs the environment with the dev dependencies, so that the

{sbmlsim-0.8.2 → sbmlsim-0.8.3}/CITATION.cff

@@ -8,7 +8,7 @@ authors:
     given-names: "Matthias"
     orcid: "https://orcid.org/0000-0003-1725-179X"
     affiliation: "Humboldt-University Berlin, Faculty of Life Science, Institute for Biology, Biology, Berlin; University Lübeck; University Hospital Schleswig-Holstein, Campus Lübeck, First Department of Medicine, Germany"
-version: "0.8.2"
+version: "0.8.3"
 date-released: "2026-10-06"
 doi: "10.5281/zenodo.3597770"
 license: MIT

{sbmlsim-0.8.2 → sbmlsim-0.8.3}/CLAUDE.md

@@ -22,22 +22,21 @@ pytest tests/simulation/test_simulation.py         # single file
 pytest tests/simulation/test_scan.py::test_scan1d  # single test
 pytest -rs                                         # list the skipped tests
 tox r -e py3.14                                    # single tox env (py3.13, py3.14 available)
-tox run-parallel                                   # full matrix + ty
+tox run-parallel                                   # the tests on every supported python
 
 # lint / format / types
 ruff check
 ruff format
-tox -e ty                       # ty type check (config in [tool.ty] in pyproject.toml)
-uvx ty check                    # same check, straight from the working tree
+uv run ty check                 # ty type check (config in [tool.ty] in pyproject.toml)
 
 # examples, they are modules of the `examples` package and not part of sbmlsim
 python -m examples.timecourse
 python -m examples.sensitivity.sensitivity_example
 ```
 
-`develop` is the default branch and takes every change through a pull request; direct pushes are rejected by the rulesets in `.github/rulesets/` (applied with `.github/rulesets/apply.sh`), which require the `tests`, `ruff`, `ty` and `docs` checks. `main` only tracks the latest release and is fast-forwarded by the `sync-main` job of the release workflow, never by hand.
+`develop` is the default branch and takes every change through a pull request; direct pushes are rejected by the rulesets in `.github/rulesets/` (applied with `.github/rulesets/apply.sh`), which require the `tests`, `ruff`, `ty` and `docs` checks (`ruff` and `ty` are the jobs of `lint.yml`). Every job of the workflows sets up uv, python and the environment with the action `.github/actions/setup` and runs the commands a developer runs, without tox; a push to `develop` is never cancelled, since a release waits for the run of its commit. `main` only tracks the latest release and is fast-forwarded by the `sync-main` job of the release workflow, never by hand.
 
-Release steps are in `docs/development.md` (there is no separate `RELEASE.md`): the release is prepared on a branch, `uvx bump-my-version bump [major|minor|patch]` updates `src/sbmlsim/__init__.py` and `CITATION.cff` and commits without tagging (`tag = false`, a squash merge would rewrite the commit), and the tag is created on `develop` after the pull request was merged, which triggers the PyPI release workflow.
+Release steps are in `docs/development.md` (there is no separate `RELEASE.md`): the release is prepared on a branch, `uvx bump-my-version bump [major|minor|patch]` updates `src/sbmlsim/__init__.py` and `CITATION.cff` and commits without tagging (`tag = false`, a squash merge would rewrite the commit), and the tag is created on `develop` after the pull request was merged, which triggers the PyPI release workflow; it does not run the test matrix again, its job `tested on develop` waits for the run of the push of the same commit to `develop`, which is why the runs of `develop` are never cancelled.
 
 Documentation is [Zensical](https://zensical.org/): markdown sources in `docs/`, configured in `zensical.toml`, built into the gitignored `site/` (`uv run zensical build --clean`, `uv run zensical serve` for the preview). The API reference is rendered from the docstrings by mkdocstrings; a page in `docs/api/` is just `::: sbmlsim.<module>`, so nothing is generated into the repository. `scripts/llms_txt.py` runs after the build and writes the agent facing files (`llms.txt`, `llms-full.txt` and the markdown of every page) into `site/`. The `documentation` workflow runs both and publishes the site from `develop`.
 
@@ -59,7 +58,7 @@ Documentation is [Zensical](https://zensical.org/): markdown sources in `docs/`,
 
 **`comparison/` — comparison of results.** `diff.py` holds `DataSetsComparison`, which matches the columns of the results of two simulators and reports the absolute and relative differences above the tolerances. The scripts which produce such results with AMICI and COPASI are `examples/comparison/`, they import the optional dependencies; `examples/comparison/diff_example.py` compares roadrunner with JWS Online.
 
-**`testsuite/` — the SBML Test Suite.** `SemanticCase` (`testsuite/cases.py`) is a semantic case on disk, read from its `NNNNN-settings.txt` and its `NNNNN-model.m` (`componentTags`, `testTags`), not from the SED-ML it also ships; `SemanticSuite` is a directory of cases with the download and the cache of a release under `~/.cache/sbmlsim/test-suite/<version>/` (`SBMLSIM_TEST_SUITE_PATH` overrides it). `SUITE_VERSION` pins the release the tests and the documentation run against, a release resolves `latest_version()` instead and `.github/workflows/testsuite-pin.yml` opens the pull request which adopts a newer one. `run_case` (`testsuite/runner.py`) simulates a case in the newest encoding it provides and answers with a `CaseResult` and its `CaseStatus` (`PASS`, `TOLERANCE`, `NOT_READ`, `SIMULATION_ERROR`, `MISSING_VARIABLE`) rather than raising; it simulates with `reset=False`, because a model with a species or parameter named `reset` hides the roadrunner method of that name for every instance created afterwards (case 00952). `compare_case` (`testsuite/comparison.py`) applies `comparison.diff.within_tolerance`, i.e. `|c-u| <= abs_tol + rel_tol*|c|`, which `DataSetsComparison` shares. `TestSuiteReport` (`testsuite/report.py`) renders the run into the interactive page `resources/templates/testsuite_report.html`, aggregated over the tags and filtered by outcome. `scripts/testsuite.py` is the command line (`download`, `run`, `report`, `baseline`, `submission`); only the timecourse cases are run, once per case, and `tests/testsuite/test_semantic.py` is one test per case against `tests/data/testsuite_baseline.json`, which fails both on a regression and on a case which passes and is still listed. The cases carry the `testsuite` marker and `addopts` deselects it, so they are not part of a normal run: they answer what libroadrunner supports, which a change to `sbmlsim` rarely moves. The `testsuite` job of `ci-cd.yml` runs them on a tag and the release waits for it; the documentation generates the report on `develop` and not on a pull request.
+**`testsuite/` — the SBML Test Suite.** `SemanticCase` (`testsuite/cases.py`) is a semantic case on disk, read from its `NNNNN-settings.txt` and its `NNNNN-model.m` (`componentTags`, `testTags`), not from the SED-ML it also ships; `SemanticSuite` is a directory of cases with the download and the cache of a release under `~/.cache/sbmlsim/test-suite/<version>/` (`SBMLSIM_TEST_SUITE_PATH` overrides it). `SUITE_VERSION` pins the release the tests and the documentation run against, a release resolves `latest_version()` instead and `.github/workflows/testsuite-pin.yml` opens the pull request which adopts a newer one. `run_case` (`testsuite/runner.py`) simulates a case in the newest encoding it provides and answers with a `CaseResult` and its `CaseStatus` (`PASS`, `TOLERANCE`, `NOT_READ`, `SIMULATION_ERROR`, `MISSING_VARIABLE`) rather than raising; it simulates with `reset=False`, because a model with a species or parameter named `reset` hides the roadrunner method of that name for every instance created afterwards (case 00952). `compare_case` (`testsuite/comparison.py`) applies `comparison.diff.within_tolerance`, i.e. `|c-u| <= abs_tol + rel_tol*|c|`, which `DataSetsComparison` shares. `TestSuiteReport` (`testsuite/report.py`) renders the run into the interactive page `resources/templates/testsuite_report.html`, aggregated over the tags and filtered by outcome. `scripts/testsuite.py` is the command line (`download`, `run`, `report`, `baseline`, `submission`), `run_suite` and `write_submission` (`testsuite/submission.py`) run the cases in one process per core through `map_cases`; only the timecourse cases are run, once per case, and `tests/testsuite/test_semantic.py` is one test per case against `tests/data/testsuite_baseline.json`, which fails both on a regression and on a case which passes and is still listed. The cases carry the `testsuite` marker and `addopts` deselects it, so they are not part of a normal run: they answer what libroadrunner supports, which a change to `sbmlsim` rarely moves. The `testsuite` job of `ci-cd.yml` runs them on a tag and the release waits for it; the documentation generates the report on `develop` and not on a pull request.
 
 `console.py` (rich console, for scripts and examples) and `log.py` provide the shared output/logging. Modules get their logger from the standard library with `logging.getLogger(__name__)`. The package never configures logging: `log.enable_rich_logging()` is the opt-in for scripts. Library code logs, it does not print, and log calls use lazy `%s` formatting rather than f-strings (enforced by ruff `G`).
 

{sbmlsim-0.8.2 → sbmlsim-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sbmlsim
-Version: 0.8.2
+Version: 0.8.3
 Summary: sbmlsim are python utilities for the simulation of SBML models.
 Project-URL: Homepage, https://matthiaskoenig.github.io/sbmlsim
 Project-URL: Documentation, https://matthiaskoenig.github.io/sbmlsim
@@ -57,7 +57,7 @@ Requires-Dist: ruff>=0.16.10; extra == 'dev'
 Requires-Dist: torch>=2.14.1; extra == 'dev'
 Requires-Dist: tox-uv>=1.36.1; extra == 'dev'
 Requires-Dist: tox>=4.64.9; extra == 'dev'
-Requires-Dist: ty>=0.0.84; extra == 'dev'
+Requires-Dist: ty>=0.0.85; extra == 'dev'
 Requires-Dist: zensical>=0.0.68; extra == 'dev'
 Provides-Extra: sciml
 Requires-Dist: h5py>=3.16.0; extra == 'sciml'

sbmlsim-0.8.3/docs/api/testsuite.submission.md

@@ -0,0 +1,3 @@
+# testsuite.submission
+
+::: sbmlsim.testsuite.submission

{sbmlsim-0.8.2 → sbmlsim-0.8.3}/docs/development.md

@@ -20,12 +20,14 @@ A pull request can only be merged once the four required checks are green:
 | check   | workflow      | content                                                              |
 | ------- | ------------- | -------------------------------------------------------------------- |
 | `tests` | `ci-cd.yml`   | the test matrix, linux with python 3.13 and 3.14, macos and windows with 3.14 |
-| `ruff`  | `ruff.yml`    | `ruff check` and `ruff format --check`                                |
-| `ty`    | `ty.yml`      | `tox r -e ty`                                                         |
+| `ruff`  | `lint.yml`    | `ruff check` and `ruff format --check`                                |
+| `ty`    | `lint.yml`    | `ty check`                                                            |
 | `docs`  | `docs.yml`    | the zensical build including the api reference and the agent files    |
 
 `tests` aggregates the test matrix into a single job, so the name of the required check stays the same when the matrix changes.
 
+Every job sets up its environment with the action `.github/actions/setup`: uv with its cache, the python of the job, the libpython roadrunner needs on linux, and `uv sync` with the extras of the job. The jobs run the same commands as a local environment (`pytest`, `ty check`, `zensical build`), the tests against the package installed as a wheel (`uv sync --no-editable`). A run of a pull request is cancelled by the next push to it; a push to `develop` or `main` is never cancelled, a release waits for the run of its commit.
+
 Further rules of a pull request:
 
 - conversations have to be resolved before the merge
@@ -98,13 +100,13 @@ The tox environments are named after the interpreter (`py3.13` to `py3.14`, see
 tox r -e py3.14
 ```
 
-and the complete matrix, including the `ty` environment, in parallel with
+and the complete matrix in parallel with
 
 ```bash
 tox run-parallel
 ```
 
-This needs the interpreters to be available, which uv installs with `uv python install 3.13 3.14`. Continuous integration runs the same environments as `uvx --with tox-uv tox -e py3.14`.
+This needs the interpreters to be available, which uv installs with `uv python install 3.13 3.14`. Continuous integration does not use tox, it runs `pytest` in an environment of the python of the job, see [pull requests](#pull-requests).
 
 To run the tests directly against the development environment use
 
@@ -115,7 +117,7 @@ pytest tests/simulation/test_simulation.py                  # a single module
 pytest tests/simulation/test_simulation.py::test_timecourse  # a single test
 ```
 
-The tests run in parallel, `addopts = "-n auto"` in `pyproject.toml` gives pytest-xdist one worker per core; `-n 0` on the command line runs everything in one process, which the debugger needs.
+The tests run in parallel, `-n auto --dist worksteal` in the `addopts` of `pyproject.toml` gives pytest-xdist one worker per core, and a worker which is idle takes over the tests which wait at a busy one; `-n 0` on the command line runs everything in one process, which the debugger needs.
 
 The `conftest.py` at the root of the repository selects the non-interactive matplotlib backend for the session and puts the repository on `sys.path`, so that the tests can import the examples.
 
@@ -139,14 +141,10 @@ The docstring rules (`D`) are enforced for the package, not for `examples/` and
 Type checking is performed with [ty](https://docs.astral.sh/ty/):
 
 ```bash
-tox r -e ty
+uv run ty check
 ```
 
-Or directly in the working tree:
-
-```bash
-uvx ty check
-```
+ty resolves the imports in the environment of the project, which `uv sync --extra dev` creates; the `ty` check of continuous integration runs the same command and the pre-commit hook runs it on every commit.
 
 The configuration lives in `[tool.ty]` in `pyproject.toml`. Warnings are treated as errors, so the codebase is kept free of diagnostics. Suppress an unavoidable diagnostic with a rule specific `# ty: ignore[rule-name]` rather than a blanket comment.
 
@@ -206,7 +204,7 @@ A release is made from `develop`. Since `develop` only accepts pull requests, th
 
 1. branch off `develop`: `git switch -c release/x.y.z develop`
 2. write the release notes for the version in `release-notes/x.y.z.md`
-3. make sure everything passes: `tox run-parallel`, `ruff check`, `tox r -e ty`
+3. make sure everything passes: `tox run-parallel`, `ruff check`, `uv run ty check`
 4. check the version bump: `uvx bump-my-version bump [major|minor|patch] --dry-run -vv`
 5. bump the version: `uvx bump-my-version bump [major|minor|patch]`, which updates `src/sbmlsim/__init__.py` and `CITATION.cff` and commits. It does not create the tag; a squash or rebase merge would rewrite the commit and leave the tag behind on a commit which is not part of `develop`
 6. push the branch, open the pull request against `develop` and merge it once the checks are green
@@ -219,7 +217,7 @@ A release is made from `develop`. Since `develop` only accepts pull requests, th
     git push origin x.y.z
     ```
 
-    This starts the `CI-CD` workflow, which runs the test matrix, publishes to [pypi](https://pypi.org/project/sbmlsim/), creates the GitHub release from `release-notes/x.y.z.md` and fast-forwards `main` to the tagged commit. Check the version before pushing, a tag cannot be moved or deleted afterwards.
+    This starts the `CI-CD` workflow, which publishes to [pypi](https://pypi.org/project/sbmlsim/), creates the GitHub release from `release-notes/x.y.z.md` and fast-forwards `main` to the tagged commit. It does not run the test matrix again: the merge into `develop` ran it on the same commit, and the job `tested on develop` waits for that run and stops the release unless it passed, so the tag can be pushed right after the merge. Next to it the SBML Test Suite and the PEtab SciML test suite run against their pins and the submission to the SBML Test Suite Database is written, which the release attaches; a release takes a few minutes once the run on `develop` has finished. Check the version before pushing, a tag cannot be moved or deleted afterwards.
 
 8. test the installation from pypi in a fresh environment:
 

{sbmlsim-0.8.2 → sbmlsim-0.8.3}/docs/sensitivity.md

@@ -80,7 +80,7 @@ groups = [
 
 ## Running an analysis
 
-Every analysis is created with the simulation, the parameters, the groups and a `results_path`; `execute` creates the samples, simulates them (in parallel on `n_cores`, cached with `cache_results=True`) and computes the sensitivities, `plot` writes the figures into the results path:
+Every analysis is created with the simulation, the parameters, the groups and a `results_path`; `execute` creates the samples, simulates them (in parallel on `n_cores`, one pool of processes for all groups, in the process itself for `n_cores=1`, cached with `cache_results=True`) and computes the sensitivities, `plot` writes the figures into the results path. The `seed` decides the samples and the bootstrap of the confidence intervals, so an analysis is reproducible:
 
 ```python
 from pathlib import Path
@@ -137,4 +137,4 @@ An output which does not vary over the samples has no Sobol or FAST indices: the
 
 The sensitivities are stored as `xarray.DataArray` objects per group and key (`sa.sensitivity[group_id][key]`), returned as data frames with `sensitivity_df`, and written as tables and figures into the results path. `sbmlsim.sensitivity.classification` groups parameters by their sensitivities across outputs.
 
-The complete example with all methods is `examples/sensitivity/sensitivity_example.py`.
+The complete example with all methods is `examples/sensitivity/sensitivity_example.py`; `--cores` sets the number of processes and `--quick` runs it with the smallest samples every method accepts, which shows that it runs and not what the parameters do.