From 6884b83e64e394cb20edc513a17b49b7394bbc7d Mon Sep 17 00:00:00 2001 From: Benedict Diederich Date: Sun, 15 Nov 2026 15:42:51 +0000 Subject: [PATCH 1/3] Arkitekt: hub on the FRAME's Pi, scans into mikro with their pyramid Tracking document: docs/arkitekt-hub-pi.md (WP-423..426), with the first figures from a konstruktor hub (rekuest 19, mikro 15) on the FRAME's Pi, connected to go.arkitekt.live. - Client family pinned to arkitekt 16.0.1 / mikro 14.0.0 (uv.lock re-locked for these packages only); mikro-next dropped. - ArkitektManager: mandate keys replace redeem tokens (gone in fakts 6), allow_insecure_transport is passed instead of set in the environment, a revoked session asks for a new login once, and an expired device code (5 min on go.arkitekt.live) is renewed for 30 min on a manual bind. - Images go into one persistent stage space, placed at their top-left corner (they were half a field off). Run Tile Scan writes one OME-Zarr canvas by stage position and uploads it once with its pyramid (orkestrator draws at most 64 layers, so per-tile datasets cannot be viewed); action interface 3.0.0. - uploadExperiments: ExperimentController announces finished canvases (sigExperimentFinished); a background task of the agent uploads them, with the levels already on disk, while the microscope is idle. The queue persists (queueArkitektUpload, getArkitektUploadQueue). - Removed a redeem token shipped in two default setups. - scripts/arkitekt_canvas_bench.py: synthetic scan canvas into mikro, timed. Co-Authored-By: Claude Opus 5.5 --- docs/ARKITEKT.md | 55 +- docs/arkitekt-hub-pi.md | 147 ++ docs/setup-config.schema.json | 22 +- .../src/backendapi/apiArkitektController.js | 4 +- .../FRAME_widefield_default.json | 2 +- .../example_FRAME_widefield_default.json | 2 +- .../_test/unit/test_arkitekt_controller.py | 132 +- .../controller/CommunicationChannel.py | 3 + .../controllers/ArkitektController.py | 282 +++- .../controllers/ExperimentController.py | 5 + imswitch/imcontrol/model/SetupInfo.py | 16 +- imswitch/imcontrol/model/io/mikro_upload.py | 212 +++ .../model/managers/ArkitektManager.py | 129 +- pyproject.toml | 23 +- scripts/arkitekt_canvas_bench.py | 124 ++ uv.lock | 1493 ++++++++--------- 16 files changed, 1728 insertions(+), 923 deletions(-) create mode 100644 docs/arkitekt-hub-pi.md create mode 100644 imswitch/imcontrol/model/io/mikro_upload.py create mode 100644 scripts/arkitekt_canvas_bench.py diff --git a/docs/ARKITEKT.md b/docs/ARKITEKT.md index f9e1c5da5..d89720607 100644 --- a/docs/ARKITEKT.md +++ b/docs/ARKITEKT.md @@ -1,13 +1,16 @@ # Arkitekt An [Arkitekt](https://arkitekt.live) server lets notebooks, other apps and workflows call the -microscope. It also stores the images in its mikro service and shows the live state. The server can -be the public one (`https://go.arkitekt.live`) or a local deployment, e.g. on a NAS. +microscope. It also stores the images in its mikro service and shows the live state. Logins and +organizations live on a coordination server (the public `https://go.arkitekt.live`); the services +(a *hub*) can run anywhere, also on the microscope's own Pi: see +[arkitekt-hub-pi.md](arkitekt-hub-pi.md). -ImSwitch uses the `arkitekt` client (5.x, formerly `arkitekt_next`): +ImSwitch uses the `arkitekt` client 16 with mikro 14 (the family is pinned in `pyproject.toml`; +the hub must run rekuest 19 and mikro 15): ```bash -pip install "arkitekt[rekuest,mikro]" +pip install "arkitekt[rekuest,mikro]==16.0.1" ``` Without the package ImSwitch starts normally. The Arkitekt panel then says what to install. @@ -25,7 +28,8 @@ writes it when a setting changes: "autoConnect": true, "allowInsecureTransport": false, "useMikro": true, - "redeemToken": "" + "uploadExperiments": false, + "mandateKey": "" } ``` @@ -36,7 +40,8 @@ writes it when a setting changes: | `autoConnect` | At startup, reconnect when the microscope was bound before. It never starts a browser login by itself. If the stored login was revoked, it stops with an error instead of asking again. | | `allowInsecureTransport` | Allow the login over plain `http://` to a host that is not localhost, e.g. a NAS without TLS. The session token then travels unencrypted. | | `useMikro` | Offer the image actions. They need mikro on the server. | -| `redeemToken` | Unattended login, with no browser. It is a credential: keep it out of shared setup files. | +| `uploadExperiments` | After an experiment, queue its OME-Zarr canvases for mikro. They are uploaded with their pyramid in the background, while bound and idle (no experiment, recording or workflow; CPU < 60 %; 1 GB free). The queue survives restarts. | +| `mandateKey` | Unattended login, with no browser: a key a member issued on the server for one hub. It is a credential: keep it out of shared setup files. (`redeemToken` is gone with arkitekt 16.) | ## Binding and unbinding @@ -45,14 +50,17 @@ and click **Bind microscope**: 1. The server is found (`/.well-known/fakts`). 2. It shows a code and an approval link: the device-code login. Open the link on any computer, sign - in, and approve the microscope. The code must match. + in, pick the hub whose services the microscope should use (`?hub=` on the link preselects + one), and approve. A code lives about five minutes; an unapproved one is replaced by a fresh one + for half an hour. 3. The microscope registers its actions and stays connected. The login is stored on this machine - (arkitekt's per-user state directory), so later starts reconnect without approval. + (arkitekt's per-user state directory), so later starts reconnect without approval. In Docker, + that directory must be on a volume (`/home/pi/.local/state/arkitekt`), or every new container + asks again. - **Disconnect / Cancel** stops a pending login or the connection. It keeps the stored login. -- **Unbind** disconnects and removes the stored login, so binding again needs a new approval. The - fakts protocol has no revocation endpoint: the server keeps the app's registration until someone - removes it in the Arkitekt web interface. +- **Unbind** disconnects and removes the stored login, so binding again needs a new approval. While + connected, the session is also revoked on the server. The stored login is kept per app name, action-interface version (`ARKITEKT_APP_VERSION`, not the ImSwitch release) and server URL. Updating ImSwitch therefore does not ask for approval again. @@ -70,8 +78,12 @@ Dropdowns list this setup's devices. Positions are in µm, in the ImSwitch user | Move To Sample Loading Position | | | Set Illumination | On/off and intensity, refused outside the source's range. | | Set Camera | Exposure (ms) and gain. | -| Acquire Frame | One frame taken after the call, stored in mikro (axes c, y, x, with a pyramid and per-channel contrast). | -| Run Tile Scan | A snake-order grid around a centre (default: here). Each tile streams back as it is stored, and all tiles are registered in one stage space, so the Arkitekt viewer shows them placed by position. Optional autofocus at each tile. Afterwards it returns to the start and restores the illumination. | +| Acquire Frame | One frame taken after the call, stored in mikro (axes c, y, x, with a pyramid, per-channel contrast and names) and placed in the stage space. | +| Run Tile Scan | A snake-order grid around a centre (default: here), written into one OME-Zarr canvas on the microscope (tiles placed by stage position, under `/ArkitektController/`). Nothing goes over the network during the scan. Afterwards the stage returns to the start, the illumination is restored, the pyramid is built and the canvas is uploaded as one image into the stage space. Optional autofocus at each tile. | + +Every image lands in one persistent µm space in mikro (reference `stage`, per app name), at its +top-left corner. One image per scan, not per tile: orkestrator draws at most 64 layers and a scene +starts with 8 sources, so a scan of single tiles cannot be viewed. - Every action that moves or acquires is refused while an experiment, a recording or a workflow runs in ImSwitch. @@ -86,10 +98,12 @@ duration, errors) and thumbnails of the images sent. | Endpoint | | |---|---| | `GET getArkitektStatus` | state (`unavailable`, `disabled`, `unbound`, `connecting`, `awaiting_login`, `connected`, `error`), userCode, approveUrl, settings, actions, activity, publishedState | -| `POST bindArkitekt?url=&redeemToken=` | Starts the login in the background and returns at once. | +| `POST bindArkitekt?url=&mandateKey=` | Starts the login in the background and returns at once. | | `POST cancelArkitekt` | Stops a pending login or the connection. | | `POST unbindArkitekt` | Disconnects and forgets the stored login. | -| `POST setArkitektSettings?url=&appName=&autoConnect=&allowInsecureTransport=&useMikro=` | Saved to the setup file. | +| `POST setArkitektSettings?url=&appName=&autoConnect=&allowInsecureTransport=&useMikro=&uploadExperiments=` | Saved to the setup file. | +| `POST queueArkitektUpload?path=&name=` | Queues an OME-Zarr canvas (e.g. an older experiment) for the background upload. | +| `GET getArkitektUploadQueue` | `{pending, uploaded, failed}`, with dataset ids, durations and errors. | | `GET getArkitektUploads` / `POST clearArkitektActivity` | | Socket signals: `sigArkitektStatus`, `sigArkitektActivity`, `sigArkitektUpload`. @@ -99,11 +113,16 @@ Socket signals: `sigArkitektStatus`, `sigArkitektActivity`, `sigArkitektUpload`. - `imswitch/imcontrol/model/managers/ArkitektManager.py`: the connection. It runs on its own asyncio loop in a thread, so a pending login can be cancelled. The device-code hook feeds the panel. - `imswitch/imcontrol/controller/controllers/ArkitektController.py`: `build_app()` declares the app - (`arkitekt.App`, `@app.action` / `@app.model` / `@app.state`), and the controller serves the panel - endpoints. + (`arkitekt.App`, `@app.action` / `@app.model` / `@app.state`, and the uploader as + `@app.background`), and the controller serves the panel endpoints. +- `imswitch/imcontrol/model/io/mikro_upload.py`: an NGFF canvas into mikro with the levels it + already has (nothing is downsampled again), the stage space, the persistent upload queue. + `ExperimentController` announces finished canvases with `sigExperimentFinished`. - `frontend/src/components/ArkitektController.jsx`, `state/slices/ArkitektSlice.js`, `backendapi/apiArkitektController.js`. - Tests: `imswitch/imcontrol/_test/unit/test_arkitekt_controller.py`. With arkitekt installed, these also check the declarations, a tile scan and the login against a local fake server. -Untested against a real server: the approved login, the agent, and uploads to mikro. +Tested against a konstruktor hub (rekuest 19, mikro 15) connected to go.arkitekt.live: the +approved login, the agent and the background upload of canvases. Not yet run on the FRAME's +hardware: Acquire Frame and Run Tile Scan. diff --git a/docs/arkitekt-hub-pi.md b/docs/arkitekt-hub-pi.md new file mode 100644 index 000000000..f794ceb13 --- /dev/null +++ b/docs/arkitekt-hub-pi.md @@ -0,0 +1,147 @@ +# Arkitekt hub on the FRAME's Pi: tracking + +Branch `feat/arkitekt-hub-mikro`, started 2026-11-15 on FRAME ID10 *berry-muscle* +(`openuc2-berry-muscle-26696`: Pi 5, 8 GB, 128 GB micro SD, Hikrobot MV-CS060 3072 × 2048 RGB). +Brief: WP-423…426. Coordination server: **go.arkitekt.live** (decided). The data stays on the Pi. + +## Status + +| Step | State | +|---|---| +| konstruktor 0.38.1 on the Pi (aarch64 binary, checked against `SHA256SUMS`) | done | +| Hub `rekuest, mikro` at `/home/pi/arkitekt/hub`, ports 2754 (http) / 2755 (https) | running | +| Hub connected to go.arkitekt.live | done: organization 7, hub id 111 | +| ImSwitch on arkitekt 16 / mikro 14 (pins, `uv.lock`, code, 27 unit tests) | done, this branch | +| Canvas with its pyramid → mikro, placed in a µm stage space | done: datasets 1–4 | +| ImSwitch background upload in the live agent (virtual microscope) | done: dataset 3 | +| View in orkestrator on the MacBook | **open** (Bene) | +| Run Tile Scan / Acquire Frame on the FRAME's hardware | open: needs an ImSwitch image from this branch | +| Hub as a pallet deployment in os-rpi | open: plan below | +| WP-424 benchmark | first figures below (synthetic scans, SD card) | + +## Figures (SD card; VS Code server and the ImSwitch container running beside it) + +Hub, idle: **485–752 MB PSS** (rekuest 223, mikro 222, rustfs 95, Postgres 90, takt 55, Caddy 44, +Redis 23 MB at start). Images: **4.0 GB on disk** (1.1 GB is only the compressed pull). Created in +243 s including the pulls. + +| Scan (RGB, 12 bit in uint16) | Raw | ImSwitch zarr | Pyramid | Upload to mikro | In RustFS | Peak RSS | +|---|---|---|---|---|---|---| +| 3 × 3 tiles, 3 × 6144 × 9216 | 0.34 GB | 258 MB | 3.7 s | 21 s | 227 MB | 744 MB | +| 10 × 10 tiles, 3 × 20480 × 30720 | 3.77 GB | 2.88 GB | **128 s** | **259 s** | 2.51 GB | 844 MB | + +10 × 10: from the end of the scan to the image in mikro takes 6.5 min. CPU averaged us 32 / sy 6 / +id 24 / **wa 38 %** (the SD card is the limit). SoC at most 45.5 °C, never throttled. + +## Findings + +1. **Hub and coordination are separate.** A hub is 8 containers: rekuest, rekuest-takt, mikro, Postgres, + Redis, RustFS, Caddy, and after connecting a reporter. It has no Lok and no accounts. Logins and + organizations stay on go.arkitekt.live. Each hub is accepted once into an organization, and each app + is approved once. The approval page is where the hub is chosen (`?hub=111` preselects it). The Pi + needs internet for logins and token refresh, so ImSwitch queues uploads and resumes them. +2. **Client jump.** arkitekt 5.0.1 → 16.0.1 and mikro 6.2.1 → 14.0.0 (released today). Both are pinned + as one family and must match the hub (rekuest 19, mikro 15). Redeem tokens are gone: use mandate + keys. Logins stored by 5.x are not reused, so expect one new approval. +3. **Orkestrator** (macOS arm64 build only, no browser build) reads zarr v3 straight from the hub's + S3 through the gateway. It picks a pyramid level per brick and refuses a large image without a + pyramid. It draws **at most 64 layers**, and a scene starts with 8 sources. So a scan must be one + image, not one dataset per tile: Run Tile Scan now writes one canvas (version 3.0.0 of the actions). +4. **mikro takes pyramid levels only when a dataset is created.** There is no server-side + downscaling. ImSwitch's levels go up as they are, with nothing recomputed. mikro re-encodes them + (zarr v3, 256² chunks, ≤ 16 MiB shards), so **every scan is stored twice** on the card + (2.9 + 2.5 GB above). +5. **ImSwitch's pyramid step re-reads level 0 for every level** (`NgffImage.finalize`): 128 s of the + 6.5 min above. Building each level from the previous one would read ~1.33 × level 0 instead of + 4 ×. Stride decimation (= NEAREST) drops sparse bright fluorescence, so it should offer max/mean. +6. **The experiment canvas is not to scale with overlap.** Tiles are butted together (tile `ix` at + `ix · tile_w` px), so in µm the canvas is stretched by 1/(1 − overlap): 11 % at 10 % overlap. + The new Run Tile Scan places tiles by stage position. The image placement was also half a field + off before (the stage position is the field's centre); fixed. +7. **RGB:** mikro shows three channels as one RGB layer only when they are labelled red/green/blue. + The uploader renames ImSwitch's `…_rgb_r/g/b`. +8. **Device codes live 5 min** (hub acceptance 10 min). ImSwitch now shows a fresh code for 30 min. +9. **For the pallet:** + - Only rekuest, rekuest-takt and mikro have a restart policy, and it is `on-failure`; the + database, Redis, RustFS and the gateway have none. Nothing comes back after a reboot. + - `cgroup_disable=memory` is on, so `docker stats` shows 0 B. Memory was measured as PSS from + `/proc` instead. Real per-container figures need `cgroup_enable=memory` and a reboot. + - The ImSwitch container keeps its Arkitekt login in `/home/pi/.local/state/arkitekt`, which is + not a volume. Every new container asks for approval again. + - Addresses are fixed when the hub connects. Reserve the DHCP lease; connect again after a change. +10. **Security:** + - konstruktor writes `hub_credentials.json` and `hub_config.yaml` (tokens, service keys) + world-readable. They are set to 600 here; to report upstream. + - Two shipped setups (`FRAME_widefield_default.json` and its `example_` copy) contained a + redeem token, now blanked. + - ImSwitch started outside Docker opens JupyterLab without a token on `0.0.0.0:8888`. +11. **Minor:** + - konstruktor's README says port 7080, but the CLI uses 2754/2755. + - `--dry-run` creates the target folder. + - `docs/setup-config.schema.json` has drifted from `SetupInfo`; only `ArkitektInfo` is + regenerated here. + +## What changed in ImSwitch (this branch) + +- Pins and `uv.lock`: the arkitekt 16 family. `mikro-next` is dropped. +- `ArkitektManager`: + - mandate key instead of redeem token + - `allow_insecure_transport=` instead of an environment variable + - a revoked session asks for a new login once + - expired codes are renewed +- `ArkitektController`: + - every image goes into one persistent stage space (`reference="stage"`), placed at its top-left + corner + - Run Tile Scan writes one canvas, then builds the pyramid and uploads it once + - setting `uploadExperiments` (off by default): `sigExperimentFinished` queues the canvases, and + an `@app.background` task uploads them while idle + - endpoints `queueArkitektUpload` and `getArkitektUploadQueue` +- `model/io/mikro_upload.py`: the canvas upload (levels from disk, contrast from the coarsest + level) and the persistent queue. +- `scripts/arkitekt_canvas_bench.py`: synthetic scan canvas → mikro, with timings. + +## Pallet plan (os-rpi, off by default) + +- `deployments/arkitekt-hub.pkg`, two options: + - **A, konstruktor owns the hub.** Forklift ships the pinned binary and a unit that runs + `konstruktor up` at boot. `hub create` and `hub connect` run once by hand, with one browser + approval. konstruktor's backup, update and rollback keep working. + - **B, Forklift owns the compose.** Digest-pinned, `restart: unless-stopped`. konstruktor only + writes the configs once (`hub create --no-start`): the keys are per device, so they cannot live + in the pallet. + + A is enough for the benchmark; B needs a decision with Ethan. In both cases: a firewalld service + for 2754/2755 and a link on the landing page. +- `imswitch.pkg`: bind `/home/pi/arkitekt/imswitch` to `/home/pi/.local/state/arkitekt` (as the + robot apps do), and an image built from this branch. + +## Open questions + +- **Bene:** + - Open datasets 1–4 in orkestrator on the MacBook, on the LAN or the hotspot: time to the first + picture, pan/zoom, and whether the RGB layer looks right. + - Is LAN and hotspot enough, or should the hub join the organization's mesh? + - Delete ImSwitch's copy after the upload? That saves half the card. + - May I enable the memory cgroup (needs a reboot)? +- **Johannes:** + - Can mikro take an existing zarr v3 (sharded) array without re-encoding? + - Can the 5-minute code lifetime be set? + - How should a scene over a persistent stage space with many scans work (`nchildren` 8)? + - konstruktor's file permissions and restart policies. + +## Reproduce + +```bash +konstruktor hub create /home/pi/arkitekt/hub --name frame-hub --identifier openuc2-berry-muscle-26696 \ + --services rekuest,mikro --no-plugin-engine --storage folder --mesh none \ + --host 192.168.178.78 --host 192.168.4.1 --host 100.117.194.33 --no-open --yes +konstruktor hub connect --in /home/pi/arkitekt/hub --server go.arkitekt.live --no-open # accept in a browser +konstruktor status | check | logs | stop | up --in /home/pi/arkitekt/hub +UV_PROJECT_ENVIRONMENT=~/arkitektio/.venv-imswitch uv sync --frozen --inexact # branch client env +python scripts/arkitekt_canvas_bench.py make 10 10 # canvas + pyramid, timed +python scripts/arkitekt_canvas_bench.py upload --hub 111 +``` + +Arkitekt sources read for this (shallow clones in `~/arkitektio`): konstruktor, mikro, mikro-server, +arkitekt, arkitekt-runtime, arkitekt-spec, rekuest, orkestrator, kontrol, lok-server, arkitekt-gateway, +arkitekt-service, arkitekt-datalayer, ome-converter, ome-tiff-converter, init-container, the docs. diff --git a/docs/setup-config.schema.json b/docs/setup-config.schema.json index 1e8423f61..861314763 100644 --- a/docs/setup-config.schema.json +++ b/docs/setup-config.schema.json @@ -57,7 +57,7 @@ "type": "null" } ], - "description": "Persisted settings for the FLIM LABS bridge (remote flim-imager server host/port, laser sync, channels, calibration reference, galvo-sync options). Free-form dict written by GalvoScannerController.setFlimLabsConfig; ``null`` when nothing has been saved. Note: this is the *browser-side* bridge panel's state. To use the FLIM card as a regular 2D detector from the backend (ExperimentController, autofocus, snap), add a ``FLIMLabsDetectorManager`` entry under ``detectors`` instead \u2014 see that manager's docstring for the property list." + "description": "Persisted settings for the FLIM LABS bridge (remote flim-imager server host/port, laser sync, channels, calibration reference, galvo-sync options). Free-form dict written by GalvoScannerController.setFlimLabsConfig; ``null`` when nothing has been saved. Note: this is the *browser-side* bridge panel's state. To use the FLIM card as a regular 2D detector from the backend (ExperimentController, autofocus, snap), add a ``FLIMLabsDetectorManager`` entry under ``detectors`` instead — see that manager's docstring for the property list." }, "rs232devices": { "type": "object", @@ -545,7 +545,7 @@ "defaultStreamSettings": { "type": "object", "additionalProperties": {}, - "description": "Optional per-detector defaults for the live stream applied at startup. Recognised top-level keys (all optional): - ``protocol``: ``\"binary\" | \"jpeg\" | \"mjpeg\" | \"webrtc\"`` - ``subsampling_factor``: int >= 1 - ``throttle_ms``: int - ``jpeg_quality``: int (0..100, JPEG-specific) - ``compression_algorithm``: ``\"lz4\" | \"zstd\" | ...`` (binary-specific) - ``compression_level``: int (binary-specific) - ``crop_size``: [width, height] or null These are baked into the per-detector params on first stream start, so the live view comes up with a sensible default per camera (e.g. heavy subsampling on a large overview camera, lossless binary on a widefield sensor). The frontend cannot mutate these \u2014 it can only override the *current* session via ``setStreamParameters``/``setDetectorStreamParameters``." + "description": "Optional per-detector defaults for the live stream applied at startup. Recognised top-level keys (all optional): - ``protocol``: ``\"binary\" | \"jpeg\" | \"mjpeg\" | \"webrtc\"`` - ``subsampling_factor``: int >= 1 - ``throttle_ms``: int - ``jpeg_quality``: int (0..100, JPEG-specific) - ``compression_algorithm``: ``\"lz4\" | \"zstd\" | ...`` (binary-specific) - ``compression_level``: int (binary-specific) - ``crop_size``: [width, height] or null These are baked into the per-detector params on first stream start, so the live view comes up with a sensible default per camera (e.g. heavy subsampling on a large overview camera, lossless binary on a widefield sensor). The frontend cannot mutate these — it can only override the *current* session via ``setStreamParameters``/``setDetectorStreamParameters``." } } }, @@ -1198,7 +1198,7 @@ "type": "object", "additionalProperties": {} }, - "description": "Per-detector affine calibration data, keyed by detector name. Format: { \"\": { \"affine_matrix\": [[a11, a12, tx], [a21, a22, ty]], # 2x3 matrix \"metrics\": {...}, # scale_x_um_per_pixel, scale_y_um_per_pixel, ... \"timestamp\": \"...\", \"detector_name\": \"\" } } The affine matrix transforms pixel coordinates to stage coordinates: [stage_x] [a11 a12 tx] [pixel_x] [stage_y] = [a21 a22 ty] \u00d7 [pixel_y] [ 1 ] Sign of metrics.scale_x_um_per_pixel / scale_y_um_per_pixel encodes flip (negative => flip on that axis)." + "description": "Per-detector affine calibration data, keyed by detector name. Format: { \"\": { \"affine_matrix\": [[a11, a12, tx], [a21, a22, ty]], # 2x3 matrix \"metrics\": {...}, # scale_x_um_per_pixel, scale_y_um_per_pixel, ... \"timestamp\": \"...\", \"detector_name\": \"\" } } The affine matrix transforms pixel coordinates to stage coordinates: [stage_x] [a11 a12 tx] [pixel_x] [stage_y] = [a21 a22 ty] × [pixel_y] [ 1 ] Sign of metrics.scale_x_um_per_pixel / scale_y_um_per_pixel encodes flip (negative => flip on that axis)." }, "defaultAffineMatrix": { "type": "array", @@ -1435,7 +1435,7 @@ }, "scaleUmPerUnit": { "type": "number", - "description": "Microns of Z per unit of controller output. Only used until a calibration has run \u2014 after that the measured sensitivity replaces it.", + "description": "Microns of Z per unit of controller output. Only used until a calibration has run — after that the measured sensitivity replaces it.", "default": 100.0 }, "minStepThreshold": { @@ -1545,14 +1545,19 @@ "description": "Arkitekt server to bind to, e.g. ``http://nas.local`` for a local deployment. Set from the Arkitekt panel when binding.", "default": "https://go.arkitekt.live" }, + "mandateKey": { + "type": "string", + "description": "Unattended login (no browser approval): a mandate key a member issued on the server for one hub. One key serves one app. It is a credential: keep it out of setup files that are shared.", + "default": "" + }, "redeemToken": { "type": "string", - "description": "Provisioning token for an unattended login (no browser approval). It is a credential: keep it out of setup files that are shared.", + "description": "Unused since arkitekt 16 (the server dropped redeem tokens; use mandateKey); kept so older setup files load.", "default": "" }, "autoConnect": { "type": "boolean", - "description": "Reconnect at startup when this microscope was bound before (stored login or redeem token). Never starts a browser login by itself.", + "description": "Reconnect at startup when this microscope was bound before (stored login or mandate key). Never starts a browser login by itself.", "default": true }, "allowInsecureTransport": { @@ -1565,6 +1570,11 @@ "description": "Offer the image actions (acquire frame, tile scan), which store images in the server's mikro service. Turn off for a server without mikro.", "default": true }, + "uploadExperiments": { + "type": "boolean", + "description": "After an experiment, queue its OME-Zarr canvases (with their pyramid) for mikro. They are uploaded in the background while bound and while the microscope is idle; the queue survives restarts.", + "default": false + }, "syncInAsync": { "type": "boolean", "description": "Unused since the move from arkitekt_next to arkitekt; kept so older setup files load.", diff --git a/frontend/src/backendapi/apiArkitektController.js b/frontend/src/backendapi/apiArkitektController.js index 97e8a24b5..b3bd46710 100644 --- a/frontend/src/backendapi/apiArkitektController.js +++ b/frontend/src/backendapi/apiArkitektController.js @@ -25,8 +25,8 @@ export const apiArkitektGetStatus = () => get("getArkitektStatus"); // Starts the login in the background and returns at once; poll the status // (or listen to sigArkitektStatus) for the code to approve. -export const apiArkitektBind = (url = "", redeemToken = "") => - post("bindArkitekt", { url, redeemToken }); +export const apiArkitektBind = (url = "", mandateKey = "") => + post("bindArkitekt", { url, mandateKey }); // Stop a pending login or disconnect; the stored login is kept. export const apiArkitektCancel = () => post("cancelArkitekt"); diff --git a/imswitch/_data/user_defaults/imcontrol_setups/FRAME_widefield_default.json b/imswitch/_data/user_defaults/imcontrol_setups/FRAME_widefield_default.json index e96e806f5..33816defc 100644 --- a/imswitch/_data/user_defaults/imcontrol_setups/FRAME_widefield_default.json +++ b/imswitch/_data/user_defaults/imcontrol_setups/FRAME_widefield_default.json @@ -384,7 +384,7 @@ "arkitekt": { "enabled": true, "appName": "FRAME Fork Approval", - "redeemToken": "3537b7ed-f341-4c09-86ce-c993764e1766", + "redeemToken": "", "url": "go.arkitekt.live", "syncInAsync": true, "deconvolveActionHash": "c58c90edbf6e208e3deafdd6f885553d6e027573f0ddc3b59ced3911f016ef4f" diff --git a/imswitch/_data/user_defaults/imcontrol_setups/example_FRAME_widefield_default.json b/imswitch/_data/user_defaults/imcontrol_setups/example_FRAME_widefield_default.json index 55534c3c3..2e2b3c96a 100644 --- a/imswitch/_data/user_defaults/imcontrol_setups/example_FRAME_widefield_default.json +++ b/imswitch/_data/user_defaults/imcontrol_setups/example_FRAME_widefield_default.json @@ -386,7 +386,7 @@ "arkitekt": { "enabled": true, "appName": "FRAME Fork Approval", - "redeemToken": "3537b7ed-f341-4c09-86ce-c993764e1766", + "redeemToken": "", "url": "go.arkitekt.live", "syncInAsync": true, "deconvolveActionHash": "c58c90edbf6e208e3deafdd6f885553d6e027573f0ddc3b59ced3911f016ef4f" diff --git a/imswitch/imcontrol/_test/unit/test_arkitekt_controller.py b/imswitch/imcontrol/_test/unit/test_arkitekt_controller.py index b8e0e6894..8a4c28c67 100644 --- a/imswitch/imcontrol/_test/unit/test_arkitekt_controller.py +++ b/imswitch/imcontrol/_test/unit/test_arkitekt_controller.py @@ -74,6 +74,15 @@ def getParameter(self, name): return 10.0 +@pytest.fixture(autouse=True) +def user_dirs(tmp_path, monkeypatch): + """The upload queue and the tile-scan canvases go to a temporary folder.""" + dirs = controller_module.dirtools.UserFileDirs + monkeypatch.setattr(dirs, "Config", str(tmp_path / "config")) + monkeypatch.setattr(dirs, "getValidatedDataPath", staticmethod(lambda: str(tmp_path / "data"))) + return tmp_path + + @pytest.fixture def no_arkitekt(monkeypatch): real = manager_module.importlib.util.find_spec @@ -283,37 +292,115 @@ def create_array_dataset(self, **kwargs): self.datasets.append(dataset) return dataset - def create_coordinate_system(self, name, axes, registrations, epoch): - space = types.SimpleNamespace(name=name, registered=[], staged=[]) + def create_coordinate_system(self, name, axes, **kwargs): + space = types.SimpleNamespace(name=name, kwargs=kwargs, registered=[]) space.register = lambda dataset, scale=None, **offsets: space.registered.append( (dataset.id, scale, offsets)) - space.stage = lambda name=None: space.staged.append(name) self.spaces.append(space) return space -def test_tile_scan_places_tiles_in_one_space_and_restores_everything(): +def test_tile_scan_is_one_canvas_placed_in_the_stage_space(user_dirs): pytest.importorskip("arkitekt") pytest.importorskip("mikro") + import zarr from arkitekt import Task controller, positioner, master = make_controller() - controller.build_app("imswitch", "2.0.0") + controller.build_app("imswitch", controller_module.ARKITEKT_APP_VERSION) led = next(m for m in controller._actions["set_illumination"].__wrapped__ .__annotations__["channel"] if m.value == "LED") mikro = FakeMikro() - tiles = list(controller._actions["run_tile_scan"]( + # 4 x 3 tiles of 80 x 60 px at 0.5 µm, 50 % overlap, around (100, 200) µm + lens = controller._actions["run_tile_scan"]( mikro=mikro, task=Task.local(), range_x_um=60.0, range_y_um=30.0, overlap_percent=50, - illumination=led, intensity=300, settle_s=0)) - assert len(tiles) == 12 and len(mikro.datasets) == 12 - xs = [offsets["x"] for _, _, offsets in mikro.spaces[0].registered] - assert xs[:4] == [70.0, 90.0, 110.0, 130.0] and xs[4:8] == [130.0, 110.0, 90.0, 70.0] - assert mikro.spaces[0].registered[0][1] == {"y": 0.5, "x": 0.5} and mikro.spaces[0].staged - assert mikro.datasets[0].kwargs["axes"] == ["c", "y", "x"] + illumination=led, intensity=300, settle_s=0) + assert lens.id == "lens" and len(mikro.datasets) == 1 and len(mikro.spaces) == 1 + assert mikro.spaces[0].kwargs["reference"] == "stage" # the same space every run + (_, scale, offsets), = mikro.spaces[0].registered + assert scale == {"y": 0.5, "x": 0.5} + assert offsets == {"x": 50.0, "y": 170.0} # top-left of the first tile, centred at (70, 185) + uploaded = mikro.datasets[0].kwargs + assert uploaded["axes"] == ["c", "y", "x"] and uploaded["data"].data.shape == (1, 120, 200) + assert uploaded["anchors"][0].label.label == "LED" + path, = (user_dirs / "data" / "ArkitektController").glob("*_tile_scan.ome.zarr") + canvas = zarr.open_group(str(path), mode="r")["0"][0, :, 0] + assert (canvas > 0).all() # tiles placed by stage position cover every pixel assert positioner.calls[-1][:3] == ("xy", 100.0, 200.0) # back where it started led_device = master.lasersManager["LED"] assert led_device.enabled is False and led_device.power == 10 # restored +def test_rgb_channels_are_named_for_mikro(): + from imswitch.imcontrol.model.io.mikro_upload import channel_labels + assert channel_labels(["LED_rgb_r", "LED_rgb_g", "LED_rgb_b"]) == ["red", "green", "blue"] + assert channel_labels(["B", "G", "R"]) == ["blue", "green", "red"] + assert channel_labels(["DAPI", "GFP", "Red"]) == ["DAPI", "GFP", "Red"] # not a photograph + assert channel_labels(["A_rgb_r", "A_rgb_g", "A_rgb_b", "B_rgb_r", "B_rgb_g", "B_rgb_b"])[0] \ + == "A_rgb_r" + + +def write_canvas(path, channels=("LED_rgb_r", "LED_rgb_g", "LED_rgb_b")): + from imswitch.imcontrol.model.aufgaben.storage import ImageSpec, NgffImage + spec = ImageSpec(shape=(1, len(channels), 1, 600, 800), dtype="uint8", pixel_size_um=0.5, + origin_um=(10.0, 20.0, 0.0), channel_names=list(channels), name="region") + image = NgffImage.create(path, spec) + for c in range(len(channels)): + image.write(np.full((600, 800), 50 + c, np.uint8), 0, c, 0) + image.finalize(min_size=128) + return image + + +def test_a_canvas_is_read_lazily_with_its_pyramid(tmp_path): + pytest.importorskip("dask") + from imswitch.imcontrol.model.io.mikro_upload import read_ngff + write_canvas(tmp_path / "r.ome.zarr") + canvas = read_ngff(tmp_path / "r.ome.zarr") + assert canvas.dims == ["c", "y", "x"] # singleton t and z dropped, c kept + assert [level.shape for level in canvas.levels] == [(3, 600, 800), (3, 300, 400), + (3, 150, 200)] + assert canvas.pixel_um == {"y": 0.5, "x": 0.5} and canvas.origin_um == {"y": 20.0, "x": 10.0} + assert canvas.labels == ["red", "green", "blue"] and canvas.name == "region" + + +def test_upload_queue_survives_a_restart_and_gives_up_after_three_failures(tmp_path): + from imswitch.imcontrol.model.io.mikro_upload import UploadQueue + queue = UploadQueue(tmp_path / "q.json") + assert queue.add("/a", "A") and queue.add("/b") and not queue.add("/a") + queue.done(queue.next(), "ds1", 3.0) + assert not queue.add("/a") # uploaded already + again = UploadQueue(tmp_path / "q.json") + assert again.next()["path"] == "/b" + for _ in range(3): + again.failed(again.next(), RuntimeError("hub down")) + state = UploadQueue(tmp_path / "q.json").snapshot() + assert state["pending"] == [] and state["uploaded"][0]["datasetId"] == "ds1" + assert state["failed"][0]["attempts"] == 3 and "hub down" in state["failed"][0]["error"] + + +def test_finished_experiments_are_queued_and_uploaded_when_idle(tmp_path, monkeypatch): + pytest.importorskip("mikro") + write_canvas(tmp_path / "exp" / "region0.ome.zarr") + controller, _, _ = make_controller(info=ArkitektInfo(autoConnect=False)) + payload = {"name": "Exp", "canvases": [str(tmp_path / "exp" / "region0.ome.zarr")]} + controller._on_experiment_finished(payload) + assert controller.getArkitektUploadQueue()["pending"] == [] # uploadExperiments is off + controller._manager.info.uploadExperiments = True + controller._on_experiment_finished(payload) + assert controller.getArkitektUploadQueue()["pending"][0]["name"] == "Exp region0" + mikro = FakeMikro() + monkeypatch.setattr(controller, "_idle_for_upload", lambda: "experiment running") + assert controller._upload_next(mikro) is False and not mikro.datasets + monkeypatch.setattr(controller, "_idle_for_upload", lambda: None) + assert controller._upload_next(mikro) is True + uploaded = mikro.datasets[0].kwargs + assert [s.level for s in uploaded["scales"]] == [1, 2] # the levels on disk, not rebuilt + assert [a.label.label for a in uploaded["anchors"]] == ["red", "green", "blue"] + assert mikro.spaces[0].registered[0][2] == {"y": 20.0, "x": 10.0} + queue = controller.getArkitektUploadQueue() + assert queue["pending"] == [] and queue["uploaded"][0]["datasetId"] == "ds0" + assert controller.getArkitektUploads()[0]["thumbnail"] + + class FakeFakts: """/.well-known/fakts, device authorization and token endpoints on 127.0.0.1.""" @@ -429,7 +516,8 @@ def test_automatic_reconnect_with_an_invalid_stored_login_does_not_prompt(privat import json import os server = FakeFakts() - path = manager_module.cache_file("imswitch", "2.0.0", server.base) + path = manager_module.cache_file("imswitch", controller_module.ARKITEKT_APP_VERSION, + server.base) os.makedirs(os.path.dirname(path), exist_ok=True) with open(path, "w") as f: json.dump({}, f) # a session fakts cannot use: it would fall back to a device code @@ -440,21 +528,9 @@ def test_automatic_reconnect_with_an_invalid_stored_login_does_not_prompt(privat assert controller.unbindArkitekt()["hasStoredLogin"] is False -def test_only_http_approval_links_reach_the_panel(no_arkitekt): - import asyncio - manager = manager_module.ArkitektManager(ArkitektInfo(autoConnect=False)) - endpoint = types.SimpleNamespace(configure="javascript:alert('{code}')", base_url="x", - name="evil") - asyncio.run(manager._on_device_code(endpoint, "ABCD")) - assert manager.status()["userCode"] == "ABCD" and manager.status()["approveUrl"] is None - endpoint.configure = "https://lok.example/configure/{code}" - asyncio.run(manager._on_device_code(endpoint, "ABCD")) - assert manager.status()["approveUrl"] == "https://lok.example/configure/ABCD" - - -def test_device_code_hook_takes_the_fakts_5_4_challenge(no_arkitekt): - """fakts 5.4+ (arkitekt 6) calls the hook with one DeviceCodeChallenge, not - (endpoint, code): the Bind button failed with a TypeError before this.""" +def test_device_code_hook_takes_the_challenge(no_arkitekt): + """fakts calls the hook with one DeviceCodeChallenge; only http(s) approval + links reach the panel, which renders them.""" import asyncio manager = manager_module.ArkitektManager(ArkitektInfo(autoConnect=False)) endpoint = types.SimpleNamespace(configure="https://lok.example/configure/{code}", diff --git a/imswitch/imcontrol/controller/CommunicationChannel.py b/imswitch/imcontrol/controller/CommunicationChannel.py index cd7209a5b..35b213459 100644 --- a/imswitch/imcontrol/controller/CommunicationChannel.py +++ b/imswitch/imcontrol/controller/CommunicationChannel.py @@ -76,6 +76,9 @@ class CommunicationChannel(SignalInterface): sigExperimentStop = Signal() + # {name, dir, canvases: [OME-Zarr canvas paths]}: emitted once an experiment's + # writers are finalized (pyramids built), also after a stop. + sigExperimentFinished = Signal(dict) #sigRequestScannersInScan = Signal() diff --git a/imswitch/imcontrol/controller/controllers/ArkitektController.py b/imswitch/imcontrol/controller/controllers/ArkitektController.py index 157a3dc71..717849b0c 100644 --- a/imswitch/imcontrol/controller/controllers/ArkitektController.py +++ b/imswitch/imcontrol/controller/controllers/ArkitektController.py @@ -13,6 +13,12 @@ PositionerController reports). Exposure is in ms. Actions that move hardware or acquire are refused while an experiment, a recording or a workflow runs, and they hold the "microscope" lock, so remote calls run one at a time. + +Images: every image lands in one persistent stage space in mikro, placed at +its top-left corner. A tile scan is written to one OME-Zarr canvas here and +uploaded once, with its pyramid, after the scan. With arkitekt.uploadExperiments, +the canvases of finished experiments are uploaded the same way, in the +background, while the microscope is idle. """ import asyncio import base64 @@ -22,28 +28,35 @@ import functools import inspect import itertools +import os import re import threading import time -from typing import Annotated, Any, Dict, Generator, List, Optional +from typing import Annotated, Any, Dict, List, Optional import numpy as np from imswitch.imcommon.framework import Signal from imswitch.imcontrol.controller.busy import busy_reasons -from imswitch.imcommon.model import APIExport, initLogger +from imswitch.imcommon.model import APIExport, dirtools, initLogger from imswitch.imcontrol.model import configfiletools from ..basecontrollers import ImConWidgetController # The action interface's version. The server registers the app under it, and # the stored login is kept per version: bump it only when actions change -# incompatibly, never with ImSwitch's release number. -ARKITEKT_APP_VERSION = "2.0.0" +# incompatibly, never with ImSwitch's release number. 3.0.0: run_tile_scan +# returns one stitched canvas instead of streaming every tile. +ARKITEKT_APP_VERSION = "3.0.0" MAX_ACTIVITY = 50 MAX_UPLOADS = 12 THUMBNAIL_PX = 192 STATE_PUBLISH_PERIOD_S = 1.0 HOMEABLE_AXES = ("X", "Y") # Z homing drives the objective towards its endstop: not remote +# Background uploads of finished experiments run only while the microscope is idle. +UPLOAD_POLL_S = 5.0 +UPLOAD_MAX_CPU_PERCENT = 60.0 +UPLOAD_MIN_FREE_MB = 1024 +UPLOAD_DASK_WORKERS = 2 def _choices(name: str, values: List[str]) -> enum.Enum: @@ -93,11 +106,18 @@ def __init__(self, *args, **kwargs): self._useTriggeredGrab = False detectors = self._master.detectorsManager.getAllDeviceNames() self.mDetector = self._master.detectorsManager[detectors[0]] if detectors else None + self._upload_queue = None if self._manager is None: self._logger.warning("ArkitektManager unavailable; Arkitekt panel only.") return if getattr(self._setupInfo, "arkitekt", None) is None: self._setupInfo.arkitekt = self._manager.info # what the panel changes gets saved + from imswitch.imcontrol.model.io.mikro_upload import UploadQueue + self._upload_queue = UploadQueue(os.path.join(dirtools.UserFileDirs.Config, + "arkitekt_uploads.json")) + finished = getattr(self._commChannel, "sigExperimentFinished", None) + if finished is not None: + finished.connect(self._on_experiment_finished) self._manager.set_app_factory(self.build_app, ARKITEKT_APP_VERSION) self._manager.add_listener(self.sigArkitektStatus.emit) self._manager.auto_connect() @@ -131,21 +151,22 @@ def getArkitektStatus(self) -> dict: "activity": activity[::-1], "uploadCount": len(self._uploads)} @APIExport(runOnUIThread=False, requestType="POST") - def bindArkitekt(self, url: str = "", redeemToken: str = "") -> dict: + def bindArkitekt(self, url: str = "", mandateKey: str = "") -> dict: """Bind this microscope to the Arkitekt server at *url* (empty = the configured one; saved to the setup file). Returns at once. Without a stored login, the state becomes awaiting_login with a userCode - and an approveUrl: open the link, sign in and approve, and the state - becomes connected. A redeemToken logs in without a browser (it is not - saved). Network only: nothing on the microscope moves.""" + and an approveUrl: open the link, sign in, pick the hub and approve, and + the state becomes connected. A mandateKey (issued for one hub on the + server) logs in without a browser; it is not saved. Network only: + nothing on the microscope moves.""" if self._manager is None: return {"status": "error", "message": "Arkitekt is not configured."} url = (url or "").strip() if url and url != self._manager.info.url: self._manager.info.url = url self._save_settings() - return self._manager.bind(url=url or None, redeem_token=redeemToken or None) + return self._manager.bind(url=url or None, mandate_key=mandateKey or None) @APIExport(runOnUIThread=False, requestType="POST") def cancelArkitekt(self) -> dict: @@ -169,16 +190,18 @@ def unbindArkitekt(self) -> dict: def setArkitektSettings(self, url: Optional[str] = None, appName: Optional[str] = None, autoConnect: Optional[bool] = None, allowInsecureTransport: Optional[bool] = None, - useMikro: Optional[bool] = None) -> dict: + useMikro: Optional[bool] = None, + uploadExperiments: Optional[bool] = None) -> dict: """Change the Arkitekt settings and save them to the setup file. They apply at the next bind. A different url or appName is a different - login (each has its own stored session).""" + login (each has its own stored session). uploadExperiments: after an + experiment, queue its OME-Zarr canvases for mikro (uploaded while idle).""" if self._manager is None: return {"status": "error", "message": "Arkitekt is not configured."} info = self._manager.info for key, value in (("url", url), ("appName", appName), ("autoConnect", autoConnect), ("allowInsecureTransport", allowInsecureTransport), - ("useMikro", useMikro)): + ("useMikro", useMikro), ("uploadExperiments", uploadExperiments)): if value is not None: setattr(info, key, value.strip() if isinstance(value, str) else bool(value)) saved = self._save_settings() @@ -194,6 +217,27 @@ def getArkitektUploads(self) -> List[dict]: thumbnail (JPEG data URL)}]. Live: sigArkitektUpload.""" return list(self._uploads)[::-1] + @APIExport(runOnUIThread=False, requestType="POST") + def queueArkitektUpload(self, path: str, name: str = "") -> dict: + """Queue an OME-Zarr canvas (an NGFF image folder, e.g. an experiment's + *.ome.zarr) for mikro. It is uploaded, with its pyramid, while bound + with mikro and the microscope is idle. Nothing is read now.""" + if self._upload_queue is None: + return {"status": "error", "message": "Arkitekt is not configured."} + if not os.path.isdir(path): + return {"status": "error", "message": f"No such canvas folder: {path}"} + added = self._upload_queue.add(path, name or None) + return {"status": "success" if added else "warning", + "message": None if added else "Already queued or uploaded."} + + @APIExport(runOnUIThread=False) + def getArkitektUploadQueue(self) -> dict: + """Canvases waiting for mikro, uploaded and failed (with the error): + {pending, uploaded, failed}.""" + if self._upload_queue is None: + return {"pending": [], "uploaded": [], "failed": []} + return self._upload_queue.snapshot() + @APIExport(runOnUIThread=False, requestType="POST") def clearArkitektActivity(self) -> dict: """Forget the activity log and the upload previews (nothing on the server).""" @@ -237,6 +281,8 @@ def build_app(self, identifier: str, version: str): self._declare_camera_action(offer) if mikro_types: self._declare_image_actions(offer, mikro_types, illumination) + if mikro_types: + self._declare_uploader(app, mikro_types["Mikro"]) self._offered = offered return app @@ -400,7 +446,8 @@ def set_camera( self._set_camera(exposure_ms, gain) def _declare_image_actions(self, offer, mikro_types, Illumination): - """acquire_frame and run_tile_scan: images go to mikro (axes c, y, x).""" + """acquire_frame and run_tile_scan: images go to mikro (axes c, y, x), + placed in the stage space.""" from arkitekt import Description, Effects, Task Mikro, Image = mikro_types["Mikro"], mikro_types["Image"] @@ -416,7 +463,7 @@ def acquire_frame( ) -> Image: """Acquire Frame Takes one camera frame (captured after the call) and stores it in - mikro, with the stage position and pixel size in its metadata.""" + mikro, placed at its stage position in the stage space.""" self._refuse_if_busy() task.progress(20, "Acquiring") frame = self.grabCameraFrame(frameSync=2) @@ -450,21 +497,30 @@ def run_tile_scan( autofocus_step_um: float = 10.0, speed: Annotated[Optional[float], Description("Default: configured speed")] = None, settle_s: Annotated[float, Description("Wait after each move")] = 0.2, - ) -> Generator[Image, None, None]: + ) -> Image: """Run Tile Scan - Scans a grid around a centre (snake order), yields each tile as it - is stored, and places all tiles in one stage space in mikro so the - Arkitekt viewer shows them stitched by position. Returns the stage - to where it started and restores the illumination.""" + Scans a grid around a centre (snake order) into one canvas on the + microscope, tiles placed by stage position. After the scan it + builds the pyramid and stores the canvas in mikro as one image, + placed in the stage space. Returns the stage to where it started + and restores the illumination.""" self._refuse_if_busy() if exposure_ms is not None: self._set_camera(exposure_ms, None) grid = self._tile_grid(range_x_um, range_y_um, center_x_um, center_y_um, overlap_percent, step_x_um, step_y_um) - yield from self._tile_scan( + return self._tile_scan( mikro, task, grid, getattr(illumination, "value", illumination), intensity, (autofocus_range_um, autofocus_step_um) if autofocus else None, speed, settle_s) + def _declare_uploader(self, app, Mikro): + """A background task of the agent: uploads queued canvases (finished + experiments, queueArkitektUpload) while the microscope is idle.""" + + @app.background + def upload_queued_canvases(mikro: Mikro) -> None: + self._upload_queued(mikro) + def _mikro_types(self) -> Optional[dict]: try: from mikro import Mikro, mikro_service @@ -697,30 +753,40 @@ def grabCameraFrame(self, frameSync: int = 2) -> np.ndarray: # ── images to mikro ───────────────────────────────────────────────────── - def _upload(self, mikro, frame: np.ndarray, name: str, position: Dict[str, float], - space=None): + def _upload(self, mikro, frame: np.ndarray, name: str, position: Dict[str, float]): """Store *frame* as an array dataset (axes c, y, x, with a pyramid and - per-channel contrast), register it in *space* at its stage position, - remember a thumbnail for the panel and return its lens.""" - import xarray as xr + per-channel contrast and names), register it in the stage space with + its top-left corner where it was seen (*position* is the field's + centre), remember a thumbnail for the panel and return its lens.""" from mikro import dataset_arrays - from mikro.api.schema import CoordinateAnchorInput + from imswitch.imcontrol.model.io.mikro_upload import channel_anchors, stage_space array = np.asarray(frame) data = array[np.newaxis] if array.ndim == 2 else np.moveaxis(array, -1, 0) - cyx = xr.DataArray(data, dims=("c", "y", "x")) - levels = max(1, min(4, int(np.log2(max(cyx.shape[1:]) / 512)) + 1)) - level_zero, scales = dataset_arrays(cyx, levels=levels, method="mean") + dims = ["c", "y", "x"] + levels = max(1, min(4, int(np.log2(max(data.shape[1:]) / 512)) + 1)) + level_zero, scales = dataset_arrays(data, levels=levels, method="mean", dims=dims) dataset = mikro.create_array_dataset( - data=level_zero, scales=scales, name=name, axes=["c", "y", "x"], - anchors=CoordinateAnchorInput.histogram_anchors(cyx)) - pixel_size = self._pixel_size_um() - if space is not None: - space.register(dataset, scale={"y": pixel_size, "x": pixel_size}, - x=position["x"], y=position["y"]) - self._remember_upload(array, name, getattr(dataset, "id", None), position, pixel_size) + data=level_zero, scales=scales, name=name, axes=dims, + anchors=channel_anchors(data, dims, self._channel_names(data.shape[0]))) + pixel = self._pixel_size_um() + height, width = data.shape[1:] + stage_space(mikro).register(dataset, scale={"y": pixel, "x": pixel}, + x=position["x"] - width * pixel / 2, + y=position["y"] - height * pixel / 2) + self._remember_upload(array, name, getattr(dataset, "id", None), position, pixel) return dataset.lens() + def _channel_names(self, channels: int) -> List[str]: + """Names for a frame's channels: red/green/blue for a colour camera, else + the light source that is on (mikro picks a hue from such names).""" + from imswitch.imcontrol.model.io.mikro_upload import channel_labels + if channels == 3: + return channel_labels(["rgb_r", "rgb_g", "rgb_b"]) + lit = [n for n in self._master.lasersManager.getAllDeviceNames() + if getattr(self._master.lasersManager[n], "enabled", False)] + return [lit[0] if len(lit) == 1 else f"C{i}" for i in range(channels)] + def _remember_upload(self, array: np.ndarray, name: str, dataset_id, position: dict, pixel_size: float) -> None: entry = {"id": next(self._activity_ids), "name": name, "datasetId": dataset_id, @@ -752,34 +818,36 @@ def _tile_grid(self, range_x_um, range_y_um, center_x_um, center_y_um, overlap_p def _tile_scan(self, mikro, task, grid: dict, illumination: Optional[str], intensity: Optional[float], autofocus: Optional[tuple], speed, settle_s): - from kanne.scalars import Unit - from mikro import space_2d + """Scan into one canvas on disk (nothing goes over the network during + the scan), then build its pyramid and upload it once.""" + from imswitch.imcontrol.model.io.mikro_upload import read_ngff, stage_space, upload_ngff autofocus_controller = self._master.getController("Autofocus") if autofocus else None if autofocus and autofocus_controller is None: raise RuntimeError("Autofocus requested, but this setup has no autofocus.") nx, ny, tiles = grid["nx"], grid["ny"], grid["tiles"] - stamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M") - space = space_2d(mikro, f"Tile scan {stamp} ({nx}x{ny})", unit=Unit("micrometer")) + stamp = datetime.datetime.now() + name = f"Tile scan {stamp:%Y-%m-%d %H:%M} ({nx}x{ny})" + path = os.path.join(dirtools.UserFileDirs.getValidatedDataPath(), "ArkitektController", + f"{stamp:%Y%m%d_%H%M%S}_tile_scan.ome.zarr") + canvas = None restore_light = self._switch_illumination(illumination, intensity) task.progress(0, f"{nx} x {ny} tiles, step {grid['step'][0]:.0f} x " f"{grid['step'][1]:.0f} µm") if autofocus_controller is None: # autofocus switches the trigger mode itself self._beginTriggeredAcquisition() try: - for index, (ix, iy, x, y) in enumerate(tiles): + for index, (_, _, x, y) in enumerate(tiles): self._move_xy(x, y, speed, None) time.sleep(max(0.0, settle_s)) if autofocus_controller is not None: self._autofocus(autofocus_controller, *autofocus) - frame = self.grabCameraFrame(frameSync=2) - position = {**self._position(None), "x": x, "y": y} - lens = self._upload(mikro, frame, f"Tile {ix:03d}_{iy:03d} x{x:.0f} y{y:.0f}", - position, space) - task.progress(int(100 * (index + 1) / len(tiles)), + frame = np.asarray(self.grabCameraFrame(frameSync=2)) + if canvas is None: + canvas = self._new_canvas(path, name, frame, grid, illumination) + self._write_tile(canvas, frame, x, y, grid) + task.progress(int(80 * (index + 1) / len(tiles)), f"Tile {index + 1}/{len(tiles)}") - yield lens - space.stage(name=f"Tile scan {stamp}") finally: self._endTriggeredAcquisition() restore_light() @@ -787,6 +855,116 @@ def _tile_scan(self, mikro, task, grid: dict, illumination: Optional[str], self._move_xy(grid["start"]["x"], grid["start"]["y"], speed, None) except Exception as e: self._logger.warning(f"Could not return to the scan start: {e}") + task.progress(82, "Building the pyramid") + canvas.finalize() + task.progress(88, "Uploading to mikro") + stored = read_ngff(path) + dataset = upload_ngff(mikro, stored, name=name, space=stage_space(mikro)) + center = {**grid["start"], "x": (grid["x_min"] + grid["x_max"]) / 2, + "y": (grid["y_min"] + grid["y_max"]) / 2} + self._remember_upload(_preview(stored), name, getattr(dataset, "id", None), center, + self._pixel_size_um()) + return dataset.lens() + + def _new_canvas(self, path: str, name: str, frame: np.ndarray, grid: dict, + illumination: Optional[str]): + """The scan's OME-Zarr canvas: every tile centre of *grid* plus half a + field around it, at the camera's pixel size, one chunk per tile.""" + from imswitch.imcontrol.model.aufgaben.storage import ImageSpec, NgffImage + + height, width = frame.shape[:2] + rgb = frame.ndim == 3 and frame.shape[2] == 3 + pixel = self._pixel_size_um() + xs, ys = [t[2] for t in grid["tiles"]], [t[3] for t in grid["tiles"]] + grid.update(x_min=min(xs), x_max=max(xs), y_min=min(ys), y_max=max(ys)) + light = illumination or "C0" + spec = ImageSpec( + shape=(1, 3 if rgb else 1, 1, + int(np.ceil((grid["y_max"] - grid["y_min"]) / pixel)) + height, + int(np.ceil((grid["x_max"] - grid["x_min"]) / pixel)) + width), + dtype=str(frame.dtype), pixel_size_um=pixel, + origin_um=(grid["x_min"] - width * pixel / 2, grid["y_min"] - height * pixel / 2, + grid["start"]["z"]), + channel_names=[f"{light}_rgb_{c}" for c in "rgb"] if rgb else [light], + name=name, chunks_yx=(height, width)) + os.makedirs(os.path.dirname(path), exist_ok=True) + return NgffImage.create(path, spec) + + def _write_tile(self, canvas, frame: np.ndarray, x: float, y: float, grid: dict) -> None: + """Put a tile where its stage position says (later tiles cover the overlap).""" + pixel = canvas.spec.pixel_size_um + _, _, _, rows, cols = canvas.spec.shape + x0 = int(round((x - grid["x_min"]) / pixel)) + y0 = int(round((y - grid["y_min"]) / pixel)) + h, w = min(frame.shape[0], rows - y0), min(frame.shape[1], cols - x0) + planes = [frame[..., c] for c in range(3)] if frame.ndim == 3 else [frame] + for c, plane in enumerate(planes): + canvas.write(np.ascontiguousarray(plane[:h, :w]), 0, c, 0, y0, x0) + + # ── finished experiments to mikro, while idle ─────────────────────────── + + def _on_experiment_finished(self, payload: dict) -> None: + """sigExperimentFinished: queue the run's canvases when the setup asks for it.""" + if self._upload_queue is None or not getattr(self._manager.info, "uploadExperiments", + False): + return + name = payload.get("name") or "Experiment" + for path in payload.get("canvases") or []: + if path and os.path.isdir(path): + region = os.path.basename(os.path.normpath(path)).replace(".ome.zarr", "") + if self._upload_queue.add(path, f"{name} {region}"): + self._logger.info(f"Queued for mikro: {path}") + + def _idle_for_upload(self) -> Optional[str]: + """None when an upload may start now, else why not.""" + reasons = busy_reasons(self._master, self._logger) + if reasons: + return ", ".join(reasons) + try: + import psutil + if psutil.cpu_percent(interval=1.0) > UPLOAD_MAX_CPU_PERCENT: + return "CPU busy" + if psutil.virtual_memory().available < UPLOAD_MIN_FREE_MB * 2 ** 20: + return "low memory" + except ImportError: + pass + return None + + def _upload_queued(self, mikro) -> None: + """The uploader's loop, in a worker thread of the agent. Stops when the + agent stops (koil cancels it between canvases).""" + from koil import check_cancelled + + while True: + check_cancelled() + if not self._upload_next(mikro): + self._upload_queue.wait(UPLOAD_POLL_S) + + def _upload_next(self, mikro) -> bool: + """Upload the oldest queued canvas if the microscope is idle. False when + there was nothing to do (empty queue, or busy).""" + import dask + from imswitch.imcontrol.model.io.mikro_upload import read_ngff, stage_space, upload_ngff + + entry = self._upload_queue.next() + if entry is None or self._idle_for_upload() is not None: + return False + started = time.time() + try: + with dask.config.set(scheduler="threads", num_workers=UPLOAD_DASK_WORKERS): + canvas = read_ngff(entry["path"]) + name = entry.get("name") or canvas.name + dataset = upload_ngff(mikro, canvas, name=name, space=stage_space(mikro)) + except Exception as e: # noqa: BLE001 - kept in the queue with its error + self._logger.error(f"Upload of {entry['path']} to mikro failed: {e}") + self._upload_queue.failed(entry, e) + return True + self._upload_queue.done(entry, getattr(dataset, "id", ""), time.time() - started) + self._logger.info(f"Uploaded {entry['path']} to mikro in {time.time() - started:.0f} s") + self._remember_upload(_preview(canvas), name, getattr(dataset, "id", None), + {"x": canvas.origin_um["x"], "y": canvas.origin_um["y"], "z": 0.0}, + canvas.pixel_um["x"]) + return True def _switch_illumination(self, name: Optional[str], intensity: Optional[float]): """Switch *name* on; returns the call that puts it back as it was.""" @@ -845,6 +1023,14 @@ def _planned_actions(self) -> List[dict]: for n, t, m, i, ok in planned if ok] +def _preview(canvas) -> np.ndarray: + """The coarsest level of a canvas as a frame for _thumbnail: (y, x, 3) or (y, x).""" + data = np.asarray(canvas.levels[-1]) + if data.ndim == 2: + return data + return np.moveaxis(data[:3], 0, -1) if data.shape[0] == 3 else data[0] + + def _thumbnail(array: np.ndarray) -> Optional[str]: """A small JPEG data URL of a frame, contrast-stretched (1-99 %).""" try: diff --git a/imswitch/imcontrol/controller/controllers/ExperimentController.py b/imswitch/imcontrol/controller/controllers/ExperimentController.py index 77d330ad0..6b7fb428f 100644 --- a/imswitch/imcontrol/controller/controllers/ExperimentController.py +++ b/imswitch/imcontrol/controller/controllers/ExperimentController.py @@ -318,6 +318,11 @@ def _cleanup(): self._logger.error(f"Post-workflow writer cleanup failed: {err}") self._endTriggeredAcquisition() self._export_step_timings_plot(ctx.dir_path) + finished = getattr(self._commChannel, "sigExperimentFinished", None) + if finished is not None: # e.g. the Arkitekt upload of the canvases + canvases = [url for url in (getattr(w, "get_zarr_url", lambda: None)() + for w in writers) if url] + finished.emit({"name": ctx.exp_name, "dir": ctx.dir_path, "canvases": canvases}) threading.Thread(target=_cleanup, daemon=True, name="TriggeredAcqCleanup").start() # Ashlar is never started automatically; use runAshlarStitching(). diff --git a/imswitch/imcontrol/model/SetupInfo.py b/imswitch/imcontrol/model/SetupInfo.py index 8649be5cb..5f95ba0f8 100644 --- a/imswitch/imcontrol/model/SetupInfo.py +++ b/imswitch/imcontrol/model/SetupInfo.py @@ -723,13 +723,18 @@ class ArkitektInfo: """ Arkitekt server to bind to, e.g. ``http://nas.local`` for a local deployment. Set from the Arkitekt panel when binding. """ + mandateKey: str = "" + """ Unattended login (no browser approval): a mandate key a member issued + on the server for one hub. One key serves one app. It is a credential: + keep it out of setup files that are shared. """ + redeemToken: str = "" - """ Provisioning token for an unattended login (no browser approval). - It is a credential: keep it out of setup files that are shared. """ + """ Unused since arkitekt 16 (the server dropped redeem tokens; use + mandateKey); kept so older setup files load. """ autoConnect: bool = True """ Reconnect at startup when this microscope was bound before (stored - login or redeem token). Never starts a browser login by itself. """ + login or mandate key). Never starts a browser login by itself. """ allowInsecureTransport: bool = False """ Allow the login over plain http to a server that is not localhost @@ -739,6 +744,11 @@ class ArkitektInfo: """ Offer the image actions (acquire frame, tile scan), which store images in the server's mikro service. Turn off for a server without mikro. """ + uploadExperiments: bool = False + """ After an experiment, queue its OME-Zarr canvases (with their pyramid) + for mikro. They are uploaded in the background while bound and while the + microscope is idle; the queue survives restarts. """ + syncInAsync: bool = True """ Unused since the move from arkitekt_next to arkitekt; kept so older setup files load. """ diff --git a/imswitch/imcontrol/model/io/mikro_upload.py b/imswitch/imcontrol/model/io/mikro_upload.py new file mode 100644 index 000000000..e941b173e --- /dev/null +++ b/imswitch/imcontrol/model/io/mikro_upload.py @@ -0,0 +1,212 @@ +"""OME-Zarr canvases into mikro, with the pyramid they already have. + +ImSwitch writes a scan region as one NGFF image (``NgffImage``: TCZYX, level +0 plus 2x stride-decimated levels, built when the scan ends). mikro takes a +dataset's levels when the dataset is created and has no way to add them +later, so the levels on disk go up as they are and nothing is downsampled +again. mikro re-encodes them (zarr v3, its own chunks and shards); dask +streams them chunk by chunk, so a canvas larger than RAM is fine. + +Placement: each canvas is registered in one persistent stage space (µm, +get-or-create by ``STAGE_SPACE``), at its top-left corner and with its pixel +size, so every scan of this microscope lands in the same space. + +``UploadQueue`` keeps the canvases still to upload in a JSON file, so they are +uploaded after a restart or a lost network too. + +Needs ``mikro`` (and dask, zarr); the import happens on use. +""" +import datetime +import json +import os +import threading +from dataclasses import dataclass, field +from pathlib import Path +from typing import Any, Dict, List, Optional, Sequence + +MAX_ATTEMPTS = 3 # then the canvas is set aside as failed (the panel shows why) +KEEP_RECORDS = 200 # uploaded and failed entries remembered + +STAGE_SPACE = "stage" # per app: this microscope's stage, every run +# mikro-server shows a 3-channel dataset as one RGB layer only when its channels +# are labelled red/green/blue (core/logic/channels.py); ImSwitch's writer names +# them "_rgb_r" and so on. +RGB_LABELS = {"r": "red", "g": "green", "b": "blue", + "red": "red", "green": "green", "blue": "blue"} + + +def _rgb_component(name: str) -> Optional[str]: + low = name.lower() + for key, label in (("rgb_r", "red"), ("rgb_g", "green"), ("rgb_b", "blue")): + if low == key or low.endswith("_" + key): + return label + return RGB_LABELS.get(low) + + +@dataclass +class NgffCanvas: + """One NGFF image on disk, opened lazily and squeezed to what mikro wants.""" + path: Path + name: str + levels: List[Any] # dask arrays, axes as in ``dims`` + dims: List[str] # e.g. ["c", "y", "x"]: singleton t and z dropped + pixel_um: Dict[str, float] # {"y": .., "x": ..} + origin_um: Dict[str, float] # top-left corner, {"y": .., "x": ..} + labels: List[str] = field(default_factory=list) # per channel + + @property + def nbytes(self) -> int: + return int(self.levels[0].nbytes) + + +def channel_labels(names: Sequence[str]) -> List[str]: + """Channel names as mikro should see them: an RGB triple as red/green/blue.""" + names = [str(n) for n in names] + rgb = [_rgb_component(n) for n in names] + if len(names) == 3 and sorted(filter(None, rgb)) == ["blue", "green", "red"]: + return rgb + return names + + +def read_ngff(path) -> NgffCanvas: + """Open the NGFF image group at *path* (NGFF 0.4 or 0.5) without reading pixels.""" + import dask.array as da + import zarr + + path = Path(path) + group = zarr.open_group(str(path), mode="r") + attrs = dict(group.attrs) + attrs = attrs.get("ome", attrs) # 0.5 nests its metadata under "ome" + multiscales = attrs["multiscales"][0] + axes = [a["name"] for a in multiscales["axes"]] + levels = [da.from_zarr(group[d["path"]]) for d in multiscales["datasets"]] + base = levels[0].shape + keep = [i for i, a in enumerate(axes) if not (a in ("t", "z") and base[i] == 1)] + index = tuple(slice(None) if i in keep else 0 for i in range(len(axes))) + transforms = {t["type"]: t for t in multiscales["datasets"][0]["coordinateTransformations"]} + scale = transforms["scale"]["scale"] + translation = transforms.get("translation", {}).get("translation", [0.0] * len(axes)) + names = [ch.get("label") or f"C{i}" + for i, ch in enumerate(attrs.get("omero", {}).get("channels", []))] + return NgffCanvas(path=path, name=multiscales.get("name") or path.name, + levels=[level[index] for level in levels], dims=[axes[i] for i in keep], + pixel_um={a: float(scale[axes.index(a)]) for a in ("y", "x")}, + origin_um={a: float(translation[axes.index(a)]) for a in ("y", "x")}, + labels=channel_labels(names)) + + +def stage_space(mikro, name: str = "Stage"): + """This microscope's stage as a µm space in mikro: created once, then reused.""" + from kanne.scalars import Unit + from mikro import space_2d + return space_2d(mikro, name, unit=Unit("micrometer"), reference=STAGE_SPACE) + + +def channel_anchors(array, dims: Sequence[str], labels: Sequence[str]) -> list: + """Per-channel contrast (a value histogram) and name. *array* should be + small: the coarsest level is enough for a display window.""" + from mikro.api.schema import CoordinateAnchorInput, LabelInput + + if "c" not in dims: + return [] + anchors = CoordinateAnchorInput.histogram_anchors(array, axis="c", dims=list(dims)) + return [a.model_copy(update={"label": LabelInput(label=labels[i])}) if i < len(labels) else a + for i, a in enumerate(anchors)] + + +def upload_ngff(mikro, canvas: NgffCanvas, *, name: Optional[str] = None, space=None): + """Create a mikro dataset from *canvas*: level 0 as data, the coarser levels + as its scales (recorded as NEAREST: NgffImage decimates by stride), the + channels named and contrast-anchored. Registered in *space* at the canvas' + top-left corner when given. Returns the dataset.""" + from mikro.api.schema import ScaleInput, ScaleMethod + from mikro.scalars import ArrayLike + + dims, levels = canvas.dims, canvas.levels + dataset = mikro.create_array_dataset( + data=ArrayLike(levels[0], dims=dims), name=name or canvas.name, axes=dims, + scales=[ScaleInput(level=i, array=ArrayLike(level, dims=dims), + scale_method=ScaleMethod.NEAREST) + for i, level in enumerate(levels) if i > 0], + anchors=channel_anchors(levels[-1].compute(), dims, canvas.labels)) + if space is not None: + space.register(dataset, scale=canvas.pixel_um, **canvas.origin_um) + return dataset + + +def _now() -> str: + return datetime.datetime.now().isoformat(timespec="seconds") + + +class UploadQueue: + """Canvases waiting for mikro, oldest first, persisted in *path* (JSON). + + {"pending": [{path, name, queuedAt, attempts, error}], + "uploaded": [{path, name, datasetId, seconds, uploadedAt}], + "failed": [...]}. Thread-safe; wait() wakes on add().""" + + def __init__(self, path): + self.path = Path(path) + self._changed = threading.Condition() + self._state = {"pending": [], "uploaded": [], "failed": []} + try: + self._state.update(json.loads(self.path.read_text())) + except (OSError, ValueError): + pass + + def add(self, canvas_path, name: Optional[str] = None) -> bool: + """Queue a canvas; False when it is queued or uploaded already.""" + canvas_path = str(canvas_path) + with self._changed: + if any(e["path"] == canvas_path for e in self._state["pending"] + self._state["uploaded"]): + return False + self._state["pending"].append({"path": canvas_path, "name": name, "queuedAt": _now(), + "attempts": 0, "error": None}) + self._save() + self._changed.notify_all() + return True + + def next(self) -> Optional[dict]: + with self._changed: + return dict(self._state["pending"][0]) if self._state["pending"] else None + + def wait(self, timeout: float) -> None: + with self._changed: + self._changed.wait(timeout) + + def done(self, entry: dict, dataset_id, seconds: float) -> None: + self._finish(entry, "uploaded", datasetId=str(dataset_id), seconds=round(seconds, 1), + uploadedAt=_now(), error=None) + + def failed(self, entry: dict, error: BaseException) -> None: + """Count a failed attempt; after MAX_ATTEMPTS the canvas is set aside.""" + message = f"{type(error).__name__}: {error}"[:300] + with self._changed: + for pending in self._state["pending"]: + if pending["path"] == entry["path"]: + pending["attempts"] += 1 + pending["error"] = message + if pending["attempts"] < MAX_ATTEMPTS: + self._state["pending"].append(self._state["pending"].pop( + self._state["pending"].index(pending))) # let the others go first + self._save() + return + self._finish(entry, "failed", error=message, failedAt=_now()) + + def snapshot(self) -> dict: + with self._changed: + return json.loads(json.dumps(self._state)) + + def _finish(self, entry: dict, bucket: str, **fields) -> None: + with self._changed: + pending = [e for e in self._state["pending"] if e["path"] == entry["path"]] + self._state["pending"] = [e for e in self._state["pending"] if e["path"] != entry["path"]] + record = {**(pending[0] if pending else entry), **fields} + self._state[bucket] = (self._state[bucket] + [record])[-KEEP_RECORDS:] + self._save() + + def _save(self) -> None: + self.path.parent.mkdir(parents=True, exist_ok=True) + temporary = self.path.with_suffix(".tmp") + temporary.write_text(json.dumps(self._state, indent=1)) + os.replace(temporary, self.path) diff --git a/imswitch/imcontrol/model/managers/ArkitektManager.py b/imswitch/imcontrol/model/managers/ArkitektManager.py index 8a8a8585b..d722dd3b3 100644 --- a/imswitch/imcontrol/model/managers/ArkitektManager.py +++ b/imswitch/imcontrol/model/managers/ArkitektManager.py @@ -3,9 +3,10 @@ It owns the connection only. What the microscope offers is declared by ArkitektController, which hands in an app factory. Binding uses the device-code login. bind() starts it on a background thread, and the code and its approval -link appear in status(). Someone approves it in a browser, then the agent -starts providing. unbind() stops the agent and forgets the stored login on this -machine. +link appear in status(). Someone approves it in a browser and picks the hub +(the services, e.g. one on this machine), then the agent starts providing. A +mandate key, issued for one hub on the server, logs in without a browser. +unbind() stops the agent and forgets the stored login on this machine. The connection runs in its own thread, on its own asyncio loop. Sync actions still reach it through koil (rekuest runs them via koil.run_threaded), and a @@ -30,9 +31,9 @@ REQUIRED_PACKAGES = ("arkitekt", "rekuest") DEFAULT_URL = "https://go.arkitekt.live" -# fakts refuses to send credentials over plain http to anything but localhost -# unless this is set (a NAS without TLS). -INSECURE_TRANSPORT_ENV = "FAKTS_ALLOW_INSECURE_TRANSPORT" +# A device code lives about five minutes; a manual bind asks for a fresh one this +# many times (about half an hour) before it gives up. +LOGIN_CODE_RENEWALS = 6 # Retry an automatic reconnect (stored login, no prompt) after this long, e.g. # when the server on the NAS is not up yet at boot. RECONNECT_DELAY_S = 30.0 @@ -71,12 +72,30 @@ class StoredLoginInvalid(RuntimeError): expired or was revoked. Asking again unattended would only pile up codes.""" +def _caused_by(e: BaseException, kind: str) -> bool: + """Whether *e*, or what it was raised from, is a *kind* (a class name).""" + seen = set() + while e is not None and id(e) not in seen: + if type(e).__name__ == kind: + return True + seen.add(id(e)) + e = e.__cause__ or e.__context__ + return False + + +def _is_reauth(e: BaseException) -> bool: + """fakts' NeedsReauthenticationError: the stored session or the mandate key + was revoked or refused, and no code is asked for by itself.""" + return _caused_by(e, "NeedsReauthenticationError") + + def cache_file(identifier: str, version: str, url: str) -> str: """Where fakts keeps an app's session (a rotating refresh token): one file - per app identifier, version and server, as arkitekt.app.fakts._cache_path - names it. Written out so that status() need not import arkitekt.""" + per app identifier, version and server, as arkitekt.app.sessions.session_path + names it (the url without a trailing slash). Written out so that status() + need not import arkitekt.""" from platformdirs import user_state_dir - key = hashlib.sha256(url.encode()).hexdigest()[:6] + key = hashlib.sha256(url.strip().rstrip("/").encode()).hexdigest()[:6] return os.path.join(user_state_dir(*ARKITEKT_DIRS), "cache", f"{identifier}-{version}-{key}_fakts_cache.json") @@ -92,6 +111,9 @@ def _friendly_error(e: BaseException, url: str) -> str: return "The login code expired before it was approved. Bind again for a new code." if isinstance(e, StoredLoginInvalid): return text + if _is_reauth(e): + return ("The stored login or the mandate key was revoked or has expired on the server. " + "Bind again to approve this microscope.") if kind == "UserDeniedError": return "The login was declined in the browser." if "discover" in text.lower() or kind in ("ClientConnectorError", "DiscoveryError"): @@ -160,7 +182,8 @@ def status(self) -> dict: "autoConnect": bool(self.info.autoConnect), "allowInsecureTransport": bool(self.info.allowInsecureTransport), "useMikro": bool(self.info.useMikro), - "hasRedeemToken": bool(self.info.redeemToken), + "uploadExperiments": bool(getattr(self.info, "uploadExperiments", False)), + "hasMandateKey": bool(getattr(self.info, "mandateKey", "")), "hasStoredLogin": self.has_stored_login(), "insecureUrl": _is_insecure(url), "services": list(self._services)} @@ -171,11 +194,11 @@ def has_stored_login(self) -> bool: # ── binding ───────────────────────────────────────────────────────────── - def bind(self, url: Optional[str] = None, redeem_token: Optional[str] = None, + def bind(self, url: Optional[str] = None, mandate_key: Optional[str] = None, automatic: bool = False) -> dict: """Connect in the background: discovery, login, then provide. - Without a stored login or redeem token this is the device-code login: + Without a stored login or mandate key this is the device-code login: status() turns to "awaiting_login" with userCode and approveUrl for someone to approve in a browser. Returns status() at once. *automatic* (startup) retries a failed connect every RECONNECT_DELAY_S instead of @@ -192,14 +215,12 @@ def bind(self, url: Optional[str] = None, redeem_token: Optional[str] = None, self._cancel_retry() self._stop_requested = self._forget = False self._automatic = automatic - if self.info.allowInsecureTransport and _is_insecure(self.url): - os.environ[INSECURE_TRANSPORT_ENV] = "1" self._session = {} self._set(state=CONNECTING, message=f"Connecting to {self.url}…", connectingSince=_now()) + key = mandate_key or getattr(self.info, "mandateKey", "") or None self._thread = threading.Thread( - target=self._run, args=(self.url, redeem_token or self.info.redeemToken or None, - automatic), + target=self._run, args=(self.url, key, automatic), name="ArkitektConnection", daemon=True) self._thread.start() return {**self.status(), "status": "started"} @@ -209,7 +230,7 @@ def auto_connect(self) -> None: Never starts a browser login by itself.""" if self._refusal() or not self.info.autoConnect: return - if self.has_stored_login() or self.info.redeemToken: + if self.has_stored_login() or getattr(self.info, "mandateKey", ""): self.__logger.info(f"Reconnecting to Arkitekt at {self.url} (stored login)") self.bind(automatic=True) @@ -220,8 +241,8 @@ def cancel(self) -> dict: def unbind(self) -> dict: """Disconnect and forget the stored login on this machine, so the next - bind asks for approval again. fakts has no revocation endpoint: the - app's client stays registered on the server until removed there.""" + bind asks for approval again. While connected, the session is also + revoked on the server (fakts 6); otherwise only the local copy goes.""" self._stop(forget=True) removed = self._delete_stored_login() state = self._session.get("state") if self._refusal() else UNBOUND @@ -269,17 +290,17 @@ def _cancel_retry(self) -> None: self._retry.cancel() self._retry = None - def _run(self, url: str, redeem_token: Optional[str], automatic: bool) -> None: + def _run(self, url: str, mandate_key: Optional[str], automatic: bool) -> None: try: - asyncio.run(self._amain(url, redeem_token)) + asyncio.run(self._amain(url, mandate_key)) except asyncio.CancelledError: pass except BaseException as e: # noqa: BLE001 - surfaced in the panel self.__logger.error(f"Arkitekt connection to {url} failed: {e!r}") self._set(state=ERROR, message=_friendly_error(e, url), userCode=None, approveUrl=None) - retry = not isinstance(e, StoredLoginInvalid) and type(e).__name__ not in ( - "InsecureTransportError", "UserDeniedError") + retry = not isinstance(e, StoredLoginInvalid) and not _is_reauth(e) and \ + type(e).__name__ not in ("InsecureTransportError", "UserDeniedError") if automatic and retry and not self._stop_requested: with self._lock: self._retry = threading.Timer(RECONNECT_DELAY_S, self.bind, @@ -296,15 +317,43 @@ def _run(self, url: str, redeem_token: Optional[str], automatic: bool) -> None: self._set(state=UNBOUND, message="Disconnected.", boundSince=None, userCode=None, approveUrl=None) - async def _amain(self, url: str, redeem_token: Optional[str]) -> None: - from arkitekt import connect - + async def _amain(self, url: str, mandate_key: Optional[str]) -> None: with self._lock: self._loop, self._task = asyncio.get_running_loop(), asyncio.current_task() app = self._factory(self.identifier, self._version) self._services = list(app.services) - runtime = connect(app, provide=True, url=url, redeem_token=redeem_token, - headless=True, device_code_hook=self._on_device_code, force=True) + reauth, renewals = False, 0 + while True: + try: + await self._provide(app, url, mandate_key, reauth=reauth) + break + except Exception as e: # noqa: BLE001 + # Only a person binding by hand gets a new code: at startup a + # prompt is StoredLoginInvalid's case instead. + if self._automatic or mandate_key or self._stop_requested: + raise + if _is_reauth(e) and not reauth: + self.__logger.info("Arkitekt: the stored login was revoked; asking anew") + reauth = True + elif _caused_by(e, "DeviceCodeExpiredError") and renewals < LOGIN_CODE_RENEWALS: + renewals += 1 + self.__logger.info("Arkitekt: the login code expired; asking for a fresh one") + else: + raise + # arun() only returns when the agent stopped on its own + if not self._stop_requested: + self._set(state=ERROR, message="The Arkitekt agent stopped.", boundSince=None) + + async def _provide(self, app, url: str, mandate_key: Optional[str], reauth: bool) -> None: + from arkitekt import connect + + login: Dict[str, Any] = {"mandate_key": mandate_key} if mandate_key else {} + if reauth: + login["reauth"] = True + if self.info.allowInsecureTransport and _is_insecure(url): + login["allow_insecure_transport"] = True + runtime = connect(app, provide=True, url=url, headless=True, + device_code_hook=self._on_device_code, force=True, **login) async with runtime: # discovery, login, service clients, agent registration manifest = runtime.snapshot.manifest if runtime.snapshot else None self._set(state=CONNECTED, message=None, userCode=None, approveUrl=None, @@ -318,29 +367,17 @@ async def _amain(self, url: str, redeem_token: Optional[str]) -> None: await runtime.fakts.alogout() except Exception as e: # noqa: BLE001 - the file is removed anyway self.__logger.warning(f"Arkitekt logout failed: {e}") - # arun() only returns when the agent stopped on its own - if not self._stop_requested: - self._set(state=ERROR, message="The Arkitekt agent stopped.", boundSince=None) - - async def _on_device_code(self, *args: Any) -> None: - """fakts' device-code hook: show the code instead of opening a browser - on the microscope's own computer. - fakts 5.4+ (arkitekt 6) hands over one DeviceCodeChallenge; earlier - releases called ``hook(endpoint, code)``. Both are accepted, because - pyproject allows ``arkitekt>=5.0.1`` and a fresh install gets the new one. - """ + async def _on_device_code(self, challenge: Any) -> None: + """fakts' device-code hook, called with a DeviceCodeChallenge: show the + code instead of opening a browser on the microscope's own computer. + Codes live about five minutes on go.arkitekt.live.""" if self._automatic: raise StoredLoginInvalid( "The stored login is no longer valid (expired or revoked on the server). " "Bind again to approve this microscope.") - if len(args) == 1: - challenge = args[0] - endpoint, code = challenge.endpoint, challenge.user_code - approve = getattr(challenge, "verification_uri_complete", None) - else: - endpoint, code = args - approve = None + endpoint, code = challenge.endpoint, challenge.user_code + approve = getattr(challenge, "verification_uri_complete", None) if not approve: configure = getattr(endpoint, "configure", None) approve = configure.replace("{code}", code) if configure else endpoint.base_url diff --git a/pyproject.toml b/pyproject.toml index d7861cb92..4ba077269 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -67,22 +67,25 @@ dependencies = [ "ome-types>=0.5", "jsonschema>=4.0", "aiohttp>=3.9.4", - # arkitekt releases near-daily with sub-dep bounds that do not hold (5.0.1 - # breaks on arkitekt-spec 3.19), so the family is pinned to the tested set. - "arkitekt[rekuest,mikro]==5.0.1", - "arkitekt-spec==3.0.0", - "arkitekt-runtime==4.1.1", - "rekuest==7.1.0", - "mikro==6.2.1", - "fakts==5.2.0", - "koil>=2.0.5", + # arkitekt releases near-daily with sub-dep bounds that do not hold, and its + # majors move together (arkitekt-runtime 10 speaks the agent protocol of + # rekuest-server 19, mikro 14 the API of mikro-server 15), so the family is + # pinned to the set tested against such a hub (docs/arkitekt-hub-pi.md). + "arkitekt[rekuest,mikro]==16.0.1", + "arkitekt-spec==10.1.0", + "arkitekt-runtime==10.0.0", + "rekuest==15.0.0", + "mikro[xarray]==14.0.0", + "fakts[crypto]==6.3.0", + "koil==3.3.7", + "kanne==2.6.0", + "rath==4.1.3", "msgpack>=1.0.4", "esptool", "av==13.1.0", "uc2-rest>=0.2.0.43", # named stepper ids (axes beyond XYZA) "unitelabs-sila", "unitelabs-cdk", - "mikro-next>=1", "pip>=26.1", # Exactly ONE OpenCV wheel: all variants install into the same cv2/ folder and # overwrite each other. contrib-headless is the superset without Qt/GUI. diff --git a/scripts/arkitekt_canvas_bench.py b/scripts/arkitekt_canvas_bench.py new file mode 100644 index 000000000..fe9abe6c6 --- /dev/null +++ b/scripts/arkitekt_canvas_bench.py @@ -0,0 +1,124 @@ +#!/usr/bin/env python3 +"""Benchmark: a scan canvas (OME-Zarr, with its pyramid) into mikro on an Arkitekt hub. + + python scripts/arkitekt_canvas_bench.py make 10 10 --out /home/pi/Datasets/arkitekt-bench + python scripts/arkitekt_canvas_bench.py upload --hub 111 + +``make`` writes a synthetic RGB scan of FRAME ID10 camera tiles (3072 x 2048) tile +by tile with ImSwitch's NgffImage, then builds its pyramid, as the ExperimentController +does. ``upload`` logs in at the coordination server (device code; cached after the first +approval, a fresh code whenever one expires) and uploads the canvas with +imswitch.imcontrol.model.io.mikro_upload, as ImSwitch does. Each prints one JSON line: +timings and peak memory. See docs/arkitekt-hub-pi.md for the figures. +""" +import argparse +import json +import resource +import sys +import time +from pathlib import Path + +import numpy as np + +TILE_H, TILE_W = 2048, 3072 + + +def peak_rss_mb() -> int: + return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss // 1024 + + +def synthetic_tile(rng, c: int, ix: int, iy: int) -> np.ndarray: + """A 12-bit tile: background, noise, a few hundred 'cells', a bright border.""" + tile = (300 + 40 * c + 60 * ((ix + iy) % 3)) * np.ones((TILE_H, TILE_W), np.float32) + tile += rng.normal(0, 25, size=(TILE_H, TILE_W)).astype(np.float32) + for _ in range(300): + cy, cx, r = rng.integers(20, TILE_H - 20), rng.integers(20, TILE_W - 20), rng.integers(4, 18) + y = np.arange(cy - r, cy + r + 1)[:, None] + x = np.arange(cx - r, cx + r + 1)[None, :] + tile[cy - r:cy + r + 1, cx - r:cx + r + 1][(y - cy) ** 2 + (x - cx) ** 2 <= r * r] += \ + rng.uniform(500, 3000) + tile[:16, :] = tile[-16:, :] = tile[:, :16] = tile[:, -16:] = 4000 # shows the placement + return np.clip(tile, 0, 4095).astype(np.uint16) + + +def make(args) -> dict: + from imswitch.imcontrol.model.aufgaben.storage import ImageSpec, NgffImage + nx, ny = args.nx, args.ny + path = args.out / f"canvas_{nx}x{ny}_{args.channels}c_{time.strftime('%H%M%S')}.ome.zarr" + path.parent.mkdir(parents=True, exist_ok=True) + names = ["LED_rgb_r", "LED_rgb_g", "LED_rgb_b"] if args.channels == 3 else \ + [f"C{i}" for i in range(args.channels)] + spec = ImageSpec(shape=(1, args.channels, 1, ny * TILE_H, nx * TILE_W), dtype="uint16", + pixel_size_um=args.pixel_um, origin_um=(*args.origin_um, 0.0), + channel_names=names, name=path.name, chunks_yx=(TILE_H, TILE_W), + bit_depth=12) + image = NgffImage.create(path, spec) + rng = np.random.default_rng(0) + started = time.time() + for iy in range(ny): + for ix in range(nx): + for c in range(args.channels): + image.write(synthetic_tile(rng, c, ix, iy), 0, c, 0, iy * TILE_H, ix * TILE_W) + written = time.time() + image.finalize() + return {"canvas": str(path), "tiles": nx * ny, "write_s": round(written - started, 1), + "pyramid_s": round(time.time() - written, 1), "levels": image.levels} + + +def upload(args) -> dict: + import dask + from arkitekt import App, connect + from mikro import Mikro, mikro_service + from imswitch.imcontrol.model.io.mikro_upload import read_ngff, stage_space, upload_ngff + + canvas = read_ngff(args.canvas) + result = {"shape": list(canvas.levels[0].shape), "raw_gb": round(canvas.nbytes / 1e9, 2), + "levels": len(canvas.levels), "workers": args.workers} + + async def show_code(challenge): + link = challenge.verification_uri_complete or challenge.endpoint + if args.hub: + link += ("&" if "?" in link else "?") + f"hub={args.hub}" + print(f"APPROVE {link} (code {challenge.user_code}, {challenge.expires_in} s)", flush=True) + + app = App("imswitch-ingest-test", "0.1.0", description="ImSwitch canvas upload benchmark", + services=[mikro_service]) + for attempt in range(12): # a fresh code whenever one expires unapproved + try: + started = time.time() + with connect(app, url=args.url, headless=True, device_code_hook=show_code) as rt: + result["login_s"] = round(time.time() - started, 1) + mikro = rt.require(Mikro) + started = time.time() + with dask.config.set(scheduler="threads", num_workers=args.workers): + dataset = upload_ngff(mikro, canvas, space=stage_space(mikro)) + result.update(upload_s=round(time.time() - started, 1), dataset=str(dataset.id)) + return result + except Exception as e: # noqa: BLE001 + if type(e).__name__ != "DeviceCodeExpiredError" or attempt == 11: + raise + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + sub = parser.add_subparsers(dest="command", required=True) + m = sub.add_parser("make", help="write a synthetic scan canvas and its pyramid") + m.add_argument("nx", type=int) + m.add_argument("ny", type=int) + m.add_argument("--channels", type=int, default=3) + m.add_argument("--pixel-um", type=float, default=0.5) + m.add_argument("--origin-um", nargs=2, type=float, default=(1000.0, 2000.0)) + m.add_argument("--out", type=Path, default=Path("/home/pi/Datasets/arkitekt-bench")) + u = sub.add_parser("upload", help="upload a canvas to mikro") + u.add_argument("canvas", type=Path) + u.add_argument("--url", default="https://go.arkitekt.live") + u.add_argument("--hub", default="", help="hub id to preselect on the approval page") + u.add_argument("--workers", type=int, default=2) + args = parser.parse_args() + result = make(args) if args.command == "make" else upload(args) + print("RESULT " + json.dumps({**result, "peak_rss_mb": peak_rss_mb()}), flush=True) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/uv.lock b/uv.lock index cfa258c49..24cb1bf67 100644 --- a/uv.lock +++ b/uv.lock @@ -1,10 +1,13 @@ version = 1 -revision = 3 +revision = 5 requires-python = ">=3.11" resolution-markers = [ - "python_full_version == '3.13.*'", - "python_full_version == '3.12.*'", - "python_full_version < '3.12'", + "(python_full_version == '3.13.*' and platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version == '3.13.*' and platform_machine == 'x86_64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version == '3.13.*' and platform_machine == 'AMD64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version == '3.13.*' and platform_machine == 'ARM64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version == '3.13.*' and platform_python_implementation == 'CPython' and sys_platform == 'darwin')", + "(python_full_version == '3.13.*' and platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux') or (python_full_version == '3.13.*' and platform_machine != 'AMD64' and platform_machine != 'ARM64' and sys_platform == 'win32') or (python_full_version == '3.13.*' and platform_python_implementation != 'CPython') or (python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')", + "(python_full_version == '3.12.*' and platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version == '3.12.*' and platform_machine == 'x86_64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version == '3.12.*' and platform_machine == 'AMD64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version == '3.12.*' and platform_machine == 'ARM64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version == '3.12.*' and platform_python_implementation == 'CPython' and sys_platform == 'darwin')", + "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux') or (python_full_version == '3.12.*' and platform_machine != 'AMD64' and platform_machine != 'ARM64' and sys_platform == 'win32') or (python_full_version == '3.12.*' and platform_python_implementation != 'CPython') or (python_full_version == '3.12.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')", + "(python_full_version < '3.12' and platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version < '3.12' and platform_machine == 'x86_64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version < '3.12' and platform_machine == 'AMD64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version < '3.12' and platform_machine == 'ARM64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version < '3.12' and platform_python_implementation == 'CPython' and sys_platform == 'darwin')", + "(python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux') or (python_full_version < '3.12' and platform_machine != 'AMD64' and platform_machine != 'ARM64' and sys_platform == 'win32') or (python_full_version < '3.12' and platform_python_implementation != 'CPython') or (python_full_version < '3.12' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')", ] supported-markers = [ "python_full_version < '3.14'", @@ -31,13 +34,13 @@ name = "aiohttp" version = "3.12.15" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "aiohappyeyeballs", marker = "python_full_version < '3.14'" }, - { name = "aiosignal", marker = "python_full_version < '3.14'" }, - { name = "attrs", marker = "python_full_version < '3.14'" }, - { name = "frozenlist", marker = "python_full_version < '3.14'" }, - { name = "multidict", marker = "python_full_version < '3.14'" }, - { name = "propcache", marker = "python_full_version < '3.14'" }, - { name = "yarl", marker = "python_full_version < '3.14'" }, + { name = "aiohappyeyeballs" }, + { name = "aiosignal" }, + { name = "attrs" }, + { name = "frozenlist" }, + { name = "multidict" }, + { name = "propcache" }, + { name = "yarl" }, ] sdist = { url = "https://files.pythonhosted.org/packages/9b/e7/d92a237d8802ca88483906c388f7c201bbe96cd80a165ffd0ac2f6a8d59f/aiohttp-3.12.15.tar.gz", hash = "sha256:4fc61385e9c98d72fcdf47e6dd81833f47b2f77c114c29cd64a361be57a763a2", size = 7823716, upload-time = "2025-07-29T05:52:32.215Z" } wheels = [ @@ -99,8 +102,8 @@ name = "aioice" version = "0.10.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "dnspython", marker = "python_full_version < '3.14'" }, - { name = "ifaddr", marker = "python_full_version < '3.14'" }, + { name = "dnspython" }, + { name = "ifaddr" }, ] sdist = { url = "https://files.pythonhosted.org/packages/95/a2/45dfab1d5a7f96c48595a5770379acf406cdf02a2cd1ac1729b599322b08/aioice-0.10.1.tar.gz", hash = "sha256:5c8e1422103448d171925c678fb39795e5fe13d79108bebb00aa75a899c2094a", size = 44304, upload-time = "2025-04-13T08:15:25.629Z" } wheels = [ @@ -112,14 +115,14 @@ name = "aiortc" version = "1.10.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "aioice", marker = "python_full_version < '3.14'" }, - { name = "av", marker = "python_full_version < '3.14'" }, - { name = "cffi", marker = "python_full_version < '3.14'" }, - { name = "cryptography", marker = "python_full_version < '3.14'" }, - { name = "google-crc32c", marker = "python_full_version < '3.14'" }, - { name = "pyee", marker = "python_full_version < '3.14'" }, - { name = "pylibsrtp", marker = "python_full_version < '3.14'" }, - { name = "pyopenssl", marker = "python_full_version < '3.14'" }, + { name = "aioice" }, + { name = "av" }, + { name = "cffi" }, + { name = "cryptography" }, + { name = "google-crc32c" }, + { name = "pyee" }, + { name = "pylibsrtp" }, + { name = "pyopenssl" }, ] sdist = { url = "https://files.pythonhosted.org/packages/8a/f8/408e092748521889c9d33dddcef920afd9891cf6db4615ba6b6bfe114ff8/aiortc-1.10.1.tar.gz", hash = "sha256:64926ad86bde20c1a4dacb7c3a164e57b522606b70febe261fada4acf79641b5", size = 1179406, upload-time = "2025-02-02T17:36:38.684Z" } wheels = [ @@ -137,8 +140,8 @@ name = "aiosignal" version = "1.4.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "frozenlist", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.13'" }, + { name = "frozenlist" }, + { name = "typing-extensions", marker = "python_full_version != '3.13.*'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" } wheels = [ @@ -177,9 +180,9 @@ name = "anyio" version = "4.11.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "idna", marker = "python_full_version < '3.14'" }, - { name = "sniffio", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.13'" }, + { name = "idna" }, + { name = "sniffio" }, + { name = "typing-extensions", marker = "python_full_version != '3.13.*'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/c6/78/7d432127c41b50bccba979505f272c16cbcadcc33645d5fa3a738110ae75/anyio-4.11.0.tar.gz", hash = "sha256:82a8d0b81e318cc5ce71a5f1f8b5c4e63619620b63141ef8c995fa0db95a57c4", size = 219094, upload-time = "2025-09-23T09:19:12.58Z" } wheels = [ @@ -209,7 +212,7 @@ name = "argon2-cffi" version = "25.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "argon2-cffi-bindings", marker = "python_full_version < '3.14'" }, + { name = "argon2-cffi-bindings" }, ] sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" } wheels = [ @@ -221,7 +224,7 @@ name = "argon2-cffi-bindings" version = "25.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cffi", marker = "python_full_version < '3.14'" }, + { name = "cffi" }, ] sdist = { url = "https://files.pythonhosted.org/packages/5c/2d/db8af0df73c1cf454f71b2bbe5e356b8c1f8041c979f505b3d3186e520a9/argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d", size = 1783441, upload-time = "2025-07-30T10:02:05.147Z" } wheels = [ @@ -249,66 +252,85 @@ wheels = [ [[package]] name = "arkitekt" -version = "5.0.1" +version = "16.0.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "aiohttp", marker = "python_full_version < '3.14'" }, - { name = "arkitekt-spec", marker = "python_full_version < '3.14'" }, - { name = "click", marker = "python_full_version < '3.14'" }, - { name = "fakts", marker = "python_full_version < '3.14'" }, - { name = "koil", marker = "python_full_version < '3.14'" }, - { name = "platformdirs", marker = "python_full_version < '3.14'" }, - { name = "py-machineid", marker = "python_full_version < '3.14'" }, - { name = "pyyaml", marker = "python_full_version < '3.14'" }, - { name = "rath", marker = "python_full_version < '3.14'" }, - { name = "semver", marker = "python_full_version < '3.14'" }, - { name = "turms", marker = "python_full_version < '3.14'" }, - { name = "typer", marker = "python_full_version < '3.14'" }, - { name = "watchfiles", marker = "python_full_version < '3.14'" }, + { name = "aiohttp" }, + { name = "arkitekt-spec" }, + { name = "click" }, + { name = "fakts", extra = ["crypto"] }, + { name = "fakts", extra = ["mesh"], marker = "(platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (platform_machine == 'x86_64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (platform_machine == 'AMD64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (platform_machine == 'ARM64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (platform_python_implementation == 'CPython' and sys_platform == 'darwin')" }, + { name = "koil" }, + { name = "platformdirs" }, + { name = "py-machineid" }, + { name = "pyyaml" }, + { name = "rath" }, + { name = "segno" }, + { name = "semver" }, + { name = "typer" }, + { name = "typing-extensions" }, + { name = "watchfiles" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/86/38/6e2e6586b8edc6e79b239062d4a3d2082f1a4d7bfcdc7bb3ee4b9139d725/arkitekt-5.0.1.tar.gz", hash = "sha256:3f2e23dc8bbcb1844037353845da35080a808a3a48a1efad4be27ff0af5a4db0", size = 527032, upload-time = "2026-09-29T23:32:15.507Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e1/a6/4793d9c731d059e9a511c34e34b4b1ec0489ae3f280424a0fc8b5a1542bf/arkitekt-16.0.1.tar.gz", hash = "sha256:6379b577108c537e25e64b28316a7c88b9655d2ca8225188271f686fc867a668", size = 220679, upload-time = "2026-11-14T23:12:25.68Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/15/e0/e82094e694f1d5bd5ce00b3b84d62aecf5a85cb00deb497c5317d152649f/arkitekt-5.0.1-py3-none-any.whl", hash = "sha256:3dcb302115d6cef40b7817de98d2ed475c34a43b824d56fb303fe32716d2dc12", size = 565234, upload-time = "2026-09-29T23:32:13.814Z" }, + { url = "https://files.pythonhosted.org/packages/1b/dd/c220b121d16dc2f7bd84e31e5571d614e441f0ebd5306df012e8c6e575c3/arkitekt-16.0.1-py3-none-any.whl", hash = "sha256:aedeff174922f384ac24e3b0783f6fdad63a7b3e90d4e5578279eb885f92cf4e", size = 271482, upload-time = "2026-11-14T23:12:24.134Z" }, ] [package.optional-dependencies] mikro = [ - { name = "mikro", marker = "python_full_version < '3.14'" }, + { name = "mikro" }, ] rekuest = [ - { name = "rekuest", marker = "python_full_version < '3.14'" }, + { name = "arkitekt-runtime" }, + { name = "rekuest" }, +] + +[[package]] +name = "arkitekt-mesh" +version = "0.12.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/d6/2040520e973861b895e85ad85b5df17e02a27b341560f46e567d4502781c/arkitekt_mesh-0.12.2.tar.gz", hash = "sha256:b144728a422e062bde9f074a9437a7fb0821e39273f578867c0a4bbf68a3d734", size = 613673, upload-time = "2026-11-06T10:05:10.347Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/91/d0/1871d3bb034f71b346425103e9d13a4b25cf3e1fa2c74a230e5b0365c3a7/arkitekt_mesh-0.12.2-cp39-abi3-macosx_10_12_universal2.macosx_10_12_x86_64.macosx_11_0_arm64.whl", hash = "sha256:baf95040e0991eb6ca66113e80918f260dc997cadd2352fe8b654d869228332e", size = 6567770, upload-time = "2026-11-06T10:04:58.857Z" }, + { url = "https://files.pythonhosted.org/packages/36/f9/0be1b1423b12d85748900a71304b6ec19e2e80c3ddeac47c6beecdf3db24/arkitekt_mesh-0.12.2-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1c3a9cdbce117e5f184b7f2e7bf1ff036e1d272d65ecdb160d9415f248af0dbb", size = 3690535, upload-time = "2026-11-06T10:05:00.761Z" }, + { url = "https://files.pythonhosted.org/packages/1c/d7/7111ee859527fb07d22f635d7bb55f0e8e3a5cb939022a4e6d8aaaaa8bda/arkitekt_mesh-0.12.2-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:87b51eecbe22af9426fa36d1797272d32881901505b1a49994c9ae78413ccd48", size = 3644679, upload-time = "2026-11-06T10:05:02.518Z" }, + { url = "https://files.pythonhosted.org/packages/d2/dc/3b7961cf6c78881efe8c989c6977c333d7c0d44fd281967b2698818c99c1/arkitekt_mesh-0.12.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:f251c24bdcb86e8bd87e71745d86b227643b16af8ca202010e780e06849cc4f8", size = 3866694, upload-time = "2026-11-06T10:05:04.05Z" }, + { url = "https://files.pythonhosted.org/packages/f1/8a/21c00ff3ca0b272b8ddf0330080a46446a98c0bb085bcbc55bbc68b9bb7c/arkitekt_mesh-0.12.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:87d345cf8b540cfef7894dc701affe09e6fa593defb2fa9199f09ee990dad1a3", size = 3962436, upload-time = "2026-11-06T10:05:05.48Z" }, + { url = "https://files.pythonhosted.org/packages/b1/a6/cf0e7addfc67b2119b1bc08aa73e0ae57a294983dbf61c85b05282b0b057/arkitekt_mesh-0.12.2-cp39-abi3-win_amd64.whl", hash = "sha256:7a4392bbd3ed252ce420d3820afb24b6f34ce319a9f349685ed27e15bdf4920e", size = 3100338, upload-time = "2026-11-06T10:05:07.223Z" }, + { url = "https://files.pythonhosted.org/packages/13/d4/8fdfc110291763150d714646dbf837175fb54be05d0e3ca516506e35a925/arkitekt_mesh-0.12.2-cp39-abi3-win_arm64.whl", hash = "sha256:ba5b9913e4bd7a7fcab35103063cbe51959dc1b8b6f80770082f52b67da12f60", size = 2900257, upload-time = "2026-11-06T10:05:08.79Z" }, ] [[package]] name = "arkitekt-runtime" -version = "4.1.1" +version = "10.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "arkitekt-spec", marker = "python_full_version < '3.14'" }, - { name = "janus", marker = "python_full_version < '3.14'" }, - { name = "jsonpatch", marker = "python_full_version < '3.14'" }, - { name = "koil", marker = "python_full_version < '3.14'" }, - { name = "pydantic", marker = "python_full_version < '3.14'" }, + { name = "arkitekt-spec" }, + { name = "janus" }, + { name = "jsonpatch" }, + { name = "koil" }, + { name = "pydantic" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a0/12/1d2ba7e3ddb2717d442a556b464328d697ccd3c8d2d01ef6342d5dd6af1f/arkitekt_runtime-4.1.1.tar.gz", hash = "sha256:9aa1eb14d4a681fa55768415d1919f09adb5b5f90f3f0dd8fcbc1d1b23227c1a", size = 110703, upload-time = "2026-09-29T23:28:32.283Z" } +sdist = { url = "https://files.pythonhosted.org/packages/38/aa/e50357740f5ec410ac26eb6329b4714bd3995d5cfc0bea9a65641ad12b13/arkitekt_runtime-10.0.0.tar.gz", hash = "sha256:691fd6a66a21f3fd4f8e86ea22daed50c572689a1ae36d40c4826e6fda808847", size = 134344, upload-time = "2026-11-14T22:43:10.165Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0e/fe/b1b83f3ff4b345c539e6b0c95fe099ebe9eba4d9044f45561a1ef380f4d3/arkitekt_runtime-4.1.1-py3-none-any.whl", hash = "sha256:c8b4051ad459008ade54a1c9c411ae39afc26c1d2d24044cc8c5f98ce3233eb7", size = 138087, upload-time = "2026-09-29T23:28:31.174Z" }, + { url = "https://files.pythonhosted.org/packages/e3/2a/9840e3f0f8a0ff21333d707f3a941280aa5a8a92a7095a08c31ae1c08986/arkitekt_runtime-10.0.0-py3-none-any.whl", hash = "sha256:4ab0f7657a79717b37c764da48ff815dc5f150ef23f616720e0820ef94665093", size = 164780, upload-time = "2026-11-14T22:43:08.787Z" }, ] [[package]] name = "arkitekt-spec" -version = "3.0.0" +version = "10.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "docstring-parser", marker = "python_full_version < '3.14'" }, - { name = "fieldz", marker = "python_full_version < '3.14'" }, - { name = "inflection", marker = "python_full_version < '3.14'" }, - { name = "pydantic", marker = "python_full_version < '3.14'" }, - { name = "pyyaml", marker = "python_full_version < '3.14'" }, + { name = "certifi" }, + { name = "docstring-parser" }, + { name = "fieldz" }, + { name = "inflection" }, + { name = "pydantic" }, + { name = "pyyaml" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/33/c5/5d5b03194261e33a7c73457992d74ed595e8afb1ed8a8e372c5a97a3e6f1/arkitekt_spec-3.0.0.tar.gz", hash = "sha256:6b1c44ef29209244c42a859100c8acb508d711f167d7dfbb3a4e7a2566ad5176", size = 153196, upload-time = "2026-09-30T18:54:28.36Z" } +sdist = { url = "https://files.pythonhosted.org/packages/65/16/93c93696858c4391344752a7e7a33bf585a11b293562cc4ed5dc6efade2d/arkitekt_spec-10.1.0.tar.gz", hash = "sha256:c43c47b4249ab8ac631189897f4613a8dfef682a437ad45af4b51dc8e735f6d3", size = 333953, upload-time = "2026-11-14T22:38:14.793Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/dc/0f/c32e1d1dd91964af3e20e895516e81db2c44932d77226961b854a8c9126f/arkitekt_spec-3.0.0-py3-none-any.whl", hash = "sha256:ced0e6672a1a6b4f33926b37e9f3a472090d904d5ce3001763bb77d044dda7b9", size = 188144, upload-time = "2026-09-30T18:54:26.761Z" }, + { url = "https://files.pythonhosted.org/packages/34/3c/4add9bca2230a4c6926876e0eab851bfc158b02a6b0a06a3fce07eeadb19/arkitekt_spec-10.1.0-py3-none-any.whl", hash = "sha256:719104cb1e38aca13437cd3d737ad1c64738991e92cf6a91a4bd62fbb70158c1", size = 388134, upload-time = "2026-11-14T22:38:13.685Z" }, ] [[package]] @@ -316,8 +338,8 @@ name = "arrow" version = "1.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "python-dateutil", marker = "python_full_version < '3.14'" }, - { name = "types-python-dateutil", marker = "python_full_version < '3.14'" }, + { name = "python-dateutil" }, + { name = "types-python-dateutil" }, ] sdist = { url = "https://files.pythonhosted.org/packages/2e/00/0f6e8fcdb23ea632c866620cc872729ff43ed91d284c866b515c6342b173/arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85", size = 131960, upload-time = "2023-09-30T22:11:18.25Z" } wheels = [ @@ -329,15 +351,15 @@ name = "ashlaruc2" version = "1.18.5" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "blessed", marker = "python_full_version < '3.14'" }, - { name = "matplotlib", marker = "python_full_version < '3.14'" }, - { name = "networkx", marker = "python_full_version < '3.14'" }, - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "scikit-image", marker = "python_full_version < '3.14'" }, - { name = "scikit-learn", marker = "python_full_version < '3.14'" }, - { name = "scipy", marker = "python_full_version < '3.14'" }, - { name = "tifffile", marker = "python_full_version < '3.14'" }, - { name = "zarr", marker = "python_full_version < '3.14'" }, + { name = "blessed" }, + { name = "matplotlib" }, + { name = "networkx" }, + { name = "numpy" }, + { name = "scikit-image" }, + { name = "scikit-learn" }, + { name = "scipy" }, + { name = "tifffile" }, + { name = "zarr" }, ] sdist = { url = "https://files.pythonhosted.org/packages/61/e6/88d873a25714e5f8483bd2a2ac511935762305e6305f3fd9052228ae3a47/ashlaruc2-1.18.5.tar.gz", hash = "sha256:ed698f836381f09cdf443e9828d01832a95fe5697213b8efd8a50e06b4d42559", size = 62150, upload-time = "2026-07-05T17:20:20.723Z" } wheels = [ @@ -411,8 +433,8 @@ name = "beautifulsoup4" version = "4.13.5" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "soupsieve", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "soupsieve" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/85/2e/3e5079847e653b1f6dc647aa24549d68c6addb4c595cc0d902d1b19308ad/beautifulsoup4-4.13.5.tar.gz", hash = "sha256:5e70131382930e7c3de33450a2f54a63d5e4b19386eab43a5b34d594268f3695", size = 622954, upload-time = "2025-08-24T14:06:13.168Z" } wheels = [ @@ -506,7 +528,7 @@ name = "bitstring" version = "4.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "bitarray", marker = "python_full_version < '3.14'" }, + { name = "bitarray" }, ] sdist = { url = "https://files.pythonhosted.org/packages/15/a8/a80c890db75d5bdd5314b5de02c4144c7de94fd0cefcae51acaeb14c6a3f/bitstring-4.3.1.tar.gz", hash = "sha256:a08bc09d3857216d4c0f412a1611056f1cc2b64fd254fb1e8a0afba7cfa1a95a", size = 251426, upload-time = "2025-03-22T09:39:06.978Z" } wheels = [ @@ -518,7 +540,7 @@ name = "bleach" version = "6.2.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "webencodings", marker = "python_full_version < '3.14'" }, + { name = "webencodings" }, ] sdist = { url = "https://files.pythonhosted.org/packages/76/9a/0e33f5054c54d349ea62c277191c020c2d6ef1d65ab2cb1993f91ec846d1/bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f", size = 203083, upload-time = "2024-10-29T18:30:40.477Z" } wheels = [ @@ -527,7 +549,7 @@ wheels = [ [package.optional-dependencies] css = [ - { name = "tinycss2", marker = "python_full_version < '3.14'" }, + { name = "tinycss2" }, ] [[package]] @@ -535,8 +557,8 @@ name = "blessed" version = "1.22.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "jinxed", marker = "python_full_version < '3.14' and sys_platform == 'win32'" }, - { name = "wcwidth", marker = "python_full_version < '3.14'" }, + { name = "jinxed", marker = "sys_platform == 'win32'" }, + { name = "wcwidth" }, ] sdist = { url = "https://files.pythonhosted.org/packages/7c/51/a72df7730aa34a94bc43cebecb7b63ffa42f019868637dbeb45e0620d26e/blessed-1.22.0.tar.gz", hash = "sha256:1818efb7c10015478286f21a412fcdd31a3d8b94a18f6d926e733827da7a844b", size = 6660050, upload-time = "2025-09-15T19:15:26.551Z" } wheels = [ @@ -548,16 +570,16 @@ name = "bokeh" version = "3.8.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "contourpy", marker = "python_full_version < '3.14'" }, - { name = "jinja2", marker = "python_full_version < '3.14'" }, - { name = "narwhals", marker = "python_full_version < '3.14'" }, - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "packaging", marker = "python_full_version < '3.14'" }, - { name = "pandas", marker = "python_full_version < '3.14'" }, - { name = "pillow", marker = "python_full_version < '3.14'" }, - { name = "pyyaml", marker = "python_full_version < '3.14'" }, - { name = "tornado", marker = "python_full_version < '3.14' and sys_platform != 'emscripten'" }, - { name = "xyzservices", marker = "python_full_version < '3.14'" }, + { name = "contourpy" }, + { name = "jinja2" }, + { name = "narwhals" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pandas" }, + { name = "pillow" }, + { name = "pyyaml" }, + { name = "tornado", marker = "sys_platform != 'emscripten'" }, + { name = "xyzservices" }, ] sdist = { url = "https://files.pythonhosted.org/packages/78/bd/8455ecfaa8100dbfbb2af40061c689a7a9c808f4f8c9582f0efd0c8c9a19/bokeh-3.8.0.tar.gz", hash = "sha256:bfdf5e9df910653b097f70cd38f4c2399d91af6e54a618126e2387cc33c9ec03", size = 6529746, upload-time = "2025-08-29T12:16:55.005Z" } wheels = [ @@ -619,7 +641,7 @@ name = "cffi" version = "2.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pycparser", marker = "python_full_version < '3.14' and implementation_name != 'PyPy'" }, + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } wheels = [ @@ -742,7 +764,7 @@ name = "click" version = "8.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "colorama", marker = "python_full_version < '3.14' and sys_platform == 'win32'" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/46/61/de6cd827efad202d7057d93e0fed9294b96952e188f7384832791c7b2254/click-8.3.0.tar.gz", hash = "sha256:e7b8232224eba16f4ebe410c25ced9f7875cb5f3263ffc93cc3e8da705e229c4", size = 276943, upload-time = "2025-09-18T17:32:23.696Z" } wheels = [ @@ -754,10 +776,10 @@ name = "clize" version = "5.0.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "attrs", marker = "python_full_version < '3.14'" }, - { name = "docutils", marker = "python_full_version < '3.14'" }, - { name = "od", marker = "python_full_version < '3.14'" }, - { name = "sigtools", marker = "python_full_version < '3.14'" }, + { name = "attrs" }, + { name = "docutils" }, + { name = "od" }, + { name = "sigtools" }, ] sdist = { url = "https://files.pythonhosted.org/packages/27/d9/351db7247739f7cdaa076a1a25163afc7b553af556273729320a64cf0ab4/clize-5.0.2.tar.gz", hash = "sha256:047f5a4473602718ab1b85672a7e15303387178d5a81c275dc429dfac1ecb510", size = 197813, upload-time = "2023-07-09T22:54:51.098Z" } wheels = [ @@ -787,7 +809,7 @@ name = "coloredlogs" version = "15.0.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "humanfriendly", marker = "python_full_version < '3.14'" }, + { name = "humanfriendly" }, ] sdist = { url = "https://files.pythonhosted.org/packages/cc/c7/eed8f27100517e8c0e6b923d5f0845d0cb99763da6fdee00478f91db7325/coloredlogs-15.0.1.tar.gz", hash = "sha256:7c991aa71a4577af2f82600d8f8f3a89f936baeaf9b50a9c197da014e5bf16b0", size = 278520, upload-time = "2021-06-11T10:22:45.202Z" } wheels = [ @@ -799,10 +821,10 @@ name = "colour-science" version = "0.4.6" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "imageio", marker = "python_full_version < '3.14'" }, - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "scipy", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "imageio" }, + { name = "numpy" }, + { name = "scipy" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/5a/29/4ea0082b8ad8c5e18b9ac7cf7ad5f21b70e10976ed53b877773ead3c268d/colour_science-0.4.6.tar.gz", hash = "sha256:be98c2c9b2a5caf0c443431f402599ca9e1cc7d944bb804156803bcc97af4cf0", size = 2228183, upload-time = "2024-10-11T05:49:40.206Z" } wheels = [ @@ -823,7 +845,7 @@ name = "contourpy" version = "1.3.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "python_full_version < '3.14'" }, + { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" } wheels = [ @@ -957,7 +979,7 @@ name = "cryptography" version = "46.0.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cffi", marker = "python_full_version < '3.14' and platform_python_implementation != 'PyPy'" }, + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/a9/62/e3664e6ffd7743e1694b244dde70b43a394f6f7fbcacf7014a8ff5197c73/cryptography-46.0.1.tar.gz", hash = "sha256:ed570874e88f213437f5cf758f9ef26cbfc3f336d889b1e592ee11283bb8d1c7", size = 749198, upload-time = "2025-09-17T00:10:35.797Z" } wheels = [ @@ -1028,14 +1050,14 @@ name = "dask" version = "2025.9.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "click", marker = "python_full_version < '3.14'" }, - { name = "cloudpickle", marker = "python_full_version < '3.14'" }, - { name = "fsspec", marker = "python_full_version < '3.14'" }, - { name = "importlib-metadata", marker = "python_full_version < '3.12'" }, - { name = "packaging", marker = "python_full_version < '3.14'" }, - { name = "partd", marker = "python_full_version < '3.14'" }, - { name = "pyyaml", marker = "python_full_version < '3.14'" }, - { name = "toolz", marker = "python_full_version < '3.14'" }, + { name = "click" }, + { name = "cloudpickle" }, + { name = "fsspec" }, + { name = "importlib-metadata", marker = "python_full_version < '3.12' or python_full_version >= '3.14'" }, + { name = "packaging" }, + { name = "partd" }, + { name = "pyyaml" }, + { name = "toolz" }, ] sdist = { url = "https://files.pythonhosted.org/packages/52/87/87af914aaf5bfaa0ee8b9da060a836477d8cc49fe4978637da8b6a47d8a3/dask-2025.9.1.tar.gz", hash = "sha256:718df73e1fd3d7e2b8546e0f04ce08e1ed7f9aa3da1eecd0c1f44c8b6d52f7e0", size = 10973663, upload-time = "2025-09-16T10:54:59.452Z" } wheels = [ @@ -1044,13 +1066,13 @@ wheels = [ [package.optional-dependencies] complete = [ - { name = "bokeh", marker = "python_full_version < '3.14'" }, - { name = "distributed", marker = "python_full_version < '3.14'" }, - { name = "jinja2", marker = "python_full_version < '3.14'" }, - { name = "lz4", marker = "python_full_version < '3.14'" }, - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "pandas", marker = "python_full_version < '3.14'" }, - { name = "pyarrow", marker = "python_full_version < '3.14'" }, + { name = "bokeh" }, + { name = "distributed" }, + { name = "jinja2" }, + { name = "lz4" }, + { name = "numpy" }, + { name = "pandas" }, + { name = "pyarrow" }, ] [[package]] @@ -1058,8 +1080,8 @@ name = "dataclasses-json" version = "0.6.7" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "marshmallow", marker = "python_full_version < '3.14'" }, - { name = "typing-inspect", marker = "python_full_version < '3.14'" }, + { name = "marshmallow" }, + { name = "typing-inspect" }, ] sdist = { url = "https://files.pythonhosted.org/packages/64/a4/f71d9cf3a5ac257c993b5ca3f93df5f7fb395c725e7f1e6479d2514173c3/dataclasses_json-0.6.7.tar.gz", hash = "sha256:b6b3e528266ea45b9535223bc53ca645f5208833c29229e847b3f26a1cc55fc0", size = 32227, upload-time = "2024-06-09T16:20:19.103Z" } wheels = [ @@ -1114,7 +1136,7 @@ name = "deprecated" version = "1.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "wrapt", marker = "python_full_version < '3.14'" }, + { name = "wrapt" }, ] sdist = { url = "https://files.pythonhosted.org/packages/49/85/12f0a49a7c4ffb70572b6c2ef13c90c88fd190debda93b23f026b25f9634/deprecated-1.3.1.tar.gz", hash = "sha256:b1b50e0ff0c1fddaa5708a2c6b0a6588bb09b892825ab2b214ac9ea9d92a5223", size = 2932523, upload-time = "2025-10-30T08:19:02.757Z" } wheels = [ @@ -1126,7 +1148,7 @@ name = "deprecation" version = "2.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "packaging", marker = "python_full_version < '3.14'" }, + { name = "packaging" }, ] sdist = { url = "https://files.pythonhosted.org/packages/5a/d3/8ae2869247df154b64c1884d7346d412fed0c49df84db635aab2d1c40e62/deprecation-2.1.0.tar.gz", hash = "sha256:72b3bde64e5d778694b0cf68178aed03d15e15477116add3fb773e581f9518ff", size = 173788, upload-time = "2020-04-20T14:23:38.738Z" } wheels = [ @@ -1138,21 +1160,21 @@ name = "distributed" version = "2025.9.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "click", marker = "python_full_version < '3.14'" }, - { name = "cloudpickle", marker = "python_full_version < '3.14'" }, - { name = "dask", marker = "python_full_version < '3.14'" }, - { name = "jinja2", marker = "python_full_version < '3.14'" }, - { name = "locket", marker = "python_full_version < '3.14'" }, - { name = "msgpack", marker = "python_full_version < '3.14'" }, - { name = "packaging", marker = "python_full_version < '3.14'" }, - { name = "psutil", marker = "python_full_version < '3.14'" }, - { name = "pyyaml", marker = "python_full_version < '3.14'" }, - { name = "sortedcontainers", marker = "python_full_version < '3.14'" }, - { name = "tblib", marker = "python_full_version < '3.14'" }, - { name = "toolz", marker = "python_full_version < '3.14'" }, - { name = "tornado", marker = "python_full_version < '3.14'" }, - { name = "urllib3", marker = "python_full_version < '3.14'" }, - { name = "zict", marker = "python_full_version < '3.14'" }, + { name = "click" }, + { name = "cloudpickle" }, + { name = "dask" }, + { name = "jinja2" }, + { name = "locket" }, + { name = "msgpack" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyyaml" }, + { name = "sortedcontainers" }, + { name = "tblib" }, + { name = "toolz" }, + { name = "tornado" }, + { name = "urllib3" }, + { name = "zict" }, ] sdist = { url = "https://files.pythonhosted.org/packages/04/0d/423f4e06519eabb5d731a1f586e84532257fc0456f0a3bb4cb29bcb2729f/distributed-2025.9.1.tar.gz", hash = "sha256:285e0de86fd5e1b941f283f5fd661884645a6a28b06d2a2fdb18079b823aca58", size = 1101310, upload-time = "2025-09-16T10:55:23.17Z" } wheels = [ @@ -1200,7 +1222,7 @@ name = "donfig" version = "0.8.1.post1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pyyaml", marker = "python_full_version < '3.14'" }, + { name = "pyyaml" }, ] sdist = { url = "https://files.pythonhosted.org/packages/25/71/80cc718ff6d7abfbabacb1f57aaa42e9c1552bfdd01e64ddd704e4a03638/donfig-0.8.1.post1.tar.gz", hash = "sha256:3bef3413a4c1c601b585e8d297256d0c1470ea012afa6e8461dc28bfb7c23f52", size = 19506, upload-time = "2024-05-23T14:14:31.513Z" } wheels = [ @@ -1221,14 +1243,14 @@ name = "esptool" version = "5.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "bitstring", marker = "python_full_version < '3.14'" }, - { name = "click", marker = "python_full_version < '3.14'" }, - { name = "cryptography", marker = "python_full_version < '3.14'" }, - { name = "intelhex", marker = "python_full_version < '3.14'" }, - { name = "pyserial", marker = "python_full_version < '3.14'" }, - { name = "pyyaml", marker = "python_full_version < '3.14'" }, - { name = "reedsolo", marker = "python_full_version < '3.14'" }, - { name = "rich-click", marker = "python_full_version < '3.14'" }, + { name = "bitstring" }, + { name = "click" }, + { name = "cryptography" }, + { name = "intelhex" }, + { name = "pyserial" }, + { name = "pyyaml" }, + { name = "reedsolo" }, + { name = "rich-click" }, ] sdist = { url = "https://files.pythonhosted.org/packages/c2/03/d7d79a77dd787dbe6029809c5f81ad88912340a131c88075189f40df3aba/esptool-5.1.0.tar.gz", hash = "sha256:2ea9bcd7eb263d380a4fe0170856a10e4c65e3f38c757ebdc73584c8dd8322da", size = 383926, upload-time = "2025-09-16T05:27:23.715Z" } @@ -1243,34 +1265,26 @@ wheels = [ [[package]] name = "fakts" -version = "5.2.0" +version = "6.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "aiohttp", marker = "python_full_version < '3.14'" }, - { name = "arkitekt-spec", marker = "python_full_version < '3.14'" }, - { name = "certifi", marker = "python_full_version < '3.14'" }, - { name = "koil", marker = "python_full_version < '3.14'" }, - { name = "pydantic", marker = "python_full_version < '3.14'" }, + { name = "aiohttp" }, + { name = "arkitekt-spec" }, + { name = "certifi" }, + { name = "koil" }, + { name = "pydantic" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/82/33/1e60eb66abca828723ca90ca615eaf796a8fc4efafc1a785a0104d708867/fakts-5.2.0.tar.gz", hash = "sha256:669fbfb8c10bdb1df55aba773560f0a8ca691ef8bbd0f96aea34fba5e9081627", size = 94995, upload-time = "2026-09-29T21:21:19.847Z" } +sdist = { url = "https://files.pythonhosted.org/packages/85/4e/cfa5916b24c8a5001890bf61ee68fc77804ef80903417f67ceb56678557f/fakts-6.3.0.tar.gz", hash = "sha256:1e9dd00c089ac86ac96263f5f7414796ba9dc96fd18b76fb583e617b10bf3b41", size = 110725, upload-time = "2026-11-07T19:56:49.299Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b4/39/5a354b9347762878e28260ee31ba96d3dc9cbe667f373116bc70ebd8758e/fakts-5.2.0-py3-none-any.whl", hash = "sha256:f9bcce32f01f8b23bd20c0bb92ae339b95766e35175281f80bf650b921ae7758", size = 102178, upload-time = "2026-09-29T21:21:18.512Z" }, + { url = "https://files.pythonhosted.org/packages/00/e7/31616180e600a520390b241bf22aa39d49d7161aee09f41363934185fdaa/fakts-6.3.0-py3-none-any.whl", hash = "sha256:1e89985d710392bebfecb8d00416b3c12b70dd9a41ad95725baf919ae7f2163d", size = 117648, upload-time = "2026-11-07T19:56:48.105Z" }, ] -[[package]] -name = "fakts-next" -version = "4.1.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "aiohttp", marker = "python_full_version < '3.14'" }, - { name = "certifi", marker = "python_full_version < '3.14'" }, - { name = "koil", marker = "python_full_version < '3.14'" }, - { name = "oauthlib", marker = "python_full_version < '3.14'" }, - { name = "pydantic", marker = "python_full_version < '3.14'" }, +[package.optional-dependencies] +crypto = [ + { name = "cryptography" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/cd/41/019aaf1303f6fe1ed418286c26d0bf03ff3e6cce7d389e0c3611bd3bad8c/fakts_next-4.1.0.tar.gz", hash = "sha256:85d15b9f9c37b51dcb754aa431c2b26e58b9760460d7e13033dfaaea11780aec", size = 49325, upload-time = "2026-06-25T15:51:02.007Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/dd/ea/c3e7e245517e291523f664bd5eab8e78934433a8b445df57e43111ea7fc1/fakts_next-4.1.0-py3-none-any.whl", hash = "sha256:2e13033b18b6bbe4d5d04a988d8c03ec274d60da3633077a4214bb12936f8f6c", size = 69765, upload-time = "2026-06-25T15:51:00.949Z" }, +mesh = [ + { name = "arkitekt-mesh" }, ] [[package]] @@ -1278,9 +1292,9 @@ name = "fastapi" version = "0.117.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pydantic", marker = "python_full_version < '3.14'" }, - { name = "starlette", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/7e/7e/d9788300deaf416178f61fb3c2ceb16b7d0dc9f82a08fdb87a5e64ee3cc7/fastapi-0.117.1.tar.gz", hash = "sha256:fb2d42082d22b185f904ca0ecad2e195b851030bd6c5e4c032d1c981240c631a", size = 307155, upload-time = "2025-09-20T20:16:56.663Z" } wheels = [ @@ -1301,7 +1315,7 @@ name = "fieldz" version = "0.1.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/90/62/698c5cc2e7d4c8c89e63033e2e9d3c74902a1bf28782712eacb0653097ce/fieldz-0.1.2.tar.gz", hash = "sha256:0448ed5dacb13eaa49da0db786e87fae298fbd2652d26c510e5d7aea6b6bebf4", size = 17277, upload-time = "2025-06-30T18:06:40.881Z" } wheels = [ @@ -1313,7 +1327,7 @@ name = "flexcache" version = "0.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/55/b0/8a21e330561c65653d010ef112bf38f60890051d244ede197ddaa08e50c1/flexcache-0.3.tar.gz", hash = "sha256:18743bd5a0621bfe2cf8d519e4c3bfdf57a269c15d1ced3fb4b64e0ff4600656", size = 15816, upload-time = "2024-03-09T03:21:07.555Z" } wheels = [ @@ -1325,7 +1339,7 @@ name = "flexparser" version = "0.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/82/99/b4de7e39e8eaf8207ba1a8fa2241dd98b2ba72ae6e16960d8351736d8702/flexparser-0.4.tar.gz", hash = "sha256:266d98905595be2ccc5da964fe0a2c3526fbbffdc45b65b3146d75db992ef6b2", size = 31799, upload-time = "2024-11-07T02:00:56.249Z" } wheels = [ @@ -1526,8 +1540,8 @@ name = "griffe" version = "2.0.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "griffecli", marker = "python_full_version < '3.14'" }, - { name = "griffelib", marker = "python_full_version < '3.14'" }, + { name = "griffecli" }, + { name = "griffelib" }, ] sdist = { url = "https://files.pythonhosted.org/packages/4a/49/eb6d2935e27883af92c930ed40cc4c69bcd32c402be43b8ca4ab20510f67/griffe-2.0.2.tar.gz", hash = "sha256:c5d56326d159f274492e9bf93a9895cec101155d944caa66d0fc4e0c13751b92", size = 293757, upload-time = "2026-03-27T11:34:52.205Z" } wheels = [ @@ -1539,8 +1553,8 @@ name = "griffecli" version = "2.0.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "colorama", marker = "python_full_version < '3.14'" }, - { name = "griffelib", marker = "python_full_version < '3.14'" }, + { name = "colorama" }, + { name = "griffelib" }, ] sdist = { url = "https://files.pythonhosted.org/packages/79/e0/6a7d661d71bb043656a109b91d84a42b5342752542074ec83b16a6eb97f0/griffecli-2.0.2.tar.gz", hash = "sha256:40a1ad4181fc39685d025e119ae2c5b669acdc1f19b705fb9bf971f4e6f6dffb", size = 56281, upload-time = "2026-03-27T11:34:50.087Z" } wheels = [ @@ -1561,7 +1575,7 @@ name = "grpcio" version = "1.80.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/b7/48/af6173dbca4454f4637a4678b67f52ca7e0c1ed7d5894d89d434fecede05/grpcio-1.80.0.tar.gz", hash = "sha256:29aca15edd0688c22ba01d7cc01cb000d72b2033f4a3c72a81a19b56fd143257", size = 12978905, upload-time = "2026-03-30T08:49:10.502Z" } wheels = [ @@ -1621,7 +1635,7 @@ name = "h5py" version = "3.14.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "python_full_version < '3.14'" }, + { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/5d/57/dfb3c5c3f1bf5f5ef2e59a22dec4ff1f3d7408b55bfcefcfb0ea69ef21c6/h5py-3.14.0.tar.gz", hash = "sha256:2372116b2e0d5d3e5e705b7f663f7c8d96fa79a4052d250484ef91d24d6a08f4", size = 424323, upload-time = "2025-06-06T14:06:15.01Z" } wheels = [ @@ -1655,8 +1669,8 @@ name = "httpcore" version = "1.0.9" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "certifi", marker = "python_full_version < '3.14'" }, - { name = "h11", marker = "python_full_version < '3.14'" }, + { name = "certifi" }, + { name = "h11" }, ] sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } wheels = [ @@ -1697,10 +1711,10 @@ name = "httpx" version = "0.28.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "anyio", marker = "python_full_version < '3.14'" }, - { name = "certifi", marker = "python_full_version < '3.14'" }, - { name = "httpcore", marker = "python_full_version < '3.14'" }, - { name = "idna", marker = "python_full_version < '3.14'" }, + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, ] sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } wheels = [ @@ -1712,7 +1726,7 @@ name = "humanfriendly" version = "10.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pyreadline3", marker = "python_full_version < '3.14' and sys_platform == 'win32'" }, + { name = "pyreadline3", marker = "sys_platform == 'win32'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/cc/3f/2c29224acb2e2df4d2046e4c73ee2662023c58ff5b113c4c1adac0886c43/humanfriendly-10.0.tar.gz", hash = "sha256:6b0b831ce8f15f7300721aa49829fc4e83921a9a301cc7f606be6686a2288ddc", size = 360702, upload-time = "2021-09-17T21:40:43.31Z" } wheels = [ @@ -1742,8 +1756,8 @@ name = "imageio" version = "2.37.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "pillow", marker = "python_full_version < '3.14'" }, + { name = "numpy" }, + { name = "pillow" }, ] sdist = { url = "https://files.pythonhosted.org/packages/0c/47/57e897fb7094afb2d26e8b2e4af9a45c7cf1a405acdeeca001fdf2c98501/imageio-2.37.0.tar.gz", hash = "sha256:71b57b3669666272c818497aebba2b4c5f20d5b37c81720e5e1a56d59c492996", size = 389963, upload-time = "2025-01-20T02:42:37.089Z" } wheels = [ @@ -1755,7 +1769,7 @@ name = "importlib-metadata" version = "8.7.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "zipp", marker = "python_full_version < '3.12'" }, + { name = "zipp" }, ] sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641, upload-time = "2025-04-27T15:29:01.736Z" } wheels = [ @@ -1767,12 +1781,12 @@ name = "imswitchclient" version = "0.2.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "matplotlib", marker = "python_full_version < '3.14'" }, - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "opencv-python", marker = "python_full_version < '3.14' and sys_platform == 'never'" }, - { name = "pillow", marker = "python_full_version < '3.14'" }, - { name = "python-socketio", marker = "python_full_version < '3.14'" }, - { name = "requests", marker = "python_full_version < '3.14'" }, + { name = "matplotlib" }, + { name = "numpy" }, + { name = "opencv-python", marker = "sys_platform == 'never'" }, + { name = "pillow" }, + { name = "python-socketio" }, + { name = "requests" }, ] sdist = { url = "https://files.pythonhosted.org/packages/b0/51/a4f6ff32a2c04ca43a3e254144c349b08b4ef251948a54b63d60992d295d/imswitchclient-0.2.0.tar.gz", hash = "sha256:6a76f252a918bd798239232d0b6dbf6c84e18a61cd438a29601008a036f42938", size = 45269, upload-time = "2026-10-24T11:04:51.366Z" } wheels = [ @@ -1783,99 +1797,100 @@ wheels = [ name = "imswitchuc2" source = { editable = "." } dependencies = [ - { name = "aiohttp", marker = "python_full_version < '3.14'" }, - { name = "aiortc", marker = "python_full_version < '3.14'" }, - { name = "arkitekt", extra = ["mikro", "rekuest"], marker = "python_full_version < '3.14'" }, - { name = "arkitekt-runtime", marker = "python_full_version < '3.14'" }, - { name = "arkitekt-spec", marker = "python_full_version < '3.14'" }, - { name = "ashlaruc2", marker = "python_full_version < '3.14'" }, - { name = "av", marker = "python_full_version < '3.14'" }, - { name = "coloredlogs", marker = "python_full_version < '3.14'" }, - { name = "colour-science", marker = "python_full_version < '3.14'" }, - { name = "dask", extra = ["complete"], marker = "python_full_version < '3.14'" }, - { name = "dataclasses-json", marker = "python_full_version < '3.14'" }, - { name = "esptool", marker = "python_full_version < '3.14'" }, - { name = "fakts", marker = "python_full_version < '3.14'" }, - { name = "fastapi", marker = "python_full_version < '3.14'" }, - { name = "h5py", marker = "python_full_version < '3.14'" }, - { name = "imswitchclient", marker = "python_full_version < '3.14'" }, - { name = "ipympl", marker = "python_full_version < '3.14'" }, - { name = "jeepney", marker = "python_full_version < '3.14' and sys_platform == 'linux'" }, - { name = "jsonschema", marker = "python_full_version < '3.14'" }, - { name = "jupyter", marker = "python_full_version < '3.14'" }, - { name = "jupyterlab", marker = "python_full_version < '3.14'" }, - { name = "koil", marker = "python_full_version < '3.14'" }, - { name = "lantzdev", marker = "python_full_version < '3.14'" }, - { name = "luddite", marker = "python_full_version < '3.14'" }, - { name = "matplotlib", marker = "python_full_version < '3.14'" }, - { name = "mikro", marker = "python_full_version < '3.14'" }, - { name = "mikro-next", marker = "python_full_version < '3.14'" }, - { name = "msgpack", marker = "python_full_version < '3.14'" }, - { name = "nanoimagingpack", marker = "python_full_version < '3.14'" }, - { name = "nidaqmx", marker = "python_full_version < '3.14'" }, - { name = "numcodecs", marker = "python_full_version < '3.14'" }, - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "ome-types", marker = "python_full_version < '3.14'" }, - { name = "ome-zarr-models", version = "1.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "aiohttp" }, + { name = "aiortc" }, + { name = "arkitekt", extra = ["mikro", "rekuest"] }, + { name = "arkitekt-runtime" }, + { name = "arkitekt-spec" }, + { name = "ashlaruc2" }, + { name = "av" }, + { name = "coloredlogs" }, + { name = "colour-science" }, + { name = "dask", extra = ["complete"] }, + { name = "dataclasses-json" }, + { name = "esptool" }, + { name = "fakts", extra = ["crypto"] }, + { name = "fastapi" }, + { name = "h5py" }, + { name = "imswitchclient" }, + { name = "ipympl" }, + { name = "jeepney", marker = "sys_platform == 'linux'" }, + { name = "jsonschema" }, + { name = "jupyter" }, + { name = "jupyterlab" }, + { name = "kanne" }, + { name = "koil" }, + { name = "lantzdev" }, + { name = "luddite" }, + { name = "matplotlib" }, + { name = "mikro", extra = ["xarray"] }, + { name = "msgpack" }, + { name = "nanoimagingpack" }, + { name = "nidaqmx" }, + { name = "numcodecs" }, + { name = "numpy" }, + { name = "ome-types" }, + { name = "ome-zarr-models", version = "1.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12' or python_full_version >= '3.14'" }, { name = "ome-zarr-models", version = "1.8.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' and python_full_version < '3.14'" }, - { name = "opencv-contrib-python-headless", marker = "python_full_version < '3.14'" }, - { name = "packaging", marker = "python_full_version < '3.14'" }, - { name = "piexif", marker = "python_full_version < '3.14'" }, - { name = "pip", marker = "python_full_version < '3.14'" }, - { name = "psutil", marker = "python_full_version < '3.14'" }, - { name = "psygnal", marker = "python_full_version < '3.14'" }, - { name = "pydantic", marker = "python_full_version < '3.14'" }, - { name = "pyserial", marker = "python_full_version < '3.14'" }, - { name = "python-dateutil", marker = "python_full_version < '3.14'" }, - { name = "python-multipart", marker = "python_full_version < '3.14'" }, - { name = "python-socketio", marker = "python_full_version < '3.14'" }, - { name = "pyvisa-py", marker = "python_full_version < '3.14'" }, - { name = "rekuest", marker = "python_full_version < '3.14'" }, - { name = "requests", marker = "python_full_version < '3.14'" }, - { name = "scikit-image", marker = "python_full_version < '3.14'" }, - { name = "send2trash", marker = "python_full_version < '3.14'" }, - { name = "setuptools", marker = "python_full_version < '3.14'" }, - { name = "tifffile", marker = "python_full_version < '3.14'" }, - { name = "uc2-rest", marker = "python_full_version < '3.14'" }, - { name = "uc2canopen", marker = "python_full_version < '3.14'" }, - { name = "unitelabs-cdk", marker = "python_full_version < '3.14'" }, - { name = "unitelabs-sila", marker = "python_full_version < '3.14'" }, - { name = "useq-schema", marker = "python_full_version < '3.14'" }, - { name = "uvicorn", extra = ["standard"], marker = "python_full_version < '3.14'" }, - { name = "vmbpy", marker = "python_full_version < '3.14' and sys_platform == 'linux'" }, - { name = "zarr", marker = "python_full_version < '3.14'" }, + { name = "opencv-contrib-python-headless" }, + { name = "packaging" }, + { name = "piexif" }, + { name = "pip" }, + { name = "psutil" }, + { name = "psygnal" }, + { name = "pydantic" }, + { name = "pyserial" }, + { name = "python-dateutil" }, + { name = "python-multipart" }, + { name = "python-socketio" }, + { name = "pyvisa-py" }, + { name = "rath" }, + { name = "rekuest" }, + { name = "requests" }, + { name = "scikit-image" }, + { name = "send2trash" }, + { name = "setuptools" }, + { name = "tifffile" }, + { name = "uc2-rest" }, + { name = "uc2canopen" }, + { name = "unitelabs-cdk" }, + { name = "unitelabs-sila" }, + { name = "useq-schema" }, + { name = "uvicorn", extra = ["standard"] }, + { name = "vmbpy", marker = "sys_platform == 'linux'" }, + { name = "zarr" }, ] [package.optional-dependencies] dev = [ - { name = "pytest", marker = "python_full_version < '3.14'" }, + { name = "pytest" }, ] lepmon = [ - { name = "luma-oled", marker = "python_full_version < '3.14'" }, - { name = "rpi-gpio", marker = "python_full_version < '3.14'" }, - { name = "smbus", marker = "python_full_version < '3.14'" }, - { name = "smbus2", marker = "python_full_version < '3.14'" }, + { name = "luma-oled" }, + { name = "rpi-gpio" }, + { name = "smbus" }, + { name = "smbus2" }, ] microeye = [ - { name = "numba", marker = "python_full_version < '3.14'" }, + { name = "numba" }, ] omero = [ - { name = "omero-py", marker = "python_full_version < '3.14'" }, + { name = "omero-py" }, ] pymmcore = [ - { name = "pymmcore-plus", marker = "python_full_version < '3.14'" }, + { name = "pymmcore-plus" }, ] slm = [ - { name = "pygame-ce", marker = "python_full_version < '3.14'" }, + { name = "pygame-ce" }, ] [package.metadata] requires-dist = [ { name = "aiohttp", specifier = ">=3.9.4" }, { name = "aiortc", specifier = ">=1.9.0" }, - { name = "arkitekt", extras = ["mikro", "rekuest"], specifier = "==5.0.1" }, - { name = "arkitekt-runtime", specifier = "==4.1.1" }, - { name = "arkitekt-spec", specifier = "==3.0.0" }, + { name = "arkitekt", extras = ["mikro", "rekuest"], specifier = "==16.0.1" }, + { name = "arkitekt-runtime", specifier = "==10.0.0" }, + { name = "arkitekt-spec", specifier = "==10.1.0" }, { name = "ashlaruc2", specifier = ">=1.18.5" }, { name = "av", specifier = "==13.1.0" }, { name = "coloredlogs", specifier = ">=15" }, @@ -1883,7 +1898,7 @@ requires-dist = [ { name = "dask", extras = ["complete"], specifier = ">=2024.8.0" }, { name = "dataclasses-json", specifier = ">=0.5" }, { name = "esptool" }, - { name = "fakts", specifier = "==5.2.0" }, + { name = "fakts", extras = ["crypto"], specifier = "==6.3.0" }, { name = "fastapi", specifier = ">=0.86.0" }, { name = "h5py", specifier = ">=2.10" }, { name = "imswitchclient", specifier = ">=0.2.0" }, @@ -1892,13 +1907,13 @@ requires-dist = [ { name = "jsonschema", specifier = ">=4.0" }, { name = "jupyter" }, { name = "jupyterlab", specifier = "==4.2.5" }, - { name = "koil", specifier = ">=2.0.5" }, + { name = "kanne", specifier = "==2.6.0" }, + { name = "koil", specifier = "==3.3.7" }, { name = "lantzdev", specifier = ">=0.5.2" }, { name = "luddite", specifier = ">=1" }, { name = "luma-oled", marker = "extra == 'lepmon'" }, { name = "matplotlib", specifier = "==3.9.2" }, - { name = "mikro", specifier = "==6.2.1" }, - { name = "mikro-next", specifier = ">=1" }, + { name = "mikro", extras = ["xarray"], specifier = "==14.0.0" }, { name = "msgpack", specifier = ">=1.0.4" }, { name = "nanoimagingpack", specifier = "==2.1.5" }, { name = "nidaqmx", specifier = ">=0.5.7" }, @@ -1923,7 +1938,8 @@ requires-dist = [ { name = "python-multipart", specifier = ">=0.0.5" }, { name = "python-socketio", extras = ["asyncio"], specifier = ">=5.11,<6" }, { name = "pyvisa-py", specifier = "==0.4.1" }, - { name = "rekuest", specifier = "==7.1.0" }, + { name = "rath", specifier = "==4.1.3" }, + { name = "rekuest", specifier = "==15.0.0" }, { name = "requests", specifier = ">=2.25" }, { name = "rpi-gpio", marker = "extra == 'lepmon'" }, { name = "scikit-image", specifier = "==0.25.2" }, @@ -1975,19 +1991,19 @@ name = "ipykernel" version = "6.30.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "appnope", marker = "python_full_version < '3.14' and sys_platform == 'darwin'" }, - { name = "comm", marker = "python_full_version < '3.14'" }, - { name = "debugpy", marker = "python_full_version < '3.14'" }, - { name = "ipython", marker = "python_full_version < '3.14'" }, - { name = "jupyter-client", marker = "python_full_version < '3.14'" }, - { name = "jupyter-core", marker = "python_full_version < '3.14'" }, - { name = "matplotlib-inline", marker = "python_full_version < '3.14'" }, - { name = "nest-asyncio", marker = "python_full_version < '3.14'" }, - { name = "packaging", marker = "python_full_version < '3.14'" }, - { name = "psutil", marker = "python_full_version < '3.14'" }, - { name = "pyzmq", marker = "python_full_version < '3.14'" }, - { name = "tornado", marker = "python_full_version < '3.14'" }, - { name = "traitlets", marker = "python_full_version < '3.14'" }, + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/bb/76/11082e338e0daadc89c8ff866185de11daf67d181901038f9e139d109761/ipykernel-6.30.1.tar.gz", hash = "sha256:6abb270161896402e76b91394fcdce5d1be5d45f456671e5080572f8505be39b", size = 166260, upload-time = "2025-08-04T15:47:35.018Z" } wheels = [ @@ -1999,12 +2015,12 @@ name = "ipympl" version = "0.10.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "ipython", marker = "python_full_version < '3.14'" }, - { name = "ipywidgets", marker = "python_full_version < '3.14'" }, - { name = "matplotlib", marker = "python_full_version < '3.14'" }, - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "pillow", marker = "python_full_version < '3.14'" }, - { name = "traitlets", marker = "python_full_version < '3.14'" }, + { name = "ipython" }, + { name = "ipywidgets" }, + { name = "matplotlib" }, + { name = "numpy" }, + { name = "pillow" }, + { name = "traitlets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/16/9c/f79e29f6262e821a15757662aa11cbb1db0a51ef836a32a46ddcb25e6832/ipympl-0.10.0.tar.gz", hash = "sha256:eda69602a010af2a42e8ebd069b0ee0dbe8df7fc69d7c1e8b99fece0a2fe613f", size = 3595672, upload-time = "2026-01-21T20:19:47.971Z" } wheels = [ @@ -2016,17 +2032,17 @@ name = "ipython" version = "9.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "colorama", marker = "python_full_version < '3.14' and sys_platform == 'win32'" }, - { name = "decorator", marker = "python_full_version < '3.14'" }, - { name = "ipython-pygments-lexers", marker = "python_full_version < '3.14'" }, - { name = "jedi", marker = "python_full_version < '3.14'" }, - { name = "matplotlib-inline", marker = "python_full_version < '3.14'" }, - { name = "pexpect", marker = "python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, - { name = "prompt-toolkit", marker = "python_full_version < '3.14'" }, - { name = "pygments", marker = "python_full_version < '3.14'" }, - { name = "stack-data", marker = "python_full_version < '3.14'" }, - { name = "traitlets", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.12'" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "decorator" }, + { name = "ipython-pygments-lexers" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, + { name = "typing-extensions", marker = "python_full_version < '3.12' or python_full_version >= '3.14'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/6e/71/a86262bf5a68bf211bcc71fe302af7e05f18a2852fdc610a854d20d085e6/ipython-9.5.0.tar.gz", hash = "sha256:129c44b941fe6d9b82d36fc7a7c18127ddb1d6f02f78f867f402e2e3adde3113", size = 4389137, upload-time = "2025-08-29T12:15:21.519Z" } wheels = [ @@ -2038,7 +2054,7 @@ name = "ipython-pygments-lexers" version = "1.1.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pygments", marker = "python_full_version < '3.14'" }, + { name = "pygments" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } wheels = [ @@ -2050,11 +2066,11 @@ name = "ipywidgets" version = "8.1.7" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "comm", marker = "python_full_version < '3.14'" }, - { name = "ipython", marker = "python_full_version < '3.14'" }, - { name = "jupyterlab-widgets", marker = "python_full_version < '3.14'" }, - { name = "traitlets", marker = "python_full_version < '3.14'" }, - { name = "widgetsnbextension", marker = "python_full_version < '3.14'" }, + { name = "comm" }, + { name = "ipython" }, + { name = "jupyterlab-widgets" }, + { name = "traitlets" }, + { name = "widgetsnbextension" }, ] sdist = { url = "https://files.pythonhosted.org/packages/3e/48/d3dbac45c2814cb73812f98dd6b38bbcc957a4e7bb31d6ea9c03bf94ed87/ipywidgets-8.1.7.tar.gz", hash = "sha256:15f1ac050b9ccbefd45dccfbb2ef6bed0029d8278682d569d71b8dd96bee0376", size = 116721, upload-time = "2025-05-05T12:42:03.489Z" } wheels = [ @@ -2066,7 +2082,7 @@ name = "isoduration" version = "20.11.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "arrow", marker = "python_full_version < '3.14'" }, + { name = "arrow" }, ] sdist = { url = "https://files.pythonhosted.org/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9", size = 11649, upload-time = "2020-11-01T11:00:00.312Z" } wheels = [ @@ -2087,7 +2103,7 @@ name = "jedi" version = "0.19.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "parso", marker = "python_full_version < '3.14'" }, + { name = "parso" }, ] sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" } wheels = [ @@ -2108,7 +2124,7 @@ name = "jinja2" version = "3.1.6" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "markupsafe", marker = "python_full_version < '3.14'" }, + { name = "markupsafe" }, ] sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } wheels = [ @@ -2120,7 +2136,7 @@ name = "jinxed" version = "1.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "ansicon", marker = "python_full_version < '3.14' and sys_platform == 'win32'" }, + { name = "ansicon" }, ] sdist = { url = "https://files.pythonhosted.org/packages/20/d0/59b2b80e7a52d255f9e0ad040d2e826342d05580c4b1d7d7747cfb8db731/jinxed-1.3.0.tar.gz", hash = "sha256:1593124b18a41b7a3da3b078471442e51dbad3d77b4d4f2b0c26ab6f7d660dbf", size = 80981, upload-time = "2024-07-31T22:39:18.854Z" } wheels = [ @@ -2150,7 +2166,7 @@ name = "jsonpatch" version = "1.33" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "jsonpointer", marker = "python_full_version < '3.14'" }, + { name = "jsonpointer" }, ] sdist = { url = "https://files.pythonhosted.org/packages/42/78/18813351fe5d63acad16aec57f94ec2b70a09e53ca98145589e185423873/jsonpatch-1.33.tar.gz", hash = "sha256:9fcd4009c41e6d12348b4a0ff2563ba56a2923a7dfee731d004e212e1ee5030c", size = 21699, upload-time = "2023-06-26T12:07:29.144Z" } wheels = [ @@ -2171,10 +2187,10 @@ name = "jsonschema" version = "4.25.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "attrs", marker = "python_full_version < '3.14'" }, - { name = "jsonschema-specifications", marker = "python_full_version < '3.14'" }, - { name = "referencing", marker = "python_full_version < '3.14'" }, - { name = "rpds-py", marker = "python_full_version < '3.14'" }, + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, ] sdist = { url = "https://files.pythonhosted.org/packages/74/69/f7185de793a29082a9f3c7728268ffb31cb5095131a9c139a74078e27336/jsonschema-4.25.1.tar.gz", hash = "sha256:e4a9655ce0da0c0b67a085847e00a3a51449e1157f4f75e9fb5aa545e122eb85", size = 357342, upload-time = "2025-08-18T17:03:50.038Z" } wheels = [ @@ -2183,15 +2199,15 @@ wheels = [ [package.optional-dependencies] format-nongpl = [ - { name = "fqdn", marker = "python_full_version < '3.14'" }, - { name = "idna", marker = "python_full_version < '3.14'" }, - { name = "isoduration", marker = "python_full_version < '3.14'" }, - { name = "jsonpointer", marker = "python_full_version < '3.14'" }, - { name = "rfc3339-validator", marker = "python_full_version < '3.14'" }, - { name = "rfc3986-validator", marker = "python_full_version < '3.14'" }, - { name = "rfc3987-syntax", marker = "python_full_version < '3.14'" }, - { name = "uri-template", marker = "python_full_version < '3.14'" }, - { name = "webcolors", marker = "python_full_version < '3.14'" }, + { name = "fqdn" }, + { name = "idna" }, + { name = "isoduration" }, + { name = "jsonpointer" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "rfc3987-syntax" }, + { name = "uri-template" }, + { name = "webcolors" }, ] [[package]] @@ -2199,7 +2215,7 @@ name = "jsonschema-specifications" version = "2025.9.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "referencing", marker = "python_full_version < '3.14'" }, + { name = "referencing" }, ] sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } wheels = [ @@ -2211,12 +2227,12 @@ name = "jupyter" version = "1.1.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "ipykernel", marker = "python_full_version < '3.14'" }, - { name = "ipywidgets", marker = "python_full_version < '3.14'" }, - { name = "jupyter-console", marker = "python_full_version < '3.14'" }, - { name = "jupyterlab", marker = "python_full_version < '3.14'" }, - { name = "nbconvert", marker = "python_full_version < '3.14'" }, - { name = "notebook", marker = "python_full_version < '3.14'" }, + { name = "ipykernel" }, + { name = "ipywidgets" }, + { name = "jupyter-console" }, + { name = "jupyterlab" }, + { name = "nbconvert" }, + { name = "notebook" }, ] sdist = { url = "https://files.pythonhosted.org/packages/58/f3/af28ea964ab8bc1e472dba2e82627d36d470c51f5cd38c37502eeffaa25e/jupyter-1.1.1.tar.gz", hash = "sha256:d55467bceabdea49d7e3624af7e33d59c37fff53ed3a350e1ac957bed731de7a", size = 5714959, upload-time = "2024-08-30T07:15:48.299Z" } wheels = [ @@ -2228,11 +2244,11 @@ name = "jupyter-client" version = "8.6.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "jupyter-core", marker = "python_full_version < '3.14'" }, - { name = "python-dateutil", marker = "python_full_version < '3.14'" }, - { name = "pyzmq", marker = "python_full_version < '3.14'" }, - { name = "tornado", marker = "python_full_version < '3.14'" }, - { name = "traitlets", marker = "python_full_version < '3.14'" }, + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/71/22/bf9f12fdaeae18019a468b68952a60fe6dbab5d67cd2a103cac7659b41ca/jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419", size = 342019, upload-time = "2024-09-17T10:44:17.613Z" } wheels = [ @@ -2244,14 +2260,14 @@ name = "jupyter-console" version = "6.6.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "ipykernel", marker = "python_full_version < '3.14'" }, - { name = "ipython", marker = "python_full_version < '3.14'" }, - { name = "jupyter-client", marker = "python_full_version < '3.14'" }, - { name = "jupyter-core", marker = "python_full_version < '3.14'" }, - { name = "prompt-toolkit", marker = "python_full_version < '3.14'" }, - { name = "pygments", marker = "python_full_version < '3.14'" }, - { name = "pyzmq", marker = "python_full_version < '3.14'" }, - { name = "traitlets", marker = "python_full_version < '3.14'" }, + { name = "ipykernel" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "pyzmq" }, + { name = "traitlets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/bd/2d/e2fd31e2fc41c14e2bcb6c976ab732597e907523f6b2420305f9fc7fdbdb/jupyter_console-6.6.3.tar.gz", hash = "sha256:566a4bf31c87adbfadf22cdf846e3069b59a71ed5da71d6ba4d8aaad14a53539", size = 34363, upload-time = "2023-03-06T14:13:31.02Z" } wheels = [ @@ -2263,9 +2279,9 @@ name = "jupyter-core" version = "5.8.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "platformdirs", marker = "python_full_version < '3.14'" }, - { name = "pywin32", marker = "python_full_version < '3.14' and platform_python_implementation != 'PyPy' and sys_platform == 'win32'" }, - { name = "traitlets", marker = "python_full_version < '3.14'" }, + { name = "platformdirs" }, + { name = "pywin32", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'win32'" }, + { name = "traitlets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/99/1b/72906d554acfeb588332eaaa6f61577705e9ec752ddb486f302dafa292d9/jupyter_core-5.8.1.tar.gz", hash = "sha256:0a5f9706f70e64786b75acba995988915ebd4601c8a52e534a40b51c95f59941", size = 88923, upload-time = "2025-05-27T07:38:16.655Z" } wheels = [ @@ -2277,14 +2293,14 @@ name = "jupyter-events" version = "0.12.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "jsonschema", extra = ["format-nongpl"], marker = "python_full_version < '3.14'" }, - { name = "packaging", marker = "python_full_version < '3.14'" }, - { name = "python-json-logger", marker = "python_full_version < '3.14'" }, - { name = "pyyaml", marker = "python_full_version < '3.14'" }, - { name = "referencing", marker = "python_full_version < '3.14'" }, - { name = "rfc3339-validator", marker = "python_full_version < '3.14'" }, - { name = "rfc3986-validator", marker = "python_full_version < '3.14'" }, - { name = "traitlets", marker = "python_full_version < '3.14'" }, + { name = "jsonschema", extra = ["format-nongpl"] }, + { name = "packaging" }, + { name = "python-json-logger" }, + { name = "pyyaml" }, + { name = "referencing" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "traitlets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/9d/c3/306d090461e4cf3cd91eceaff84bede12a8e52cd821c2d20c9a4fd728385/jupyter_events-0.12.0.tar.gz", hash = "sha256:fc3fce98865f6784c9cd0a56a20644fc6098f21c8c33834a8d9fe383c17e554b", size = 62196, upload-time = "2025-02-03T17:23:41.485Z" } wheels = [ @@ -2296,7 +2312,7 @@ name = "jupyter-lsp" version = "2.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "jupyter-server", marker = "python_full_version < '3.14'" }, + { name = "jupyter-server" }, ] sdist = { url = "https://files.pythonhosted.org/packages/eb/5a/9066c9f8e94ee517133cd98dba393459a16cd48bba71a82f16a65415206c/jupyter_lsp-2.3.0.tar.gz", hash = "sha256:458aa59339dc868fb784d73364f17dbce8836e906cd75fd471a325cba02e0245", size = 54823, upload-time = "2025-08-27T17:47:34.671Z" } wheels = [ @@ -2308,25 +2324,25 @@ name = "jupyter-server" version = "2.17.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "anyio", marker = "python_full_version < '3.14'" }, - { name = "argon2-cffi", marker = "python_full_version < '3.14'" }, - { name = "jinja2", marker = "python_full_version < '3.14'" }, - { name = "jupyter-client", marker = "python_full_version < '3.14'" }, - { name = "jupyter-core", marker = "python_full_version < '3.14'" }, - { name = "jupyter-events", marker = "python_full_version < '3.14'" }, - { name = "jupyter-server-terminals", marker = "python_full_version < '3.14'" }, - { name = "nbconvert", marker = "python_full_version < '3.14'" }, - { name = "nbformat", marker = "python_full_version < '3.14'" }, - { name = "overrides", marker = "python_full_version < '3.12'" }, - { name = "packaging", marker = "python_full_version < '3.14'" }, - { name = "prometheus-client", marker = "python_full_version < '3.14'" }, - { name = "pywinpty", marker = "python_full_version < '3.14' and os_name == 'nt'" }, - { name = "pyzmq", marker = "python_full_version < '3.14'" }, - { name = "send2trash", marker = "python_full_version < '3.14'" }, - { name = "terminado", marker = "python_full_version < '3.14'" }, - { name = "tornado", marker = "python_full_version < '3.14'" }, - { name = "traitlets", marker = "python_full_version < '3.14'" }, - { name = "websocket-client", marker = "python_full_version < '3.14'" }, + { name = "anyio" }, + { name = "argon2-cffi" }, + { name = "jinja2" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "jupyter-events" }, + { name = "jupyter-server-terminals" }, + { name = "nbconvert" }, + { name = "nbformat" }, + { name = "overrides", marker = "python_full_version < '3.12' or python_full_version >= '3.14'" }, + { name = "packaging" }, + { name = "prometheus-client" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "pyzmq" }, + { name = "send2trash" }, + { name = "terminado" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "websocket-client" }, ] sdist = { url = "https://files.pythonhosted.org/packages/5b/ac/e040ec363d7b6b1f11304cc9f209dac4517ece5d5e01821366b924a64a50/jupyter_server-2.17.0.tar.gz", hash = "sha256:c38ea898566964c888b4772ae1ed58eca84592e88251d2cfc4d171f81f7e99d5", size = 731949, upload-time = "2025-08-21T14:42:54.042Z" } wheels = [ @@ -2338,8 +2354,8 @@ name = "jupyter-server-terminals" version = "0.5.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pywinpty", marker = "python_full_version < '3.14' and os_name == 'nt'" }, - { name = "terminado", marker = "python_full_version < '3.14'" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "terminado" }, ] sdist = { url = "https://files.pythonhosted.org/packages/fc/d5/562469734f476159e99a55426d697cbf8e7eb5efe89fb0e0b4f83a3d3459/jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269", size = 31430, upload-time = "2024-03-12T14:37:03.049Z" } wheels = [ @@ -2351,19 +2367,19 @@ name = "jupyterlab" version = "4.2.5" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "async-lru", marker = "python_full_version < '3.14'" }, - { name = "httpx", marker = "python_full_version < '3.14'" }, - { name = "ipykernel", marker = "python_full_version < '3.14'" }, - { name = "jinja2", marker = "python_full_version < '3.14'" }, - { name = "jupyter-core", marker = "python_full_version < '3.14'" }, - { name = "jupyter-lsp", marker = "python_full_version < '3.14'" }, - { name = "jupyter-server", marker = "python_full_version < '3.14'" }, - { name = "jupyterlab-server", marker = "python_full_version < '3.14'" }, - { name = "notebook-shim", marker = "python_full_version < '3.14'" }, - { name = "packaging", marker = "python_full_version < '3.14'" }, - { name = "setuptools", marker = "python_full_version < '3.14'" }, - { name = "tornado", marker = "python_full_version < '3.14'" }, - { name = "traitlets", marker = "python_full_version < '3.14'" }, + { name = "async-lru" }, + { name = "httpx" }, + { name = "ipykernel" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyter-lsp" }, + { name = "jupyter-server" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "packaging" }, + { name = "setuptools" }, + { name = "tornado" }, + { name = "traitlets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/4a/78/ba006df6edaa561fe40be26c35e9da3f9316f071167cd7cc1a1a25bd2664/jupyterlab-4.2.5.tar.gz", hash = "sha256:ae7f3a1b8cb88b4f55009ce79fa7c06f99d70cd63601ee4aa91815d054f46f75", size = 21508698, upload-time = "2024-08-26T19:35:25.726Z" } wheels = [ @@ -2384,13 +2400,13 @@ name = "jupyterlab-server" version = "2.27.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "babel", marker = "python_full_version < '3.14'" }, - { name = "jinja2", marker = "python_full_version < '3.14'" }, - { name = "json5", marker = "python_full_version < '3.14'" }, - { name = "jsonschema", marker = "python_full_version < '3.14'" }, - { name = "jupyter-server", marker = "python_full_version < '3.14'" }, - { name = "packaging", marker = "python_full_version < '3.14'" }, - { name = "requests", marker = "python_full_version < '3.14'" }, + { name = "babel" }, + { name = "jinja2" }, + { name = "json5" }, + { name = "jsonschema" }, + { name = "jupyter-server" }, + { name = "packaging" }, + { name = "requests" }, ] sdist = { url = "https://files.pythonhosted.org/packages/0a/c9/a883ce65eb27905ce77ace410d83587c82ea64dc85a48d1f7ed52bcfa68d/jupyterlab_server-2.27.3.tar.gz", hash = "sha256:eb36caca59e74471988f0ae25c77945610b887f777255aa21f8065def9e51ed4", size = 76173, upload-time = "2024-07-16T17:02:04.149Z" } wheels = [ @@ -2408,15 +2424,15 @@ wheels = [ [[package]] name = "kanne" -version = "2.5.0" +version = "2.6.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pint", marker = "python_full_version < '3.14'" }, - { name = "pydantic", marker = "python_full_version < '3.14'" }, + { name = "pint" }, + { name = "pydantic" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/23/60/fc7a38bf1ac1831cb5075f7b8dbe7c9a86ded15e103f4274bc63e8815807/kanne-2.5.0.tar.gz", hash = "sha256:303e40e8ae8bea726d1f96c988c3da266f2a682e149f740df62ef6a6879870ac", size = 18610, upload-time = "2026-07-03T14:41:03.636Z" } +sdist = { url = "https://files.pythonhosted.org/packages/4f/72/4f948fed59bc1eb0670002e7659bed64de151d86aeee76965382a1cb13bd/kanne-2.6.0.tar.gz", hash = "sha256:948ac31c01dc33a9cc72ad5e01944071ceae0858220a89706adf055a7dd63d70", size = 18620, upload-time = "2026-09-01T21:45:52.91Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/df/71/03f17b644c4d69088937460702d087f23d6bc9c94258c0dcfc8cfd32ab12/kanne-2.5.0-py3-none-any.whl", hash = "sha256:94b96291c52929c425bfe91610e861be89199463467b6eef6bad36b9b5673bf0", size = 19779, upload-time = "2026-07-03T14:41:02.75Z" }, + { url = "https://files.pythonhosted.org/packages/8f/1c/1a55716d3181155b0ff187ad76a39f4c938e7031e54ad7f9b7159099ef65/kanne-2.6.0-py3-none-any.whl", hash = "sha256:e2610c9c5c022d49579d877a61623bbeaa64cdc2889a2e9ced81748178f2e2a2", size = 19784, upload-time = "2026-09-01T21:45:52.037Z" }, ] [[package]] @@ -2514,7 +2530,7 @@ name = "koil" version = "3.3.7" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pydantic", marker = "python_full_version < '3.14'" }, + { name = "pydantic" }, ] sdist = { url = "https://files.pythonhosted.org/packages/cb/97/aee2693f3206e25c9ce47f65765b4a09f19a960c6376ebd2cb6bfd8183f4/koil-3.3.7.tar.gz", hash = "sha256:92803f5b912be0e648cb996be65936a0c2e1c44f05aa05dc4451114d76c711e2", size = 43171, upload-time = "2026-10-07T13:45:33.822Z" } wheels = [ @@ -2526,13 +2542,13 @@ name = "lantz-core" version = "0.5.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pimpmyclass", marker = "python_full_version < '3.14'" }, - { name = "pint", marker = "python_full_version < '3.14'" }, - { name = "pysignal", marker = "python_full_version < '3.14'" }, - { name = "pyvisa", marker = "python_full_version < '3.14'" }, - { name = "pyyaml", marker = "python_full_version < '3.14'" }, - { name = "serialize", marker = "python_full_version < '3.14'" }, - { name = "stringparser", marker = "python_full_version < '3.14'" }, + { name = "pimpmyclass" }, + { name = "pint" }, + { name = "pysignal" }, + { name = "pyvisa" }, + { name = "pyyaml" }, + { name = "serialize" }, + { name = "stringparser" }, ] sdist = { url = "https://files.pythonhosted.org/packages/24/35/b4255ea9bfd9f309e3cea5f5c78e95e45e841aff5a415671eb94765e1653/lantz-core-0.5.3.tar.gz", hash = "sha256:9ad1b74c1549fb31db492b3cb836bf710f4b7b9a0c729e0a908c7eec21db0afb", size = 38057, upload-time = "2019-05-16T00:00:01.653Z" } @@ -2541,7 +2557,7 @@ name = "lantz-drivers" version = "0.5.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "lantz-core", marker = "python_full_version < '3.14'" }, + { name = "lantz-core" }, ] sdist = { url = "https://files.pythonhosted.org/packages/83/3d/708d2abbbea452dfb5657188a576234244da6e296ba3c95a961e28d375dc/lantz-drivers-0.5.2.tar.gz", hash = "sha256:8a8de249f07fda0ae008f55446f8e2964ff793fe6bde07be492435823bbf1023", size = 709115, upload-time = "2019-01-21T17:38:34.328Z" } @@ -2550,7 +2566,7 @@ name = "lantz-sims" version = "0.5.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "lantz-core", marker = "python_full_version < '3.14'" }, + { name = "lantz-core" }, ] sdist = { url = "https://files.pythonhosted.org/packages/dd/7a/2334917858d98b500943a8854cd412c1c0829e676fb7e5febed4c84239e8/lantz-sims-0.5.2.tar.gz", hash = "sha256:5e538f7a5b40ffeb16795df0a053dc0106d35b1e4f3fbdfad8995123efced431", size = 11153, upload-time = "2019-01-21T19:21:25.847Z" } @@ -2559,9 +2575,9 @@ name = "lantzdev" version = "0.5.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "lantz-core", marker = "python_full_version < '3.14'" }, - { name = "lantz-drivers", marker = "python_full_version < '3.14'" }, - { name = "lantz-sims", marker = "python_full_version < '3.14'" }, + { name = "lantz-core" }, + { name = "lantz-drivers" }, + { name = "lantz-sims" }, ] sdist = { url = "https://files.pythonhosted.org/packages/99/c3/2323e0ec6ba6fdb6a749ab912f88353ece8c388aa731ce2ad15bd67ad5ad/lantzdev-0.5.2.tar.gz", hash = "sha256:d13e828bccd57fb7e29e417dbf78626d2ea3dd3ecdd429440830205788376eb1", size = 930295, upload-time = "2019-01-21T17:34:23.442Z" } @@ -2579,7 +2595,7 @@ name = "lazy-loader" version = "0.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "packaging", marker = "python_full_version < '3.14'" }, + { name = "packaging" }, ] sdist = { url = "https://files.pythonhosted.org/packages/6f/6b/c875b30a1ba490860c93da4cabf479e03f584eba06fe5963f6f6644653d8/lazy_loader-0.4.tar.gz", hash = "sha256:47c75182589b91a4e1a85a136c074285a5ad4d9f39c63e0d7fb76391c4574cd1", size = 15431, upload-time = "2024-04-05T13:03:12.261Z" } wheels = [ @@ -2623,8 +2639,8 @@ name = "luddite" version = "1.0.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "colorama", marker = "python_full_version < '3.14' and sys_platform == 'win32'" }, - { name = "packaging", marker = "python_full_version < '3.14'" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "packaging" }, ] sdist = { url = "https://files.pythonhosted.org/packages/9e/93/23defe449b102db8744ea89984aafb4b10df7f91ddabc73ecae07ef13a6e/luddite-1.0.4.tar.gz", hash = "sha256:e05001efc80eb6c1c7514439812fbc71a66d59e031e09f9a72772f3e6cddfab7", size = 9563, upload-time = "2024-03-14T18:05:40.032Z" } wheels = [ @@ -2636,9 +2652,9 @@ name = "luma-core" version = "2.5.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cbor2", marker = "python_full_version < '3.14'" }, - { name = "pillow", marker = "python_full_version < '3.14'" }, - { name = "smbus2", marker = "python_full_version < '3.14'" }, + { name = "cbor2" }, + { name = "pillow" }, + { name = "smbus2" }, ] sdist = { url = "https://files.pythonhosted.org/packages/0a/1a/e706039601ac5a3e3a13a5baf8d9fc3764a62e425a674c296f7ddfc546a0/luma_core-2.5.1.tar.gz", hash = "sha256:9b88fbe868989ec4477e210fe2993e774a7425d7de8378814109f98be32ca653", size = 102996, upload-time = "2025-07-20T16:18:38.637Z" } wheels = [ @@ -2650,7 +2666,7 @@ name = "luma-oled" version = "3.14.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "luma-core", marker = "python_full_version < '3.14'" }, + { name = "luma-core" }, ] sdist = { url = "https://files.pythonhosted.org/packages/95/a7/c5a51d4980a3a4db3b63570731eeac61f2e1142d5462f7e2866ed9d87070/luma_oled-3.14.0.tar.gz", hash = "sha256:36218565eda0614c8cf44ef42cb9a5904ddf808e4516e99ddae111fc93c5a206", size = 16429131, upload-time = "2024-11-02T23:20:47.97Z" } wheels = [ @@ -2694,7 +2710,7 @@ name = "markdown-it-py" version = "4.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "mdurl", marker = "python_full_version < '3.14'" }, + { name = "mdurl" }, ] sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" } wheels = [ @@ -2754,7 +2770,7 @@ name = "marshmallow" version = "3.26.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "packaging", marker = "python_full_version < '3.14'" }, + { name = "packaging" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ab/5e/5e53d26b42ab75491cda89b871dab9e97c840bf12c63ec58a1919710cd06/marshmallow-3.26.1.tar.gz", hash = "sha256:e6d8affb6cb61d39d26402096dc0aee12d5a26d490a121f118d2e81dc0719dc6", size = 221825, upload-time = "2025-02-03T15:32:25.093Z" } wheels = [ @@ -2766,15 +2782,15 @@ name = "matplotlib" version = "3.9.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "contourpy", marker = "python_full_version < '3.14'" }, - { name = "cycler", marker = "python_full_version < '3.14'" }, - { name = "fonttools", marker = "python_full_version < '3.14'" }, - { name = "kiwisolver", marker = "python_full_version < '3.14'" }, - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "packaging", marker = "python_full_version < '3.14'" }, - { name = "pillow", marker = "python_full_version < '3.14'" }, - { name = "pyparsing", marker = "python_full_version < '3.14'" }, - { name = "python-dateutil", marker = "python_full_version < '3.14'" }, + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, ] sdist = { url = "https://files.pythonhosted.org/packages/9e/d8/3d7f706c69e024d4287c1110d74f7dabac91d9843b99eadc90de9efc8869/matplotlib-3.9.2.tar.gz", hash = "sha256:96ab43906269ca64a6366934106fa01534454a69e471b7bf3d79083981aaab92", size = 36088381, upload-time = "2024-08-13T01:45:36.875Z" } wheels = [ @@ -2808,7 +2824,7 @@ name = "matplotlib-inline" version = "0.1.7" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "traitlets", marker = "python_full_version < '3.14'" }, + { name = "traitlets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/99/5b/a36a337438a14116b16480db471ad061c36c3694df7c2084a0da7ba538b7/matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90", size = 8159, upload-time = "2024-04-15T13:44:44.803Z" } wheels = [ @@ -2826,45 +2842,28 @@ wheels = [ [[package]] name = "mikro" -version = "6.2.1" +version = "14.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "arkitekt-spec", marker = "python_full_version < '3.14'" }, - { name = "dask", marker = "python_full_version < '3.14'" }, - { name = "fakts", marker = "python_full_version < '3.14'" }, - { name = "kanne", marker = "python_full_version < '3.14'" }, - { name = "numcodecs", marker = "python_full_version < '3.14'" }, + { name = "arkitekt-spec" }, + { name = "dask" }, + { name = "fakts" }, + { name = "kanne" }, + { name = "numcodecs" }, { name = "numpy", marker = "python_full_version >= '3.12' and python_full_version < '3.14'" }, - { name = "obstore", marker = "python_full_version < '3.14'" }, - { name = "rath", marker = "python_full_version < '3.14'" }, - { name = "websockets", marker = "python_full_version < '3.14'" }, - { name = "xarray", marker = "python_full_version < '3.14'" }, - { name = "zarr", marker = "python_full_version < '3.14'" }, + { name = "obstore" }, + { name = "rath" }, + { name = "websockets" }, + { name = "zarr" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d1/f9/55cdf6eb526e16841037bb71b66afdd75161878b9eaee8b5c551536218ce/mikro-6.2.1.tar.gz", hash = "sha256:b69faa724192ccb41b3eec771a7a2da2d9b4c24cda022a9f3eeae729945ed501", size = 373287, upload-time = "2026-09-30T19:17:19.134Z" } +sdist = { url = "https://files.pythonhosted.org/packages/75/87/c74aa9811166f441936819deebba75c3829f559d42642e712e48b58dd1c9/mikro-14.0.0.tar.gz", hash = "sha256:34e0975c8485a5556acc52213a5a2b237b9af94a90398a63240bbadf24c1e2a8", size = 526024, upload-time = "2026-11-15T12:27:03.883Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/31/79/8b50528aba523be4ba25e722d3cce4a321f63b9578028d44caff43e6d1cf/mikro-6.2.1-py3-none-any.whl", hash = "sha256:b2d80e4d8909d2eed1f1d0e5ee02d42976db75687bbbd2963e8a4aed1baeeb1e", size = 391308, upload-time = "2026-09-30T19:17:17.997Z" }, + { url = "https://files.pythonhosted.org/packages/a0/b7/32fe9ea2cc8886da50cf1b39479bbeac149690ed125b5e2c2c00a40d9ab4/mikro-14.0.0-py3-none-any.whl", hash = "sha256:c0dc8f14f85ae33e9d707b4e806077e8897b7c6e242bf81e60891f08f8cfba47", size = 545265, upload-time = "2026-11-15T12:27:02.415Z" }, ] -[[package]] -name = "mikro-next" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "dask", marker = "python_full_version < '3.14'" }, - { name = "fakts-next", marker = "python_full_version < '3.14'" }, - { name = "numcodecs", marker = "python_full_version < '3.14'" }, - { name = "numpy", marker = "python_full_version >= '3.12' and python_full_version < '3.14'" }, - { name = "obstore", marker = "python_full_version < '3.14'" }, - { name = "pytest", marker = "python_full_version < '3.14'" }, - { name = "rath", marker = "python_full_version < '3.14'" }, - { name = "websockets", marker = "python_full_version < '3.14'" }, - { name = "xarray", marker = "python_full_version < '3.14'" }, - { name = "zarr", marker = "python_full_version < '3.14'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/8b/4c/f73f14af5d650d83ed2c6810f54ccb569f5f9f85d8c7c47291da61e8cd5b/mikro_next-2.0.0.tar.gz", hash = "sha256:ebebfe23707a6dbcc012d36063521b4467a67a278996bc832b73a6c1d629e6d1", size = 108533, upload-time = "2026-06-24T16:29:29.574Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/85/ec/caa686f24145b88bc7aa2de12c5e9afa169445fb645eede8bbc37bea5087/mikro_next-2.0.0-py3-none-any.whl", hash = "sha256:e6f66b1700e40ab8658d5bf043be9532b45597b9aae7381a949c0699e31a467f", size = 119301, upload-time = "2026-06-24T16:29:28.529Z" }, +[package.optional-dependencies] +xarray = [ + { name = "xarray" }, ] [[package]] @@ -2881,7 +2880,7 @@ name = "ml-dtypes" version = "0.5.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "python_full_version < '3.14'" }, + { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/0e/4a/c27b42ed9b1c7d13d9ba8b6905dece787d6259152f2309338aed29b2447b/ml_dtypes-0.5.4.tar.gz", hash = "sha256:8ab06a50fb9bf9666dd0fe5dfb4676fa2b0ac0f31ecff72a6c3af8e22c063453", size = 692314, upload-time = "2025-11-17T22:32:31.031Z" } wheels = [ @@ -3050,14 +3049,14 @@ name = "nanoimagingpack" version = "2.1.5" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "clize", marker = "python_full_version < '3.14'" }, - { name = "imageio", marker = "python_full_version < '3.14'" }, - { name = "matplotlib", marker = "python_full_version < '3.14'" }, - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "ruamel-yaml", marker = "python_full_version < '3.14'" }, - { name = "scipy", marker = "python_full_version < '3.14'" }, - { name = "tifffile", marker = "python_full_version < '3.14'" }, - { name = "tkinterdnd2", marker = "python_full_version < '3.14'" }, + { name = "clize" }, + { name = "imageio" }, + { name = "matplotlib" }, + { name = "numpy" }, + { name = "ruamel-yaml" }, + { name = "scipy" }, + { name = "tifffile" }, + { name = "tkinterdnd2" }, ] sdist = { url = "https://files.pythonhosted.org/packages/28/21/4ff6f22688995e3a7acf5685e370edb202fd267c28ce4cc6f12acbb06e33/nanoimagingpack-2.1.5.tar.gz", hash = "sha256:6857ff5c037418de9703b4b9908c7bfe9770f5b8e47ac51fa5fc63553ee751b7", size = 5112961, upload-time = "2026-05-02T09:36:38.022Z" } wheels = [ @@ -3078,10 +3077,10 @@ name = "nbclient" version = "0.10.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "jupyter-client", marker = "python_full_version < '3.14'" }, - { name = "jupyter-core", marker = "python_full_version < '3.14'" }, - { name = "nbformat", marker = "python_full_version < '3.14'" }, - { name = "traitlets", marker = "python_full_version < '3.14'" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/87/66/7ffd18d58eae90d5721f9f39212327695b749e23ad44b3881744eaf4d9e8/nbclient-0.10.2.tar.gz", hash = "sha256:90b7fc6b810630db87a6d0c2250b1f0ab4cf4d3c27a299b0cde78a4ed3fd9193", size = 62424, upload-time = "2024-12-19T10:32:27.164Z" } wheels = [ @@ -3093,20 +3092,20 @@ name = "nbconvert" version = "7.16.6" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "beautifulsoup4", marker = "python_full_version < '3.14'" }, - { name = "bleach", extra = ["css"], marker = "python_full_version < '3.14'" }, - { name = "defusedxml", marker = "python_full_version < '3.14'" }, - { name = "jinja2", marker = "python_full_version < '3.14'" }, - { name = "jupyter-core", marker = "python_full_version < '3.14'" }, - { name = "jupyterlab-pygments", marker = "python_full_version < '3.14'" }, - { name = "markupsafe", marker = "python_full_version < '3.14'" }, - { name = "mistune", marker = "python_full_version < '3.14'" }, - { name = "nbclient", marker = "python_full_version < '3.14'" }, - { name = "nbformat", marker = "python_full_version < '3.14'" }, - { name = "packaging", marker = "python_full_version < '3.14'" }, - { name = "pandocfilters", marker = "python_full_version < '3.14'" }, - { name = "pygments", marker = "python_full_version < '3.14'" }, - { name = "traitlets", marker = "python_full_version < '3.14'" }, + { name = "beautifulsoup4" }, + { name = "bleach", extra = ["css"] }, + { name = "defusedxml" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyterlab-pygments" }, + { name = "markupsafe" }, + { name = "mistune" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pandocfilters" }, + { name = "pygments" }, + { name = "traitlets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/a3/59/f28e15fc47ffb73af68a8d9b47367a8630d76e97ae85ad18271b9db96fdf/nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582", size = 857715, upload-time = "2025-01-28T09:29:14.724Z" } wheels = [ @@ -3118,10 +3117,10 @@ name = "nbformat" version = "5.10.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "fastjsonschema", marker = "python_full_version < '3.14'" }, - { name = "jsonschema", marker = "python_full_version < '3.14'" }, - { name = "jupyter-core", marker = "python_full_version < '3.14'" }, - { name = "traitlets", marker = "python_full_version < '3.14'" }, + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749, upload-time = "2024-04-04T11:20:37.371Z" } wheels = [ @@ -3151,14 +3150,14 @@ name = "nidaqmx" version = "1.2.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "click", marker = "python_full_version < '3.14'" }, - { name = "deprecation", marker = "python_full_version < '3.14'" }, - { name = "distro", marker = "python_full_version < '3.14' and sys_platform == 'linux'" }, - { name = "hightime", marker = "python_full_version < '3.14'" }, - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "python-decouple", marker = "python_full_version < '3.14'" }, - { name = "requests", marker = "python_full_version < '3.14'" }, - { name = "tzlocal", marker = "python_full_version < '3.14'" }, + { name = "click" }, + { name = "deprecation" }, + { name = "distro", marker = "sys_platform == 'linux'" }, + { name = "hightime" }, + { name = "numpy" }, + { name = "python-decouple" }, + { name = "requests" }, + { name = "tzlocal" }, ] sdist = { url = "https://files.pythonhosted.org/packages/3b/ba/d6d915cb1e2b18b95dc756f5394db2bc0d6c516dbf40dc5a3c6e05d6e4f3/nidaqmx-1.2.0.tar.gz", hash = "sha256:faeea9889a2dae03b7e23f525a44889264a5cfbf5590558e3792c28871620c87", size = 475927, upload-time = "2025-07-30T16:32:12.247Z" } wheels = [ @@ -3170,11 +3169,11 @@ name = "notebook" version = "7.2.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "jupyter-server", marker = "python_full_version < '3.14'" }, - { name = "jupyterlab", marker = "python_full_version < '3.14'" }, - { name = "jupyterlab-server", marker = "python_full_version < '3.14'" }, - { name = "notebook-shim", marker = "python_full_version < '3.14'" }, - { name = "tornado", marker = "python_full_version < '3.14'" }, + { name = "jupyter-server" }, + { name = "jupyterlab" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "tornado" }, ] sdist = { url = "https://files.pythonhosted.org/packages/07/66/d13ec1837cba25b8cfe07a6f727916929dff238023ebaaaeb33ee2359912/notebook-7.2.3.tar.gz", hash = "sha256:3bf03e92f97f0f28bfd3faabe19bdb7fde0c53a58adac78f0b61b1334a53f7a1", size = 5010536, upload-time = "2024-12-05T11:27:14.754Z" } wheels = [ @@ -3186,7 +3185,7 @@ name = "notebook-shim" version = "0.2.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "jupyter-server", marker = "python_full_version < '3.14'" }, + { name = "jupyter-server" }, ] sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167, upload-time = "2024-02-14T23:35:18.353Z" } wheels = [ @@ -3198,8 +3197,8 @@ name = "numba" version = "0.62.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "llvmlite", marker = "python_full_version < '3.14'" }, - { name = "numpy", marker = "python_full_version < '3.14'" }, + { name = "llvmlite" }, + { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/e5/96/66dae7911cb331e99bf9afe35703317d8da0fad81ff49fed77f4855e4b60/numba-0.62.0.tar.gz", hash = "sha256:2afcc7899dc93fefecbb274a19c592170bc2dbfae02b00f83e305332a9857a5a", size = 2749680, upload-time = "2025-09-18T17:58:11.394Z" } wheels = [ @@ -3225,8 +3224,8 @@ name = "numcodecs" version = "0.16.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "numpy" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/f6/48/6188e359b90a9d8a1850f2bc888c023e66f4a8b2b496820babbea414f008/numcodecs-0.16.3.tar.gz", hash = "sha256:53d705865faaf0a7927c973af3777532001c8fbb653de119c1e844608614d799", size = 6275704, upload-time = "2025-09-18T18:54:57.221Z" } wheels = [ @@ -3249,7 +3248,7 @@ wheels = [ [package.optional-dependencies] crc32c = [ - { name = "crc32c", marker = "python_full_version < '3.14'" }, + { name = "crc32c" }, ] [[package]] @@ -3298,21 +3297,12 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/48/6f/129e3c17e3befe7fefdeaa6890f4c4df3f3cf0831aa053802c3862da67aa/numpy-2.1.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:ef444c57d664d35cac4e18c298c47d7b504c66b17c2ea91312e979fcfbdfb08a", size = 14066202, upload-time = "2024-10-05T18:43:06.803Z" }, ] -[[package]] -name = "oauthlib" -version = "3.3.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/0b/5f/19930f824ffeb0ad4372da4812c50edbd1434f678c90c2733e1188edfc63/oauthlib-3.3.1.tar.gz", hash = "sha256:0f0f8aa759826a193cf66c12ea1af1637f87b9b4622d46e866952bb022e538c9", size = 185918, upload-time = "2025-06-19T22:48:08.269Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/be/9c/92789c596b8df838baa98fa71844d84283302f7604ed565dafe5a6b5041a/oauthlib-3.3.1-py3-none-any.whl", hash = "sha256:88119c938d2b8fb88561af5f6ee0eec8cc8d552b7bb1f712743136eb7523b7a1", size = 160065, upload-time = "2025-06-19T22:48:06.508Z" }, -] - [[package]] name = "obstore" version = "0.11.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.13'" }, + { name = "typing-extensions", marker = "python_full_version != '3.13.*'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/2e/2f/f83afaab7945509d72245b2b00af0b4834ce78fdd2d9ae9f0ad1a3036a91/obstore-0.11.0.tar.gz", hash = "sha256:a2f55163bcd348b4a60d12e6893eac50eddc742bad8032a1705d49140b992204", size = 130565, upload-time = "2026-06-25T18:29:49.405Z" } wheels = [ @@ -3370,10 +3360,10 @@ name = "ome-types" version = "0.6.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pydantic", marker = "python_full_version < '3.14'" }, + { name = "pydantic" }, { name = "pydantic-core", marker = "python_full_version == '3.13.*'" }, - { name = "pydantic-extra-types", marker = "python_full_version < '3.14'" }, - { name = "xsdata", marker = "python_full_version < '3.14'" }, + { name = "pydantic-extra-types" }, + { name = "xsdata" }, ] sdist = { url = "https://files.pythonhosted.org/packages/48/4c/d252c1619c733eec9b4d2d21fe369fd21a2594954b396bf4352edea1e272/ome_types-0.6.3.tar.gz", hash = "sha256:eef4138cda5edfdcb2a44cfb90b714a59ead1b69e4c5ce5f9892ad397ccaaa68", size = 121784, upload-time = "2025-11-26T00:28:24.34Z" } wheels = [ @@ -3385,12 +3375,13 @@ name = "ome-zarr-models" version = "1.7" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version < '3.12'", + "(python_full_version < '3.12' and platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version < '3.12' and platform_machine == 'x86_64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version < '3.12' and platform_machine == 'AMD64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version < '3.12' and platform_machine == 'ARM64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version < '3.12' and platform_python_implementation == 'CPython' and sys_platform == 'darwin')", + "(python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux') or (python_full_version < '3.12' and platform_machine != 'AMD64' and platform_machine != 'ARM64' and sys_platform == 'win32') or (python_full_version < '3.12' and platform_python_implementation != 'CPython') or (python_full_version < '3.12' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')", ] dependencies = [ - { name = "pydantic", marker = "python_full_version < '3.12'" }, - { name = "pydantic-zarr", version = "0.9.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, - { name = "zarr", marker = "python_full_version < '3.12'" }, + { name = "pydantic" }, + { name = "pydantic-zarr", version = "0.9.2", source = { registry = "https://pypi.org/simple" } }, + { name = "zarr" }, ] sdist = { url = "https://files.pythonhosted.org/packages/03/17/f4aa0b46a59ba4e7875dc031f5401f709c9fe987bed9932b067c64bac0e2/ome_zarr_models-1.7.tar.gz", hash = "sha256:3979d304f7669e7a22be0bd8a6dd5dcc93fe85af3d842e56930d2ef2e6929090", size = 107192, upload-time = "2026-04-16T12:23:19.147Z" } wheels = [ @@ -3402,14 +3393,16 @@ name = "ome-zarr-models" version = "1.8.1" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version == '3.13.*'", - "python_full_version == '3.12.*'", + "(python_full_version == '3.13.*' and platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version == '3.13.*' and platform_machine == 'x86_64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version == '3.13.*' and platform_machine == 'AMD64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version == '3.13.*' and platform_machine == 'ARM64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version == '3.13.*' and platform_python_implementation == 'CPython' and sys_platform == 'darwin')", + "(python_full_version == '3.13.*' and platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux') or (python_full_version == '3.13.*' and platform_machine != 'AMD64' and platform_machine != 'ARM64' and sys_platform == 'win32') or (python_full_version == '3.13.*' and platform_python_implementation != 'CPython') or (python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')", + "(python_full_version == '3.12.*' and platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version == '3.12.*' and platform_machine == 'x86_64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version == '3.12.*' and platform_machine == 'AMD64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version == '3.12.*' and platform_machine == 'ARM64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version == '3.12.*' and platform_python_implementation == 'CPython' and sys_platform == 'darwin')", + "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux') or (python_full_version == '3.12.*' and platform_machine != 'AMD64' and platform_machine != 'ARM64' and sys_platform == 'win32') or (python_full_version == '3.12.*' and platform_python_implementation != 'CPython') or (python_full_version == '3.12.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')", ] dependencies = [ - { name = "numpy", marker = "python_full_version >= '3.12' and python_full_version < '3.14'" }, - { name = "pydantic", marker = "python_full_version >= '3.12' and python_full_version < '3.14'" }, - { name = "pydantic-zarr", version = "0.10.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' and python_full_version < '3.14'" }, - { name = "zarr", marker = "python_full_version >= '3.12' and python_full_version < '3.14'" }, + { name = "numpy" }, + { name = "pydantic" }, + { name = "pydantic-zarr", version = "0.10.0", source = { registry = "https://pypi.org/simple" } }, + { name = "zarr" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ce/dc/40862badc53b5f7188b88bbaa44f86e59b66f3d0ce42aa154990eaeaded2/ome_zarr_models-1.8.1.tar.gz", hash = "sha256:df51b4007151e46e2400460ada140bc6f793b4cfc50cdbfc932969350ec7137b", size = 60603, upload-time = "2026-09-02T10:25:43.946Z" } wheels = [ @@ -3421,15 +3414,15 @@ name = "omero-py" version = "5.22.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "appdirs", marker = "python_full_version < '3.14'" }, - { name = "future", marker = "python_full_version < '3.14'" }, - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "pillow", marker = "python_full_version < '3.14'" }, - { name = "portalocker", marker = "python_full_version < '3.14'" }, - { name = "pywin32", marker = "python_full_version < '3.14' and sys_platform == 'win32'" }, - { name = "pyyaml", marker = "python_full_version < '3.14'" }, - { name = "requests", marker = "python_full_version < '3.14'" }, - { name = "zeroc-ice", marker = "python_full_version < '3.14'" }, + { name = "appdirs" }, + { name = "future" }, + { name = "numpy" }, + { name = "pillow" }, + { name = "portalocker" }, + { name = "pywin32", marker = "sys_platform == 'win32'" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "zeroc-ice" }, ] sdist = { url = "https://files.pythonhosted.org/packages/5e/b2/41573b991d45925a48a46d8f0ef91a11fb71f80e463f34130f2b596e9e2b/omero_py-5.22.0.tar.gz", hash = "sha256:ccebff4eecaaf73236336b22218d0b18ac7b5ab6442578687658ac91af1d8cd8", size = 2343420, upload-time = "2026-02-09T10:42:43.466Z" } wheels = [ @@ -3441,7 +3434,7 @@ name = "opencv-contrib-python-headless" version = "4.13.0.92" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "python_full_version < '3.14'" }, + { name = "numpy" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/70/b5/9af5b81d9279e9982e21dad52f8a6aec10f7c891ae1e3d3d1b3ce111f8e7/opencv_contrib_python_headless-4.13.0.92-cp37-abi3-macosx_13_0_arm64.whl", hash = "sha256:b0467988c2d56c283b00fb808e0b57f5db2e3ca7743164a3b3efc733bfa03d3a", size = 52041681, upload-time = "2026-02-05T07:01:39.651Z" }, @@ -3459,7 +3452,7 @@ name = "opencv-python" version = "4.13.0.92" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "python_full_version < '3.14'" }, + { name = "numpy" }, ] [[package]] @@ -3485,10 +3478,10 @@ name = "pandas" version = "2.3.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "python-dateutil", marker = "python_full_version < '3.14'" }, - { name = "pytz", marker = "python_full_version < '3.14'" }, - { name = "tzdata", marker = "python_full_version < '3.14'" }, + { name = "numpy" }, + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "tzdata" }, ] sdist = { url = "https://files.pythonhosted.org/packages/79/8e/0e90233ac205ad182bd6b422532695d2b9414944a280488105d598c70023/pandas-2.3.2.tar.gz", hash = "sha256:ab7b58f8f82706890924ccdfb5f48002b83d2b5a3845976a9fb705d36c34dcdb", size = 4488684, upload-time = "2025-08-21T10:28:29.257Z" } wheels = [ @@ -3544,8 +3537,8 @@ name = "partd" version = "1.4.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "locket", marker = "python_full_version < '3.14'" }, - { name = "toolz", marker = "python_full_version < '3.14'" }, + { name = "locket" }, + { name = "toolz" }, ] sdist = { url = "https://files.pythonhosted.org/packages/b2/3a/3f06f34820a31257ddcabdfafc2672c5816be79c7e353b02c1f318daa7d4/partd-1.4.2.tar.gz", hash = "sha256:d022c33afbdc8405c226621b015e8067888173d85f7f5ecebb3cafed9a20f02c", size = 21029, upload-time = "2024-05-06T19:51:41.945Z" } wheels = [ @@ -3557,7 +3550,7 @@ name = "pexpect" version = "4.9.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "ptyprocess", marker = "python_full_version < '3.14'" }, + { name = "ptyprocess" }, ] sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } wheels = [ @@ -3668,10 +3661,10 @@ name = "pint" version = "0.25.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "flexcache", marker = "python_full_version < '3.14'" }, - { name = "flexparser", marker = "python_full_version < '3.14'" }, - { name = "platformdirs", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "flexcache" }, + { name = "flexparser" }, + { name = "platformdirs" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/52/9d/b1379cdbd33a49d17d627bc24e2b63cca06a1c5343b38072d2889499e82e/pint-0.25.3.tar.gz", hash = "sha256:f8f5df6cf65314d74da1ade1bf96f8e3e4d0c41b51577ac53c49e7d44ca5acee", size = 255106, upload-time = "2026-03-19T21:57:08.72Z" } wheels = [ @@ -3710,7 +3703,7 @@ name = "portalocker" version = "3.2.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pywin32", marker = "python_full_version < '3.14' and sys_platform == 'win32'" }, + { name = "pywin32", marker = "sys_platform == 'win32'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/5e/77/65b857a69ed876e1951e88aaba60f5ce6120c33703f7cb61a3c894b8c1b6/portalocker-3.2.0.tar.gz", hash = "sha256:1f3002956a54a8c3730586c5c77bf18fae4149e07eaf1c29fc3faf4d5a3f89ac", size = 95644, upload-time = "2025-06-14T13:20:40.03Z" } wheels = [ @@ -3731,7 +3724,7 @@ name = "prompt-toolkit" version = "3.0.52" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "wcwidth", marker = "python_full_version < '3.14'" }, + { name = "wcwidth" }, ] sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" } wheels = [ @@ -3874,7 +3867,7 @@ name = "py-machineid" version = "1.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "winregistry", marker = "python_full_version < '3.14' and sys_platform == 'win32'" }, + { name = "winregistry", marker = "sys_platform == 'win32'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/f4/b0/c7fa6de7298a8f4e544929b97fa028304c0e11a4bc9500eff8689821bdbb/py_machineid-1.0.0.tar.gz", hash = "sha256:8a902a00fae8c6d6433f463697c21dc4ce98c6e55a2e0535c0273319acb0047a", size = 4629, upload-time = "2025-12-02T16:12:54.286Z" } wheels = [ @@ -3931,10 +3924,10 @@ name = "pydantic" version = "2.12.5" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "annotated-types", marker = "python_full_version < '3.14'" }, - { name = "pydantic-core", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, - { name = "typing-inspection", marker = "python_full_version < '3.14'" }, + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, ] sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" } wheels = [ @@ -3946,7 +3939,7 @@ name = "pydantic-core" version = "2.41.5" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" } wheels = [ @@ -4043,39 +4036,26 @@ name = "pydantic-extra-types" version = "2.11.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pydantic", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "pydantic" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/66/71/dba38ee2651f84f7842206adbd2233d8bbdb59fb85e9fa14232486a8c471/pydantic_extra_types-2.11.1.tar.gz", hash = "sha256:46792d2307383859e923d8fcefa82108b1a141f8a9c0198982b3832ab5ef1049", size = 172002, upload-time = "2026-03-16T08:08:03.92Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/17/c1/3226e6d7f5a4f736f38ac11a6fbb262d701889802595cdb0f53a885ac2e0/pydantic_extra_types-2.11.1-py3-none-any.whl", hash = "sha256:1722ea2bddae5628ace25f2aa685b69978ef533123e5638cfbddb999e0100ec1", size = 79526, upload-time = "2026-03-16T08:08:02.533Z" }, ] -[[package]] -name = "pydantic-settings" -version = "2.11.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pydantic", marker = "python_full_version < '3.14'" }, - { name = "python-dotenv", marker = "python_full_version < '3.14'" }, - { name = "typing-inspection", marker = "python_full_version < '3.14'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/20/c5/dbbc27b814c71676593d1c3f718e6cd7d4f00652cefa24b75f7aa3efb25e/pydantic_settings-2.11.0.tar.gz", hash = "sha256:d0e87a1c7d33593beb7194adb8470fc426e95ba02af83a0f23474a04c9a08180", size = 188394, upload-time = "2025-09-24T14:19:11.764Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/83/d6/887a1ff844e64aa823fb4905978d882a633cfe295c32eacad582b78a7d8b/pydantic_settings-2.11.0-py3-none-any.whl", hash = "sha256:fe2cea3413b9530d10f3a5875adffb17ada5c1e1bab0b2885546d7310415207c", size = 48608, upload-time = "2025-09-24T14:19:10.015Z" }, -] - [[package]] name = "pydantic-zarr" version = "0.9.2" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version < '3.12'", + "(python_full_version < '3.12' and platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version < '3.12' and platform_machine == 'x86_64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version < '3.12' and platform_machine == 'AMD64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version < '3.12' and platform_machine == 'ARM64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version < '3.12' and platform_python_implementation == 'CPython' and sys_platform == 'darwin')", + "(python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux') or (python_full_version < '3.12' and platform_machine != 'AMD64' and platform_machine != 'ARM64' and sys_platform == 'win32') or (python_full_version < '3.12' and platform_python_implementation != 'CPython') or (python_full_version < '3.12' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')", ] dependencies = [ - { name = "numpy", marker = "python_full_version < '3.12'" }, - { name = "packaging", marker = "python_full_version < '3.12'" }, - { name = "pydantic", marker = "python_full_version < '3.12'" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pydantic" }, ] sdist = { url = "https://files.pythonhosted.org/packages/6a/19/ad4f22b7a395408c90cc0f213d70cf5b9ed5f3b0db2b319cacff93b66850/pydantic_zarr-0.9.2.tar.gz", hash = "sha256:59f536cbc456ff4dc64d887d651476e2a6a2ca9f3ea13228dce4e3aeb1cf00b9", size = 80379, upload-time = "2026-03-18T14:38:30.766Z" } wheels = [ @@ -4087,13 +4067,15 @@ name = "pydantic-zarr" version = "0.10.0" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version == '3.13.*'", - "python_full_version == '3.12.*'", + "(python_full_version == '3.13.*' and platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version == '3.13.*' and platform_machine == 'x86_64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version == '3.13.*' and platform_machine == 'AMD64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version == '3.13.*' and platform_machine == 'ARM64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version == '3.13.*' and platform_python_implementation == 'CPython' and sys_platform == 'darwin')", + "(python_full_version == '3.13.*' and platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux') or (python_full_version == '3.13.*' and platform_machine != 'AMD64' and platform_machine != 'ARM64' and sys_platform == 'win32') or (python_full_version == '3.13.*' and platform_python_implementation != 'CPython') or (python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')", + "(python_full_version == '3.12.*' and platform_machine == 'aarch64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version == '3.12.*' and platform_machine == 'x86_64' and platform_python_implementation == 'CPython' and sys_platform == 'linux') or (python_full_version == '3.12.*' and platform_machine == 'AMD64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version == '3.12.*' and platform_machine == 'ARM64' and platform_python_implementation == 'CPython' and sys_platform == 'win32') or (python_full_version == '3.12.*' and platform_python_implementation == 'CPython' and sys_platform == 'darwin')", + "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux') or (python_full_version == '3.12.*' and platform_machine != 'AMD64' and platform_machine != 'ARM64' and sys_platform == 'win32') or (python_full_version == '3.12.*' and platform_python_implementation != 'CPython') or (python_full_version == '3.12.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')", ] dependencies = [ - { name = "numpy", marker = "python_full_version >= '3.12' and python_full_version < '3.14'" }, - { name = "packaging", marker = "python_full_version >= '3.12' and python_full_version < '3.14'" }, - { name = "pydantic", marker = "python_full_version >= '3.12' and python_full_version < '3.14'" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pydantic" }, ] sdist = { url = "https://files.pythonhosted.org/packages/2f/57/aac9e500abe15719b7406d55871fc8787e7d0ebf83de5f98d44471139f70/pydantic_zarr-0.10.0.tar.gz", hash = "sha256:996b5b4225fb05757e7fff831ee7a75c61f54514a4c2493c7b79635bade7b415", size = 80374, upload-time = "2026-04-23T14:23:12.575Z" } wheels = [ @@ -4105,7 +4087,7 @@ name = "pyee" version = "13.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/95/03/1fd98d5841cd7964a27d729ccf2199602fe05eb7a405c1462eb7277945ed/pyee-13.0.0.tar.gz", hash = "sha256:b391e3c5a434d1f5118a25615001dbc8f669cf410ab67d04c4d4e07c55481c37", size = 31250, upload-time = "2025-03-17T18:53:15.955Z" } wheels = [ @@ -4174,7 +4156,7 @@ name = "pylibsrtp" version = "0.12.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cffi", marker = "python_full_version < '3.14'" }, + { name = "cffi" }, ] sdist = { url = "https://files.pythonhosted.org/packages/54/c8/a59e61f5dd655f5f21033bd643dd31fe980a537ed6f373cdfb49d3a3bd32/pylibsrtp-0.12.0.tar.gz", hash = "sha256:f5c3c0fb6954e7bb74dc7e6398352740ca67327e6759a199fe852dbc7b84b8ac", size = 10878, upload-time = "2025-04-06T12:35:51.804Z" } wheels = [ @@ -4195,7 +4177,7 @@ name = "pymmcore" version = "12.5.0.75.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "python_full_version < '3.14'" }, + { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/f5/51/e75186deeff67e4ba5b6c340343d7efc2d6819a2607e1927547754ea6183/pymmcore-12.5.0.75.0.tar.gz", hash = "sha256:c78670ff99ea2a4424d41eea7f0f0b6059053689af7700a5b19815fa8dde8390", size = 1418871, upload-time = "2026-05-06T08:34:20.948Z" } wheels = [ @@ -4222,16 +4204,16 @@ name = "pymmcore-plus" version = "0.17.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "ome-types", marker = "python_full_version < '3.14'" }, - { name = "platformdirs", marker = "python_full_version < '3.14'" }, - { name = "psygnal", marker = "python_full_version < '3.14'" }, - { name = "pymmcore", marker = "python_full_version < '3.14'" }, - { name = "rich", marker = "python_full_version < '3.14'" }, - { name = "tensorstore", marker = "python_full_version < '3.14'" }, - { name = "typer", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, - { name = "useq-schema", marker = "python_full_version < '3.14'" }, + { name = "numpy" }, + { name = "ome-types" }, + { name = "platformdirs" }, + { name = "psygnal" }, + { name = "pymmcore" }, + { name = "rich" }, + { name = "tensorstore" }, + { name = "typer" }, + { name = "typing-extensions" }, + { name = "useq-schema" }, ] sdist = { url = "https://files.pythonhosted.org/packages/4e/c8/262b1f3eed32f04f1796281f5e4629cc0b3d6e936499a25a79a898f26e4b/pymmcore_plus-0.17.3.tar.gz", hash = "sha256:c247a386d954fa9467ca7793ac274cf48cec4f86a0575fb1d867eb32df1a7348", size = 275218, upload-time = "2026-02-21T00:35:03.21Z" } wheels = [ @@ -4243,8 +4225,8 @@ name = "pyopenssl" version = "25.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cryptography", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.13'" }, + { name = "cryptography" }, + { name = "typing-extensions", marker = "python_full_version != '3.13.*'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/80/be/97b83a464498a79103036bc74d1038df4a7ef0e402cfaf4d5e113fb14759/pyopenssl-25.3.0.tar.gz", hash = "sha256:c981cb0a3fd84e8602d7afc209522773b94c1c2446a3c710a75b06fe1beae329", size = 184073, upload-time = "2025-09-17T00:32:21.037Z" } wheels = [ @@ -4289,11 +4271,11 @@ name = "pytest" version = "8.4.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "colorama", marker = "python_full_version < '3.14' and sys_platform == 'win32'" }, - { name = "iniconfig", marker = "python_full_version < '3.14'" }, - { name = "packaging", marker = "python_full_version < '3.14'" }, - { name = "pluggy", marker = "python_full_version < '3.14'" }, - { name = "pygments", marker = "python_full_version < '3.14'" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, ] sdist = { url = "https://files.pythonhosted.org/packages/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618, upload-time = "2025-09-04T14:34:22.711Z" } wheels = [ @@ -4305,9 +4287,9 @@ name = "python-can" version = "4.6.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "packaging", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, - { name = "wrapt", marker = "python_full_version < '3.14'" }, + { name = "packaging" }, + { name = "typing-extensions" }, + { name = "wrapt" }, ] sdist = { url = "https://files.pythonhosted.org/packages/74/f9/a9d99d36dd33be5badb747801c9255c3c526171a5542092eaacc73350fb8/python_can-4.6.1.tar.gz", hash = "sha256:290fea135d04b8504ebff33889cc6d301e2181a54099116609f940825ffe5005", size = 1206049, upload-time = "2025-08-12T07:44:58.314Z" } wheels = [ @@ -4319,7 +4301,7 @@ name = "python-dateutil" version = "2.9.0.post0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "six", marker = "python_full_version < '3.14'" }, + { name = "six" }, ] sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } wheels = [ @@ -4349,7 +4331,7 @@ name = "python-engineio" version = "4.12.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "simple-websocket", marker = "python_full_version < '3.14'" }, + { name = "simple-websocket" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ba/0b/67295279b66835f9fa7a491650efcd78b20321c127036eef62c11a31e028/python_engineio-4.12.2.tar.gz", hash = "sha256:e7e712ffe1be1f6a05ee5f951e72d434854a32fcfc7f6e4d9d3cae24ec70defa", size = 91677, upload-time = "2025-06-04T19:22:18.789Z" } wheels = [ @@ -4379,8 +4361,8 @@ name = "python-socketio" version = "5.12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "bidict", marker = "python_full_version < '3.14'" }, - { name = "python-engineio", marker = "python_full_version < '3.14'" }, + { name = "bidict" }, + { name = "python-engineio" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ce/d0/40ed38076e8aee94785d546d3e3a1cae393da5806a8530be877187e2875f/python_socketio-5.12.1.tar.gz", hash = "sha256:0299ff1f470b676c09c1bfab1dead25405077d227b2c13cf217a34dadc68ba9c", size = 119991, upload-time = "2024-12-29T20:11:51.506Z" } wheels = [ @@ -4407,7 +4389,7 @@ name = "pyvisa-py" version = "0.4.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pyvisa", marker = "python_full_version < '3.14'" }, + { name = "pyvisa" }, ] sdist = { url = "https://files.pythonhosted.org/packages/15/33/cb7d367d00702338c2bcc32dcdefb4c2d2ae4b77044759595435244231d8/PyVISA-py-0.4.1.tar.gz", hash = "sha256:4b60d984906c1957c70044b5e5c5eac02e560d0bce678f81af26630bdf38be90", size = 5868007, upload-time = "2020-05-27T22:08:37.995Z" } wheels = [ @@ -4485,7 +4467,7 @@ name = "pyzmq" version = "27.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cffi", marker = "python_full_version < '3.14' and implementation_name == 'pypy'" }, + { name = "cffi", marker = "implementation_name == 'pypy'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" } wheels = [ @@ -4540,16 +4522,16 @@ wheels = [ [[package]] name = "rath" -version = "4.1.2" +version = "4.1.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "graphql-core", marker = "python_full_version < '3.14'" }, - { name = "koil", marker = "python_full_version < '3.14'" }, - { name = "pydantic", marker = "python_full_version < '3.14'" }, + { name = "graphql-core" }, + { name = "koil" }, + { name = "pydantic" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/cb/4c/bf0a743f97c933b7032c986922525f23dab532e81646982062ae0e12d038/rath-4.1.2.tar.gz", hash = "sha256:2b3e482dd5906d09d1536e40f73ca9c7716e5356eb3f1fe18502b76bb428204f", size = 46274, upload-time = "2026-10-07T14:16:59.965Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/64/892a7dd1b67c584c7f086b7faa094f3a21c876a51271137233dcb8132217/rath-4.1.3.tar.gz", hash = "sha256:fd02259ff67ad804d2151a7e468c491971c077708b032216b786a84430d27755", size = 46172, upload-time = "2026-11-14T22:44:10.386Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/70/44/8a10d17526f7b25353039f596f8b4e13f9ce423cc831a202dfe1f5b9af26/rath-4.1.2-py3-none-any.whl", hash = "sha256:7ee5e28bf687aa6877684b23465fa274dab3da93274414104bbdbcf1064e1155", size = 65204, upload-time = "2026-10-07T14:16:58.978Z" }, + { url = "https://files.pythonhosted.org/packages/02/89/f105097af804b39c9d1f91c5b5957c2b2157f13ac907b82be7ea4d05b4e1/rath-4.1.3-py3-none-any.whl", hash = "sha256:de95077d20c0d45a23f872a6921df7e0728bd742fd54d650078bb62e588e6e3e", size = 65299, upload-time = "2026-11-14T22:44:09.368Z" }, ] [[package]] @@ -4566,9 +4548,9 @@ name = "referencing" version = "0.36.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "attrs", marker = "python_full_version < '3.14'" }, - { name = "rpds-py", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.13'" }, + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions", marker = "python_full_version != '3.13.*'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/2f/db/98b5c277be99dd18bfd91dd04e1b759cad18d1a338188c936e92f921c7e2/referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa", size = 74744, upload-time = "2025-01-25T08:48:16.138Z" } wheels = [ @@ -4577,20 +4559,21 @@ wheels = [ [[package]] name = "rekuest" -version = "7.1.0" +version = "15.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "arkitekt-runtime", marker = "python_full_version < '3.14'" }, - { name = "arkitekt-spec", marker = "python_full_version < '3.14'" }, - { name = "fakts", marker = "python_full_version < '3.14'" }, - { name = "koil", marker = "python_full_version < '3.14'" }, - { name = "pydantic", marker = "python_full_version < '3.14'" }, - { name = "rath", marker = "python_full_version < '3.14'" }, - { name = "websockets", marker = "python_full_version < '3.14'" }, + { name = "arkitekt-runtime" }, + { name = "arkitekt-spec" }, + { name = "fakts" }, + { name = "koil" }, + { name = "obstore" }, + { name = "pydantic" }, + { name = "rath" }, + { name = "websockets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/8e/d9/cdee7a69669be1127e93cf8c9a5410f57ef2914734a4b35df3812988cb6a/rekuest-7.1.0.tar.gz", hash = "sha256:92929cafeb824cbadfa6889e744bb0b89ed71c71782b8174fbe82216b44f8274", size = 130797, upload-time = "2026-09-29T22:42:04.205Z" } +sdist = { url = "https://files.pythonhosted.org/packages/4e/86/47d54c1f347f82994812542657d090d0872846ff27dc06a32d13dc3aba91/rekuest-15.0.0.tar.gz", hash = "sha256:fae2fffbac8db456dcdf59f25e5f8fef323ac4e2eca76a32156d5d0bee3be1fa", size = 207067, upload-time = "2026-11-14T22:57:38.979Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/98/eb/d1f7fbf532163df65fac1d27fafa58a709467370fbb73efa848c3a00c948/rekuest-7.1.0-py3-none-any.whl", hash = "sha256:df5616fdfe8e0d089d7433a6c0fe064573583a911b032c018a3618a9af588661", size = 140638, upload-time = "2026-09-29T22:42:03.105Z" }, + { url = "https://files.pythonhosted.org/packages/86/19/d98bd7e97b0422dca2bd6ec7ce75abfd79515cab81e0fc85ac2817add3e0/rekuest-15.0.0-py3-none-any.whl", hash = "sha256:e47b3b0397f752b93b2ed91413623ff0f02754dc71cb0e6b89826fa60f88dc51", size = 219004, upload-time = "2026-11-14T22:57:37.833Z" }, ] [[package]] @@ -4598,10 +4581,10 @@ name = "requests" version = "2.32.5" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "certifi", marker = "python_full_version < '3.14'" }, - { name = "charset-normalizer", marker = "python_full_version < '3.14'" }, - { name = "idna", marker = "python_full_version < '3.14'" }, - { name = "urllib3", marker = "python_full_version < '3.14'" }, + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, ] sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" } wheels = [ @@ -4613,7 +4596,7 @@ name = "rfc3339-validator" version = "0.1.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "six", marker = "python_full_version < '3.14'" }, + { name = "six" }, ] sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513, upload-time = "2021-05-12T16:37:54.178Z" } wheels = [ @@ -4634,7 +4617,7 @@ name = "rfc3987-syntax" version = "1.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "lark", marker = "python_full_version < '3.14'" }, + { name = "lark" }, ] sdist = { url = "https://files.pythonhosted.org/packages/2c/06/37c1a5557acf449e8e406a830a05bf885ac47d33270aec454ef78675008d/rfc3987_syntax-1.1.0.tar.gz", hash = "sha256:717a62cbf33cffdd16dfa3a497d81ce48a660ea691b1ddd7be710c22f00b4a0d", size = 14239, upload-time = "2025-07-18T01:05:05.015Z" } wheels = [ @@ -4646,8 +4629,8 @@ name = "rich" version = "14.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "markdown-it-py", marker = "python_full_version < '3.14'" }, - { name = "pygments", marker = "python_full_version < '3.14'" }, + { name = "markdown-it-py" }, + { name = "pygments" }, ] sdist = { url = "https://files.pythonhosted.org/packages/fe/75/af448d8e52bf1d8fa6a9d089ca6c07ff4453d86c65c145d0a300bb073b9b/rich-14.1.0.tar.gz", hash = "sha256:e497a48b844b0320d45007cdebfeaeed8db2a4f4bcf49f15e455cfc4af11eaa8", size = 224441, upload-time = "2025-07-25T07:32:58.125Z" } wheels = [ @@ -4659,8 +4642,8 @@ name = "rich-click" version = "1.9.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "click", marker = "python_full_version < '3.14'" }, - { name = "rich", marker = "python_full_version < '3.14'" }, + { name = "click" }, + { name = "rich" }, ] sdist = { url = "https://files.pythonhosted.org/packages/29/c2/f08b5e7c1a33af8a115be640aa0796ba01c4732696da6d2254391376b314/rich_click-1.9.1.tar.gz", hash = "sha256:4f2620589d7287f86265432e6a909de4f281de909fe68d8c835fbba49265d268", size = 73109, upload-time = "2025-09-20T22:40:35.362Z" } wheels = [ @@ -4786,7 +4769,7 @@ name = "ruamel-yaml" version = "0.18.15" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "ruamel-yaml-clib", marker = "python_full_version < '3.14' and platform_python_implementation == 'CPython'" }, + { name = "ruamel-yaml-clib", marker = "platform_python_implementation == 'CPython'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/3e/db/f3950f5e5031b618aae9f423a39bf81a55c148aecd15a34527898e752cf4/ruamel.yaml-0.18.15.tar.gz", hash = "sha256:dbfca74b018c4c3fba0b9cc9ee33e53c371194a9000e694995e620490fd40700", size = 146865, upload-time = "2025-08-19T11:15:10.694Z" } wheels = [ @@ -4842,14 +4825,14 @@ name = "scikit-image" version = "0.25.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "imageio", marker = "python_full_version < '3.14'" }, - { name = "lazy-loader", marker = "python_full_version < '3.14'" }, - { name = "networkx", marker = "python_full_version < '3.14'" }, - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "packaging", marker = "python_full_version < '3.14'" }, - { name = "pillow", marker = "python_full_version < '3.14'" }, - { name = "scipy", marker = "python_full_version < '3.14'" }, - { name = "tifffile", marker = "python_full_version < '3.14'" }, + { name = "imageio" }, + { name = "lazy-loader" }, + { name = "networkx" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "scipy" }, + { name = "tifffile" }, ] sdist = { url = "https://files.pythonhosted.org/packages/c7/a8/3c0f256012b93dd2cb6fda9245e9f4bff7dc0486880b248005f15ea2255e/scikit_image-0.25.2.tar.gz", hash = "sha256:e5a37e6cd4d0c018a7a55b9d601357e3382826d3888c10d0213fc63bff977dde", size = 22693594, upload-time = "2025-02-18T18:05:24.538Z" } wheels = [ @@ -4876,10 +4859,10 @@ name = "scikit-learn" version = "1.7.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "joblib", marker = "python_full_version < '3.14'" }, - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "scipy", marker = "python_full_version < '3.14'" }, - { name = "threadpoolctl", marker = "python_full_version < '3.14'" }, + { name = "joblib" }, + { name = "numpy" }, + { name = "scipy" }, + { name = "threadpoolctl" }, ] sdist = { url = "https://files.pythonhosted.org/packages/98/c2/a7855e41c9d285dfe86dc50b250978105dce513d6e459ea66a6aeb0e1e0c/scikit_learn-1.7.2.tar.gz", hash = "sha256:20e9e49ecd130598f1ca38a1d85090e1a600147b9c02fa6f15d69cb53d968fda", size = 7193136, upload-time = "2025-09-09T08:21:29.075Z" } wheels = [ @@ -4915,7 +4898,7 @@ name = "scipy" version = "1.16.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "python_full_version < '3.14'" }, + { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/4c/3b/546a6f0bfe791bbb7f8d591613454d15097e53f906308ec6f7c1ce588e8e/scipy-1.16.2.tar.gz", hash = "sha256:af029b153d243a80afb6eabe40b0a07f8e35c9adc269c019f364ad747f826a6b", size = 30580599, upload-time = "2025-09-11T17:48:08.271Z" } wheels = [ @@ -4981,6 +4964,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/97/30/2f9a5243008f76dfc5dee9a53dfb939d9b31e16ce4bd4f2e628bfc5d89d2/scipy-1.16.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d2a4472c231328d4de38d5f1f68fdd6d28a615138f842580a8a321b5845cf779", size = 26448374, upload-time = "2025-09-11T17:45:03.45Z" }, ] +[[package]] +name = "segno" +version = "1.6.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/2e/b396f750c53f570055bf5a9fc1ace09bed2dff013c73b7afec5702a581ba/segno-1.6.6.tar.gz", hash = "sha256:e60933afc4b52137d323a4434c8340e0ce1e58cec71439e46680d4db188f11b3", size = 1628586, upload-time = "2025-03-12T22:12:53.324Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d6/02/12c73fd423eb9577b97fc1924966b929eff7074ae6b2e15dd3d30cb9e4ae/segno-1.6.6-py3-none-any.whl", hash = "sha256:28c7d081ed0cf935e0411293a465efd4d500704072cdb039778a2ab8736190c7", size = 76503, upload-time = "2025-03-12T22:12:48.106Z" }, +] + [[package]] name = "semver" version = "3.0.4" @@ -5019,7 +5011,7 @@ name = "shapely" version = "2.1.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "python_full_version < '3.14'" }, + { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/4d/bc/0989043118a27cccb4e906a46b7565ce36ca7b57f5a18b78f4f1b0f72d9d/shapely-2.1.2.tar.gz", hash = "sha256:2ed4ecb28320a433db18a5bf029986aa8afcfd740745e78847e330d5d94922a9", size = 315489, upload-time = "2025-09-24T13:51:41.432Z" } wheels = [ @@ -5087,7 +5079,7 @@ name = "sigtools" version = "4.0.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "attrs", marker = "python_full_version < '3.14'" }, + { name = "attrs" }, ] sdist = { url = "https://files.pythonhosted.org/packages/5f/db/669ca14166814da187b3087b908ca924cf83f5b504fe23b3859a3ef67d4f/sigtools-4.0.1.tar.gz", hash = "sha256:4b8e135a9cd4d2ea00da670c093372d74e672ba3abb87f4c98d8e73dea54445c", size = 71910, upload-time = "2022-10-13T07:03:54.149Z" } wheels = [ @@ -5099,7 +5091,7 @@ name = "simple-websocket" version = "1.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "wsproto", marker = "python_full_version < '3.14'" }, + { name = "wsproto" }, ] sdist = { url = "https://files.pythonhosted.org/packages/b0/d4/bfa032f961103eba93de583b161f0e6a5b63cebb8f2c7d0c6e6efe1e3d2e/simple_websocket-1.1.0.tar.gz", hash = "sha256:7939234e7aa067c534abdab3a9ed933ec9ce4691b0713c78acb195560aa52ae4", size = 17300, upload-time = "2024-10-10T22:39:31.412Z" } wheels = [ @@ -5162,9 +5154,9 @@ name = "stack-data" version = "0.6.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "asttokens", marker = "python_full_version < '3.14'" }, - { name = "executing", marker = "python_full_version < '3.14'" }, - { name = "pure-eval", marker = "python_full_version < '3.14'" }, + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, ] sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } wheels = [ @@ -5176,8 +5168,8 @@ name = "starlette" version = "0.48.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "anyio", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.13'" }, + { name = "anyio" }, + { name = "typing-extensions", marker = "python_full_version != '3.13.*'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/a7/a5/d6f429d43394057b67a6b5bbe6eae2f77a6bf7459d961fdb224bf206eee6/starlette-0.48.0.tar.gz", hash = "sha256:7e8cee469a8ab2352911528110ce9088fdc6a37d9876926e73da7ce4aa4c7a46", size = 2652949, upload-time = "2025-09-13T08:41:05.699Z" } wheels = [ @@ -5189,7 +5181,7 @@ name = "stringparser" version = "0.7" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ac/c0/57c5e808f68ed9a822d83413a3516f06a7751dc35e7039252e25994bf654/stringparser-0.7.tar.gz", hash = "sha256:bf37aac0166fc8f5705b450cc332f0d323e2d8b8191017bbfebe1f489f18f64d", size = 10211, upload-time = "2023-11-16T00:08:35.958Z" } wheels = [ @@ -5210,8 +5202,8 @@ name = "tensorstore" version = "0.1.84" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "ml-dtypes", marker = "python_full_version < '3.14'" }, - { name = "numpy", marker = "python_full_version < '3.14'" }, + { name = "ml-dtypes" }, + { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/83/18/c8e8b4faffab1a434b6c013d54cf7f5b754a6849429d9dbb718297705796/tensorstore-0.1.84.tar.gz", hash = "sha256:3cb091dfde68600e6d8f03a389ccc92ffa7c0798a0c600d1013c0138d7163e6b", size = 7208048, upload-time = "2026-05-16T06:17:58.448Z" } wheels = [ @@ -5246,9 +5238,9 @@ name = "terminado" version = "0.18.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "ptyprocess", marker = "python_full_version < '3.14' and os_name != 'nt'" }, - { name = "pywinpty", marker = "python_full_version < '3.14' and os_name == 'nt'" }, - { name = "tornado", marker = "python_full_version < '3.14'" }, + { name = "ptyprocess", marker = "os_name != 'nt'" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "tornado" }, ] sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e", size = 32701, upload-time = "2024-03-12T14:34:39.026Z" } wheels = [ @@ -5269,7 +5261,7 @@ name = "tifffile" version = "2025.9.20" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "python_full_version < '3.14'" }, + { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/e4/1d/99d2eb1d50f0832d6e6e057f7d3239b77210d663a048780b029d10324b14/tifffile-2025.9.20.tar.gz", hash = "sha256:a0fed4c613ff728979cb6abfd40832b6f36dc9da8183e52840418a25a00552eb", size = 368988, upload-time = "2025-09-20T17:24:43.498Z" } wheels = [ @@ -5281,7 +5273,7 @@ name = "tinycss2" version = "1.4.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "webencodings", marker = "python_full_version < '3.14'" }, + { name = "webencodings" }, ] sdist = { url = "https://files.pythonhosted.org/packages/7a/fd/7a5ee21fd08ff70d3d33a5781c255cbe779659bd03278feb98b19ee550f4/tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7", size = 87085, upload-time = "2024-10-24T14:58:29.895Z" } wheels = [ @@ -5334,34 +5326,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" }, ] -[[package]] -name = "turms" -version = "2.2.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "graphql-core", marker = "python_full_version < '3.14'" }, - { name = "pydantic", marker = "python_full_version < '3.14'" }, - { name = "pydantic-settings", marker = "python_full_version < '3.14'" }, - { name = "pyyaml", marker = "python_full_version < '3.14'" }, - { name = "requests", marker = "python_full_version < '3.14'" }, - { name = "rich", marker = "python_full_version < '3.14'" }, - { name = "rich-click", marker = "python_full_version < '3.14'" }, - { name = "watchfiles", marker = "python_full_version < '3.14'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/eb/2a/4572f4b67b197a5fe68278491b3c3bc1667d7e8aed576de8939037f8ec1e/turms-2.2.1.tar.gz", hash = "sha256:f9813e7bc17bd342e931b2b36e9d72e3ca5c3ce7664fa78fd5c1a7fee92e19f0", size = 96597, upload-time = "2026-09-30T19:05:15.404Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/32/0b/134b74552e5d154756ff2ad86d1b90acc1d7d3dcd2f65d7b82938161ebb6/turms-2.2.1-py3-none-any.whl", hash = "sha256:4ecb9f640b1b652ca4bd05cfd3bf16d41c2b3f7b3b0d803d94cb8762ba0b7590", size = 115394, upload-time = "2026-09-30T19:05:14.174Z" }, -] - [[package]] name = "typer" version = "0.26.8" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "annotated-doc", marker = "python_full_version < '3.14'" }, - { name = "colorama", marker = "python_full_version < '3.14' and sys_platform == 'win32'" }, - { name = "rich", marker = "python_full_version < '3.14'" }, - { name = "shellingham", marker = "python_full_version < '3.14'" }, + { name = "annotated-doc" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "rich" }, + { name = "shellingham" }, ] sdist = { url = "https://files.pythonhosted.org/packages/7c/f7/68adc395201b20b872d68e975386832e8005ffeacedd43a1d837a32815be/typer-0.26.8.tar.gz", hash = "sha256:c244a6bd558886fe3f8780efb6bdd28bb9aff005a94eedebaa5cb32926fe2f7e", size = 202097, upload-time = "2026-06-26T09:22:45.705Z" } wheels = [ @@ -5391,8 +5364,8 @@ name = "typing-inspect" version = "0.9.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "mypy-extensions", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "mypy-extensions" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/dc/74/1789779d91f1961fa9438e9a8710cdae6bd138c80d7303996933d117264a/typing_inspect-0.9.0.tar.gz", hash = "sha256:b23fc42ff6f6ef6954e4852c1fb512cdd18dbea03134f91f856a95ccc9461f78", size = 13825, upload-time = "2023-05-24T20:25:47.612Z" } wheels = [ @@ -5404,7 +5377,7 @@ name = "typing-inspection" version = "0.4.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/a3/26/b09b8010994eccc3c09092e6b34058f36a460eea2d4c3e8b910c695975a0/typing_inspection-0.4.4.tar.gz", hash = "sha256:547274fa6b0a561ccf549cc9524b999a578e737d015d8709d021f9d0d13bea47", size = 76928, upload-time = "2026-08-12T12:37:25.997Z" } wheels = [ @@ -5425,7 +5398,7 @@ name = "tzlocal" version = "5.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "tzdata", marker = "python_full_version < '3.14' and sys_platform == 'win32'" }, + { name = "tzdata", marker = "sys_platform == 'win32'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/8b/2e/c14812d3d4d9cd1773c6be938f89e5735a1f11a9f184ac3639b93cef35d5/tzlocal-5.3.1.tar.gz", hash = "sha256:cceffc7edecefea1f595541dbd6e990cb1ea3d19bf01b2809f362a03dd7921fd", size = 30761, upload-time = "2025-03-05T21:17:41.549Z" } wheels = [ @@ -5437,9 +5410,9 @@ name = "uc2-rest" version = "0.2.0.43" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "pyserial", marker = "python_full_version < '3.14'" }, - { name = "requests", marker = "python_full_version < '3.14'" }, + { name = "numpy" }, + { name = "pyserial" }, + { name = "requests" }, ] sdist = { url = "https://files.pythonhosted.org/packages/5c/f4/940abdc45a81d50c2189036fa6d271d0414dbc110adc9ea1d84a5b1464b9/uc2_rest-0.2.0.43.tar.gz", hash = "sha256:34fa84dff32591b03973043c640d04964d62d1d681c59006d079fbd54ef6282f", size = 91074, upload-time = "2026-10-14T18:20:10.442Z" } wheels = [ @@ -5451,8 +5424,8 @@ name = "uc2canopen" version = "0.1.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pyserial", marker = "python_full_version < '3.14'" }, - { name = "python-can", marker = "python_full_version < '3.14'" }, + { name = "pyserial" }, + { name = "python-can" }, ] sdist = { url = "https://files.pythonhosted.org/packages/5a/66/42f0827f2d9ac047c771058e12a8ecf856e31362c88438f4b12886e97215/uc2canopen-0.1.4.tar.gz", hash = "sha256:2a3093cc1ab7d3f1dc939149169ddd49cb50ae80a49ceff28bd76cb881ecbc6c", size = 45910, upload-time = "2026-06-22T13:28:23.809Z" } wheels = [ @@ -5464,16 +5437,16 @@ name = "unitelabs-cdk" version = "0.9.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "click", marker = "python_full_version < '3.14'" }, - { name = "deprecated", marker = "python_full_version < '3.14'" }, - { name = "griffe", marker = "python_full_version < '3.14'" }, - { name = "packaging", marker = "python_full_version < '3.14'" }, - { name = "pydantic", marker = "python_full_version < '3.14'" }, - { name = "python-dotenv", marker = "python_full_version < '3.14'" }, - { name = "rich", marker = "python_full_version < '3.14'" }, - { name = "ruamel-yaml", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, - { name = "unitelabs-sila", marker = "python_full_version < '3.14'" }, + { name = "click" }, + { name = "deprecated" }, + { name = "griffe" }, + { name = "packaging" }, + { name = "pydantic" }, + { name = "python-dotenv" }, + { name = "rich" }, + { name = "ruamel-yaml" }, + { name = "typing-extensions" }, + { name = "unitelabs-sila" }, ] sdist = { url = "https://files.pythonhosted.org/packages/d3/da/d8888b7926d9edb3a35455becee98e8a5fbad40312ff2ce0c79ef61dbaaa/unitelabs_cdk-0.9.0.tar.gz", hash = "sha256:9dcdc44a671dc828582192574b586bf79e77576338435a41104b0b5a87c9cb00", size = 132663, upload-time = "2026-04-03T10:42:02.173Z" } wheels = [ @@ -5485,11 +5458,11 @@ name = "unitelabs-sila" version = "0.7.5" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "grpcio", marker = "python_full_version < '3.14'" }, - { name = "jsonschema", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, - { name = "xmlschema", marker = "python_full_version < '3.14'" }, - { name = "zeroconf", marker = "python_full_version < '3.14'" }, + { name = "grpcio" }, + { name = "jsonschema" }, + { name = "typing-extensions" }, + { name = "xmlschema" }, + { name = "zeroconf" }, ] sdist = { url = "https://files.pythonhosted.org/packages/32/78/32c4c494c4f8413b746fc17bcc6cc21621c9325e34c6f2dcc6fb80e61adf/unitelabs_sila-0.7.5.tar.gz", hash = "sha256:1082fa8fd48d0a028b45ddc2fc1783d6fbbcf606e5f7ef9fdd72aae702bf8083", size = 7266, upload-time = "2026-02-18T12:53:50.272Z" } wheels = [ @@ -5519,10 +5492,10 @@ name = "useq-schema" version = "0.9.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "pydantic", marker = "python_full_version < '3.14'" }, - { name = "shapely", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "numpy" }, + { name = "pydantic" }, + { name = "shapely" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/2c/52/562f51ba6d7b8b49325d20ead16be79ff3edccdd03fb8cae494bcddd6643/useq_schema-0.9.2.tar.gz", hash = "sha256:a84a374f734c0441c63ecb463d150dae4449e215347bfd990c8c13711184bbf1", size = 114984, upload-time = "2026-04-01T13:33:39.091Z" } wheels = [ @@ -5534,8 +5507,8 @@ name = "uvicorn" version = "0.37.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "click", marker = "python_full_version < '3.14'" }, - { name = "h11", marker = "python_full_version < '3.14'" }, + { name = "click" }, + { name = "h11" }, ] sdist = { url = "https://files.pythonhosted.org/packages/71/57/1616c8274c3442d802621abf5deb230771c7a0fec9414cb6763900eb3868/uvicorn-0.37.0.tar.gz", hash = "sha256:4115c8add6d3fd536c8ee77f0e14a7fd2ebba939fed9b02583a97f80648f9e13", size = 80367, upload-time = "2025-09-23T13:33:47.486Z" } wheels = [ @@ -5544,13 +5517,13 @@ wheels = [ [package.optional-dependencies] standard = [ - { name = "colorama", marker = "python_full_version < '3.14' and sys_platform == 'win32'" }, - { name = "httptools", marker = "python_full_version < '3.14'" }, - { name = "python-dotenv", marker = "python_full_version < '3.14'" }, - { name = "pyyaml", marker = "python_full_version < '3.14'" }, - { name = "uvloop", marker = "python_full_version < '3.14' and platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" }, - { name = "watchfiles", marker = "python_full_version < '3.14'" }, - { name = "websockets", marker = "python_full_version < '3.14'" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "httptools" }, + { name = "python-dotenv" }, + { name = "pyyaml" }, + { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" }, + { name = "watchfiles" }, + { name = "websockets" }, ] [[package]] @@ -5593,7 +5566,7 @@ name = "watchfiles" version = "1.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "anyio", marker = "python_full_version < '3.14'" }, + { name = "anyio" }, ] sdist = { url = "https://files.pythonhosted.org/packages/2a/9a/d451fcc97d029f5812e898fd30a53fd8c15c7bbd058fd75cfc6beb9bd761/watchfiles-1.1.0.tar.gz", hash = "sha256:693ed7ec72cbfcee399e92c895362b6e66d63dac6b91e2c11ae03d10d503e575", size = 94406, upload-time = "2025-06-15T19:06:59.42Z" } wheels = [ @@ -5832,7 +5805,7 @@ name = "wsproto" version = "1.2.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "h11", marker = "python_full_version < '3.14'" }, + { name = "h11" }, ] sdist = { url = "https://files.pythonhosted.org/packages/c9/4a/44d3c295350d776427904d73c189e10aeae66d7f555bb2feee16d1e4ba5a/wsproto-1.2.0.tar.gz", hash = "sha256:ad565f26ecb92588a3e43bc3d96164de84cd9902482b130d0ddbaa9664a85065", size = 53425, upload-time = "2022-08-23T19:58:21.447Z" } wheels = [ @@ -5844,9 +5817,9 @@ name = "xarray" version = "2025.9.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "packaging", marker = "python_full_version < '3.14'" }, - { name = "pandas", marker = "python_full_version < '3.14'" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pandas" }, ] sdist = { url = "https://files.pythonhosted.org/packages/4e/0b/bbb76e05c8e2099baf90e259c29cafe6a525524b1d1da8bfbc39577c043e/xarray-2025.9.0.tar.gz", hash = "sha256:7dd6816fe0062c49c5e9370dd483843bc13e5ed80a47a9ff10baff2b51e070fb", size = 3040318, upload-time = "2025-09-04T04:20:26.296Z" } wheels = [ @@ -5858,7 +5831,7 @@ name = "xmlschema" version = "4.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "elementpath", marker = "python_full_version < '3.14'" }, + { name = "elementpath" }, ] sdist = { url = "https://files.pythonhosted.org/packages/da/c4/ef78a231be72349fd6677b989ff80e276ef62e28054c36c4fea3b4db9611/xmlschema-4.3.1.tar.gz", hash = "sha256:853effdfaf127849d4724368c17bd669e7f1486e15a0376404ad7954ec31a338", size = 646611, upload-time = "2026-01-17T23:01:04.422Z" } wheels = [ @@ -5870,7 +5843,7 @@ name = "xsdata" version = "26.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/2f/c9/71e9e8eac669091fd434ed494d806c8cc37614aecb34ce4c62c283f99abf/xsdata-26.2.tar.gz", hash = "sha256:c631af71aaa75734f8ce92a08fcf8389d905dee2aab0b5032c9032e9071009a6", size = 349690, upload-time = "2026-02-15T16:13:31.274Z" } wheels = [ @@ -5891,9 +5864,9 @@ name = "yarl" version = "1.20.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "idna", marker = "python_full_version < '3.14'" }, - { name = "multidict", marker = "python_full_version < '3.14'" }, - { name = "propcache", marker = "python_full_version < '3.14'" }, + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, ] sdist = { url = "https://files.pythonhosted.org/packages/3c/fb/efaa23fa4e45537b827620f04cf8f3cd658b76642205162e072703a5b963/yarl-1.20.1.tar.gz", hash = "sha256:d017a4997ee50c91fd5466cef416231bb82177b93b029906cefc542ce14c35ac", size = 186428, upload-time = "2025-06-10T00:46:09.923Z" } wheels = [ @@ -5973,11 +5946,11 @@ name = "zarr" version = "3.1.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "donfig", marker = "python_full_version < '3.14'" }, - { name = "numcodecs", extra = ["crc32c"], marker = "python_full_version < '3.14'" }, - { name = "numpy", marker = "python_full_version < '3.14'" }, - { name = "packaging", marker = "python_full_version < '3.14'" }, - { name = "typing-extensions", marker = "python_full_version < '3.14'" }, + { name = "donfig" }, + { name = "numcodecs", extra = ["crc32c"] }, + { name = "numpy" }, + { name = "packaging" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/d6/67/14be68a7bad15eecda09b1e81fca2420f7533645fe187bf4d6104c1aad52/zarr-3.1.3.tar.gz", hash = "sha256:01342f3e26a02ed5670db608a5576fbdb8d76acb5c280bd2d0082454b1ba6f79", size = 349125, upload-time = "2025-09-18T19:32:41.688Z" } wheels = [ @@ -5995,7 +5968,7 @@ name = "zeroconf" version = "0.148.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "ifaddr", marker = "python_full_version < '3.14'" }, + { name = "ifaddr" }, ] sdist = { url = "https://files.pythonhosted.org/packages/67/46/10db987799629d01930176ae523f70879b63577060d63e05ebf9214aba4b/zeroconf-0.148.0.tar.gz", hash = "sha256:03fcca123df3652e23d945112d683d2f605f313637611b7d4adf31056f681702", size = 164447, upload-time = "2025-10-05T00:21:19.199Z" } wheels = [ From 3666c8b6584746ee517a4f16d5beb313f078bb20 Mon Sep 17 00:00:00 2001 From: Benedict Diederich Date: Sun, 15 Nov 2026 22:38:54 +0000 Subject: [PATCH 2/3] Arkitekt: delete scans once in mikro, name an outdated client - deleteAfterUpload (off by default): once mikro holds every level of an uploaded canvas, asked of the server, the canvas is removed from the microscope, so a scan is stored once. Only OME-Zarr image folders go. The panel gets toggles for it and for uploadExperiments. - An arkitekt older than 16 (an old environment) makes the panel name the version it needs, instead of a TypeError at the login. - A bare host means https: one stored login per server, no plain-http try. - The aufgaben test declares hw as the app context: arkitekt-spec 10 dropped omitkeys. - Tracking doc: orkestrator reaches no address from the Mac, Forklift removes compose projects it does not know, the os-rpi deployment, the offline route. Co-Authored-By: Claude Opus 5.5 --- docs/ARKITEKT.md | 14 ++-- docs/arkitekt-hub-pi.md | 76 +++++++++++++------ docs/setup-config.schema.json | 5 ++ .../src/backendapi/apiArkitektController.js | 3 +- .../src/components/ArkitektController.jsx | 10 +++ .../_test/unit/test_arkitekt_controller.py | 75 +++++++++++++++++- .../_test/unit/test_aufgaben_registry_useq.py | 5 +- .../controllers/ArkitektController.py | 44 +++++++++-- imswitch/imcontrol/model/SetupInfo.py | 5 ++ imswitch/imcontrol/model/io/mikro_upload.py | 35 ++++++++- .../model/managers/ArkitektManager.py | 38 ++++++++-- 11 files changed, 261 insertions(+), 49 deletions(-) diff --git a/docs/ARKITEKT.md b/docs/ARKITEKT.md index d89720607..685d8133c 100644 --- a/docs/ARKITEKT.md +++ b/docs/ARKITEKT.md @@ -13,7 +13,8 @@ the hub must run rekuest 19 and mikro 15): pip install "arkitekt[rekuest,mikro]==16.0.1" ``` -Without the package ImSwitch starts normally. The Arkitekt panel then says what to install. +Without the package ImSwitch starts normally. The Arkitekt panel then says what to install, and +with an older arkitekt (e.g. 5.x in an old environment) which version it needs. ## Setup @@ -29,18 +30,20 @@ writes it when a setting changes: "allowInsecureTransport": false, "useMikro": true, "uploadExperiments": false, + "deleteAfterUpload": false, "mandateKey": "" } ``` | Key | Meaning | |---|---| -| `url` | The server. Set from the panel when binding. | +| `url` | The server. Set from the panel when binding. A bare host (`go.arkitekt.live`) means https. | | `appName` | The app identifier (lower-cased, spaces become dashes). Each name is its own registration and login. | | `autoConnect` | At startup, reconnect when the microscope was bound before. It never starts a browser login by itself. If the stored login was revoked, it stops with an error instead of asking again. | | `allowInsecureTransport` | Allow the login over plain `http://` to a host that is not localhost, e.g. a NAS without TLS. The session token then travels unencrypted. | | `useMikro` | Offer the image actions. They need mikro on the server. | | `uploadExperiments` | After an experiment, queue its OME-Zarr canvases for mikro. They are uploaded with their pyramid in the background, while bound and idle (no experiment, recording or workflow; CPU < 60 %; 1 GB free). The queue survives restarts. | +| `deleteAfterUpload` | Remove an uploaded canvas from the microscope once mikro holds every level of it (asked of the server first), so a scan is stored once. Off by default. Only OME-Zarr image folders are removed. | | `mandateKey` | Unattended login, with no browser: a key a member issued on the server for one hub. It is a credential: keep it out of shared setup files. (`redeemToken` is gone with arkitekt 16.) | ## Binding and unbinding @@ -56,7 +59,8 @@ and click **Bind microscope**: 3. The microscope registers its actions and stays connected. The login is stored on this machine (arkitekt's per-user state directory), so later starts reconnect without approval. In Docker, that directory must be on a volume (`/home/pi/.local/state/arkitekt`), or every new container - asks again. + asks again: on openUC2 OS, `forklift plt enable-depl-feat imswitch arkitekt` keeps it in + `/home/pi/arkitekt/imswitch`. - **Disconnect / Cancel** stops a pending login or the connection. It keeps the stored login. - **Unbind** disconnects and removes the stored login, so binding again needs a new approval. While @@ -101,9 +105,9 @@ duration, errors) and thumbnails of the images sent. | `POST bindArkitekt?url=&mandateKey=` | Starts the login in the background and returns at once. | | `POST cancelArkitekt` | Stops a pending login or the connection. | | `POST unbindArkitekt` | Disconnects and forgets the stored login. | -| `POST setArkitektSettings?url=&appName=&autoConnect=&allowInsecureTransport=&useMikro=&uploadExperiments=` | Saved to the setup file. | +| `POST setArkitektSettings?url=&appName=&autoConnect=&allowInsecureTransport=&useMikro=&uploadExperiments=&deleteAfterUpload=` | Saved to the setup file. | | `POST queueArkitektUpload?path=&name=` | Queues an OME-Zarr canvas (e.g. an older experiment) for the background upload. | -| `GET getArkitektUploadQueue` | `{pending, uploaded, failed}`, with dataset ids, durations and errors. | +| `GET getArkitektUploadQueue` | `{pending, uploaded, failed}`, with dataset ids, durations, errors and, with `deleteAfterUpload`, what became of the local copy (`localCopy`). | | `GET getArkitektUploads` / `POST clearArkitektActivity` | | Socket signals: `sigArkitektStatus`, `sigArkitektActivity`, `sigArkitektUpload`. diff --git a/docs/arkitekt-hub-pi.md b/docs/arkitekt-hub-pi.md index f794ceb13..d298f000c 100644 --- a/docs/arkitekt-hub-pi.md +++ b/docs/arkitekt-hub-pi.md @@ -14,9 +14,10 @@ Brief: WP-423…426. Coordination server: **go.arkitekt.live** (decided). The da | ImSwitch on arkitekt 16 / mikro 14 (pins, `uv.lock`, code, 27 unit tests) | done, this branch | | Canvas with its pyramid → mikro, placed in a µm stage space | done: datasets 1–4 | | ImSwitch background upload in the live agent (virtual microscope) | done: dataset 3 | -| View in orkestrator on the MacBook | **open** (Bene) | -| Run Tile Scan / Acquire Frame on the FRAME's hardware | open: needs an ImSwitch image from this branch | -| Hub as a pallet deployment in os-rpi | open: plan below | +| View in orkestrator on the MacBook | **blocked**: the Mac reaches none of mikro's addresses (finding 11) | +| Run Tile Scan / Acquire Frame on the FRAME's hardware | open: ImSwitch from this branch runs natively (`.venv` on arkitekt 16) | +| Hub as a pallet deployment in os-rpi | done on os-rpi branch `feat/arkitekt-hub` (local), tested on a throwaway hub; this Pi not switched | +| Delete ImSwitch's copy after the upload | done: `deleteAfterUpload`, off by default | | WP-424 benchmark | first figures below (synthetic scans, SD card) | ## Figures (SD card; VS Code server and the ImSwitch container running beside it) @@ -75,7 +76,22 @@ id 24 / **wa 38 %** (the SD card is the limit). SoC at most 45.5 °C, never thro - Two shipped setups (`FRAME_widefield_default.json` and its `example_` copy) contained a redeem token, now blanked. - ImSwitch started outside Docker opens JupyterLab without a token on `0.0.0.0:8888`. -11. **Minor:** +11. **Orkestrator "Service mikro not found"** means that no address of mikro answered from the Mac + within 5 s. The Pi lets it through: + - the tailnet allows every port; + - firewalld accepts Docker's DNAT; + - the served certificate is the one the hub registered, which orkestrator pins. + + Yet no packet from the Mac reached 2754/2755. To check on the Mac: macOS Local Network + permission for Orkestrator, and `curl -k https://100.117.194.33:2755/mikro/ht`. +12. **Forklift removes compose projects it does not know** at every apply. `forklift plt plan` on + this Pi lists `remove hub`, so the next boot removes konstruktor's containers (the data + stays). So the hub has to be a Forklift deployment (option B below). +13. **Offline:** `konstruktor coord create` makes a local coordination server. It runs lok, + kontrol, Postgres, Redis, RustFS and Caddy, with accounts of its own. A hub connected to it + works without internet. With go.arkitekt.live, logins and token refresh need internet; scans + stay on disk and the upload queue waits. +14. **Minor:** - konstruktor's README says port 7080, but the CLI uses 2754/2755. - `--dry-run` creates the target folder. - `docs/setup-config.schema.json` has drifted from `SetupInfo`; only `ArkitektInfo` is @@ -99,30 +115,46 @@ id 24 / **wa 38 %** (the SD card is the limit). SoC at most 45.5 °C, never thro - `model/io/mikro_upload.py`: the canvas upload (levels from disk, contrast from the coarsest level) and the persistent queue. - `scripts/arkitekt_canvas_bench.py`: synthetic scan canvas → mikro, with timings. +- `deleteAfterUpload`: removes a canvas once mikro holds every level of it (checked on the server). + Toggles for it and `uploadExperiments` are in the panel. +- An arkitekt older than 16 makes the panel name the version it needs. Before, the login failed + with a TypeError, as in Bene's `.venv`. +- A bare host means https. + +## Pallet (os-rpi branch `feat/arkitekt-hub`, option B) + +```sh +forklift plt enable-depl arkitekt-hub +forklift plt enable-depl-feat imswitch arkitekt # ImSwitch keeps its Arkitekt login +forklift plt stage && sudo reboot +konstruktor hub connect --in /home/pi/arkitekt/arkitekt-hub --server go.arkitekt.live # once +``` -## Pallet plan (os-rpi, off by default) - -- `deployments/arkitekt-hub.pkg`, two options: - - **A, konstruktor owns the hub.** Forklift ships the pinned binary and a unit that runs - `konstruktor up` at boot. `hub create` and `hub connect` run once by hand, with one browser - approval. konstruktor's backup, update and rollback keep working. - - **B, Forklift owns the compose.** Digest-pinned, `restart: unless-stopped`. konstruktor only - writes the configs once (`hub create --no-start`): the keys are per device, so they cannot live - in the pallet. - - A is enough for the benchmark; B needs a decision with Ethan. In both cases: a firewalld service - for 2754/2755 and a link on the landing page. -- `imswitch.pkg`: bind `/home/pi/arkitekt/imswitch` to `/home/pi/.local/state/arkitekt` (as the - robot apps do), and an image built from this branch. +- **Forklift owns the containers:** digest-pinned images and `restart: unless-stopped`. +- **konstruktor writes the per-device files once:** `arkitekt-hub-setup.service` runs + `hub create --no-start` with the same pinned images, before `forklift-apply`. +- **Credentials:** the containers read them from files (`POSTGRES_*_FILE`, + `RUSTFS_*_FILE`). +- **Before `hub connect`:** rekuest, mikro and the reporter wait for their configs instead of + failing. +- **Shared commands:** the compose project is named like the folder, so konstruktor's commands act + on the same containers. +- **Tested** on a throwaway hub: up in 11.5 s, Postgres healthy, both databases created, buckets + made, gateway on HTTP and HTTPS. `forklift dev plt check` passes with everything enabled. +- **Not tested:** the boot unit itself, and `hub connect` in this layout. +- **Switching this Pi** to the branch would also remove flim-imager and uc2-flasher, which this + Pi's pallet has but `edge` has not. +- **Moving this Pi's hub:** see the package README (`mv` to `/home/pi/arkitekt/arkitekt-hub`). ## Open questions - **Bene:** - - Open datasets 1–4 in orkestrator on the MacBook, on the LAN or the hotspot: time to the first - picture, pan/zoom, and whether the RGB layer looks right. + - On the Mac: the Local Network permission for Orkestrator and the `curl` above, then datasets + 1–4. + - Switch this Pi to the os-rpi branch (with flim-imager and uc2-flasher enabled again) and move + its hub? + - Push the two branches? - Is LAN and hotspot enough, or should the hub join the organization's mesh? - - Delete ImSwitch's copy after the upload? That saves half the card. - - May I enable the memory cgroup (needs a reboot)? - **Johannes:** - Can mikro take an existing zarr v3 (sharded) array without re-encoding? - Can the 5-minute code lifetime be set? diff --git a/docs/setup-config.schema.json b/docs/setup-config.schema.json index 861314763..b25060aad 100644 --- a/docs/setup-config.schema.json +++ b/docs/setup-config.schema.json @@ -1575,6 +1575,11 @@ "description": "After an experiment, queue its OME-Zarr canvases (with their pyramid) for mikro. They are uploaded in the background while bound and while the microscope is idle; the queue survives restarts.", "default": false }, + "deleteAfterUpload": { + "type": "boolean", + "description": "Remove an uploaded OME-Zarr canvas from this microscope once mikro holds every level of it (checked on the server first), so each scan is stored once. Applies to Run Tile Scan and to queued canvases.", + "default": false + }, "syncInAsync": { "type": "boolean", "description": "Unused since the move from arkitekt_next to arkitekt; kept so older setup files load.", diff --git a/frontend/src/backendapi/apiArkitektController.js b/frontend/src/backendapi/apiArkitektController.js index b3bd46710..f61c35557 100644 --- a/frontend/src/backendapi/apiArkitektController.js +++ b/frontend/src/backendapi/apiArkitektController.js @@ -34,7 +34,8 @@ export const apiArkitektCancel = () => post("cancelArkitekt"); // Disconnect and forget the stored login on this microscope. export const apiArkitektUnbind = () => post("unbindArkitekt"); -// Only the given keys change: {url, appName, autoConnect, allowInsecureTransport, useMikro} +// Only the given keys change: {url, appName, autoConnect, allowInsecureTransport, useMikro, +// uploadExperiments, deleteAfterUpload} export const apiArkitektSetSettings = (settings) => post("setArkitektSettings", settings); // [{id, name, datasetId, shape, dtype, positionUm, pixelSizeUm, time, thumbnail}] diff --git a/frontend/src/components/ArkitektController.jsx b/frontend/src/components/ArkitektController.jsx index 86a72cc07..efe98ac89 100644 --- a/frontend/src/components/ArkitektController.jsx +++ b/frontend/src/components/ArkitektController.jsx @@ -338,6 +338,16 @@ const ArkitektController = () => { onChange={(e) => saveSetting({ useMikro: e.target.checked })} />} label={{t("Offer image actions (stores images in the server's mikro)")}} /> + saveSetting({ uploadExperiments: e.target.checked })} />} + label={{t("Upload finished experiments to mikro (in the background, while idle)")}} + /> + saveSetting({ deleteAfterUpload: e.target.checked })} />} + label={{t("Delete a scan from this microscope once mikro holds all of it")}} + /> saveSetting({ allowInsecureTransport: e.target.checked })} />} diff --git a/imswitch/imcontrol/_test/unit/test_arkitekt_controller.py b/imswitch/imcontrol/_test/unit/test_arkitekt_controller.py index 8a4c28c67..548373c12 100644 --- a/imswitch/imcontrol/_test/unit/test_arkitekt_controller.py +++ b/imswitch/imcontrol/_test/unit/test_arkitekt_controller.py @@ -281,10 +281,12 @@ def test_state_publishing_never_reads_the_device(no_arkitekt): class FakeMikro: - """create_array_dataset and create_coordinate_system, recorded.""" + """create_array_dataset, get_array_dataset and create_coordinate_system, + recorded. *loses_a_level*: the server holds one level less than was sent.""" - def __init__(self): + def __init__(self, loses_a_level=False): self.datasets, self.spaces = [], [] + self.loses_a_level = loses_a_level def create_array_dataset(self, **kwargs): dataset = types.SimpleNamespace(id=f"ds{len(self.datasets)}", kwargs=kwargs, @@ -292,6 +294,16 @@ def create_array_dataset(self, **kwargs): self.datasets.append(dataset) return dataset + def get_array_dataset(self, id): + kwargs = next(d.kwargs for d in self.datasets if d.id == id) + shape = lambda array: tuple(getattr(array, "data", array).shape) # noqa: E731 + levels = [(0, shape(kwargs["data"]))] + [(s.level, shape(s.array)) + for s in kwargs.get("scales") or []] + if self.loses_a_level: + levels = levels[:-1] + return types.SimpleNamespace(id=id, data_arrays=[ + types.SimpleNamespace(level=level, shape=s) for level, s in levels]) + def create_coordinate_system(self, name, axes, **kwargs): space = types.SimpleNamespace(name=name, kwargs=kwargs, registered=[]) space.register = lambda dataset, scale=None, **offsets: space.registered.append( @@ -399,6 +411,65 @@ def test_finished_experiments_are_queued_and_uploaded_when_idle(tmp_path, monkey queue = controller.getArkitektUploadQueue() assert queue["pending"] == [] and queue["uploaded"][0]["datasetId"] == "ds0" assert controller.getArkitektUploads()[0]["thumbnail"] + # deleteAfterUpload is off: the canvas stays + assert (tmp_path / "exp" / "region0.ome.zarr").is_dir() + assert "localCopy" not in queue["uploaded"][0] + + +def test_an_uploaded_canvas_is_deleted_only_once_mikro_holds_all_of_it(tmp_path, monkeypatch): + pytest.importorskip("mikro") + kept, gone = tmp_path / "exp" / "kept.ome.zarr", tmp_path / "exp" / "gone.ome.zarr" + write_canvas(kept) + write_canvas(gone) + controller, _, _ = make_controller(info=ArkitektInfo( + autoConnect=False, uploadExperiments=True, deleteAfterUpload=True)) + monkeypatch.setattr(controller, "_idle_for_upload", lambda: None) + controller.queueArkitektUpload(str(kept)) + assert controller._upload_next(FakeMikro(loses_a_level=True)) is True + assert kept.is_dir() # the server is missing a level: keep the only full copy + controller.queueArkitektUpload(str(gone)) + assert controller._upload_next(FakeMikro()) is True + assert not gone.exists() + uploaded = controller.getArkitektUploadQueue()["uploaded"] + assert uploaded[0]["localCopy"].startswith("kept: mikro holds levels") + assert uploaded[1]["localCopy"] == "deleted" + assert controller.getArkitektUploads()[0]["thumbnail"] # taken before the canvas went + + +def test_only_an_ome_zarr_image_folder_is_deleted(tmp_path): + pytest.importorskip("zarr") + from imswitch.imcontrol.model.io.mikro_upload import delete_canvas + (tmp_path / "notes.ome.zarr").mkdir() + (tmp_path / "notes.ome.zarr" / "keep.txt").write_text("not an image") + write_canvas(tmp_path / "region.zarr") + write_canvas(tmp_path / "real.ome.zarr") + (tmp_path / "link.ome.zarr").symlink_to(tmp_path / "real.ome.zarr") + for path in ("notes.ome.zarr", "region.zarr", "link.ome.zarr", "missing.ome.zarr"): + with pytest.raises((ValueError, FileNotFoundError)): + delete_canvas(tmp_path / path) + assert (tmp_path / "notes.ome.zarr" / "keep.txt").exists() + assert (tmp_path / "region.zarr").is_dir() and (tmp_path / "real.ome.zarr").is_dir() + delete_canvas(tmp_path / "real.ome.zarr") + assert not (tmp_path / "real.ome.zarr").exists() + + +def test_a_bare_host_is_the_https_server(no_arkitekt): + manager = manager_module.ArkitektManager(ArkitektInfo(url=" go.arkitekt.live/ ")) + assert manager.url == "https://go.arkitekt.live" # one stored login, never plain http + assert manager_module.ArkitektManager(ArkitektInfo(url="http://nas.local")).url == \ + "http://nas.local" + + +def test_an_old_arkitekt_is_named_instead_of_failing_at_the_login(monkeypatch): + import importlib.metadata + monkeypatch.setattr(manager_module.importlib.util, "find_spec", lambda name: object()) + monkeypatch.setattr(importlib.metadata, "version", + lambda name: "5.0.1" if name == "arkitekt" else "1.0.0") + manager = manager_module.ArkitektManager(ArkitektInfo(autoConnect=False)) + status = manager.status() + assert status["state"] == "unavailable" and status["available"] is False + assert "arkitekt 5.0.1 is installed" in status["message"] + assert manager.bind()["status"] == "error" class FakeFakts: diff --git a/imswitch/imcontrol/_test/unit/test_aufgaben_registry_useq.py b/imswitch/imcontrol/_test/unit/test_aufgaben_registry_useq.py index 868b59c6a..30dc07610 100644 --- a/imswitch/imcontrol/_test/unit/test_aufgaben_registry_useq.py +++ b/imswitch/imcontrol/_test/unit/test_aufgaben_registry_useq.py @@ -93,10 +93,13 @@ def test_arkitekt_accepts_every_primitive_unchanged(): structures = registry.StructureRegistry() for cls, identifier in A.MEMORY_STRUCTURES.items(): # what an app declares once structures.register_as_memory_structure(cls, identifier=identifier) + # hw is handed in by the agent: arkitekt 16 knows it as the app context + # (run(context=...)), where 5 took omitkeys=["hw"] + structures.app_context(Microscope) for task_id, spec in A.REGISTRY.items(): if spec.category in FRAME_STEPS: # engine-only: read ctx.frame, return mixed data continue - definition = define.prepare_definition(spec.function, structures, omitkeys=["hw"]) + definition = define.prepare_definition(spec.function, structures) keys = [a.key for a in definition.args] assert keys == list(spec.params_model.model_fields), task_id assert "ctx" not in keys # injected through the task marker diff --git a/imswitch/imcontrol/controller/controllers/ArkitektController.py b/imswitch/imcontrol/controller/controllers/ArkitektController.py index 717849b0c..ec386fd7a 100644 --- a/imswitch/imcontrol/controller/controllers/ArkitektController.py +++ b/imswitch/imcontrol/controller/controllers/ArkitektController.py @@ -191,17 +191,21 @@ def setArkitektSettings(self, url: Optional[str] = None, appName: Optional[str] autoConnect: Optional[bool] = None, allowInsecureTransport: Optional[bool] = None, useMikro: Optional[bool] = None, - uploadExperiments: Optional[bool] = None) -> dict: + uploadExperiments: Optional[bool] = None, + deleteAfterUpload: Optional[bool] = None) -> dict: """Change the Arkitekt settings and save them to the setup file. They apply at the next bind. A different url or appName is a different login (each has its own stored session). uploadExperiments: after an - experiment, queue its OME-Zarr canvases for mikro (uploaded while idle).""" + experiment, queue its OME-Zarr canvases for mikro (uploaded while idle). + deleteAfterUpload: remove a canvas from this microscope once mikro holds + every level of it (applies at once).""" if self._manager is None: return {"status": "error", "message": "Arkitekt is not configured."} info = self._manager.info for key, value in (("url", url), ("appName", appName), ("autoConnect", autoConnect), ("allowInsecureTransport", allowInsecureTransport), - ("useMikro", useMikro), ("uploadExperiments", uploadExperiments)): + ("useMikro", useMikro), ("uploadExperiments", uploadExperiments), + ("deleteAfterUpload", deleteAfterUpload)): if value is not None: setattr(info, key, value.strip() if isinstance(value, str) else bool(value)) saved = self._save_settings() @@ -862,7 +866,9 @@ def _tile_scan(self, mikro, task, grid: dict, illumination: Optional[str], dataset = upload_ngff(mikro, stored, name=name, space=stage_space(mikro)) center = {**grid["start"], "x": (grid["x_min"] + grid["x_max"]) / 2, "y": (grid["y_min"] + grid["y_max"]) / 2} - self._remember_upload(_preview(stored), name, getattr(dataset, "id", None), center, + preview = _preview(stored) + self._discard_local_copy(mikro, dataset, stored) + self._remember_upload(preview, name, getattr(dataset, "id", None), center, self._pixel_size_um()) return dataset.lens() @@ -959,13 +965,37 @@ def _upload_next(self, mikro) -> bool: self._logger.error(f"Upload of {entry['path']} to mikro failed: {e}") self._upload_queue.failed(entry, e) return True - self._upload_queue.done(entry, getattr(dataset, "id", ""), time.time() - started) - self._logger.info(f"Uploaded {entry['path']} to mikro in {time.time() - started:.0f} s") - self._remember_upload(_preview(canvas), name, getattr(dataset, "id", None), + seconds = time.time() - started + self._logger.info(f"Uploaded {entry['path']} to mikro in {seconds:.0f} s") + preview = _preview(canvas) # before the canvas may go + local = self._discard_local_copy(mikro, dataset, canvas) + self._upload_queue.done(entry, getattr(dataset, "id", ""), seconds, + **({"localCopy": local} if local else {})) + self._remember_upload(preview, name, getattr(dataset, "id", None), {"x": canvas.origin_um["x"], "y": canvas.origin_um["y"], "z": 0.0}, canvas.pixel_um["x"]) return True + def _discard_local_copy(self, mikro, dataset, canvas) -> Optional[str]: + """With arkitekt.deleteAfterUpload, remove an uploaded canvas from disk, + but only once the server holds every level of it. Returns "deleted" or + why it was kept; None when the setup keeps uploaded canvases.""" + if not getattr(self._manager.info, "deleteAfterUpload", False): + return None + from imswitch.imcontrol.model.io.mikro_upload import check_upload, delete_canvas + + try: + problem = check_upload(mikro, dataset, canvas) + if problem is None: + delete_canvas(canvas.path) + except Exception as e: # noqa: BLE001 - the upload itself went through + problem = f"{type(e).__name__}: {e}" + if problem is not None: + self._logger.warning(f"Kept {canvas.path} after its upload: {problem}") + return f"kept: {problem}"[:300] + self._logger.info(f"Deleted {canvas.path}: mikro holds all its levels") + return "deleted" + def _switch_illumination(self, name: Optional[str], intensity: Optional[float]): """Switch *name* on; returns the call that puts it back as it was.""" if not name: diff --git a/imswitch/imcontrol/model/SetupInfo.py b/imswitch/imcontrol/model/SetupInfo.py index 5f95ba0f8..f56210004 100644 --- a/imswitch/imcontrol/model/SetupInfo.py +++ b/imswitch/imcontrol/model/SetupInfo.py @@ -749,6 +749,11 @@ class ArkitektInfo: for mikro. They are uploaded in the background while bound and while the microscope is idle; the queue survives restarts. """ + deleteAfterUpload: bool = False + """ Remove an uploaded OME-Zarr canvas from this microscope once mikro + holds every level of it (checked on the server first), so each scan is + stored once. Applies to Run Tile Scan and to queued canvases. """ + syncInAsync: bool = True """ Unused since the move from arkitekt_next to arkitekt; kept so older setup files load. """ diff --git a/imswitch/imcontrol/model/io/mikro_upload.py b/imswitch/imcontrol/model/io/mikro_upload.py index e941b173e..a596afdf6 100644 --- a/imswitch/imcontrol/model/io/mikro_upload.py +++ b/imswitch/imcontrol/model/io/mikro_upload.py @@ -134,6 +134,32 @@ def upload_ngff(mikro, canvas: NgffCanvas, *, name: Optional[str] = None, space= return dataset +def check_upload(mikro, dataset, canvas: NgffCanvas) -> Optional[str]: + """Why mikro's copy of *canvas* differs from it, or None when the server + holds every level with the shape it has on disk. Asked of the server, not + taken from what the upload returned.""" + stored = mikro.get_array_dataset(dataset.id) + there = {int(array.level): tuple(array.shape) for array in stored.data_arrays} + here = {i: tuple(level.shape) for i, level in enumerate(canvas.levels)} + return None if there == here else f"mikro holds levels {there}, the canvas {here}" + + +def delete_canvas(path) -> None: + """Remove an uploaded canvas folder from disk. Anything but an OME-Zarr image + (a *.ome.zarr folder with multiscales metadata) is refused, so a wrong path + cannot take other data with it.""" + import shutil + import zarr + + path = Path(path) + if not path.name.endswith(".ome.zarr") or not path.is_dir() or path.is_symlink(): + raise ValueError(f"Not an OME-Zarr image folder: {path}") + attrs = dict(zarr.open_group(str(path), mode="r").attrs) + if "multiscales" not in attrs.get("ome", attrs): + raise ValueError(f"No NGFF image in {path}") + shutil.rmtree(path) + + def _now() -> str: return datetime.datetime.now().isoformat(timespec="seconds") @@ -142,8 +168,9 @@ class UploadQueue: """Canvases waiting for mikro, oldest first, persisted in *path* (JSON). {"pending": [{path, name, queuedAt, attempts, error}], - "uploaded": [{path, name, datasetId, seconds, uploadedAt}], - "failed": [...]}. Thread-safe; wait() wakes on add().""" + "uploaded": [{path, name, datasetId, seconds, uploadedAt, localCopy}], + "failed": [...]}. localCopy is "deleted", or why the canvas was kept, when + the setup deletes uploaded canvases. Thread-safe; wait() wakes on add().""" def __init__(self, path): self.path = Path(path) @@ -174,9 +201,9 @@ def wait(self, timeout: float) -> None: with self._changed: self._changed.wait(timeout) - def done(self, entry: dict, dataset_id, seconds: float) -> None: + def done(self, entry: dict, dataset_id, seconds: float, **fields) -> None: self._finish(entry, "uploaded", datasetId=str(dataset_id), seconds=round(seconds, 1), - uploadedAt=_now(), error=None) + uploadedAt=_now(), error=None, **fields) def failed(self, entry: dict, error: BaseException) -> None: """Count a failed attempt; after MAX_ATTEMPTS the canvas is set aside.""" diff --git a/imswitch/imcontrol/model/managers/ArkitektManager.py b/imswitch/imcontrol/model/managers/ArkitektManager.py index d722dd3b3..0e1a9f6d8 100644 --- a/imswitch/imcontrol/model/managers/ArkitektManager.py +++ b/imswitch/imcontrol/model/managers/ArkitektManager.py @@ -30,6 +30,9 @@ from imswitch.imcontrol.model.SetupInfo import ArkitektInfo REQUIRED_PACKAGES = ("arkitekt", "rekuest") +# The client this code is written for (pinned with its family in pyproject.toml). +# An older one fails at the login instead: its device-code hook takes other arguments. +ARKITEKT_VERSION = "16.0.1" DEFAULT_URL = "https://go.arkitekt.live" # A device code lives about five minutes; a manual bind asks for a fresh one this # many times (about half an hour) before it gives up. @@ -56,6 +59,17 @@ def _now() -> str: return datetime.datetime.now().isoformat(timespec="seconds") +def _outdated_arkitekt() -> Optional[str]: + """The installed arkitekt's version when its major is older than ARKITEKT_VERSION's.""" + try: + from importlib.metadata import version + installed = version("arkitekt") + except Exception: # noqa: BLE001 - no metadata: let the import decide + return None + have, need = (re.match(r"\d+", v) for v in (installed, ARKITEKT_VERSION)) + return installed if have and need and int(have.group()) < int(need.group()) else None + + def _slug(name: str) -> str: """An app identifier from the configured name ("FRAME Fork" -> "frame-fork").""" return re.sub(r"[^a-z0-9._-]+", "-", (name or "").strip().lower()).strip("-") or "imswitch" @@ -128,6 +142,7 @@ def __init__(self, setupInfo: Optional[ArkitektInfo]): self.__logger = initLogger(self) self.info = setupInfo if setupInfo is not None else ArkitektInfo() self._missing = [p for p in REQUIRED_PACKAGES if importlib.util.find_spec(p) is None] + self._outdated = None if self._missing else _outdated_arkitekt() self._factory: Optional[AppFactory] = None self._version = "0.0.1" self._listeners: List[Callable[[dict], None]] = [] @@ -141,9 +156,10 @@ def __init__(self, setupInfo: Optional[ArkitektInfo]): self._retry: Optional[threading.Timer] = None self._services: List[str] = [] self._session: Dict[str, Any] = {} - initial = UNAVAILABLE if self._missing else DISABLED if not self.info.enabled else UNBOUND + initial = UNAVAILABLE if not self.is_available() else \ + DISABLED if not self.info.enabled else UNBOUND self._set(state=initial, message=self._missing_message()) - if self._missing: + if not self.is_available(): self.__logger.warning(self._missing_message()) # ── for the controller ────────────────────────────────────────────────── @@ -160,7 +176,7 @@ def add_listener(self, callback: Callable[[dict], None]) -> None: self._listeners.append(callback) def is_available(self) -> bool: - return not self._missing + return not self._missing and not self._outdated @property def identifier(self) -> str: @@ -168,21 +184,25 @@ def identifier(self) -> str: @property def url(self) -> str: - """The server a bind goes to: the setup's url, $FAKTS_URL, the public one.""" - return (self.info.url or os.getenv("FAKTS_URL") or DEFAULT_URL).strip() + """The server a bind goes to: the setup's url, $FAKTS_URL, the public one. + A bare host ("go.arkitekt.live") means https: fakts would otherwise try + protocols in turn, and the stored login is kept per url string.""" + url = (self.info.url or os.getenv("FAKTS_URL") or DEFAULT_URL).strip().rstrip("/") + return url if "://" in url else f"https://{url}" def status(self) -> dict: with self._lock: session = dict(self._session) url = self.url return {**session, - "available": not self._missing, "missingPackages": list(self._missing), + "available": self.is_available(), "missingPackages": list(self._missing), "enabled": bool(self.info.enabled), "url": url, "appName": self.identifier, "appVersion": self._version, "autoConnect": bool(self.info.autoConnect), "allowInsecureTransport": bool(self.info.allowInsecureTransport), "useMikro": bool(self.info.useMikro), "uploadExperiments": bool(getattr(self.info, "uploadExperiments", False)), + "deleteAfterUpload": bool(getattr(self.info, "deleteAfterUpload", False)), "hasMandateKey": bool(getattr(self.info, "mandateKey", "")), "hasStoredLogin": self.has_stored_login(), "insecureUrl": _is_insecure(url), @@ -256,7 +276,7 @@ def shutdown(self) -> None: # ── internals ─────────────────────────────────────────────────────────── def _refusal(self) -> Optional[str]: - if self._missing: + if not self.is_available(): return self._missing_message() if not self.info.enabled: return "Arkitekt is disabled in the setup file (arkitekt.enabled = false)." @@ -265,6 +285,10 @@ def _refusal(self) -> Optional[str]: return None def _missing_message(self) -> Optional[str]: + if self._outdated: + return (f"arkitekt {self._outdated} is installed, but ImSwitch needs arkitekt " + f"{ARKITEKT_VERSION} and its family. Update the environment (uv sync), or: " + f"pip install \"arkitekt[rekuest,mikro]=={ARKITEKT_VERSION}\"") if not self._missing: return None return (f"Python package(s) {', '.join(self._missing)} not installed. Install with: " From 479f4ebd3e4296be5973d753399002ef76d76220 Mon Sep 17 00:00:00 2001 From: Benedict Diederich Date: Mon, 16 Nov 2026 09:26:10 +0000 Subject: [PATCH 3/3] Arkitekt: sigUploadToMikro, any controller sends images to mikro A controller emits sigUploadToMikro with an OME-Zarr folder ("path") or an array ("image": (y, x), (y, x, 3) RGB or (c, y, x)), optionally with a name, channel names, position and pixel size. An array is written to disk as a canvas with its pyramid, on a worker thread, and placed by its centre; both go into the upload queue, which uploads while ImSwitch is bound and idle. ARKITEKT.md lists every way images reach mikro without an Arkitekt call, and notes that newswitch only saves to local files. Co-Authored-By: Claude Opus 5.5 --- docs/ARKITEKT.md | 19 ++++++- docs/arkitekt-hub-pi.md | 5 +- .../_test/unit/test_arkitekt_controller.py | 25 +++++++++ .../controller/CommunicationChannel.py | 6 +++ .../controllers/ArkitektController.py | 51 +++++++++++++++++++ imswitch/imcontrol/model/io/mikro_upload.py | 33 ++++++++++++ 6 files changed, 137 insertions(+), 2 deletions(-) diff --git a/docs/ARKITEKT.md b/docs/ARKITEKT.md index 685d8133c..790f70d28 100644 --- a/docs/ARKITEKT.md +++ b/docs/ARKITEKT.md @@ -97,6 +97,22 @@ starts with 8 sources, so a scan of single tiles cannot be viewed. The panel shows the connection, the offered actions, a log of remote calls (arguments, result, duration, errors) and thumbnails of the images sent. +## Images that go to mikro on their own + +Orkestrator only views images; nothing has to be triggered from Arkitekt. While ImSwitch is bound, +the sources below share one upload queue. It uploads while the microscope is idle, survives +restarts and network loss, and applies `deleteAfterUpload`. + +| From | How | +|---|---| +| Experiments | `uploadExperiments`: the canvases of every finished run | +| Any controller | `self._commChannel.sigUploadToMikro.emit({"image": frame, "name": "…", "positionUm": {"x": …, "y": …}})` (an array is first written to disk as a canvas with a pyramid), or `{"path": "….ome.zarr"}` | +| HTTP, scripts | `POST queueArkitektUpload?path=` | +| Other programs | their own Arkitekt login and the `mikro` client, as in `scripts/arkitekt_canvas_bench.py upload` | + +[newswitch](https://github.com/openUC2/newswitch) saves only to local files. It does not use mikro +yet, and it is on the older `arkitekt-next` packages. + ## HTTP endpoints (`ArkitektController`) | Endpoint | | @@ -121,7 +137,8 @@ Socket signals: `sigArkitektStatus`, `sigArkitektActivity`, `sigArkitektUpload`. `@app.background`), and the controller serves the panel endpoints. - `imswitch/imcontrol/model/io/mikro_upload.py`: an NGFF canvas into mikro with the levels it already has (nothing is downsampled again), the stage space, the persistent upload queue. - `ExperimentController` announces finished canvases with `sigExperimentFinished`. + `ExperimentController` announces finished canvases with `sigExperimentFinished`; any + controller sends images with `sigUploadToMikro` (both in `CommunicationChannel`). - `frontend/src/components/ArkitektController.jsx`, `state/slices/ArkitektSlice.js`, `backendapi/apiArkitektController.js`. - Tests: `imswitch/imcontrol/_test/unit/test_arkitekt_controller.py`. With arkitekt installed, these diff --git a/docs/arkitekt-hub-pi.md b/docs/arkitekt-hub-pi.md index d298f000c..a5ca08f4e 100644 --- a/docs/arkitekt-hub-pi.md +++ b/docs/arkitekt-hub-pi.md @@ -91,7 +91,9 @@ id 24 / **wa 38 %** (the SD card is the limit). SoC at most 45.5 °C, never thro kontrol, Postgres, Redis, RustFS and Caddy, with accounts of its own. A hub connected to it works without internet. With go.arkitekt.live, logins and token refresh need internet; scans stay on disk and the upload queue waits. -14. **Minor:** +14. **newswitch** saves only to local files and has no mikro upload. It runs on `arkitekt-next`, so + it would first move to arkitekt 16. +15. **Minor:** - konstruktor's README says port 7080, but the CLI uses 2754/2755. - `--dry-run` creates the target folder. - `docs/setup-config.schema.json` has drifted from `SetupInfo`; only `ArkitektInfo` is @@ -120,6 +122,7 @@ id 24 / **wa 38 %** (the SD card is the limit). SoC at most 45.5 °C, never thro - An arkitekt older than 16 makes the panel name the version it needs. Before, the login failed with a TypeError, as in Bene's `.venv`. - A bare host means https. +- `sigUploadToMikro`: any controller sends an array or an OME-Zarr folder to the upload queue. ## Pallet (os-rpi branch `feat/arkitekt-hub`, option B) diff --git a/imswitch/imcontrol/_test/unit/test_arkitekt_controller.py b/imswitch/imcontrol/_test/unit/test_arkitekt_controller.py index 548373c12..baedfb52f 100644 --- a/imswitch/imcontrol/_test/unit/test_arkitekt_controller.py +++ b/imswitch/imcontrol/_test/unit/test_arkitekt_controller.py @@ -436,6 +436,31 @@ def test_an_uploaded_canvas_is_deleted_only_once_mikro_holds_all_of_it(tmp_path, assert controller.getArkitektUploads()[0]["thumbnail"] # taken before the canvas went +def test_any_controller_can_send_an_image_or_a_canvas_to_mikro(tmp_path, monkeypatch): + pytest.importorskip("mikro") + controller, _, _ = make_controller() + rgb = np.zeros((60, 80, 3), np.uint8) + rgb[..., 1] = 200 + sent = controller._on_upload_request({"image": rgb, "name": "Overview", + "positionUm": {"x": 100.0, "y": 50.0}, + "pixelSizeUm": 0.5}).result() + assert sent.endswith("_Overview.ome.zarr") + write_canvas(tmp_path / "other.ome.zarr") + assert controller._on_upload_request({"path": str(tmp_path / "other.ome.zarr")}).result() + assert controller._on_upload_request({"path": str(tmp_path / "missing")}).result() is None + assert [e["name"] for e in controller.getArkitektUploadQueue()["pending"]] == ["Overview", None] + monkeypatch.setattr(controller, "_idle_for_upload", lambda: None) + mikro = FakeMikro() + assert controller._upload_next(mikro) + uploaded = mikro.datasets[0].kwargs + assert uploaded["data"].data.shape == (3, 60, 80) + assert [a.label.label for a in uploaded["anchors"]] == ["red", "green", "blue"] + # placed at its top-left corner: the centre minus half a field + assert mikro.spaces[0].registered[0][2] == {"x": 80.0, "y": 35.0} + controller._manager.info.enabled = False + assert controller._on_upload_request({"image": rgb}) is None # nothing written + + def test_only_an_ome_zarr_image_folder_is_deleted(tmp_path): pytest.importorskip("zarr") from imswitch.imcontrol.model.io.mikro_upload import delete_canvas diff --git a/imswitch/imcontrol/controller/CommunicationChannel.py b/imswitch/imcontrol/controller/CommunicationChannel.py index 35b213459..0c8b85d11 100644 --- a/imswitch/imcontrol/controller/CommunicationChannel.py +++ b/imswitch/imcontrol/controller/CommunicationChannel.py @@ -79,6 +79,12 @@ class CommunicationChannel(SignalInterface): # {name, dir, canvases: [OME-Zarr canvas paths]}: emitted once an experiment's # writers are finalized (pyramids built), also after a stop. sigExperimentFinished = Signal(dict) + # Send an image to the Arkitekt server's mikro, from any controller: + # {"path": OME-Zarr image folder} or {"image": array (y, x), (y, x, 3) RGB or + # (c, y, x)}, optional "name", "channels", "positionUm" {x, y, z} (where the + # image's centre was; default: the stage now), "pixelSizeUm" (default: the + # camera's). Queued and uploaded while ImSwitch is bound and idle. + sigUploadToMikro = Signal(dict) #sigRequestScannersInScan = Signal() diff --git a/imswitch/imcontrol/controller/controllers/ArkitektController.py b/imswitch/imcontrol/controller/controllers/ArkitektController.py index ec386fd7a..48e5adec6 100644 --- a/imswitch/imcontrol/controller/controllers/ArkitektController.py +++ b/imswitch/imcontrol/controller/controllers/ArkitektController.py @@ -23,6 +23,7 @@ import asyncio import base64 import collections +import concurrent.futures import datetime import enum import functools @@ -118,6 +119,13 @@ def __init__(self, *args, **kwargs): finished = getattr(self._commChannel, "sigExperimentFinished", None) if finished is not None: finished.connect(self._on_experiment_finished) + # Arrays sent with sigUploadToMikro are written to disk here, in order, + # off the sender's thread. + self._mikro_writer = concurrent.futures.ThreadPoolExecutor( + max_workers=1, thread_name_prefix="sigUploadToMikro") + requested = getattr(self._commChannel, "sigUploadToMikro", None) + if requested is not None: + requested.connect(self._on_upload_request) self._manager.set_app_factory(self.build_app, ARKITEKT_APP_VERSION) self._manager.add_listener(self.sigArkitektStatus.emit) self._manager.auto_connect() @@ -125,6 +133,8 @@ def __init__(self, *args, **kwargs): def closeEvent(self): if self._manager is not None: self._manager.shutdown() + if getattr(self, "_mikro_writer", None) is not None: + self._mikro_writer.shutdown(wait=True) # finish writing what was sent # ── HTTP: the Arkitekt panel ──────────────────────────────────────────── @@ -921,6 +931,47 @@ def _on_experiment_finished(self, payload: dict) -> None: if self._upload_queue.add(path, f"{name} {region}"): self._logger.info(f"Queued for mikro: {path}") + def _on_upload_request(self, payload: dict): + """sigUploadToMikro: queue an OME-Zarr folder ("path") or an array + ("image") for mikro. An array is first written to disk as a canvas with + its pyramid, so it survives a restart too. Returns the future of the + queued path (None when Arkitekt is off here).""" + if self._upload_queue is None or not self._manager.info.enabled: + self._logger.debug("sigUploadToMikro ignored: Arkitekt is not enabled") + return None + return self._mikro_writer.submit(self._queue_upload, dict(payload)) + + def _queue_upload(self, payload: dict) -> Optional[str]: + from imswitch.imcontrol.model.io.mikro_upload import write_image_canvas + + name, path = payload.get("name") or None, payload.get("path") + try: + if payload.get("image") is not None: + stamp = datetime.datetime.now() + name = name or f"Image {stamp:%Y-%m-%d %H:%M:%S}" + try: + here = payload.get("positionUm") or self._position(None) + except Exception: # noqa: BLE001 - no stage: placed at the origin + here = {"x": 0.0, "y": 0.0, "z": 0.0} + path = os.path.join(dirtools.UserFileDirs.getValidatedDataPath(), + "ArkitektController", "uploads", + f"{stamp:%Y%m%d_%H%M%S_%f}_" + f"{re.sub(r'[^A-Za-z0-9._-]+', '_', name)[:40]}.ome.zarr") + write_image_canvas(path, payload["image"], name=name, + pixel_um=float(payload.get("pixelSizeUm") + or self._pixel_size_um()), + center_um=(float(here["x"]), float(here["y"])), + z_um=float(here.get("z") or 0.0), + channels=payload.get("channels")) + if not path or not os.path.isdir(path): + raise ValueError(f"neither an image nor an OME-Zarr folder: {path!r}") + if self._upload_queue.add(path, name): + self._logger.info(f"Queued for mikro: {path}") + return path + except Exception as e: # noqa: BLE001 - a sender must not fail on this + self._logger.error(f"sigUploadToMikro: {e}") + return None + def _idle_for_upload(self) -> Optional[str]: """None when an upload may start now, else why not.""" reasons = busy_reasons(self._master, self._logger) diff --git a/imswitch/imcontrol/model/io/mikro_upload.py b/imswitch/imcontrol/model/io/mikro_upload.py index a596afdf6..6ed2bdc5b 100644 --- a/imswitch/imcontrol/model/io/mikro_upload.py +++ b/imswitch/imcontrol/model/io/mikro_upload.py @@ -95,6 +95,39 @@ def read_ngff(path) -> NgffCanvas: labels=channel_labels(names)) +def write_image_canvas(path, image, *, name: str, pixel_um: float, center_um: Sequence[float], + z_um: float = 0.0, channels: Optional[Sequence[str]] = None): + """Write *image* as an OME-Zarr canvas with its pyramid, centred at + *center_um* (x, y: the stage position it was taken at). (y, x) is one + channel, (y, x, 3) a camera's RGB, (c, y, x) channels named by *channels*.""" + import numpy as np + from imswitch.imcontrol.model.aufgaben.storage import ImageSpec, NgffImage + + image = np.asarray(image) + if image.ndim == 2: + planes, default = [image], ["C0"] + elif image.ndim == 3 and image.shape[2] == 3: + planes, default = [image[..., c] for c in range(3)], ["rgb_r", "rgb_g", "rgb_b"] + elif image.ndim == 3: + planes, default = list(image), [f"C{i}" for i in range(image.shape[0])] + else: + raise ValueError(f"An image is (y, x), (y, x, 3) or (c, y, x), not {image.shape}") + names = list(channels or default) + if len(names) != len(planes): + raise ValueError(f"{len(names)} channel names for {len(planes)} channels") + height, width = planes[0].shape + spec = ImageSpec(shape=(1, len(planes), 1, height, width), dtype=str(image.dtype), + pixel_size_um=pixel_um, channel_names=names, name=name, + origin_um=(center_um[0] - width * pixel_um / 2, + center_um[1] - height * pixel_um / 2, z_um)) + Path(path).parent.mkdir(parents=True, exist_ok=True) + canvas = NgffImage.create(str(path), spec) + for c, plane in enumerate(planes): + canvas.write(np.ascontiguousarray(plane), 0, c, 0) + canvas.finalize() + return canvas + + def stage_space(mikro, name: str = "Stage"): """This microscope's stage as a µm space in mikro: created once, then reused.""" from kanne.scalars import Unit