fibsem 0.5.1.dev0__tar.gz → 0.5.2rc2__tar.gz

fibsem-0.5.2rc2/.github/workflows/publish.yml

@@ -0,0 +1,142 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+jobs:
+  # The version in pyproject.toml is written by hand and the tag is created
+  # separately, so the two can disagree. Nothing downstream notices: the build
+  # takes its version from pyproject, so a tag of v0.5.2rc1 on a commit that
+  # still says 0.5.2.dev0 uploads 0.5.2.dev0 to PyPI -- wrong version, no error,
+  # and unfixable afterwards because PyPI never allows a version to be reused.
+  # Runs alongside the tests rather than inside publish so the failure lands in
+  # seconds, while retagging is still cheap.
+  check-version:
+    runs-on: ubuntu-latest
+    outputs:
+      # Consumed by github-release, so the pre-release decision is made once,
+      # by packaging, rather than re-derived from the tag string in shell.
+      prerelease: ${{ steps.check.outputs.prerelease }}
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.11"
+      - run: pip install packaging
+      - name: Tag must match the packaged version
+        id: check
+        env:
+          TAG: ${{ github.ref_name }}
+        run: |
+          python - <<'PY'
+          import os
+          import sys
+          import tomllib
+
+          from packaging.version import InvalidVersion, Version
+
+          tag = os.environ["TAG"]
+
+          with open("pyproject.toml", "rb") as fh:
+              project = tomllib.load(fh)["project"]
+          if "version" not in project:
+              sys.exit(
+                  "::error::pyproject.toml declares no static [project] version. "
+                  "The versioning scheme changed; this check needs updating."
+              )
+          declared = project["version"]
+
+          try:
+              tagged = Version(tag.removeprefix("v"))
+          except InvalidVersion:
+              sys.exit(f"::error::tag {tag} is not a PEP 440 version")
+
+          # is_devrelease, not is_prerelease: packaging counts rcN as a
+          # pre-release too, and those are exactly what we do publish.
+          if tagged.is_devrelease:
+              sys.exit(
+                  f"::error::tag {tag} is a development version. .devN marks "
+                  f"the working state of main and is never published; it is "
+                  f"also the one form that matches pyproject.toml unchanged, so "
+                  f"the check below would not catch it. Tag an rcN for Early "
+                  f"Access, or a final release. See RELEASE.md."
+              )
+
+          if tagged != Version(declared):
+              sys.exit(
+                  f"::error::tag {tag} would publish {declared}. pyproject.toml "
+                  f'says version = "{declared}". Fix one or the other and retag: '
+                  f"a version cannot be reused once it is on PyPI."
+              )
+
+          print(f"tag {tag} matches pyproject.toml version {declared}")
+
+          # is_prerelease is the right test *here*, unlike above: dev releases
+          # are already rejected, so anything still prerelease is an rc/a/b.
+          with open(os.environ["GITHUB_OUTPUT"], "a") as fh:
+              fh.write(f"prerelease={str(tagged.is_prerelease).lower()}\n")
+          PY
+
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.11"
+          cache: pip
+      - run: pip install ".[test]"
+      - name: Test with pytest
+        run: pytest tests/ -n auto --dist worksteal --timeout=300
+
+  publish:
+    needs: [check-version, test]
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.11"
+          cache: pip
+      - run: pip install build
+      - run: python -m build
+      - uses: pypa/gh-action-pypi-publish@release/v1
+
+  # The Release page is how Early Access finds out a candidate exists, and its
+  # Atom feed (/releases.atom) is the only notification channel the programme
+  # has. Created by hand until now, which meant it could simply be forgotten.
+  #
+  # Separate job rather than a step in publish: this needs contents: write,
+  # and publish holds the id-token used for trusted publishing to PyPI. Runs
+  # after it, so a failed upload never announces a release nobody can install.
+  github-release:
+    needs: [check-version, publish]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Create the GitHub Release
+        env:
+          GH_TOKEN: ${{ github.token }}
+          GH_REPO: ${{ github.repository }}
+          TAG: ${{ github.ref_name }}
+          PRERELEASE: ${{ needs.check-version.outputs.prerelease }}
+        run: |
+          if gh release view "$TAG" >/dev/null 2>&1; then
+            echo "release $TAG already exists, leaving it alone"
+            exit 0
+          fi
+
+          args=(--generate-notes --verify-tag)
+          # Keeps a candidate from taking the "Latest" badge from a real release.
+          if [ "$PRERELEASE" = "true" ]; then
+            args+=(--prerelease)
+          fi
+
+          gh release create "$TAG" "${args[@]}"

fibsem-0.5.2rc2/.github/workflows/python-package.yml

@@ -0,0 +1,185 @@
+# This workflow will install Python dependencies, run tests and lint with a variety of Python versions
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Python package
+
+on:
+  # `release/**` alongside main: a release branch is cut from a release tag and the
+  # final is tagged from it, so what lands there by cherry-pick is what ships -- and
+  # without this it would be the one code path in the repository that reaches users
+  # having run no tests at all. Nothing else is branch-scoped here, so this is the
+  # whole of what has to change.
+  push:
+    branches: [ "main", "release/**" ]
+  pull_request:
+    branches: [ "main", "release/**" ]
+
+jobs:
+  build:
+
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        # Linux on every supported version, Windows on the ends of the range.
+        # The microscopes all run Windows, so every platform-specific claim in the
+        # codebase was previously untested on the platform that matters (FIB-704) --
+        # but twelve jobs is more wall-clock than the coverage is worth, and the
+        # oldest and newest catch what the middle would.
+        os: [ubuntu-latest]
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+        include:
+          - os: windows-latest
+            python-version: "3.8"
+          - os: windows-latest
+            python-version: "3.13"
+
+    steps:
+    - uses: actions/checkout@v7
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v7
+      with:
+        python-version: ${{ matrix.python-version }}
+        cache: 'pip'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        # UI deps (the [ui] extra) are intentionally not installed *here*. Not
+        # because the tests that need them do not matter -- the `ui-tests` job
+        # below runs every one of them -- but because installing napari adds 100
+        # packages and 116 MB to a job that runs eight times, and registers three
+        # pytest plugins (napari, napari-plugin-engine, npe2) into the session,
+        # one of them an autouse fixture that would run around all 2000-odd tests
+        # here to serve none of them.
+        python -m pip install ".[test]"
+    - name: Install the plugin entry point fixture
+      # A packaged plugin is the only way into two of the three extension
+      # points, so the entry point contract needs a plugin installed the way a
+      # user installs one. Without this step tests/test_plugin_entry_points.py
+      # skips, and a refactor could break every third-party plugin with no test
+      # failure. --no-deps because fibsem is already installed above.
+      run: python -m pip install --no-deps tests/fixtures/plugin
+    - name: Test with pytest
+      env:
+        # Turns the fixture-missing skip into a hard error. Without this, losing
+        # the install step above would silently skip the entry point tests and
+        # leave the build green -- the exact silent breakage they exist to catch.
+        FIBSEM_REQUIRE_PLUGIN_FIXTURE: "1"
+      run: pytest tests/ -n auto --dist worksteal --timeout=300
+
+  ui-tests:
+    # The one job that installs the [ui] extra, and the only place the 2270 tests
+    # under tests/ui/ are ever run.
+    #
+    # Every file there opens with `pytest.importorskip("PyQt5")`. The matrix job
+    # above installs `.[test]` without it, so all 103 files skip silently and its
+    # green says nothing whatsoever about that directory. That is not theoretical:
+    # main reported success while tests/ui/test_fm_overview_widget.py failed 17
+    # tests locally, because two pull requests that were each green alone bound the
+    # same name to two different constants (#581). Only a run with PyQt5 installed
+    # could have caught it, and this is that run.
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v7
+    - name: Set up Python
+      uses: actions/setup-python@v7
+      with:
+        # One version, not the matrix. What this job answers -- does the UI code
+        # import, and does it behave -- does not vary across Python versions, so
+        # running it six times would repeat the same answer. 3.11 rather than the
+        # ends of the range because the `ui` extra resolves differently at both:
+        # 3.8 gets napari 0.4.x, a different codebase to the 0.5.x everyone
+        # develops against.
+        python-version: "3.11"
+        cache: 'pip'
+    - name: Install the libraries Qt's offscreen platform plugin links against
+      # libqoffscreen.so needs libGL, libX11, libXext, libfontconfig, libfreetype
+      # and libglib (read off the wheel's ELF DT_NEEDED entries). All but libGL are
+      # already on the runner image. Note it does NOT need the xcb/xkbcommon stack
+      # that the normal `xcb` platform pulls in -- that is the point of running
+      # offscreen rather than under a virtual display.
+      #
+      # If one of the others ever goes missing the failure is loud and immediate:
+      # Qt refuses to load the platform plugin, names the library, and every test
+      # errors at QApplication construction. There is no version of this that
+      # passes while broken.
+      run: sudo apt-get update && sudo apt-get install -y libgl1 libegl1
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install ".[test,ui]"
+    - name: Fail if the UI extra did not actually install
+      # A green job that skipped everything is the exact failure mode this job
+      # exists to end. Because every file guards on importorskip, a broken install
+      # does not turn the run red -- it empties it, and empty reads as passing.
+      # So check the imports directly, where absence is an error.
+      run: python -c "import PyQt5, napari, qtawesome"
+    - name: Test with pytest
+      env:
+        QT_QPA_PLATFORM: offscreen
+      # Deliberately serial, unlike the matrix job above. These tests share one
+      # QApplication and leak top-level widgets across files, so some of them
+      # depend on what the files before them left behind. `-n auto --dist
+      # worksteal` would shuffle that order differently on every run and turn a
+      # deterministic failure into a flake; `--dist loadfile` does not help either,
+      # since it only holds order *within* a file. Three minutes is a fair price
+      # for a result that means the same thing twice in a row.
+      run: pytest tests/ui/ -q --timeout=300
+
+  lint:
+    # Its own job, not a step inside the matrix above: ruff's result does not
+    # vary by OS or Python version, so running it in the matrix would repeat the
+    # same answer eight times. This takes about ten seconds.
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v7
+      with:
+        # The formatting step below diffs against the merge base, which does not
+        # exist in the default shallow clone.
+        fetch-depth: 0
+    - uses: actions/setup-python@v7
+      with:
+        python-version: "3.12"
+    # Pinned so a new ruff release cannot turn this red on a commit that changed
+    # nothing. Keep in sync with the `dev` extra in pyproject.toml.
+    - run: python -m pip install ruff==0.16.3
+    # --output-format=github annotates the diff instead of only failing the job.
+    - run: ruff check --output-format=github .
+    - name: Check formatting of the files this PR changes
+      # Format-on-touch rather than a whole-tree flag day: a file has to be
+      # formatted once something in it is edited, so the tree converts fastest
+      # where the work actually happens. `main` stays mixed for a while, which
+      # is the accepted cost.
+      #
+      # The count is echoed on purpose. The failure mode of a diff-scoped check
+      # is that the diff comes back empty -- wrong base, shallow clone -- and
+      # the job passes green having checked nothing, so the number has to be
+      # visible in the log to be disbelieved.
+      run: |
+        set -euo pipefail
+        base=$(git merge-base origin/main HEAD)
+        # mktemp, not a file in the repo root: this script is meant to be
+        # runnable locally too, and it should not leave anything behind.
+        changed=$(mktemp)
+        trap 'rm -f "$changed"' EXIT
+        git diff --name-only --diff-filter=d "$base" HEAD -- '*.py' > "$changed"
+        count=$(wc -l < "$changed" | tr -d ' ')
+        echo "python files changed against $base: $count"
+        if [ "$count" -eq 0 ]; then
+          echo "no python files changed; nothing to check"
+          exit 0
+        fi
+        sed 's/^/  /' "$changed"
+        # NUL-separated: a path with a space would otherwise split into two.
+        # --force-exclude is required, not optional: ruff ignores `exclude` for
+        # paths named explicitly on the command line, and this step names every
+        # path explicitly. Without it the config's `exclude` silently stops
+        # applying here -- today that means a pull request touching a notebook-
+        # adjacent or otherwise excluded path gets told to reformat it anyway.
+        if ! tr '\n' '\0' < "$changed" \
+             | xargs -0 ruff format --check --force-exclude --; then
+          echo
+          echo "To fix, from the repo root:"
+          echo "  ruff format \$(git diff --name-only --diff-filter=d \$(git merge-base origin/main HEAD) HEAD -- '*.py')"
+          exit 1
+        fi

fibsem-0.5.2rc2/.gitignore

@@ -0,0 +1,104 @@
+*.pyc
+*.egg-info/*
+.vscode/*
+.coverage
+*.code-workspace
+*.log
+scratch/test_image.tif
+*.zarr/*
+
+fibsem/wandb/*
+
+*.json
+fibsem/segmentation/wandb/*
+fibsem/segmentation/models/*.pt*
+wandb/*
+
+build/*
+fibsem/segmentation/training/*
+scratch/training/*
+fibsem/testing.ipynb
+fibsem/_version.py
+demo_*/*
+scratch/figure/wd*/*
+fibsem/log/data/*
+test_images/test.tif
+
+fibsem/detection/notebook.ipynb
+
+media/*
+.DS_Store
+fibsem/segmentation/models/**/*.pt*
+fibsem/segmentation/models/*
+example/**/*.tif
+example/demo/*
+fibsem/chat/secret.txt
+
+dist/*
+scratch/tile-images/*
+fibsem/log/*
+fibsem/db/fibsem.db
+fibsem/notebook.ipynb
+scratch/health-monitor/*
+example/notebook.ipynb
+fibsem/segmentation/*config*.y*ml
+!fibsem/segmentation/segementation_config.yaml
+
+fibsem/config/*.yaml
+!fibsem/config/microscope-configuration.yaml
+!fibsem/config/tescan_manipulator.yaml
+!fibsem/config/tfs*.yaml
+!fibsem/config/odemis*.yaml
+!fibsem/config/tescan-*.yaml
+!fibsem/config/sim-*.yaml
+!fibsem/config/sample-holder.yaml
+!fibsem/config/default-sample-holder.yaml
+
+**/wandb/*
+tests/notebook.ipynb
+fibsem/db/v2/notebook.ipynb
+scripts/segformer-*/*
+*.onnx
+scripts/**/*.jpeg
+scripts/**/*.png
+fibsem/ui/test_qt.py
+scripts/dev-notebook2.ipynb
+scripts/launch-autolamella.sh
+fibsem/applications/autolamella/log/*
+fibsem/fm/*.ome.tiff
+notes.md
+fibsem/ui/test-ndv.py
+scripts/reporting-notebook.ipynb
+fibsem/applications/autolamella/protocol/protocol-on-grid-trench-horizontal.yaml
+scripts/Test-Experiment/*
+fibsem/applications/autolamella/autolamella_architecture.md
+projects/*
+tmp/*
+recommendations/*
+
+fibsem/applications/test-data/*
+database_migration.md
+fibsem/ui/OFFLINE_ICONS.md
+fibsem/correlation/scaling_factor_lookup_table.csv
+fibsem/correlation/slice_scaling_factor_LUT.ipynb
+sashimi/*
+fibsem/applications/sashimi/log/*
+# Refractive-index LUT (downloaded on demand from the data release)
+fibsem/correlation/data/
+# Belt-and-braces: a path built from an unset (None) save path lands here
+None/
+publications/*
+# Real acquisition images used to generate the metadata fixtures. The images stay
+# local: they embed the acquiring site's directory layout, hostname and instrument
+# serial number, and this remote is public. Only the scrubbed metadata is committed
+# -- see tests/fixtures/metadata/README.md.
+tests/data/
+# Those scrubbed fixtures are the committed artifact, so they have to be re-included
+# against the blanket `*.json` above.
+!tests/fixtures/metadata/*.json
+
+# Overview runs started without a save directory fall back to the working directory
+# (`FibsemOverviewWidget.acquire`), so running the app from a checkout writes tilesets
+# into it. 11 MB of them reached a commit once.
+overview-image-*.tif
+overview-image-*/

fibsem-0.5.2rc2/AGENTS.md

@@ -0,0 +1,36 @@
+# AGENTS.md
+
+**Read [CONTRIBUTING.md](CONTRIBUTING.md) first.** Everything in it applies to you: the
+five-file cap on pull requests, the `Release-Note:` commit trailer and where it must sit,
+the Python 3.8 floor in signatures, format-on-touch, `QT_QPA_PLATFORM=offscreen`, the
+palette tokens, and the rule that nothing reaches the network unless a user asked it to.
+
+This file covers only what is specific to working here as an agent.
+
+## Do not run the full test suite by default
+
+Run the files your change affects. The full suite takes several minutes, and running it
+after every edit spends most of a session waiting. Run it once before pushing, or when
+asked.
+
+## Green tests are weaker evidence here than usual
+
+Two reasons, both of which have produced confidently wrong reports:
+
+- **napari cannot be constructed under `QT_QPA_PLATFORM=offscreen`** — its GL canvas
+  aborts the process with no traceback. Any test of a napari path is therefore against a
+  stub, and proves nothing about the real widget.
+- **CI installs `.[test]`, not `.[ui]`.** The Qt tests `importorskip` there. A UI test you
+  watched pass locally may not have run in CI at all.
+
+For anything about wiring, say plainly that you have not run the application, or run it.
+
+## Say what you did not verify
+
+Prefer "I checked X by reading the code, not by running it" over silence. A claim that
+turns out to rest on inspection when the reader assumed execution costs more than the
+hedge does.
+
+## Attribution
+
+Do not add AI or assistant attribution to commit messages or pull request bodies.