diff --git a/docs/validation/generic_runtime_owners_323_20260930/README.md b/docs/validation/generic_runtime_owners_323_20260930/README.md new file mode 100644 index 0000000000..f20b4a2928 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/README.md @@ -0,0 +1,258 @@ +# Generic runtime optimization owners — issue 323 + +Current qualification is production `f7b39a2a4` on main `f24a828da`: 1,538 tests +plus 42 subtests, original guards, and all 30 native-reference cases pass. The +warmed-parent review fix, test-context isolation, exact receipts and matched +current timing limits are in [the synchronized validation note](../runtime_owner_sync_323_20261001.rst). +The source cohorts and timing observations below are historical evidence. + +Store-bound query-cache invalidation, provider-independent object columns, and +persistent kernel preparation now derive from nominal core owners. The obsolete +provider classes, weak-global query caches, and forwarding imports are removed. +This is the user-requested ownership repair. It is not a demonstrated pipeline +speedup, and the ImagingFlow timing concern remains open for review. + +The validated production source is +`eba8e5c871a84b5ddd2581d7562798223ebd2415`, normally integrated with main +`74eac059f67389ca071055c93fcbdd556ba79f1a`. Main's artifact-publication fix and +paired-field identity fix are preserved. The independent ACK fixture repair +was merged through PR 325 and closed issue 324; it is not duplicated by this PR. + +| Behavior | Determining owner | Consumers | +| --- | --- | --- | +| Store mutation and derived-query lifetime | `RuntimeValueStore` | Generic measurement table lookup and CP label/vector lookups | +| Bounded value storage | `BoundedCache` | Store query domains and the existing process cache family | +| Process singleton lifetime | `ProcessLocalBoundedCache` | Existing process-local cache subclasses | +| Complete object-column domain and shared mapping iteration | Core `ObjectMeasurementColumnarRows` | Colocalization, granularity, shape, intensity, intensity distribution, Zernike | +| CPU/persistent Numba cache admission | `PersistentNumbaKernelPreparation` | Backend families and standalone registered kernels | +| Standalone kernel identity, operation derivation, parent preparation | `RegisteredNumbaKernelPreparation` | Existing CP declarations and an independent provider exercised in tests | +| Intrinsic kernels, provider requirements, fixture effects | Numerical/provider declarations | Their existing generic preparation consumers | + +Store query domains have no process-singleton API. Record, replacement, clearing, +and worker-observation merge invalidate attached query values at the store's +existing mutation point. Derived caches are excluded from serialization; tests +compare transport bytes before and after a large populated derived cache and +verify retained records/revision. The old unbounded query dictionaries now use +the shared bounded LRU (default 4,096 entries); eviction recomputes values without +changing query scope. This capacity change is explicit. + +The old long-row iterator was overridden by every child, whose columns are wide; +it was removed rather than moved as dead behavior. The wide forwarding class is +also removed. Typed numerical iteration remains with its leaf. The old private +abstract-class import/pickle paths are intentionally not retained; dynamic +external callers of those paths are an OPEN boundary. + +The final combined native behavior checks pass **783 tests**, with one unchanged +optional Napari skip in the headless environment. Two existing watershed warnings +are retained. Coverage includes numerical consumers, actual cache mutations and +eviction, worker transport, materialization, current-main artifact publication +and paired-field identity, fork failure/cancellation, registry independence, and +once-only preparation effects. A non-CP family runs through the existing registry +consumer and remains eligible under a CP-specific capture flag. + +Original CI-pinned R0 passes for all three roots: OpenHCS has 5,243 metrics with +only `StringSubscript -2`; scripts has 228 metrics and benchmark has 409, both +unchanged. Original NRA R1 against current main completes with no increased +findings. Its complete source/dependency context has 3,058 base and 3,056 candidate +projections; the policy configures two detectors. Existing mapping reads, raw +record shapes, and redundant checks remain visible in the receipt. This is not +an all-detector clean scan or a native equivalence theorem. + +The original ClassDef census covers every declaration in OpenHCS and setup.py. +The final census has 701 modules, 5,123 original classes, 5,111 projected classes, +and all 12 unprojected OPEN declarations. The ownership receipts include required +and forbidden owner/consumer pairs, independent provider effects, counterevidence, +and the original OPEN rows. NRA performs declaration-selected rename, movement, +and base introduction for kernel preparation. Consumer closure and algorithm +extraction use explicitly authored, revision-checked source patches. The empty +obsolete row module is removed with an explicit emptiness assertion because NRA +has no file-deletion primitive. Native tests and production parity supply the +executed behavior evidence; syntax/preflight does not prove authored semantics. + +All timed observations use the public benchmark route, one well, one native +thread, CPU 5, current shared dependency pins and persistent declared-kernel +cache. Mandatory registry/kernel readiness precedes pipeline clocks. Server +startup and shutdown are excluded. `1w_1t` selects the **inline** executor; fork +is configured for actual multiworker execution, not these single-lane observations. +No tests, audits, builds or other replays overlap the timed observations. + +| Source cohort / case | Main execution | Candidate execution | Main total | Candidate total | +| --- | ---: | ---: | ---: | ---: | +| Final kernel-owner ABBA, ImagingFlow (means of two per side) | 18.201s | 17.051s | 20.689s | 19.456s | +| Final kernel-owner ABBA, 3D (means of two per side) | 8.583s | 8.300s | 11.024s | 10.760s | +| After paired-field main integration, ImagingFlow (one per side) | 15.849s | 16.566s | 18.063s | 18.740s | +| After paired-field main integration, 3D (one per side) | 8.362s | 8.316s | 10.777s | 10.753s | + +Compilation in the latest pair is 1.500/1.509s for ImagingFlow and 1.656/1.683s +for 3D (main/candidate). The latest pair is source and parity qualification, not +statistical performance evidence. Earlier ImagingFlow cohorts also showed slower +candidate averages: +2.04s and +0.73s. The favorable ABBA cohort includes a slow +19.970s main observation; all observations are retained. The sign changes across +cohorts do not establish a gain or performance neutrality. The latest +0.72s +ImagingFlow concern is not dismissed. + +On the latest source, all 14 complete requested CSVs and 240 persisted label +images across the four qualification outputs match exactly. The earlier ABBA +plus diagnostic comparison checks 30 complete CSVs and 480 label images. +The extended latest-source main/candidate gate also compares **every produced +TIFF**: 128 images, all series pixels, dtype, shape, axes, physical calibration +and source metadata. Both native ROI archives decode, with 1,256 ROI geometries; +native members are byte-exact and sidecar metadata agrees. Only the explicitly +different, admitted run-directory prefixes in JSON source addresses are +normalized; no measurements, identities, coordinates or calibration fields are +discarded. ZIP container timestamps are not scientific content. This extends +the earlier `*Labels.tiff` gate, which missed eight ImagingFlow checkpoint TIFFs +and two ROI archives. + +Full-step owner-thread diagnostics retain numerical, finalization and progress +phases separately from unprofiled clocks. No execution-time Numba compilation was +observed in those diagnostics. A follow-up production cache probe invalidates +the extra-hashing hypothesis: ImagingFlow does not call the store-query cache or +hash the object-label query; all bounded cache lookups/writes sum to about 2ms, +and store mutation invalidation totals about 0.13ms on each side. These cannot +explain a 0.72s difference, so this route is rejected. Diagnostic clocks are not +promoted as performance improvements or as proof that the difference is harmless. + +The exact-column CSV prototype saves only about 0.19s and was rejected as a +primary runtime fix. A saved-table provenance replay costs 15.9s, but that route +was not established in live CP execution and is not presented as a production +payoff. The continuing performance work remains under issue 162; native +CellProfiler timing and scaling-figure refresh are not completed by this receipt. + +Compressed original guard/census/test artifacts, raw observations, complete +parity receipts, attribution traces, transactions, and SHA256SUMS are retained +here. `*.py.txt` files are exact task-local archival recipes with historical +paths, not installed utilities or portable product examples. Production timing +is reproduced with `scripts/benchmark_cppipe_well_throughput.py`, manifest +`benchmark/manifests/official30_portable_axis1.json`, mode `1w_1t`, and the two case +names in the tables, using the recorded revisions and shared environment. + +The validated source tree lists every committed Python blob and dependency +gitlink. Publication adds documentation and evidence only; its source membership +is checked against that validated tree. Hosted CI remains separate from the +locally executed, original checks above. + + +The October 1 closure is validated at +`95a98b0083aba2384c271e224746824fc9e40ce5`, against the same current main +`74eac059f67389ca071055c93fcbdd556ba79f1a`. Earlier source cohorts and concerns +above remain retained; the new source is listed separately in +`validated-source-tree-95a98b008.txt`. + +Four remaining numerical caches now derive LRU storage and process lifetime from +the shared parents: granularity series, radial-label geometry, radial-spectrum +geometry and Zernike-label geometry. Each retains its existing 16-entry capacity +and numerical key/value calculation. The provider-owned OrderedDict globals, +eviction loops and granularity lock global are deleted. `SynchronizedBoundedCache` +owns granularity's individual operation locking through cooperative inheritance; +the process parent serializes first singleton construction. The executed gate +checks the MI constructor/MRO, singleton identity under simultaneous threads, +LRU promotion/eviction, registration and cleanup. Registry cleanup remains an +explicit operation, not a new automatic clearing policy between wells. + +The logger-bound `RuntimeProfiler` moves from granularity to core runtime profiling. +Its eight numerical consumers now import core directly. The shared existing sink +determines environment gating and log/file output effects, covered with enabled +and disabled tests. The identically named CP module/function context profiler in +measurement execution support is a different authority; it and its bridge +consumer are byte-unchanged. NRA initially rejected the imported declaration +rename because dynamic importer exports were unresolved. The admitted sequence +migrates exact direct consumers in an authored, revision-checked stage before +guarded declaration rename/movement. The dynamic numerical export declarations +stay unchanged; this does not turn their OPEN export contract into a proved one. +The initial failed guard log, final complete simulation and recipes are retained. + +The final combined execution gate passes **1,055 tests**, with the same one +optional Napari skip and two existing watershed warnings. Original CI-pinned R0 +passes all three roots; OpenHCS has no increases and removes one StringDispatch, +three StringDispatchArms and two StringSubscript findings. Scripts and benchmark +are unchanged. Original NRA R1 reports no increased findings with complete +context (3,058 base / 3,056 candidate projections; the same two configured +detectors). The final original-ClassDef census has 5,128 original declarations, +5,116 projected declarations, and all 12 OPEN declarations across 701 modules. + +Fresh normal public qualification uses the same single-lane route, dependency +pins, CPU 5 and shared persistent kernel directory. Mandatory readiness precedes +pipeline clocks; startup/shutdown are excluded. All four normal CLI runs report +success and one successful well. No checks or other task replays overlap them. + +| Latest source / case | Main compile | Candidate compile | Main execution | Candidate execution | Main total | Candidate total | +| --- | ---: | ---: | ---: | ---: | ---: | ---: | +| ImagingFlow | 2.000s | 1.535s | 17.000s | 17.992s | 19.683s | 20.285s | +| 3D | 1.677s | 1.847s | 8.486s | 8.204s | 10.887s | 10.772s | + +These are source/parity qualification pairs, not statistical performance proof. +The new ImagingFlow execution difference is +0.992s and its total difference is ++0.601s; the concern remains open. No speedup or neutrality is claimed. All 14 +complete CSV comparisons and 240 persisted label checks pass exactly. The +extended gate also matches all 128 TIFF series, pixels, dtype, shape, axes, +calibration and source metadata, and both native ROI archives (1,256 geometries), +using only the previously admitted run-directory normalization for source +addresses and ignoring ZIP container timestamps. + +A separate minimal process-global GC diagnostic on earlier candidate 00683 and +main 74e records overlap with actual step windows, including other threads. +Execution GC overlap is 0.244841s on candidate versus 0.059044s on main, a +0.185797s difference against that diagnostic pair's 0.177079s execution difference. +This explains that trace's difference, not all historical timing differences or +the latest source pair. GC is too small there to close the overall execution gap; +no production GC freezing/disabling policy was added. Public process headers +hash the embedded launch arguments; complete original traces remain in the local +run root. GC clocks remain diagnostic rather than unprofiled performance evidence. + +Granularity's reconstruction is still a large intrinsic numerical term (about +2.22s in the saved live phase trace), with generic data movement around that step +small. The ownership migration intentionally leaves that numerical algorithm +with its provider. Further runtime optimization, fresh native CP timings and +scaling figures remain outstanding under the continuing performance goal. + + +Further October 1 diagnostics use the same production source (95a98b008); no +performance algorithm, GC policy, clock owner or export parser was added. +The normal public ImagingFlow +0.992s concern above remains unresolved. +In the minimal global-GC ABBA, execution is 16.476s / 16.868s / 24.282s / 16.122s +(main / candidate / candidate / main). The 24.282s outlier includes about 6.7s +in OverlayOutlines and its following gap; overlapping GC is only 0.231s. +Thus the earlier GC explanation does not generalize to all observations. + +A separate owner-thread timeline has candidate/main execution 16.200s/16.039s. +Its 23 numerical steps total 13.494s/13.354s wall and 12.066s/11.951s owner-thread +CPU, with 1.375s/1.355s Linux scheduler run-queue wait. No Numba dispatcher +compilation is observed during those step/progress windows. These are diagnostic +clocks, not neutrality or speedup proof. The IPO progress-context path accounts +for about 0.4s; ordinary worker emits total only 6–8ms. Step sums do not include +the entire execution job. The native extension instruction and data sections +match main exactly; whole shared-object hashes differ in build-location metadata. +No cause for the scheduler wait is asserted. + +Two exact-output reconstruction prototypes are rejected rather than promoted. +Against all six saved production float32 frontiers, the constant-five-spectrum +queue saves about 0.347s and the active-field queue about 0.340s across per-input +medians. The active-field version retains 64% of full field visits, insufficient +collapse to close the execution target gap. Constructing a component tree alone +costs 9.069s for the first input, versus about 0.54s for its current complete +reconstruction series; that route is rejected immediately. Task-only source and +replay receipts are retained, with no installed prototype or production claim. + +Fresh native CellProfiler 4.2.8.1 uses the existing native synthetic-well batch +driver and native batch clock. One well owns six source planes and two image +sets, one native process, one native thread, CPU 5. One full warm-up batch precedes +two observed batches. First-module through post-run completion is 73.065s and +64.415s; invocation through completion is 73.194s and 64.524s. Python/JVM startup +is excluded; the worker separately records 1.004s startup after imports. No other +task benchmark, test or audit overlaps these runs. Provenance retains exact input +hashes, versions, thread policy, revisions and command-request membership. + +Directly comparing raw exported tables was the wrong comparison scope: native +uses contextual headers while ordinary OpenHCS combined CSV uses flattened +headers (528 versus 595 columns). Both failed diagnostic attempts are retained; +neither is evidence of a measurement regression. The existing production +OpenHCSAdapter reference path instead compares native's contextual reference +with typed OpenHCS measurement artifacts and passes with **zero differences** +under the existing strict 1e-6 policy. No parser workaround, ignored measurement +field or relaxed tolerance was introduced. This adapter run retains value +observations for parity, whereas the normal throughput runs retain outcomes; +its 25.473s execution / 30.669s server job is a different observation scope and +must not replace the normal single-lane clocks or be claimed as a refactor +regression. Equivalence comparison (32.703s) occurs after the pipeline job. +Native image/ROI parity and the full scaling-figure refresh remain outstanding. diff --git a/docs/validation/generic_runtime_owners_323_20260930/SHA256SUMS b/docs/validation/generic_runtime_owners_323_20260930/SHA256SUMS new file mode 100644 index 0000000000..1f4b7d68b4 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/SHA256SUMS @@ -0,0 +1,116 @@ +16e73fe9a831e8f7e08c72c56797a8b665563b311531f000f9d877b2a40d6101 README.md +f811c8c56ad671caaa92d51be13c4fcf87eb55d098e22808f9c2dc84310cb83f apply_generic_measurement_runtime_owners_20260930.py.txt +94ce22b82a2ff871397f5aa827b79e7a390cb46c2a2fab08e77dbd19304fdd0c census_refill_preparation_20260930.py.txt +33d08eea6b45dbbe76c7e0eb4afd9a861cbd832b98eb74688ed31df8993018b0 check_runtime_owner_fresh_native_facts_20261001.py.txt +584a3b4d5d848aa9aa6400d552f6a7ca0a398160c17c92b29115d695306d1f6b check_runtime_owner_fresh_native_tables_20261001.py.txt +69ce8bac6365fca894e58c666e72547f15e98ba3e2ebe154fdf7c7a1984765fd closure-global-gc-sitecustomize.py.txt +21e987a04a75fae94244197cca4cfaf87734ec208ca3b6555f848c76e21de49b cpu-timeline-candidate-20261001.jsonl.gz +794fe3c70b50df604d26ad73d646a946f07bc55daa22e28344fe5aaa19dd7aee cpu-timeline-main-20261001.jsonl.gz +5e6eade3d2c8b404ff7910001133bf5f51e0b5e2fa5c14780d888c1e812123cf cpu-timeline-sitecustomize.py.txt +cde3ebcd93bbea6287a5e809225401118badd15c5c70cae2a31bf3aadfee2874 fresh-native-imaging-provenance.json.gz +6007fd0a0bb5c49d6c2b9f2ed4536c0dc4a937563c4877dc1813ddf6508a583f fresh-native-imaging-request_0.json.gz +84d17ba1384d1e908bd781b1b24d419d13949f804c41999634958cbd63b51fcc fresh-native-imaging-summary.json.gz +a97203b9937186d312725de6314314f513e60e5ca4f5f65d5ffc481e53b8ac09 global-gc-candidate-intervals-20260930.jsonl.gz +b326124946b5391403c2874fc08961b91d9f07ac65a8e5252f291f6cf7d5313b global-gc-closure-candidate-a-20261001.jsonl.gz +868a746a14ce2ac5e076b069e7fd53400f9363ec9e301af66295718e89fb730a global-gc-closure-candidate-b-20261001.jsonl.gz +7c6808bb95297f94c40bd3ee1a074808bb7c4bc38e9e17c2c0d7f1f0a68dc35a global-gc-closure-main-a-20261001.jsonl.gz +03e545a5f82951362b3cab6260b86926e97454c893b8917d232f89307ab5afb9 global-gc-closure-main-b-20261001.jsonl.gz +1a6517c2b8c2cc8e9b1b1576f0f7c4811eb6b8b88fadb913d6081c50444465c0 global-gc-diagnostic-sitecustomize.py.txt +8c31483ab3505148aad41f026180d5c79e875d84e95cd3846fb33bd3c2046fc3 global-gc-main-intervals-20260930.jsonl.gz +7b73fc33d3d06a0c967338f21fd1396ae51216703d200a39133117bae00f4956 kernel-preparation-ownership.json +120db5ef628f5ea3fd637500535287b668f24aff61a253ed1653d09ea1970543 make_runtime_owner_cpu_timeline_20261001.py.txt +b04939348a028e78b884376d5aa0122d130cd767aff916c3dbfc4624679a3945 measurement-cache-and-column-ownership.json +476b7ebe896143deac434c944affaf7bb9b39ca4350fa1bbd9c392c40066041d move_bound_runtime_profiler_20261001.py.txt +fe0a2e90822203cff4a070e47ef02e5aaa4b8216f95afcd2ea3e8c7136f9d405 move_generic_numba_preparation_owner_20260930.py.txt +d527ce08164db70c6daa478cdc873a83ac4745758a80389fecde7dabb7a9aeac move_numerical_cache_mechanics_20261001.py.txt +cd910aa324d5f1e8fc9573e18d76a546798b0f131e27cbb8b48cdbbbe4936fd9 nra-r1.log +eabdb9b75fa08eedb84c33363b9e35b3e82a384a43b500c5f6f7bd21f967d46d perf-bound-runtime-profiler-plan-20261001.log.gz +f149be2f9a012008661151a404d51d511a0d3b2400b5b7bed6a238f3e2f66592 perf-bound-runtime-profiler-simulation-20261001.json.gz +1e1c7c8d830f8906012e60598bc5899cfdfc4a44914fb3705f4ea7a678b36729 perf-bound-runtime-profiler-transaction-20261001.diff.gz +5c54512dcdce2b8526bf2efc5ed75f2862649632475ab6ab78f6e5be266dd7ac perf-columnar-export-frontier-probe-20260930.json +715f4ebf7e8d88180eacce70b90153c783616dcce797d36ea2135bef1ef957ec perf-generic-measurement-runtime-all-consumers-20260930.xml.gz +3999c8d302700616164169c4d2a1075263dc004984eaed8fb22ab1f465bbc9bc perf-generic-measurement-runtime-before-census-20260930.json.gz +24b9af7fa6d55c8799fc10828c6984f28042a04d55caad5b965c2fdffa244ec8 perf-generic-measurement-runtime-focused-20260930.xml.gz +351016c98e961a1908a59b828c09ee4fc293d1c126923be3e88783a148ecc694 perf-generic-measurement-runtime-nra-transaction-20260930.diff +37c1f8f5044ac4865731904290a376ec4d52ac3d9d2096961fb9883bfc3336a3 perf-generic-measurement-runtime-public-comparison-20260930.json +068e41e5ef204ed81d194e4d74ab8f680788ad89985b26976e67fdedb1a58a18 perf-generic-measurement-runtime-public-observations-20260930.json +5d6a203617b60d9f666b645db0f6418216b74c95f478babdba7a3dce941af472 perf-generic-measurement-runtime-refinement-20260930.diff +aa6ca25c2c7710b28239424328cd5db70f45a352af6103024c92c7bb9fa50d2c perf-generic-measurement-runtime-unchanged-main-materialization-20260930.xml.gz +608fd83495f1cab4d6de55f2b2594e35abee5767beef577944a0cb33fe3154b2 perf-generic-numba-owner-application-20260930.log +547bd55b8968612ee9a7fa4e1fdbc2d8cd8539f8b2d624aa8cbee6548e6c008e perf-generic-numba-owner-application-corrected-20260930.log +07fdeb69d3f170e9fb5970f81c160081a2ed9f692e6610f6ba28797b8c74296b perf-generic-numba-owner-complete-simulation-20260930.json.gz +02953b04c2af9f34709a77a5f8d31cd14fd63323cbe2d92016072db6da16e953 perf-generic-numba-owner-consumer-test-20260930.diff +0ef0e0ea3c540db1b0c2a0a67cf74aca0043fb3b05c3ba6eb3a5e02f4c17a51d perf-generic-numba-owner-initial-simulation-20260930.json.gz +a4edd93a01f35364580d1a72f4d22d535cb032a385e0528c29d8f57ffdb736ad perf-generic-numba-owner-transaction-20260930.diff +442259f07ddef37242fd141c700f2364a7aa6e188c5ad0dc461dcb4dd4349302 perf-generic-runtime-cache-lifetime-refinement-20260930.diff +9f4dcf635fd7f5edf1d93a0a6dd3b8dbaf2403efd2eedb7998ec7de98885d828 perf-generic-runtime-global-gc-diagnostic-observations-20260930.json.gz +fbbf338c32b3775dbc8cb664015ea98c344525d46c46f01ef831fc7b62f6d149 perf-generic-runtime-global-gc-overlap-20260930.json.gz +231afd93b32397b47daf0a4b3d6d7400bb4dec8fc3d5262a016a75402138795a perf-generic-runtime-imaging-confirmation-observations-20260930.json +0e4f21a37c8b9efaa88162c7f28bc18238a605123e4498bf6c1ca464d0eaf6f2 perf-generic-runtime-owners-complete-native-artifact-parity-20260930.json +2ecdf52add8d59670cad2fe7bae2382bb80fa4ee3c47a5f44f038e7dcab80ed3 perf-generic-runtime-owners-complete-public-comparison-20260930.json +c9ac1892db4386160f4671a3b1b32135543b0c6aa1ac24babbf837f1ceac617d perf-generic-runtime-owners-complete-public-observations-20260930.json +93efa739dfe467693536873670c2d35ceaa988962e16d21431d9948843fb63e9 perf-generic-runtime-owners-paired-main-census-20260930.json.gz +c07f660f556cfad7606c45da0bd2e202e98786e0aa03ed1a486229fd9dcb2c80 perf-generic-runtime-owners-paired-main-consumers-20260930.xml.gz +b3c8851acfe6d889c3a4da647697a881384b3e8a06b14254c33862f8a8e4a245 perf-generic-runtime-owners-paired-main-public-comparison-20260930.json +8457700a5d399e9f1a44c5e8822844a5fd5260835424486cb5dc5e0ac5d0808b perf-generic-runtime-owners-paired-main-public-observations-20260930.json +3a090e8bc409e732966d5d5f4493b93cae8628c235f1a499e806f04493a89a29 perf-generic-runtime-owners-paired-main-r0-benchmark-20260930.json.gz +39fc10c2f32b6527ddd922b2d7422144818a74dfcc21b0daf5a2727a20c8ff0f perf-generic-runtime-owners-paired-main-r0-openhcs-20260930.json.gz +7fd1e33e5ed6bcc1ee3399f51106c6fab21fe96afb56baca13da4d24e2e39a51 perf-generic-runtime-owners-paired-main-r0-scripts-20260930.json.gz +66f0f0b649c6664db782e050c8012ac444d5ee72c97c1222fca0ede32eae7c0e perf-generic-runtime-owners-paired-main-r1-20260930.json.gz +79b09a99387139ab0eb0252e707ddec5576fb1d370a886fb19e1b15ee95b91de perf-generic-runtime-phase-diagnostic-20260930.json.gz +260e95439002eaba2f1a079d517fbf7e82ff338821bdb286cb6619b5d0ba5232 perf-generic-runtime-phase-diagnostic-observations-20260930.json +edfc603c06fc80f01c3caccb6a638ef201cef3d22bc74f0ea0fe2bb59380c0a5 perf-generic-runtime-query-hash-costs-20260930.json +1c876e12ec9e6d7d4101e6b25311397bd1396ae8d5601dcffaad7f5d85bd4bf2 perf-generic-runtime-query-hash-diagnostic-20260930.json.gz +9971939a1ba0f59790497f823c87c80b7bfc13b41089532c4be8251e5eaa8ccb perf-generic-runtime-query-hash-diagnostic-observations-20260930.json +f5fb958c42347bd57cce48b10df065c60396c5b995c788d34f2d0d8a07e1d56f perf-granularity-active-spectra-production-replay-20261001.json.gz +aeb705f6a2c2192e04121b0569e389266b8a5ca4a034af811ec774810072344b perf-granularity-constant-spectra-production-replay-20261001.json.gz +97acbd937fdeab5a484cfc0778e3edcd1efdbb8d0145457abdf3e8c690c21e6b perf-granularity-maxtree-admission-20261001.json.gz +b9848aa105498128470b5a39e84c874ae97a6c7a6b3416ebaa576f8777ea8066 perf-materialization-ack-current-main-corrected-20260930.xml.gz +6c2e8b8e742394ebaabf1b5a90a77f2cc83aff8edc2ea9b7a994bda3531774e7 perf-measurement-provenance-frontier-probe-20260930.json +5f61e515cf8cfdda7ec41642bdcb50df8368cf15601a9d11607f541939cb5337 perf-numerical-cache-owner-simulation-20261001.json.gz +b68864ab4ac025a031b2cf6cb0d578a58a0114fe9bb2812fe52acf4a07405bcd perf-numerical-cache-owner-transaction-20261001.diff.gz +1a6f5fd354b349b3828917595bf625a1fce6cb095658a00d87aa9c48a5dbb653 perf-numerical-cache-owners-before-census-20261001.json.gz +1607f17f03daeadfcb3ae7584b9644e38c03ce0d0f6f643fd61aca4b9084b494 perf-numerical-cache-owners-public-comparison-20261001.json.gz +0d647bc19eab2609c04dd9effe7a4d1546ddbc705261e679de0343c5dbb8071b perf-numerical-cache-owners-public-observations-20261001.json.gz +a81c59e0a166b6cd7d5187d3cb98fe4644eecffa5bcbe6cc97c80a15b556e8ca perf-runtime-owner-closure-census-20261001.json.gz +e22c93ed6b91282c3a9ad5772696a20d2cfb51600e4fabe72dcbff4e46bdbda9 perf-runtime-owner-closure-combined-tests-20261001.xml.gz +4df0f9526b980d3fa365ba7291f97e5bab086b81165058b99eb386ca61d438d4 perf-runtime-owner-closure-decision-20261001.json.gz +2e99a110b98c5cb17953b082f6b65bf6f4c3fc628ef99dc227d8b59007b6e9c0 perf-runtime-owner-closure-global-gc-diagnostic-observations-20261001.json.gz +24d626dd75926894689beeaa850ad6c9b046f0d69a820ca0544cd7e6baa4efdf perf-runtime-owner-closure-global-gc-overlap-20261001.json.gz +97235d573eb8500fbb4a3df157c68ff21adf1a800433611b0443bd95afdf823c perf-runtime-owner-closure-native-artifact-parity-20261001.json.gz +e54285d23bfbdc7274698b6291be496048c560a8bcae693d8ab5a58ea383413f perf-runtime-owner-closure-r0-benchmark-20261001.json.gz +9da0cdeae0c1a6ce89a028860270468ed8b8d752573bd4124e7c3e265f4bbb9c perf-runtime-owner-closure-r0-openhcs-20261001.json.gz +6e1eed08ebae793c0dfb8c28a99fb8210d318095cb73692438f440193e0354fa perf-runtime-owner-closure-r0-scripts-20261001.json.gz +ef8ed3b62f225ee4049ff4bda30c91925e09e35f933f3bfb0ff71c9ce80c6a26 perf-runtime-owner-closure-r1-20261001.json.gz +c54b6f8d9846e2018417a634e879568386f07975525ed97c479b38ce6c713d63 perf-runtime-owner-closure-step-deltas-20261001.json.gz +0e10472d75e657b9bef4a2c64e16e1ed435fd8fc00e1fe205f654d47cbf5a346 perf-runtime-owner-cpu-timeline-attribution-20261001.json.gz +4d5387738be36f2a347f919eb1e0d4452d5537ee0512d9b5bfb35fc9c8f1a866 perf-runtime-owner-cpu-timeline-observations-20261001.json.gz +a5505b33d3b9dec8731ac0c1e54959cfcef8ed4d73f288de81c832a8659f489f perf-runtime-owner-fresh-native-fact-parity-20261001.log.gz +d8b42efa1d665f118c963c756cb27abbc42ec74ef2b3a514b3f7ae523016b930 perf-runtime-owner-fresh-native-reference-result-20261001.json.gz +7b0f898e093ec6fb7103adfbd053c96073d7f3678a0687e51dadb510db02ff03 perf-runtime-owner-fresh-native-table-parity-20261001.json.gz +87fd01d23102c614e6f6eeec6b1d2d7142f438ce32574a05bf836fab4a941c49 perf-runtime-owner-native-binary-inventory-20261001.json.gz +d3b53cba58c6fa534103474240df70b182612a6ad37e9c4345ae1b7b4e33532b perf-runtime-owner-native-binary-sections-20261001.json.gz +ff2bc219b1a5268cf4a064f224d89cfcd3b0c69a32427bb6633d31074f4af031 phase-diagnostic-sitecustomize.py.txt +751863adb3ebe1bad8d0226144ace36011a3cb7507c7075660918129e3d0c789 prototype_granularity_active_spectra_20261001.cpp.txt +e7d285828c814cd8e772473f26657472fc948e204ddcdb8410882d653844bd7e prototype_granularity_constant_spectra_20261001.cpp.txt +1277d57e6e12687ee2815f27309dae9e97ee5701b44b83091211e0e904e26a3f query-hash-diagnostic-sitecustomize.py.txt +788638395ab7ba7ff35bb3ad0ce15de745ad8bd028dabbca4c586d38a00ca17d refine_generic_measurement_runtime_owners_20260930.py.txt +44cc7382bbdf46221fb60b57923b520b806e09b472811d243cb3c3f31550b4c8 replay_granularity_active_spectra_20261001.py.txt +3904cd2d117602fd10873e84b1b44150345128f1f3298d66dc3d26f1fd03dae5 replay_granularity_constant_spectra_20261001.py.txt +dc913b82d2c5ff5697cccc2f86a758b6be1c1da0b13fd58f75348d8591e6c625 run_generic_runtime_global_gc_diagnostic_20260930.py.txt +bceb63cf7887e666b41659255b9c9a90711eabf9f19ba6be4ac4a300c7d81c6a run_generic_runtime_owners_complete_acceptance_20260930.py.txt +6d27682ebc27534b4239c6f521e57511c252cbbf33b46a6c055745e96b8223e6 run_generic_runtime_owners_paired_main_acceptance_20260930.py.txt +701ffd4cdc9411d5554679c04d1bc63d3da44ad1cedf7672491ffa5ed5ff66e9 run_numerical_cache_owners_acceptance_20261001.py.txt +d5fea9a13a7274e107c152de14422e0c6bf6e5a619bf6df590ba46807161ea63 run_runtime_owner_closure_global_gc_diagnostic_20261001.py.txt +bbd45e7ef81557afa8247897c116ace623ecde1bd57c3e11986dbc519a18c106 run_runtime_owner_cpu_timeline_20261001.py.txt +8c9a358652706862a06b023b732189d614e628546bfb084d2ca79813c6bf1bb5 run_runtime_owner_fresh_native_reference_20261001.py.txt +c75793d666d48231d018d00c5a9a5888484f19044dc0e5203aac91cf1763419e separate_cache_values_from_process_lifetime_20260930.py.txt +a1caf62cc3213dc4b22012d7bec071c96f69291da2be7e7813e8e910ba0261a7 test_generic_registered_numba_preparation_20260930.py.txt +4499f08266a16f84cf98756eee83ad4c2b65d13ae12bd0d153c733a3051b3413 test_shared_numerical_cache_owners_20261001.py.txt +cf1507206fed074104e432033711f4ea98762fc4a328bede9e031464fecc90dd validate_generic_runtime_native_artifacts_20260930.py.txt +77b93bf1147aed2551cb0d4099194f17b1e9d9c203c2a11ea3f751d479686915 validate_generic_runtime_owners_complete_outputs_20260930.py.txt +c1b5cb55dc12208ffad5c904da93235d6a33616a580c2775a37ab67c011f240c validate_generic_runtime_owners_paired_main_outputs_20260930.py.txt +945bfa8f8e001e9e5a3c6a231de82bf682eb1b7eb653186242af5932b0ddbb37 validate_runtime_owner_closure_native_artifacts_20261001.py.txt +c6965dbee67d9d759f20f22f6294c4d69840a164fe2853edf4603d8a21959c4c validate_runtime_owner_closure_owners_paired_main_outputs_20261001.py.txt +1f47d79bc11ae78c7aa9d1740b94da396ab48969966b2d4cb254b8fb7b79f89b validated-source-tree-95a98b008.txt +6b28fec58c0a0dce691a0ab0bcd4e1372cb8c05ad71b3222d41158201d0ffdec validated-source-tree.txt diff --git a/docs/validation/generic_runtime_owners_323_20260930/apply_generic_measurement_runtime_owners_20260930.py.txt b/docs/validation/generic_runtime_owners_323_20260930/apply_generic_measurement_runtime_owners_20260930.py.txt new file mode 100644 index 0000000000..6b8dc74007 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/apply_generic_measurement_runtime_owners_20260930.py.txt @@ -0,0 +1,218 @@ +import ast +import json +import subprocess +from pathlib import Path + +from nominal_refactor_advisor.ast_tools import SourceModule, module_syntax_index +from nominal_refactor_advisor.codemod import ( + CodemodPlanDocument, CodemodSourceSnapshot, PatchTargetOperation, + RefactorRecipe, SourceRewriteTarget, SourceTextReplacement, +) + +root = Path('/home/ts/code/projects/openhcs-compile-perf') +runs = root.parent / 'openhcs-benchmark-runs' +base = subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=root, text=True).strip() +census = json.loads((runs / 'perf-generic-measurement-runtime-before-census-20260930.json').read_text()) +assert base == census['source_revision'] +assert not subprocess.check_output(['git', 'status', '--porcelain'], cwd=root, text=True).strip() +sources = {}; changes = {} +def read(relative): + path = root / relative + text = path.read_text() + sources[str(path)] = text + return path, text +def replace_once(text, old, new): + assert text.count(old) == 1, old + return text.replace(old, new, 1) + +provider_path, provider = read('openhcs/processing/backends/cellprofiler/object_measurement_columnar_rows.py') +syntax = module_syntax_index(SourceModule.from_source_path(provider_path, provider).parse().module) +classes = {node.name:node for _,node in syntax.indexed_nodes_of_type(ast.ClassDef)} +assert set(classes) == {'ObjectMeasurementColumnarRows', 'WideObjectMeasurementColumnarRows', 'LongObjectMeasurementColumnarRows'} +lines = provider.splitlines(keepends=True) +owner = classes['ObjectMeasurementColumnarRows'] +base_declaration = ''.join(lines[owner.lineno-1:owner.end_lineno]) +base_declaration = replace_once(base_declaration, ' slice_index: int | None\n\n', '') +base_declaration = replace_once(base_declaration, + ' """OpenHCS object-measurement carriers are built on their label domain."""', + ' """Object-measurement carriers span their declared label domain."""') +wide = classes['WideObjectMeasurementColumnarRows'] +iterator, = [node for node in wide.body if isinstance(node, ast.FunctionDef) and node.name == '__iter__'] +base_declaration += '\n\n' + ''.join(lines[iterator.lineno-1:iterator.end_lineno]) +core_path, core = read('openhcs/core/measurement_row_materialization.py') +core = replace_once(core, 'class MeasurementRowDeclaredValue(', base_declaration + '\n\n\nclass MeasurementRowDeclaredValue(') +changes[str(core_path)] = core +changes[str(provider_path)] = '' +consumer_paths = [ + 'openhcs/processing/backends/cellprofiler/' + name + '.py' + for name in ('colocalization', 'granularity', 'shape', 'intensity', 'intensity_distribution', 'zernike') +] + ['tests/unit/test_cellprofiler_nominal_policy_migration.py'] +for relative in consumer_paths: + path, text = read(relative) + text = replace_once(text, + 'from openhcs.processing.backends.cellprofiler.object_measurement_columnar_rows import (', + 'from openhcs.core.measurement_row_materialization import (') + text = text.replace('LongObjectMeasurementColumnarRows', 'ObjectMeasurementColumnarRows') + text = text.replace('WideObjectMeasurementColumnarRows', 'ObjectMeasurementColumnarRows') + changes[str(path)] = text + +store_path, store = read('openhcs/core/runtime_stores.py') +store = replace_once(store, 'from typing import Any\n', 'from typing import Any, TypeVar, cast\n') +store = replace_once(store, 'from openhcs.core.component_set import ComponentSet\n', + 'from openhcs.core.component_set import ComponentSet\n' + 'from openhcs.core.process_local_cache import ProcessLocalBoundedCache\n') +store = replace_once(store, '\n\nclass RuntimeValueStore:', + '\n\nStoreQueryCacheT = TypeVar("StoreQueryCacheT", bound=ProcessLocalBoundedCache[Any, Any])\n\n\nclass RuntimeValueStore:') +store = replace_once(store, ' self._revision = 0\n', + ' self._revision = 0\n' + ' self._query_caches: dict[\n' + ' type[ProcessLocalBoundedCache[Any, Any]],\n' + ' ProcessLocalBoundedCache[Any, Any],\n' + ' ] = {}\n') +store = replace_once(store, ' @staticmethod\n def address_matches_plan(', ''' def query_cache(self, cache_type: type[StoreQueryCacheT]) -> StoreQueryCacheT: + """Return a bounded derived-value cache owned by this store's lifetime. + + Concrete cache types separate query domains. Every store mutation clears + their values; transport reconstructs the store without derived caches. + """ + cache = self._query_caches.get(cache_type) + if cache is None: + cache = cache_type() + self._query_caches[cache_type] = cache + return cast(StoreQueryCacheT, cache) + + def __getstate__(self) -> dict[str, object]: + state = dict(self.__dict__) + del state["_query_caches"] + return state + + def __setstate__(self, state: dict[str, object]) -> None: + self.__dict__.update(state) + self._query_caches = {} + + @staticmethod + def address_matches_plan(''') +store = replace_once(store, ' def _mark_mutated(self) -> None:\n self._revision += 1\n', + ' def _mark_mutated(self) -> None:\n self._revision += 1\n' + ' for cache in self._query_caches.values():\n cache.clear()\n') +changes[str(store_path)] = store + +feature_path, feature = read('openhcs/core/measurement_feature_queries.py') +feature = replace_once(feature, ' IdentityBoundProcessCache,\n', + ' IdentityBoundProcessCache,\n ProcessLocalBoundedCache,\n') +feature = replace_once(feature, '\n\ndef _diagnostic_value(', ''' + +class RuntimeObjectLabelMeasurementQueryCache( + ProcessLocalBoundedCache[ + RuntimeObjectLabelMeasurementQuery, + tuple[np.ndarray, ...], + ] +): + """Store-owned label-aligned values keyed by their full nominal query.""" + + +def _diagnostic_value(''') +changes[str(feature_path)] = feature + +query_path, query = read('openhcs/core/runtime_artifact_queries.py') +query = replace_once(query, 'from weakref import WeakKeyDictionary\n', '') +query = replace_once(query, ' RegisteredProcessLocalBoundedCache,\n', + ' ProcessLocalBoundedCache,\n RegisteredProcessLocalBoundedCache,\n') +query = replace_once(query, '''_MEASUREMENT_TABLE_CACHE: WeakKeyDictionary[ + RuntimeValueStore, + dict[tuple[int, str, str | None], tuple[MeasurementTable, ...]], +] = WeakKeyDictionary() +''', '''class RuntimeMeasurementTablesQueryCache( + ProcessLocalBoundedCache[ + tuple[str, str | None], + tuple[MeasurementTable, ...], + ] +): + """Store-owned measurement tables for one axis and component group.""" +''') +query = replace_once(query, ''' cache_key = (context.store.revision, context.axis_id, context.group_key) + store_cache = _MEASUREMENT_TABLE_CACHE.setdefault(context.store, {}) + cached = store_cache.get(cache_key) +''', ''' cache_key = (context.axis_id, context.group_key) + store_cache = context.store.query_cache(RuntimeMeasurementTablesQueryCache) + cached = store_cache.cached_value(cache_key) +''') +query = replace_once(query, ''' for key in tuple(store_cache): + if key[0] != context.store.revision: + del store_cache[key] + store_cache[cache_key] = tables + return tables +''', ''' return store_cache.store_value(cache_key, tables) +''') +changes[str(query_path)] = query + +label_path, label = read('openhcs/interop/cellprofiler/runtime/object_label_measurements.py') +label = replace_once(label, 'from weakref import WeakKeyDictionary\n', '') +label = replace_once(label, 'from openhcs.core.measurement_feature_queries import (\n', + 'from openhcs.core.measurement_feature_queries import (\n RuntimeObjectLabelMeasurementQueryCache,\n') +label = replace_once(label, 'from openhcs.core.runtime_stores import RuntimeValueStore\n', '') +start = label.index('ObjectLabelMeasurementValuesProcessCache = dict[') +end = label.index('@dataclass(frozen=True, slots=True, kw_only=True)', start) +label = label[:start] + label[end:] +label = replace_once(label, ''' object_label_values_cache = object_label_measurement_values_cache( + adapter.request.context.runtime_value_store + ) + cached = object_label_values_cache.get(query) +''', ''' object_label_values_cache = adapter.request.context.runtime_value_store.query_cache( + RuntimeObjectLabelMeasurementQueryCache + ) + cached = object_label_values_cache.cached_value(query) +''') +label = replace_once(label, ' object_label_values_cache[query] = values\n return values\n', + ' return object_label_values_cache.store_value(query, values)\n') +changes[str(label_path)] = label + +vector_path, vector = read('openhcs/interop/cellprofiler/runtime/object_measurement_vectors.py') +vector = replace_once(vector, ' object_label_measurement_values_cache,\n', '') +vector = replace_once(vector, 'from openhcs.core.measurement_feature_queries import MeasurementFeatureQuery\n', + 'from openhcs.core.measurement_feature_queries import (\n' + ' MeasurementFeatureQuery,\n RuntimeObjectLabelMeasurementQueryCache,\n)\n') +old = ''' process_cache = object_label_measurement_values_cache( + adapter.request.context.runtime_value_store + )''' +new = ''' store_cache = adapter.request.context.runtime_value_store.query_cache( + RuntimeObjectLabelMeasurementQueryCache + )''' +assert vector.count(old) == 2 +vector = vector.replace(old, new) +vector = replace_once(vector, ' process_cache[query] = values\n', ' store_cache.store_value(query, values)\n') +vector = replace_once(vector, ' cached = process_cache.get(query)\n', ' cached = store_cache.cached_value(query)\n') +changes[str(vector_path)] = vector + +test_path, test = read('tests/unit/test_cellprofiler_runtime_cache_authorities.py') +test = replace_once(test, ' object_label_measurement_values_cache,\n', '') +test = replace_once(test, 'from openhcs.core.runtime_stores import RuntimeValueStore\n', + 'from openhcs.core.runtime_stores import RuntimeValueStore\n' + 'from openhcs.core.measurement_feature_queries import RuntimeObjectLabelMeasurementQueryCache\n') +test = replace_once(test, ' object_label_measurement_values_cache(store)[query] = expected\n', + ' store.query_cache(RuntimeObjectLabelMeasurementQueryCache).store_value(query, expected)\n') +changes[str(test_path)] = test + +receipt = { + 'base': base, + 'authorization': 'User explicitly requests removing optimizations at the wrong abstraction layer and consolidating shared algorithms through nominal owners.', + 'census': {k:v for k,v in census.items() if k != 'classes'}, + 'OPEN_original_classes': [r for r in census['classes'] if r['status'] != 'projected'], + 'domain': 'Store-bound derived measurement queries and provider-independent dense object measurement columns.', + 'determining_owners': {'mutation_and_lifetime': 'RuntimeValueStore', 'bounded_lookup_and_retention': 'Existing ProcessLocalBoundedCache', 'query_identity': 'Existing RuntimeObjectLabelMeasurementQuery and axis/group coordinates', 'dense_object_column_semantics': 'Existing ObjectMeasurementColumnarRows moved to core.measurement_row_materialization'}, + 'required_pairs': ['Store.record/replace/clear/merge_observed_values invalidate all attached query caches through _mark_mutated.', 'Generic measurement table lookup and CellProfiler label/vector consumers use store.query_cache.', 'Concrete cache subclasses select domain and key/value types; existing parent owns bounded storage, lookup and clearing.', 'All six numerical column providers inherit the existing object columnar owner in core.', 'Shared mapping iteration belongs to that object-column parent; typed leaf iteration remains leaf-owned.'], + 'forbidden_pairs': ['Provider modules own weak-global store revision caches.', 'Generic artifact consumers duplicate revision invalidation logic.', 'Numerical providers import generic row behavior from another provider module.', 'Unused long-row conversion or behavior-only forwarding subclasses remain.'], + 'counterevidence': ['LongObjectMeasurementColumnarRows.__iter__ is shadowed by all three current children; those children declare wide feature columns, so moving its dead conversion loop would perpetuate an incorrect role.', 'WideObjectMeasurementColumnarRows only adds generic mapping iteration; its two children now inherit that behavior from their actual object-column ancestor.', 'Numerical kernel caches, CP feature naming and CP relationship interpretation have intrinsic/provider meaning and remain at those owners.', 'No speedup is claimed for lifecycle relocation. Column CSV prototype saves only 0.19s and is rejected as a primary runtime fix.', 'Saved measurement provenance replay costs15.9s but is not yet demonstrated in the live CP path; no production payoff is inferred.'], + 'production_consumers': ['runtime_measurement_tables', 'ObjectLabelMeasurementSliceRequest.values', 'CellProfilerObjectMeasurementVectorBatch.cache_runtime_batch_vectors/cached_runtime_batch_vectors', 'Six object measurement column providers'], + 'proof_limits': ['Authored exact replacements: NRA revision/syntax checks do not prove native semantic equivalence.', 'Module deletion lacks NRA file-deletion primitive; emptying is revision checked and the empty owned file is then removed with an explicit assertion.', 'Removal of obsolete provider class import paths is intentional; external dynamic/pickle callers of those abstract classes remain OPEN.', 'Query cache capacity changes from unbounded dictionaries to existing bounded LRU; misses recompute. Derived caches must be excluded from serialization.', 'Current query IDs retain all existing axis/group/source/label-plane/domain scopes; the change does not add a new cross-dialect caller.'], +} +(runs / 'perf-generic-measurement-runtime-ownership-20260930.json').write_text(json.dumps(receipt, indent=2) + '\n') +operations = tuple(PatchTargetOperation(target=SourceRewriteTarget(file_path=path), replacements=(SourceTextReplacement(old_source=sources[path], new_source=text),), rationale='NRA original declarations determine source geometry; authored lifecycle and inheritance changes require behavioral and runtime gates.') for path,text in changes.items()) +plan = CodemodPlanDocument(recipes=(RefactorRecipe(recipe_id='own-generic-measurement-caches-and-columns', reason='One store mutation/lifetime authority; numerical providers consume the common core columnar owner.', operations=operations),)) +simulation = plan.simulate(CodemodSourceSnapshot.from_source_mapping(sources)) +assert simulation.is_clean, simulation.simulation_payload() +(runs / 'perf-generic-measurement-runtime-nra-transaction-20260930.diff').write_text(simulation.unified_diff(sources)) +print(simulation.apply()) +assert provider_path.read_text() == '' +provider_path.unlink() +print('Removed empty obsolete provider module:', provider_path) diff --git a/docs/validation/generic_runtime_owners_323_20260930/census_refill_preparation_20260930.py.txt b/docs/validation/generic_runtime_owners_323_20260930/census_refill_preparation_20260930.py.txt new file mode 100644 index 0000000000..bb17e3da34 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/census_refill_preparation_20260930.py.txt @@ -0,0 +1,41 @@ +import ast +import json +from pathlib import Path + +from nominal_refactor_advisor.ast_tools import SourceModule, module_syntax_index +from nominal_refactor_advisor.class_index import CompactClassFamilyIndex + +import sys +root = Path(sys.argv[1]) +paths = sorted((root / 'openhcs').rglob('*.py')) + [root / 'setup.py'] +modules = tuple(SourceModule.from_source_path(path, path.read_text()).parse() for path in paths) +family = CompactClassFamilyIndex.from_modules(modules) +projected = {(item.file_path, item.line): item for item in family.classes_by_symbol.values()} +rows = [] +for module in modules: + syntax = module_syntax_index(module.module) + for index, node in syntax.indexed_nodes_of_type(ast.ClassDef): + owner = projected.get((str(module.path), node.lineno)) + scope = syntax.scopes[syntax.scope_ids[index]] + row = dict(path=str(module.path.relative_to(root)), line=node.lineno, + name=node.name, lexical_scope=list(scope.names), decorators=[ast.unparse(d) for d in node.decorator_list], + status='projected' if owner is not None else 'OPEN-unprojected') + if owner is not None: + row.update(symbol=owner.symbol, bases=owner.declared_base_names, + resolved_bases=owner.resolved_base_symbols, + base_resolution_complete=owner.base_resolution_is_complete, + methods=owner.method_names, abstract_methods=owner.abstract_method_names, + is_abstract=owner.is_abstract, + is_dataclass=owner.dataclass_declaration is not None, + is_enum=owner.enum_declaration is not None, + metaclasses=owner.metaclass_names) + rows.append(row) +report = dict(source_revision=sys.argv[2], + module_count=len(modules), original_class_count=len(rows), + projected_count=sum(row['status'] == 'projected' for row in rows), + classes=rows) +destination = Path(sys.argv[3]) +destination.write_text(json.dumps(report, indent=2) + '\n') +print(json.dumps({key: value for key, value in report.items() if key != 'classes'})) +print('OPEN-unprojected:', sum(row['status'] != 'projected' for row in rows)) +print('artifact:', destination) diff --git a/docs/validation/generic_runtime_owners_323_20260930/check_runtime_owner_fresh_native_facts_20261001.py.txt b/docs/validation/generic_runtime_owners_323_20260930/check_runtime_owner_fresh_native_facts_20261001.py.txt new file mode 100644 index 0000000000..a8302873ef --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/check_runtime_owner_fresh_native_facts_20261001.py.txt @@ -0,0 +1,31 @@ +import json +from pathlib import Path + +from benchmark.adapters.openhcs import _strict_cellprofiler_runtime_equivalence_policy +from openhcs.core.equivalence.outputs import RuntimeOutputSnapshot, RuntimeTableNamespaceAdapter +from openhcs.core.equivalence.tables import RuntimeTableSnapshot +from openhcs.core.runtime_equivalence import RuntimeMeasurementSnapshot, runtime_measurement_equivalence + +runs = Path('/home/ts/code/projects/openhcs-benchmark-runs') +native = runs / 'perf-runtime-owner-native-imaging-1w1j-20261001/native_jobs/0' +candidate_root = runs / 'perf-numerical-cache-owners-public-ExampleImagingFlowCytometryObjectsInGrid-1-candidate-20261001' +(candidate_path,) = tuple(candidate_root.rglob('BF_cells_on_grid.csv')) +policy = _strict_cellprofiler_runtime_equivalence_policy() +def snapshot(path): + output = RuntimeOutputSnapshot(tables=RuntimeTableNamespaceAdapter.normalize((RuntimeTableSnapshot.from_csv(path),))) + return RuntimeMeasurementSnapshot.from_output_snapshot(output, policy=policy) +candidate = snapshot(candidate_path) +checks = [] +for repetition in (-1, 0, 1): + reference = snapshot(native / str(repetition) / 'BF_cells_on_grid.csv') + report = runtime_measurement_equivalence(reference, candidate, policy=policy) + checks.append(dict(repetition=repetition, + reference_features=len(reference.measurement_fact_counts), + candidate_features=len(candidate.measurement_fact_counts), + differences=report.failure_messages())) + print(json.dumps(dict(repetition=repetition, difference_count=len(report.differences), sample=report.failure_messages()[:12])), flush=True) +receipt = dict(source_revision='95a98b0083aba2384c271e224746824fc9e40ce5', + scope='Existing strict measurement-fact comparison of the exported BF_cells_on_grid table; no image or ROI claim.', + numeric_abs_tolerance=1e-6, numeric_rel_tolerance=1e-6, checks=checks) +(runs / 'perf-runtime-owner-fresh-native-fact-parity-20261001.json').write_text(json.dumps(receipt, indent=2) + '\n') +assert not any(check['differences'] for check in checks) diff --git a/docs/validation/generic_runtime_owners_323_20260930/check_runtime_owner_fresh_native_tables_20261001.py.txt b/docs/validation/generic_runtime_owners_323_20260930/check_runtime_owner_fresh_native_tables_20261001.py.txt new file mode 100644 index 0000000000..0d6052e84c --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/check_runtime_owner_fresh_native_tables_20261001.py.txt @@ -0,0 +1,36 @@ +import hashlib +import json +from pathlib import Path + +from benchmark.adapters.openhcs import _strict_cellprofiler_runtime_equivalence_policy +from openhcs.core.equivalence.comparison import runtime_table_differences +from openhcs.core.equivalence.outputs import RuntimeTableNamespaceAdapter +from openhcs.core.equivalence.tables import RuntimeTableSnapshot + +runs = Path('/home/ts/code/projects/openhcs-benchmark-runs') +native = runs / 'perf-runtime-owner-native-imaging-1w1j-20261001/native_jobs/0' +candidate_root = runs / 'perf-numerical-cache-owners-public-ExampleImagingFlowCytometryObjectsInGrid-1-candidate-20261001' +(candidate_path,) = tuple(candidate_root.rglob('BF_cells_on_grid.csv')) +candidate = RuntimeTableNamespaceAdapter.normalize((RuntimeTableSnapshot.from_csv(candidate_path),)) +policy = _strict_cellprofiler_runtime_equivalence_policy() +checks = [] +for repetition in (-1, 0, 1): + path = native / str(repetition) / 'BF_cells_on_grid.csv' + reference = RuntimeTableNamespaceAdapter.normalize((RuntimeTableSnapshot.from_csv(path),)) + differences = runtime_table_differences(reference, candidate, policy) + checks.append(dict(repetition=repetition, reference=str(path), + candidate=str(candidate_path), + native_rows=len(reference[0].rows), + candidate_rows=len(candidate[0].rows), + native_columns=len(reference[0].header), + candidate_columns=len(candidate[0].header), + native_sha256=hashlib.sha256(path.read_bytes()).hexdigest(), + candidate_sha256=hashlib.sha256(candidate_path.read_bytes()).hexdigest(), + differences=[str(value) for value in differences])) +receipt = dict(source_revision='95a98b0083aba2384c271e224746824fc9e40ce5', + scope='Existing strict CellProfiler exported-table semantic comparison only; no image or ROI equivalence claim.', + numeric_abs_tolerance=1e-6, numeric_rel_tolerance=1e-6, + checks=checks) +(runs / 'perf-runtime-owner-fresh-native-table-parity-20261001.json').write_text(json.dumps(receipt, indent=2) + '\n') +print(json.dumps(receipt, indent=2)) +assert not any(check['differences'] for check in checks) diff --git a/docs/validation/generic_runtime_owners_323_20260930/closure-global-gc-sitecustomize.py.txt b/docs/validation/generic_runtime_owners_323_20260930/closure-global-gc-sitecustomize.py.txt new file mode 100644 index 0000000000..57f090330a --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/closure-global-gc-sitecustomize.py.txt @@ -0,0 +1,79 @@ +"""Minimal process-global GC timeline; processing/profile branches stay intact.""" +import functools +import gc +import importlib.abc +import importlib.machinery +import json +import os +import sys +import threading +import time +from pathlib import Path + +OUTPUT = Path('/home/ts/code/projects/openhcs-benchmark-runs/perf-runtime-owner-closure-global-gc-diagnostic-20261001') +label = os.environ['OPENHCS_EXECUTION_DIAGNOSTIC_CASE'] +descriptor = os.open(str(OUTPUT / (label + '.jsonl')), os.O_CREAT | os.O_APPEND | os.O_WRONLY, 0o600) +started = {} + + +def write(event): + event['pid'] = os.getpid() + os.write(descriptor, (json.dumps(event) + '\n').encode()) + + +write({'kind': 'process', 'argv': sys.orig_argv}) + + +def gc_timeline(phase, information): + generation = information['generation'] + key = (os.getpid(), generation) + if phase == 'start': + started[key] = (time.time(), time.perf_counter(), threading.get_ident()) + elif key in started: + epoch, clock, thread = started.pop(key) + ended_at = time.time() + elapsed = time.perf_counter() - clock + write({'kind': 'gc', 'generation': generation, 'thread': thread, + 'started_at': epoch, 'ended_at': ended_at, 'seconds': elapsed, + 'collected': information['collected'], 'uncollectable': information['uncollectable']}) + + +gc.callbacks.append(gc_timeline) + + +class StepTimelineLoader(importlib.abc.Loader): + def __init__(self, loader): + self.loader = loader + + def create_module(self, spec): + return self.loader.create_module(spec) + + def exec_module(self, module): + self.loader.exec_module(module) + assert Path(module.__file__).resolve() == Path(os.environ['OPENHCS_DIAGNOSTIC_SOURCE']) / 'openhcs/core/steps/function_execution.py' + original = module.FunctionStepExecutor.run + + @functools.wraps(original) + def step_timeline(executor, *args, **kwargs): + epoch, clock = time.time(), time.perf_counter() + try: + return original(executor, *args, **kwargs) + finally: + ended_at, elapsed = time.time(), time.perf_counter() - clock + write({'kind': 'step', 'thread': threading.get_ident(), + 'step_index': executor.plan.step_index, 'step_name': executor.plan.step_name, + 'started_at': epoch, 'ended_at': ended_at, 'seconds': elapsed}) + module.FunctionStepExecutor.run = step_timeline + + +class StepTimelineFinder(importlib.abc.MetaPathFinder): + def find_spec(self, fullname, path=None, target=None): + if fullname != 'openhcs.core.steps.function_execution': + return None + spec = importlib.machinery.PathFinder.find_spec(fullname, path, target) + assert spec is not None and isinstance(spec.loader, importlib.machinery.SourceFileLoader) + spec.loader = StepTimelineLoader(spec.loader) + return spec + + +sys.meta_path.insert(0, StepTimelineFinder()) diff --git a/docs/validation/generic_runtime_owners_323_20260930/cpu-timeline-candidate-20261001.jsonl.gz b/docs/validation/generic_runtime_owners_323_20260930/cpu-timeline-candidate-20261001.jsonl.gz new file mode 100644 index 0000000000..2d027c1308 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/cpu-timeline-candidate-20261001.jsonl.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/cpu-timeline-main-20261001.jsonl.gz b/docs/validation/generic_runtime_owners_323_20260930/cpu-timeline-main-20261001.jsonl.gz new file mode 100644 index 0000000000..7c4d316607 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/cpu-timeline-main-20261001.jsonl.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/cpu-timeline-sitecustomize.py.txt b/docs/validation/generic_runtime_owners_323_20260930/cpu-timeline-sitecustomize.py.txt new file mode 100644 index 0000000000..1ef8f01a3b --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/cpu-timeline-sitecustomize.py.txt @@ -0,0 +1,139 @@ +"""Minimal process-global GC timeline; processing/profile branches stay intact.""" +import functools +import gc +import importlib.abc +import importlib.machinery +import json +import os +import resource +import sys +import threading +import time +from pathlib import Path + +OUTPUT = Path('/home/ts/code/projects/openhcs-benchmark-runs/perf-runtime-owner-cpu-timeline-20261001') +label = os.environ['OPENHCS_EXECUTION_DIAGNOSTIC_CASE'] +descriptor = os.open(str(OUTPUT / (label + '.jsonl')), os.O_CREAT | os.O_APPEND | os.O_WRONLY, 0o600) +started = {} + + +def write(event): + event['pid'] = os.getpid() + os.write(descriptor, (json.dumps(event) + '\n').encode()) + + +write({'kind': 'process', 'argv': sys.orig_argv}) + + +def gc_timeline(phase, information): + generation = information['generation'] + key = (os.getpid(), generation) + if phase == 'start': + started[key] = (time.time(), time.perf_counter(), threading.get_ident()) + elif key in started: + epoch, clock, thread = started.pop(key) + ended_at = time.time() + elapsed = time.perf_counter() - clock + write({'kind': 'gc', 'generation': generation, 'thread': thread, + 'started_at': epoch, 'ended_at': ended_at, 'seconds': elapsed, + 'collected': information['collected'], 'uncollectable': information['uncollectable']}) + + +gc.callbacks.append(gc_timeline) + + + +def start_span(): + usage = resource.getrusage(resource.RUSAGE_THREAD) + return (time.time(), time.perf_counter(), time.thread_time(), time.process_time(), + usage.ru_nvcsw, usage.ru_nivcsw, + tuple(int(value) for value in Path(f"/proc/self/task/{threading.get_native_id()}/schedstat").read_text().split())) + + +def stop_span(started, fields): + epoch, clock, thread_cpu, process_cpu, voluntary, involuntary, scheduling = started + ended_at = time.time() + elapsed = time.perf_counter() - clock + usage = resource.getrusage(resource.RUSAGE_THREAD) + current = tuple(int(value) for value in Path(f"/proc/self/task/{threading.get_native_id()}/schedstat").read_text().split()) + write(dict(fields, thread=threading.get_ident(), native_thread=threading.get_native_id(), + started_at=epoch, ended_at=ended_at, seconds=elapsed, + thread_cpu_seconds=time.thread_time()-thread_cpu, + process_cpu_seconds=time.process_time()-process_cpu, + voluntary_switches=usage.ru_nvcsw-voluntary, + involuntary_switches=usage.ru_nivcsw-involuntary, + runqueue_wait_seconds=(current[1]-scheduling[1])/1e9)) + + +class StepTimelineLoader(importlib.abc.Loader): + def __init__(self, loader): + self.loader = loader + + def create_module(self, spec): + return self.loader.create_module(spec) + + def exec_module(self, module): + self.loader.exec_module(module) + if module.__name__ == 'openhcs.core.steps.function_execution': + assert Path(module.__file__).resolve() == Path(os.environ['OPENHCS_DIAGNOSTIC_SOURCE']) / 'openhcs/core/steps/function_execution.py' + original = module.FunctionStepExecutor.run + + @functools.wraps(original) + def step_timeline(executor, *args, **kwargs): + started = start_span() + try: + return original(executor, *args, **kwargs) + finally: + stop_span(started, dict(kind='step', step_index=executor.plan.step_index, + step_name=executor.plan.step_name)) + module.FunctionStepExecutor.run = step_timeline + elif module.__name__ == 'openhcs.core.orchestrator.worker_execution': + assert Path(module.__file__).resolve() == Path(os.environ['OPENHCS_DIAGNOSTIC_SOURCE']) / 'openhcs/core/orchestrator/worker_execution.py' + original_context = module._runtime_observation_progress_context + original_emit = module.emit + + @functools.wraps(original_context) + def context_span(records, *, plan, context): + started = start_span() + try: + return original_context(records, plan=plan, context=context) + finally: + stop_span(started, dict(kind='progress_context', step_index=plan.step_index, + step_name=plan.step_name, records=len(records))) + + @functools.wraps(original_emit) + def emit_span(*args, **kwargs): + started = start_span() + try: + return original_emit(*args, **kwargs) + finally: + stop_span(started, dict(kind='worker_emit', step_name=kwargs.get('step_name'), + phase=str(kwargs.get('phase')))) + + module._runtime_observation_progress_context = context_span + module.emit = emit_span + else: + original_compile = module.Dispatcher.compile + + @functools.wraps(original_compile) + def compile_span(dispatcher, *args, **kwargs): + started = start_span() + try: + return original_compile(dispatcher, *args, **kwargs) + finally: + stop_span(started, dict(kind='numba_compile', function=dispatcher.py_func.__qualname__)) + module.Dispatcher.compile = compile_span + + +class StepTimelineFinder(importlib.abc.MetaPathFinder): + def find_spec(self, fullname, path=None, target=None): + if fullname not in ('openhcs.core.steps.function_execution', + 'openhcs.core.orchestrator.worker_execution', 'numba.core.dispatcher'): + return None + spec = importlib.machinery.PathFinder.find_spec(fullname, path, target) + assert spec is not None and isinstance(spec.loader, importlib.machinery.SourceFileLoader) + spec.loader = StepTimelineLoader(spec.loader) + return spec + + +sys.meta_path.insert(0, StepTimelineFinder()) diff --git a/docs/validation/generic_runtime_owners_323_20260930/fresh-native-imaging-provenance.json.gz b/docs/validation/generic_runtime_owners_323_20260930/fresh-native-imaging-provenance.json.gz new file mode 100644 index 0000000000..4f05d92952 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/fresh-native-imaging-provenance.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/fresh-native-imaging-request_0.json.gz b/docs/validation/generic_runtime_owners_323_20260930/fresh-native-imaging-request_0.json.gz new file mode 100644 index 0000000000..9a8fc8c8c7 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/fresh-native-imaging-request_0.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/fresh-native-imaging-summary.json.gz b/docs/validation/generic_runtime_owners_323_20260930/fresh-native-imaging-summary.json.gz new file mode 100644 index 0000000000..4117e415ec Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/fresh-native-imaging-summary.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/global-gc-candidate-intervals-20260930.jsonl.gz b/docs/validation/generic_runtime_owners_323_20260930/global-gc-candidate-intervals-20260930.jsonl.gz new file mode 100644 index 0000000000..22db29316b Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/global-gc-candidate-intervals-20260930.jsonl.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/global-gc-closure-candidate-a-20261001.jsonl.gz b/docs/validation/generic_runtime_owners_323_20260930/global-gc-closure-candidate-a-20261001.jsonl.gz new file mode 100644 index 0000000000..3c159ac630 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/global-gc-closure-candidate-a-20261001.jsonl.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/global-gc-closure-candidate-b-20261001.jsonl.gz b/docs/validation/generic_runtime_owners_323_20260930/global-gc-closure-candidate-b-20261001.jsonl.gz new file mode 100644 index 0000000000..d859113970 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/global-gc-closure-candidate-b-20261001.jsonl.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/global-gc-closure-main-a-20261001.jsonl.gz b/docs/validation/generic_runtime_owners_323_20260930/global-gc-closure-main-a-20261001.jsonl.gz new file mode 100644 index 0000000000..2ab2c982e2 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/global-gc-closure-main-a-20261001.jsonl.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/global-gc-closure-main-b-20261001.jsonl.gz b/docs/validation/generic_runtime_owners_323_20260930/global-gc-closure-main-b-20261001.jsonl.gz new file mode 100644 index 0000000000..600e0d1601 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/global-gc-closure-main-b-20261001.jsonl.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/global-gc-diagnostic-sitecustomize.py.txt b/docs/validation/generic_runtime_owners_323_20260930/global-gc-diagnostic-sitecustomize.py.txt new file mode 100644 index 0000000000..a9a09411fd --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/global-gc-diagnostic-sitecustomize.py.txt @@ -0,0 +1,79 @@ +"""Minimal process-global GC timeline; processing/profile branches stay intact.""" +import functools +import gc +import importlib.abc +import importlib.machinery +import json +import os +import sys +import threading +import time +from pathlib import Path + +OUTPUT = Path('/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-global-gc-diagnostic-20260930') +label = os.environ['OPENHCS_EXECUTION_DIAGNOSTIC_CASE'] +descriptor = os.open(str(OUTPUT / (label + '.jsonl')), os.O_CREAT | os.O_APPEND | os.O_WRONLY, 0o600) +started = {} + + +def write(event): + event['pid'] = os.getpid() + os.write(descriptor, (json.dumps(event) + '\n').encode()) + + +write({'kind': 'process', 'argv': sys.orig_argv}) + + +def gc_timeline(phase, information): + generation = information['generation'] + key = (os.getpid(), generation) + if phase == 'start': + started[key] = (time.time(), time.perf_counter(), threading.get_ident()) + elif key in started: + epoch, clock, thread = started.pop(key) + ended_at = time.time() + elapsed = time.perf_counter() - clock + write({'kind': 'gc', 'generation': generation, 'thread': thread, + 'started_at': epoch, 'ended_at': ended_at, 'seconds': elapsed, + 'collected': information['collected'], 'uncollectable': information['uncollectable']}) + + +gc.callbacks.append(gc_timeline) + + +class StepTimelineLoader(importlib.abc.Loader): + def __init__(self, loader): + self.loader = loader + + def create_module(self, spec): + return self.loader.create_module(spec) + + def exec_module(self, module): + self.loader.exec_module(module) + assert Path(module.__file__).resolve() == Path(os.environ['OPENHCS_DIAGNOSTIC_SOURCE']) / 'openhcs/core/steps/function_execution.py' + original = module.FunctionStepExecutor.run + + @functools.wraps(original) + def step_timeline(executor, *args, **kwargs): + epoch, clock = time.time(), time.perf_counter() + try: + return original(executor, *args, **kwargs) + finally: + ended_at, elapsed = time.time(), time.perf_counter() - clock + write({'kind': 'step', 'thread': threading.get_ident(), + 'step_index': executor.plan.step_index, 'step_name': executor.plan.step_name, + 'started_at': epoch, 'ended_at': ended_at, 'seconds': elapsed}) + module.FunctionStepExecutor.run = step_timeline + + +class StepTimelineFinder(importlib.abc.MetaPathFinder): + def find_spec(self, fullname, path=None, target=None): + if fullname != 'openhcs.core.steps.function_execution': + return None + spec = importlib.machinery.PathFinder.find_spec(fullname, path, target) + assert spec is not None and isinstance(spec.loader, importlib.machinery.SourceFileLoader) + spec.loader = StepTimelineLoader(spec.loader) + return spec + + +sys.meta_path.insert(0, StepTimelineFinder()) diff --git a/docs/validation/generic_runtime_owners_323_20260930/global-gc-main-intervals-20260930.jsonl.gz b/docs/validation/generic_runtime_owners_323_20260930/global-gc-main-intervals-20260930.jsonl.gz new file mode 100644 index 0000000000..38e2685d67 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/global-gc-main-intervals-20260930.jsonl.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/kernel-preparation-ownership.json b/docs/validation/generic_runtime_owners_323_20260930/kernel-preparation-ownership.json new file mode 100644 index 0000000000..dd9d70dea2 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/kernel-preparation-ownership.json @@ -0,0 +1,366 @@ +{ + "source_revision": "01e8994018c62cb4ea8a57d6786ed3f4f2e8b262", + "authorization": "User requests all optimization behavior at incorrect layers to move to nominal platform owners. Pure intrinsic provider algorithms remain provider-owned.", + "domain": "Persistent Numba cache preparation admission and nominal registry family consumption", + "source_witnesses": [ + { + "path": "openhcs/core/callable_contract.py", + "line": 148, + "name": "CompilerPreparedAutoRegisterFamily", + "lexical_scope": [], + "decorators": [], + "status": "projected", + "symbol": "home.ts.code.projects.openhcs-compile-perf.openhcs.core.callable_contract.CompilerPreparedAutoRegisterFamily", + "bases": [ + "ABC" + ], + "resolved_bases": [], + "base_resolution_complete": true, + "methods": [ + "prepare_registered_family", + "cache_preparation_operations", + "can_prepare_in_child" + ], + "abstract_methods": [ + "prepare_registered_family" + ], + "is_abstract": true, + "is_dataclass": false, + "is_enum": false, + "metaclasses": [] + }, + { + "path": "openhcs/core/processing_preparation.py", + "line": 28, + "name": "PreparationOperation", + "lexical_scope": [], + "decorators": [], + "status": "projected", + "symbol": "home.ts.code.projects.openhcs-compile-perf.openhcs.core.processing_preparation.PreparationOperation", + "bases": [ + "ABC" + ], + "resolved_bases": [], + "base_resolution_complete": true, + "methods": [ + "identity", + "execute", + "cache_operations", + "can_prepare_in_child", + "prepare", + "reset" + ], + "abstract_methods": [ + "execute", + "identity" + ], + "is_abstract": true, + "is_dataclass": false, + "is_enum": false, + "metaclasses": [] + }, + { + "path": "openhcs/core/processing_preparation.py", + "line": 70, + "name": "RegistryFamilyPreparation", + "lexical_scope": [], + "decorators": [ + "dataclass(frozen=True, slots=True)" + ], + "status": "projected", + "symbol": "home.ts.code.projects.openhcs-compile-perf.openhcs.core.processing_preparation.RegistryFamilyPreparation", + "bases": [ + "PreparationOperation" + ], + "resolved_bases": [ + "home.ts.code.projects.openhcs-compile-perf.openhcs.core.processing_preparation.PreparationOperation" + ], + "base_resolution_complete": true, + "methods": [ + "identity", + "execute", + "can_prepare_in_child" + ], + "abstract_methods": [], + "is_abstract": false, + "is_dataclass": true, + "is_enum": false, + "metaclasses": [] + }, + { + "path": "openhcs/core/processing_preparation.py", + "line": 261, + "name": "PreparationCacheBatch", + "lexical_scope": [], + "decorators": [ + "dataclass(frozen=True, slots=True)" + ], + "status": "projected", + "symbol": "home.ts.code.projects.openhcs-compile-perf.openhcs.core.processing_preparation.PreparationCacheBatch", + "bases": [], + "resolved_bases": [], + "base_resolution_complete": true, + "methods": [ + "from_callables", + "populate_child_caches" + ], + "abstract_methods": [], + "is_abstract": false, + "is_dataclass": true, + "is_enum": false, + "metaclasses": [] + }, + { + "path": "openhcs/processing/backends/cellprofiler/_backend.py", + "line": 283, + "name": "CellProfilerBackendStrategyMixin", + "lexical_scope": [], + "decorators": [], + "status": "projected", + "symbol": "home.ts.code.projects.openhcs-compile-perf.openhcs.processing.backends.cellprofiler._backend.CellProfilerBackendStrategyMixin", + "bases": [ + "CellProfilerKernelCachePreparationMixin", + "CompilerPreparedAutoRegisterFamily" + ], + "resolved_bases": [ + "home.ts.code.projects.openhcs-compile-perf.openhcs.processing.backends.cellprofiler._preparation.CellProfilerKernelCachePreparationMixin", + "home.ts.code.projects.openhcs-compile-perf.openhcs.core.callable_contract.CompilerPreparedAutoRegisterFamily" + ], + "base_resolution_complete": true, + "methods": [ + "requires_persistent_kernel_cache", + "prepare_registered_family", + "prepare_backend", + "requires_explicit_prepare_backend", + "for_memory_type", + "for_callable", + "available_backend_providers", + "_resolve_backend_class" + ], + "abstract_methods": [], + "is_abstract": false, + "is_dataclass": false, + "is_enum": false, + "metaclasses": [] + }, + { + "path": "openhcs/processing/backends/cellprofiler/_preparation.py", + "line": 15, + "name": "CellProfilerKernelCachePreparationMixin", + "lexical_scope": [], + "decorators": [], + "status": "projected", + "symbol": "home.ts.code.projects.openhcs-compile-perf.openhcs.processing.backends.cellprofiler._preparation.CellProfilerKernelCachePreparationMixin", + "bases": [], + "resolved_bases": [], + "base_resolution_complete": true, + "methods": [ + "requires_persistent_kernel_cache", + "can_prepare_in_child" + ], + "abstract_methods": [], + "is_abstract": false, + "is_dataclass": false, + "is_enum": false, + "metaclasses": [] + }, + { + "path": "openhcs/processing/backends/cellprofiler/_preparation.py", + "line": 38, + "name": "CellProfilerCallableKernelPreparation", + "lexical_scope": [], + "decorators": [], + "status": "projected", + "symbol": "home.ts.code.projects.openhcs-compile-perf.openhcs.processing.backends.cellprofiler._preparation.CellProfilerCallableKernelPreparation", + "bases": [ + "CellProfilerKernelCachePreparationMixin", + "PreparationOperation", + "CompilerPreparedAutoRegisterFamily" + ], + "resolved_bases": [ + "home.ts.code.projects.openhcs-compile-perf.openhcs.processing.backends.cellprofiler._preparation.CellProfilerKernelCachePreparationMixin", + "home.ts.code.projects.openhcs-compile-perf.openhcs.core.processing_preparation.PreparationOperation", + "home.ts.code.projects.openhcs-compile-perf.openhcs.core.callable_contract.CompilerPreparedAutoRegisterFamily" + ], + "base_resolution_complete": true, + "methods": [ + "can_prepare_in_child", + "identity", + "cache_preparation_operations", + "prepare_registered_family" + ], + "abstract_methods": [], + "is_abstract": false, + "is_dataclass": false, + "is_enum": false, + "metaclasses": [] + } + ], + "determining_owners": { + "CPU_and_persistent_cache_admission": "Existing algorithm moved into core PersistentNumbaKernelPreparation, a CompilerPreparedAutoRegisterFamily child", + "provider_kernel_requirement": "Existing CellProfilerBackendStrategyMixin provider declarations", + "fixture_effects": "Existing CellProfilerCallableKernelPreparation fixture-capture policy", + "scheduling_and_readiness": "Existing PreparationOperation/RegistryFamilyPreparation/PreparationCacheBatch", + "standalone_kernel_registry_identity_and_derivation": "RegisteredNumbaKernelPreparation in core.processing_preparation" + }, + "required_pairs": [ + "The core persistent Numba family owns CPU-only admission, explicit cache-directory admission and existing cache-index detection.", + "Backend families derive this policy and retain their declaration-derived kernel requirement.", + "Callable kernel families derive this policy and retain fixture-capture effect admission.", + "Core uses the existing compiler family and preparation contracts; all old provider imports migrate to the actual core owner.", + "Registered standalone Numba kernel declarations share type identity, registry-derived operations and successful parent preparation through RegisteredNumbaKernelPreparation. CellProfiler retains only its independent fixture-capture overrides." + ], + "forbidden_pairs": [ + "Core imports CellProfiler preparation classes.", + "CellProfiler modules copy the generic CPU/cache algorithm.", + "The old CellProfilerKernelCachePreparationMixin or a forwarding alias remains after consumer migration.", + "Unrelated backend families automatically opt into persistent Numba work.", + "Provider-local identity and operation-derivation loops duplicate the generic registered-kernel contract." + ], + "counterevidence": [ + "Fixture capture has CellProfiler numerical-input meaning and stays provider-owned.", + "The algorithm is Numba-specific, so it is an opt-in specialization of the generic compiler family, not a universal operation default.", + "The existing any-.nbi cache admission is retained. Mandatory parent preparation still fills missing specializations before readiness.", + "The move has zero direct pipeline-clock saving because mandatory preparation precedes those clocks; this is explicitly requested ownership cleanup." + ], + "OPEN": { + "unprojected_original_classes": [ + { + "path": "openhcs/components/framework.py", + "line": 198, + "name": "_ComponentTemplate", + "lexical_scope": [ + "ComponentConfigurationFactory", + "create_openhcs_default_configuration" + ], + "decorators": [], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/gui_startup.py", + "line": 481, + "name": "_EventBridge", + "lexical_scope": [ + "_run_startup_window_child" + ], + "decorators": [], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/gui_startup.py", + "line": 485, + "name": "_StartupWindow", + "lexical_scope": [ + "_run_startup_window_child" + ], + "decorators": [], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/gui_startup.py", + "line": 612, + "name": "_StartupWindowPresentation", + "lexical_scope": [ + "_run_startup_window_child" + ], + "decorators": [], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/mcp/http.py", + "line": 76, + "name": "OpenHCSHostedFastMCP", + "lexical_scope": [ + "create_hosted_fastmcp_type" + ], + "decorators": [], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/processing/backends/analysis/dxf_mask_pipeline.py", + "line": 107, + "name": "_RegistrationCNN_torch", + "lexical_scope": [], + "decorators": [], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/pyqt_gui/widgets/shared/services/execution_submission_service.py", + "line": 102, + "name": "_ClientDisconnected", + "lexical_scope": [ + "ExecutionSubmissionService", + "start_completion_poller" + ], + "decorators": [], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/runtime/fiji_viewer_server.py", + "line": 2618, + "name": "DimensionScrollbarListener", + "lexical_scope": [ + "FijiViewerServer", + "_add_dimension_change_listener" + ], + "decorators": [ + "jpype.JImplements('java.awt.event.AdjustmentListener')" + ], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/runtime/fiji_viewer_server.py", + "line": 2696, + "name": "WindowCloseListener", + "lexical_scope": [ + "FijiViewerServer", + "_add_dimension_change_listener" + ], + "decorators": [ + "jpype.JImplements('java.awt.event.WindowListener')" + ], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/runtime/fiji_viewer_server.py", + "line": 3064, + "name": "FijiUiWorkUnit", + "lexical_scope": [ + "FijiRoiManagerProvider", + "invoke_on_event_dispatch_thread" + ], + "decorators": [ + "JImplements('java.lang.Runnable')" + ], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/utils/import_utils.py", + "line": 67, + "name": "Placeholder", + "lexical_scope": [ + "create_placeholder_class" + ], + "decorators": [], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/utils/pipeline_migration.py", + "line": 358, + "name": "MigratingGroupBy", + "lexical_scope": [ + "LegacyGroupByUnpickler", + "_create_migrating_groupby_class" + ], + "decorators": [], + "status": "OPEN-unprojected" + } + ], + "external_dynamic_imports_of_removed_private_mixin": "Not inferred from source; no compatibility alias is retained." + }, + "proof_limits": [ + "Declaration rename/move/base preflights check supported source dependencies and bindings, not native metaclass execution.", + "Final consumer/import closure uses exact source patches checked against the projected state. Native registry/MRO/effects need existing real declaration, fork preparation and readiness tests.", + "The registry algorithm extraction is an authored semantic source patch against the source selected by NRA; this is not claimed as a native equivalence theorem." + ] +} diff --git a/docs/validation/generic_runtime_owners_323_20260930/make_runtime_owner_cpu_timeline_20261001.py.txt b/docs/validation/generic_runtime_owners_323_20260930/make_runtime_owner_cpu_timeline_20261001.py.txt new file mode 100644 index 0000000000..572cab4bea --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/make_runtime_owner_cpu_timeline_20261001.py.txt @@ -0,0 +1,109 @@ +from pathlib import Path +site=Path('/tmp/openhcs-runtime-owner-cpu-timeline-site-20261001') +site.mkdir() +original=Path('/tmp/openhcs-runtime-owner-closure-global-gc-site-20261001/sitecustomize.py').read_text() +text=original.replace('import os\n','import os\nimport resource\n') +text=text.replace('perf-runtime-owner-closure-global-gc-diagnostic-20261001','perf-runtime-owner-cpu-timeline-20261001') +start=text.index('class StepTimelineLoader(') +text=text[:start]+''' +def start_span(): + usage = resource.getrusage(resource.RUSAGE_THREAD) + return (time.time(), time.perf_counter(), time.thread_time(), time.process_time(), + usage.ru_nvcsw, usage.ru_nivcsw, + tuple(int(value) for value in Path(f"/proc/self/task/{threading.get_native_id()}/schedstat").read_text().split())) + + +def stop_span(started, fields): + epoch, clock, thread_cpu, process_cpu, voluntary, involuntary, scheduling = started + ended_at = time.time() + elapsed = time.perf_counter() - clock + usage = resource.getrusage(resource.RUSAGE_THREAD) + current = tuple(int(value) for value in Path(f"/proc/self/task/{threading.get_native_id()}/schedstat").read_text().split()) + write(dict(fields, thread=threading.get_ident(), native_thread=threading.get_native_id(), + started_at=epoch, ended_at=ended_at, seconds=elapsed, + thread_cpu_seconds=time.thread_time()-thread_cpu, + process_cpu_seconds=time.process_time()-process_cpu, + voluntary_switches=usage.ru_nvcsw-voluntary, + involuntary_switches=usage.ru_nivcsw-involuntary, + runqueue_wait_seconds=(current[1]-scheduling[1])/1e9)) + + +class StepTimelineLoader(importlib.abc.Loader): + def __init__(self, loader): + self.loader = loader + + def create_module(self, spec): + return self.loader.create_module(spec) + + def exec_module(self, module): + self.loader.exec_module(module) + if module.__name__ == 'openhcs.core.steps.function_execution': + assert Path(module.__file__).resolve() == Path(os.environ['OPENHCS_DIAGNOSTIC_SOURCE']) / 'openhcs/core/steps/function_execution.py' + original = module.FunctionStepExecutor.run + + @functools.wraps(original) + def step_timeline(executor, *args, **kwargs): + started = start_span() + try: + return original(executor, *args, **kwargs) + finally: + stop_span(started, dict(kind='step', step_index=executor.plan.step_index, + step_name=executor.plan.step_name)) + module.FunctionStepExecutor.run = step_timeline + elif module.__name__ == 'openhcs.core.orchestrator.worker_execution': + assert Path(module.__file__).resolve() == Path(os.environ['OPENHCS_DIAGNOSTIC_SOURCE']) / 'openhcs/core/orchestrator/worker_execution.py' + original_context = module._runtime_observation_progress_context + original_emit = module.emit + + @functools.wraps(original_context) + def context_span(records, *, plan, context): + started = start_span() + try: + return original_context(records, plan=plan, context=context) + finally: + stop_span(started, dict(kind='progress_context', step_index=plan.step_index, + step_name=plan.step_name, records=len(records))) + + @functools.wraps(original_emit) + def emit_span(*args, **kwargs): + started = start_span() + try: + return original_emit(*args, **kwargs) + finally: + stop_span(started, dict(kind='worker_emit', step_name=kwargs.get('step_name'), + phase=str(kwargs.get('phase')))) + + module._runtime_observation_progress_context = context_span + module.emit = emit_span + else: + original_compile = module.Dispatcher.compile + + @functools.wraps(original_compile) + def compile_span(dispatcher, *args, **kwargs): + started = start_span() + try: + return original_compile(dispatcher, *args, **kwargs) + finally: + stop_span(started, dict(kind='numba_compile', function=dispatcher.py_func.__qualname__)) + module.Dispatcher.compile = compile_span + + +class StepTimelineFinder(importlib.abc.MetaPathFinder): + def find_spec(self, fullname, path=None, target=None): + if fullname not in ('openhcs.core.steps.function_execution', + 'openhcs.core.orchestrator.worker_execution', 'numba.core.dispatcher'): + return None + spec = importlib.machinery.PathFinder.find_spec(fullname, path, target) + assert spec is not None and isinstance(spec.loader, importlib.machinery.SourceFileLoader) + spec.loader = StepTimelineLoader(spec.loader) + return spec + + +sys.meta_path.insert(0, StepTimelineFinder()) +''' +(site/'sitecustomize.py').write_text(text) +controller=Path('/tmp/run_runtime_owner_closure_global_gc_diagnostic_20261001.py').read_text() +controller=controller.replace('perf-runtime-owner-closure-global-gc-diagnostic','perf-runtime-owner-cpu-timeline').replace('/tmp/openhcs-runtime-owner-closure-global-gc-site-20261001','/tmp/openhcs-runtime-owner-cpu-timeline-site-20261001') +controller=controller.replace("(('main-a', root), ('candidate-a', candidate), ('candidate-b', candidate), ('main-b', root))","(('candidate', candidate), ('main', root))") +Path('/tmp/run_runtime_owner_cpu_timeline_20261001.py').write_text(controller) +print('Prepared owner-thread CPU, process CPU, scheduler, progress and NumBa compile spans.') diff --git a/docs/validation/generic_runtime_owners_323_20260930/measurement-cache-and-column-ownership.json b/docs/validation/generic_runtime_owners_323_20260930/measurement-cache-and-column-ownership.json new file mode 100644 index 0000000000..345cc05b9f --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/measurement-cache-and-column-ownership.json @@ -0,0 +1,186 @@ +{ + "base": "447c926346084b5da434edf5bef3a1a602792f5c", + "authorization": "User explicitly requests removing optimizations at the wrong abstraction layer and consolidating shared algorithms through nominal owners.", + "census": { + "source_revision": "447c926346084b5da434edf5bef3a1a602792f5c", + "module_count": 702, + "original_class_count": 5121, + "projected_count": 5109 + }, + "OPEN_original_classes": [ + { + "path": "openhcs/components/framework.py", + "line": 198, + "name": "_ComponentTemplate", + "lexical_scope": [ + "ComponentConfigurationFactory", + "create_openhcs_default_configuration" + ], + "decorators": [], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/gui_startup.py", + "line": 481, + "name": "_EventBridge", + "lexical_scope": [ + "_run_startup_window_child" + ], + "decorators": [], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/gui_startup.py", + "line": 485, + "name": "_StartupWindow", + "lexical_scope": [ + "_run_startup_window_child" + ], + "decorators": [], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/gui_startup.py", + "line": 612, + "name": "_StartupWindowPresentation", + "lexical_scope": [ + "_run_startup_window_child" + ], + "decorators": [], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/mcp/http.py", + "line": 76, + "name": "OpenHCSHostedFastMCP", + "lexical_scope": [ + "create_hosted_fastmcp_type" + ], + "decorators": [], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/processing/backends/analysis/dxf_mask_pipeline.py", + "line": 107, + "name": "_RegistrationCNN_torch", + "lexical_scope": [], + "decorators": [], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/pyqt_gui/widgets/shared/services/execution_submission_service.py", + "line": 102, + "name": "_ClientDisconnected", + "lexical_scope": [ + "ExecutionSubmissionService", + "start_completion_poller" + ], + "decorators": [], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/runtime/fiji_viewer_server.py", + "line": 2618, + "name": "DimensionScrollbarListener", + "lexical_scope": [ + "FijiViewerServer", + "_add_dimension_change_listener" + ], + "decorators": [ + "jpype.JImplements('java.awt.event.AdjustmentListener')" + ], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/runtime/fiji_viewer_server.py", + "line": 2696, + "name": "WindowCloseListener", + "lexical_scope": [ + "FijiViewerServer", + "_add_dimension_change_listener" + ], + "decorators": [ + "jpype.JImplements('java.awt.event.WindowListener')" + ], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/runtime/fiji_viewer_server.py", + "line": 3064, + "name": "FijiUiWorkUnit", + "lexical_scope": [ + "FijiRoiManagerProvider", + "invoke_on_event_dispatch_thread" + ], + "decorators": [ + "JImplements('java.lang.Runnable')" + ], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/utils/import_utils.py", + "line": 67, + "name": "Placeholder", + "lexical_scope": [ + "create_placeholder_class" + ], + "decorators": [], + "status": "OPEN-unprojected" + }, + { + "path": "openhcs/utils/pipeline_migration.py", + "line": 358, + "name": "MigratingGroupBy", + "lexical_scope": [ + "LegacyGroupByUnpickler", + "_create_migrating_groupby_class" + ], + "decorators": [], + "status": "OPEN-unprojected" + } + ], + "domain": "Store-bound derived measurement queries and provider-independent dense object measurement columns.", + "determining_owners": { + "mutation_and_lifetime": "RuntimeValueStore", + "bounded_lookup_and_retention": "BoundedCache, extracted from the existing storage algorithm; ProcessLocalBoundedCache retains only process singleton lifetime policy", + "query_identity": "Existing RuntimeObjectLabelMeasurementQuery and axis/group coordinates", + "dense_object_column_semantics": "Existing ObjectMeasurementColumnarRows moved to core.measurement_row_materialization", + "store_query_domains": "RuntimeObjectLabelMeasurementQueryCache and RuntimeMeasurementTablesQueryCache derive from BoundedCache without process singleton APIs" + }, + "required_pairs": [ + "Store.record/replace/clear/merge_observed_values invalidate all attached query caches through _mark_mutated.", + "Generic measurement table lookup and CellProfiler label/vector consumers use store.query_cache.", + "Concrete cache subclasses select domain and key/value types; existing parent owns bounded storage, lookup and clearing.", + "All six numerical column providers inherit the existing object columnar owner in core.", + "Shared mapping iteration belongs to that object-column parent; typed leaf iteration remains leaf-owned.", + "Store-owned query domains do not inherit process-global singleton policy." + ], + "forbidden_pairs": [ + "Provider modules own weak-global store revision caches.", + "Generic artifact consumers duplicate revision invalidation logic.", + "Numerical providers import generic row behavior from another provider module.", + "Unused long-row conversion or behavior-only forwarding subclasses remain." + ], + "counterevidence": [ + "LongObjectMeasurementColumnarRows.__iter__ is shadowed by all three current children; those children declare wide feature columns, so moving its dead conversion loop would perpetuate an incorrect role.", + "WideObjectMeasurementColumnarRows only adds generic mapping iteration; its two children now inherit that behavior from their actual object-column ancestor.", + "Numerical kernel caches, CP feature naming and CP relationship interpretation have intrinsic/provider meaning and remain at those owners.", + "No speedup is claimed for lifecycle relocation. Column CSV prototype saves only 0.19s and is rejected as a primary runtime fix.", + "Saved measurement provenance replay costs15.9s but is not yet demonstrated in the live CP path; no production payoff is inferred." + ], + "production_consumers": [ + "runtime_measurement_tables", + "ObjectLabelMeasurementSliceRequest.values", + "CellProfilerObjectMeasurementVectorBatch.cache_runtime_batch_vectors/cached_runtime_batch_vectors", + "Six object measurement column providers" + ], + "proof_limits": [ + "Authored exact replacements: NRA revision/syntax checks do not prove native semantic equivalence.", + "Module deletion lacks NRA file-deletion primitive; emptying is revision checked and the empty owned file is then removed with an explicit assertion.", + "Removal of obsolete provider class import paths is intentional; external dynamic/pickle callers of those abstract classes remain OPEN.", + "Query cache capacity changes from unbounded dictionaries to existing bounded LRU; misses recompute. Derived caches must be excluded from serialization.", + "Current query IDs retain all existing axis/group/source/label-plane/domain scopes; the change does not add a new cross-dialect caller." + ], + "head": "eba8e5c871a84b5ddd2581d7562798223ebd2415", + "current_main": "74eac059f67389ca071055c93fcbdd556ba79f1a" +} diff --git a/docs/validation/generic_runtime_owners_323_20260930/move_bound_runtime_profiler_20261001.py.txt b/docs/validation/generic_runtime_owners_323_20260930/move_bound_runtime_profiler_20261001.py.txt new file mode 100644 index 0000000000..847be28e27 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/move_bound_runtime_profiler_20261001.py.txt @@ -0,0 +1,94 @@ +import json +from pathlib import Path +from nominal_refactor_advisor.codemod import ( + CodemodPlanDocument, CodemodPlanSequence, CodemodSourceSnapshot, + MoveSymbolsToModuleOperation, PatchTargetOperation, RefactorRecipe, + RenameTopLevelDeclarationAuthorityOperation, SourceRewriteTarget, + SourceTextReplacement, +) +root=Path('/home/ts/code/projects/openhcs-compile-perf') +runs=root.parent/'openhcs-benchmark-runs' +source=str(root/'openhcs/processing/backends/cellprofiler/granularity.py') +destination=str(root/'openhcs/core/runtime_profile.py') +sources={str(path):path.read_text() for path in (root/'openhcs').rglob('*.py')} +sources[str(root/'setup.py')]=(root/'setup.py').read_text() +snapshot=CodemodSourceSnapshot.from_source_mapping(sources,analysis_roots=(root,)) +obsolete='''def profile_enabled() -> bool: + """Return whether per-function granularity runtime profiling is enabled.""" + return os.environ.get(_PROFILE_RUNTIME_ENV, "").lower() in {"1", "true", "yes"} + + +''' +initial=sources[source] +assert initial.count(obsolete)==1 +prepared=initial.replace(obsolete,'').replace('import os\n','').replace('_PROFILE_RUNTIME_ENV = "OPENHCS_PROFILE_FUNCTION_RUNTIME"\n','').replace('return profile_enabled()','return RuntimeProfileLogger.enabled()') +# Imported direct declarations need an explicit export boundary for NRA's rename guard. +# This is an unexecuted intermediate declaration; closure removes it from the provider. +prepared=prepared.replace('__all__ = [','__all__ = [\n "CellProfilerRuntimeProfiler",',1) +direct_import='from openhcs.processing.backends.cellprofiler.granularity import (\n CellProfilerRuntimeProfiler,\n)' +consumers={path for path,text in sources.items() if direct_import in text} +assert len(consumers)==8,consumers +prepared_sources={source:prepared} +for path in consumers: + text=sources[path] + assert text.count(direct_import)==1 + prepared_sources[path]=text.replace(direct_import,'from openhcs.core.runtime_profile import RuntimeProfiler').replace('CellProfilerRuntimeProfiler','RuntimeProfiler') +boundary=CodemodPlanDocument(recipes=(RefactorRecipe(recipe_id='bound-profiler-export-boundary',reason='Migrate exact imported consumers before a guarded declaration move; dynamic numerical public_names exports stay unchanged.',operations=tuple(PatchTargetOperation(target=SourceRewriteTarget(file_path=path),replacements=(SourceTextReplacement(old_source=sources[path],new_source=text),),rationale='Authored consumer migration and gating stage; OPEN dynamic exports are not declared proved by the rename guard.') for path,text in prepared_sources.items())),)) +operations=( + RenameTopLevelDeclarationAuthorityOperation(target=SourceRewriteTarget(file_path=source,qualname='CellProfilerRuntimeProfiler'),new_name='RuntimeProfiler',rationale='The bound logger has no CellProfiler-specific semantics.'), + MoveSymbolsToModuleOperation(target=SourceRewriteTarget(file_path=source),symbol_qualnames=('RuntimeProfiler',),destination_path=destination,rationale='The existing core runtime event sink determines environment gating and output effects.'), +) +documents=(boundary,*tuple(CodemodPlanDocument(recipes=(RefactorRecipe(recipe_id=f'bound-runtime-profiler-owner-{index}',reason='Move the existing generic profiler declaration and close every original consumer.',operations=(operation,)),)) for index,operation in enumerate(operations))) +projected=CodemodPlanSequence(documents=documents).simulate(snapshot) +assert projected.is_clean,projected.simulation_payload() +after=projected.final_snapshot.sources_by_file_path +(runs/'perf-bound-runtime-profiler-initial-projection-20261001.json').write_text(json.dumps({path:after[path] for path in (source,destination)},indent=2)+'\n') +changes={} +for path in (source,destination,*sorted(consumers)): + text=after[path] + if 'RuntimeProfiler' in text or 'CellProfilerRuntimeProfiler' in text: + updated=text.replace('from openhcs.processing.backends.cellprofiler.granularity import (\n RuntimeProfiler,\n)', 'from openhcs.core.runtime_profile import RuntimeProfiler') + updated=updated.replace('CellProfilerRuntimeProfiler','RuntimeProfiler') + if path==source: + updated=updated.replace('import os\n','') + updated=updated.replace('_PROFILE_RUNTIME_ENV = "OPENHCS_PROFILE_FUNCTION_RUNTIME"\n','') + assert obsolete not in updated + updated=updated.replace(' "RuntimeProfiler",\n','') + # Move leaves a temporary qualified relative import; derive the new source import directly. + lines=updated.splitlines(keepends=True) + lines=[line for line in lines if not (line.startswith('from ') and 'core.runtime_profile import RuntimeProfiler' in line)] + updated=''.join(lines) + if 'from openhcs.core.runtime_profile import RuntimeProfileLogger' in updated: + updated=updated.replace('from openhcs.core.runtime_profile import RuntimeProfileLogger','from openhcs.core.runtime_profile import RuntimeProfiler') + else: + updated=updated.replace('from __future__ import annotations','from __future__ import annotations\n\nfrom openhcs.core.runtime_profile import RuntimeProfiler',1) + if path==destination: + updated=updated.replace('return profile_enabled()','return RuntimeProfileLogger.enabled()') + updated=updated.replace('Shared CellProfiler runtime-profile emitter bound to a module logger.','Runtime-profile emitter bound to a module logger.') + if updated!=text:changes[path]=updated + +# Consumers may originally import other granularity symbols in the same block. +for path,text in list(changes.items()): + if path in (source,destination):continue + if 'RuntimeProfiler,' in text and 'from openhcs.processing.backends.cellprofiler.granularity import (' in text: + block=text.split('from openhcs.processing.backends.cellprofiler.granularity import (',1)[1].split(')',1)[0] + if 'RuntimeProfiler,' in block: + text=text.replace(' RuntimeProfiler,\n','',1) + text=text.replace('from __future__ import annotations','from __future__ import annotations\n\nfrom openhcs.core.runtime_profile import RuntimeProfiler',1) + changes[path]=text + +closure=CodemodPlanDocument(recipes=(RefactorRecipe(recipe_id='bound-runtime-profiler-consumer-closure',reason='Remove the legacy import and duplicated environment gate; all consumers use the core bound owner.',operations=tuple(PatchTargetOperation(target=SourceRewriteTarget(file_path=path),replacements=(SourceTextReplacement(old_source=after[path],new_source=text),),rationale='Authored closure requires executed environment/output checks; syntax simulation alone does not prove effects.') for path,text in changes.items())),)) +complete=CodemodPlanSequence(documents=(*documents,closure)).simulate(snapshot) +assert complete.is_clean,complete.simulation_payload() +for path in (source,destination,*sorted(consumers)): + text=complete.final_snapshot.sources_by_file_path[path] + assert 'CellProfilerRuntimeProfiler' not in text,path + if path!=destination: + assert 'from openhcs.core.runtime_profile import RuntimeProfiler' in text,path +# Same-spelled CP module-scoped profiler is a different authority, not this bound logger. +for relative in ('openhcs/interop/cellprofiler/runtime/module_execution.py','openhcs/interop/cellprofiler/runtime/measurement_execution_support.py'): + path=str(root/relative) + assert complete.final_snapshot.sources_by_file_path[path]==sources[path] +(runs/'perf-bound-runtime-profiler-simulation-20261001.json').write_text(json.dumps(complete.simulation_payload(),indent=2)+'\n') +(runs/'perf-bound-runtime-profiler-transaction-20261001.diff').write_text(complete.unified_diff(sources)) +print(complete.apply()) diff --git a/docs/validation/generic_runtime_owners_323_20260930/move_generic_numba_preparation_owner_20260930.py.txt b/docs/validation/generic_runtime_owners_323_20260930/move_generic_numba_preparation_owner_20260930.py.txt new file mode 100644 index 0000000000..27d56d7639 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/move_generic_numba_preparation_owner_20260930.py.txt @@ -0,0 +1,130 @@ +import ast +import difflib +import json +import subprocess +from pathlib import Path + +from nominal_refactor_advisor.codemod import ( + AddClassBaseOperation, + CodemodPlanDocument, + CodemodPlanSequence, + CodemodSourceSnapshot, + MoveSymbolsToModuleOperation, + PatchTargetOperation, + RefactorRecipe, + RenameTopLevelDeclarationAuthorityOperation, + SourceRewriteTarget, + SourceTextReplacement, +) +from nominal_refactor_advisor.ast_tools import SourceModule, module_syntax_index + +root = Path('/home/ts/code/projects/openhcs-compile-perf') +runs = root.parent / 'openhcs-benchmark-runs' +revision = subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=root, text=True).strip() +census = json.loads((runs / 'perf-generic-runtime-owners-synced-before-census-20260930.json').read_text()) +assert revision == census['source_revision'] +assert not subprocess.check_output(['git', 'status', '--porcelain'], cwd=root, text=True).strip() +source = str(root / 'openhcs/processing/backends/cellprofiler/_preparation.py') +destination = str(root / 'openhcs/core/processing_preparation.py') +backend = str(root / 'openhcs/processing/backends/cellprofiler/_backend.py') +sources = {str(path): path.read_text() for path in (root / 'openhcs').rglob('*.py')} +sources[str(root / 'setup.py')] = (root / 'setup.py').read_text() +snapshot = CodemodSourceSnapshot.from_source_mapping(sources, analysis_roots=(root,)) +operations = ( + RenameTopLevelDeclarationAuthorityOperation( + target=SourceRewriteTarget(file_path=source, qualname='CellProfilerKernelCachePreparationMixin'), + new_name='PersistentNumbaKernelPreparation', + rationale='The CPU/cache eligibility contract has no CellProfiler semantics.'), + MoveSymbolsToModuleOperation( + target=SourceRewriteTarget(file_path=source), + symbol_qualnames=('PersistentNumbaKernelPreparation',), + destination_path=destination, + rationale='Move the existing algorithm; retain its temporary source binding until consumer migration closes.'), + AddClassBaseOperation( + target=SourceRewriteTarget(file_path=destination, qualname='PersistentNumbaKernelPreparation'), + base_name='CompilerPreparedAutoRegisterFamily', + rationale='The generic preparation capability is a declared compiler-prepared family.'), +) +documents = tuple(CodemodPlanDocument(recipes=(RefactorRecipe( + recipe_id=f'generic-numba-preparation-owner-{index}', + reason='Existing family declarations consume one generic CPU/persistent-cache policy.', + operations=(operation,)),)) for index, operation in enumerate(operations)) +sequence = CodemodPlanSequence(documents=documents) +projected = sequence.simulate(snapshot) +(runs / 'perf-generic-numba-owner-initial-simulation-20260930.json').write_text(json.dumps(projected.simulation_payload(), indent=2) + '\n') +assert projected.is_clean, 'Initial nominal move/rename/base preflight failed; retained complete report.' +after = projected.final_snapshot.sources_by_file_path +Path('/tmp/openhcs-generic-numba-projected-20260930.json').write_text(json.dumps({path: after[path] for path in (source, destination, backend)}, indent=2)) +print('Initial declaration-selected rename/move/base simulation passed; no source applied.') + +def replace_once(text, old, new): + assert text.count(old) == 1, old + return text.replace(old, new, 1) + +provider = after[source] +syntax = module_syntax_index(SourceModule.from_source_path(Path(source), provider).parse().module) +owner, = [node for _, node in syntax.indexed_nodes_of_type(ast.ClassDef) + if node.name == 'CellProfilerCallableKernelPreparation'] +lines = provider.splitlines(keepends=True) +def member_source(name): + member, = [node for node in owner.body if isinstance(node, ast.FunctionDef) and node.name == name] + start = min([member.lineno, *(d.lineno for d in member.decorator_list)]) + return ''.join(lines[start - 1:member.end_lineno]) + +identity = member_source('identity') +operations_source = member_source('cache_preparation_operations') +prepare = member_source('prepare_registered_family') +common_prepare = replace_once(prepare, ' if capture_enabled():\n return\n', '') +generic = '''class RegisteredNumbaKernelPreparation( + PersistentNumbaKernelPreparation, PreparationOperation +): + """Derive independent pure-kernel obligations from each declared registry. + + This abstract parent has no registry. Concrete AutoRegisterMeta declarations + own their registries; the common parent owns identity, operation derivation + and successful parent preparation. + """ + + __registry_key__ = "__name__" + __registry__: ClassVar[dict[str, type[RegisteredNumbaKernelPreparation]]] + +''' + identity + '\n\n' + operations_source + '\n\n' + common_prepare +core = replace_once(after[destination], '@dataclass(frozen=True, slots=True)\nclass RegistryFamilyPreparation', generic + '\n\n\n@dataclass(frozen=True, slots=True)\nclass RegistryFamilyPreparation') +provider = replace_once(provider, identity + '\n', '') +provider = replace_once(provider, operations_source + '\n', '') +provider = replace_once(provider, prepare, + replace_once(prepare, ' for operation in cls.cache_preparation_operations():\n operation.prepare()\n', ' super().prepare_registered_family()\n')) +provider = replace_once(provider, ' __registry_key__ = "__name__"\n __registry__: ClassVar[dict[str, type[CellProfilerCallableKernelPreparation]]]\n\n', '') +provider = replace_once(provider, 'class CellProfilerCallableKernelPreparation(\n PersistentNumbaKernelPreparation,\n PreparationOperation,\n CompilerPreparedAutoRegisterFamily,\n):', 'class CellProfilerCallableKernelPreparation(RegisteredNumbaKernelPreparation):') +provider = replace_once(provider, 'from collections.abc import Hashable\nfrom typing import ClassVar\n\nfrom openhcs.core.callable_contract import CompilerPreparedAutoRegisterFamily\nfrom openhcs.core.processing_preparation import PreparationOperation\n', 'from openhcs.core.processing_preparation import RegisteredNumbaKernelPreparation\n') +provider = replace_once(provider, '\nfrom ....core.processing_preparation import PersistentNumbaKernelPreparation as PersistentNumbaKernelPreparation\n', '') +provider = replace_once(provider, ' """Own pure kernel work; concrete declarations own independent registries.\n\n This abstract protocol has no registry. AutoRegisterMeta creates one on\n each direct concrete declaration, deriving child work from the existing\n module registry discovery without inspecting callable or module hooks.\n Parent registry preparation owns kernel readiness. Generic callable hooks\n retain their independent completion and effect phase.\n """', ' """Keep CellProfiler fixture capture in the parent processing hook."""') +backend_source = replace_once(after[backend], 'from openhcs.core.callable_contract import (\n CallableContract,\n CompilerPreparedAutoRegisterFamily,\n)\n', 'from openhcs.core.callable_contract import CallableContract\nfrom openhcs.core.processing_preparation import PersistentNumbaKernelPreparation\n') +backend_source = replace_once(backend_source, '\nfrom ....core.processing_preparation import PersistentNumbaKernelPreparation\n', '') +backend_source = replace_once(backend_source, 'class CellProfilerBackendStrategyMixin(\n PersistentNumbaKernelPreparation, CompilerPreparedAutoRegisterFamily\n):', 'class CellProfilerBackendStrategyMixin(PersistentNumbaKernelPreparation):') +changes = {source: provider, destination: core, backend: backend_source} +for path, text in changes.items(): + ranges = [(max(1, j1 - 2), j2 + 3) + for tag, i1, i2, j1, j2 in difflib.SequenceMatcher(a=sources[path].splitlines(), b=text.splitlines()).get_opcodes() + if tag != 'equal' and j2 > j1] + command = ['/home/ts/code/projects/openhcs/.venv/bin/python', '-m', 'black', '--quiet', '--target-version', 'py311'] + for start, end in ranges: + command.extend(['--line-ranges', f'{start}-{end}']) + command.extend(['--stdin-filename', path, '-']) + changes[path] = subprocess.check_output(command, input=text, text=True) +closure_operations = tuple(PatchTargetOperation( + target=SourceRewriteTarget(file_path=path), + replacements=(SourceTextReplacement(old_source=after[path], new_source=text),), + rationale='Move the existing pure registry algorithm and close every provider import. The provider retains only its fixture effect policy; no compatibility alias remains.') + for path, text in changes.items()) +closure = CodemodPlanDocument(recipes=(RefactorRecipe( + recipe_id='close-generic-numba-family-and-provider-effects', + reason='Standalone declared kernel operations own one generic registry algorithm; provider-specific capture vetoes are substitutable overrides.', + operations=closure_operations),)) +complete = CodemodPlanSequence(documents=(*documents, closure)).simulate(snapshot) +(runs / 'perf-generic-numba-owner-complete-simulation-20260930.json').write_text(json.dumps(complete.simulation_payload(), indent=2) + '\n') +assert complete.is_clean, 'Full owner migration preflight failed.' +(runs / 'perf-generic-numba-owner-transaction-20260930.diff').write_text(complete.unified_diff(sources)) +assert 'CellProfilerKernelCachePreparationMixin' not in ''.join(complete.final_snapshot.sources_by_file_path.values()) +assert 'processing.backends.cellprofiler' not in complete.final_snapshot.sources_by_file_path[destination] +print(complete.apply()) diff --git a/docs/validation/generic_runtime_owners_323_20260930/move_numerical_cache_mechanics_20261001.py.txt b/docs/validation/generic_runtime_owners_323_20260930/move_numerical_cache_mechanics_20261001.py.txt new file mode 100644 index 0000000000..3984204934 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/move_numerical_cache_mechanics_20261001.py.txt @@ -0,0 +1,187 @@ +import json +from pathlib import Path +from nominal_refactor_advisor.codemod import ( + CodemodPlanDocument, CodemodSourceSnapshot, PatchTargetOperation, + RefactorRecipe, SourceRewriteTarget, SourceTextReplacement, +) + +root = Path('/home/ts/code/projects/openhcs-compile-perf') +out = Path('/home/ts/code/projects/openhcs-benchmark-runs') +sources = {} +changes = {} + +def edit(relative, replacements): + path = str(root / relative) + original = Path(path).read_text() + sources[path] = original + text = original + for old, new in replacements: + assert text.count(old) == 1, (relative, old, text.count(old)) + text = text.replace(old, new, 1) + changes[path] = text + +edit('openhcs/core/process_local_cache.py', [ + ('from typing import Any, ClassVar, Generic, TypeVar', + 'from typing import Any, ClassVar, Generic, TypeVar\nfrom threading import Lock\nfrom _thread import LockType'), + ('@dataclass(slots=True)\nclass ProcessLocalBoundedCache', '''@dataclass +class SynchronizedBoundedCache(BoundedCache[CacheKey, CachedValue]): + """Bounded storage whose individual mutations share one instance lock.""" + + _lock: LockType = field(default_factory=Lock, init=False, repr=False, compare=False) + + def cached_value(self, key: CacheKey) -> CachedValue | None: + with self._lock: + return super().cached_value(key) + + def store_value(self, key: CacheKey, value: CachedValue) -> CachedValue: + with self._lock: + return super().store_value(key, value) + + def clear(self) -> None: + with self._lock: + super().clear() + + +@dataclass(slots=True) +class ProcessLocalBoundedCache'''), + (' if cache is None:\n cache = cls()\n cls._process_cache = cache\n return cache', ''' if cache is None: + with cls._process_cache_lock: + cache = cls._process_cache + if cache is None: + cache = cls() + cls._process_cache = cache + return cache'''), + (' _process_cache: ClassVar["ProcessLocalBoundedCache[object, object] | None"] = None', + ' _process_cache: ClassVar["ProcessLocalBoundedCache[object, object] | None"] = None\n _process_cache_lock: ClassVar[LockType] = Lock()'), +]) + +edit('openhcs/processing/backends/cellprofiler/granularity.py', [ + ('from collections import OrderedDict\n', ''), + ('from threading import Lock\n', ''), + ('from openhcs.core.runtime_profile import RuntimeProfileLogger', '''from openhcs.core.process_local_cache import ( + RegisteredProcessLocalBoundedCache, + SynchronizedBoundedCache, +) +from openhcs.core.runtime_profile import RuntimeProfileLogger'''), + (''' with GRANULARITY_IMAGE_SERIES_CACHE_LOCK: + entry = GRANULARITY_IMAGE_SERIES_CACHE.get(key) + if entry is not None: + GRANULARITY_IMAGE_SERIES_CACHE.move_to_end(key) + self.log_profile("granularity_series_cache_hit", 0.0) + return entry''', ''' cache = GranularityImageSeriesCache.process_cache() + entry = cache.cached_value(key) + if entry is not None: + self.log_profile("granularity_series_cache_hit", 0.0) + return entry'''), + (''' with GRANULARITY_IMAGE_SERIES_CACHE_LOCK: + GRANULARITY_IMAGE_SERIES_CACHE[key] = series + GRANULARITY_IMAGE_SERIES_CACHE.move_to_end(key) + while ( + len(GRANULARITY_IMAGE_SERIES_CACHE) + > GRANULARITY_IMAGE_SERIES_CACHE_MAX_ENTRIES + ): + GRANULARITY_IMAGE_SERIES_CACHE.popitem(last=False) + return series''', ''' return cache.store_value(key, series)'''), + ('''GRANULARITY_IMAGE_SERIES_CACHE: dict[ + tuple[str, tuple[int, ...], bytes, float, float, int, int], + GranularityImageSeries, +] = OrderedDict() +GRANULARITY_IMAGE_SERIES_CACHE_MAX_ENTRIES = 16 +GRANULARITY_IMAGE_SERIES_CACHE_LOCK = Lock()''', '''@dataclass +class GranularityImageSeriesCache( + SynchronizedBoundedCache[ + tuple[str, tuple[int, ...], bytes, float, float, int, int], + GranularityImageSeries, + ], + RegisteredProcessLocalBoundedCache[ + tuple[str, tuple[int, ...], bytes, float, float, int, int], + GranularityImageSeries, + ], +): + """Process-local reconstructed spectra; calculation and keys stay numerical.""" + + max_entries: int = 16'''), + (' "GRANULARITY_IMAGE_SERIES_CACHE",\n "GRANULARITY_IMAGE_SERIES_CACHE_MAX_ENTRIES",', + ' "GranularityImageSeriesCache",'), +]) + +specs = ( + ('intensity_distribution.py', '_RADIAL_LABEL_GEOMETRY_CACHE', '''_RADIAL_LABEL_GEOMETRY_CACHE_LIMIT = 16 +_RADIAL_LABEL_GEOMETRY_CACHE: OrderedDict[ + "RadialLabelGeometryCacheKey", "RadialLabelGeometry" +] = OrderedDict()''', 'RadialLabelGeometryCache', '"RadialLabelGeometryCacheKey", "RadialLabelGeometry"', 'cache_key', 'geometry', ''' while len(_RADIAL_LABEL_GEOMETRY_CACHE) > _RADIAL_LABEL_GEOMETRY_CACHE_LIMIT: + _RADIAL_LABEL_GEOMETRY_CACHE.popitem(last=False)'''), + ('image_quality.py', '_RADIAL_SPECTRUM_GEOMETRY_CACHE', '''_RADIAL_SPECTRUM_GEOMETRY_CACHE: OrderedDict[ + tuple[int, int], _RadialSpectrumGeometry +] = OrderedDict() +_RADIAL_SPECTRUM_GEOMETRY_CACHE_MAX_ENTRIES = 16''', 'RadialSpectrumGeometryCache', 'tuple[int, int], _RadialSpectrumGeometry', 'key', 'geometry', ''' while ( + len(_RADIAL_SPECTRUM_GEOMETRY_CACHE) + > _RADIAL_SPECTRUM_GEOMETRY_CACHE_MAX_ENTRIES + ): + _RADIAL_SPECTRUM_GEOMETRY_CACHE.popitem(last=False)'''), + ('zernike.py', '_ZERNIKE_LABEL_GEOMETRY_CACHE', '''_ZERNIKE_LABEL_GEOMETRY_CACHE: OrderedDict[ + tuple[str, tuple[int, ...], bytes, str, tuple[int, ...], bytes], + _ZernikeLabelGeometry, +] = OrderedDict() +_ZERNIKE_LABEL_GEOMETRY_CACHE_MAX_ENTRIES = 16''', 'ZernikeLabelGeometryCache', 'tuple[str, tuple[int, ...], bytes, str, tuple[int, ...], bytes], _ZernikeLabelGeometry', 'key', 'geometry', ''' while ( + len(_ZERNIKE_LABEL_GEOMETRY_CACHE) + > _ZERNIKE_LABEL_GEOMETRY_CACHE_MAX_ENTRIES + ): + _ZERNIKE_LABEL_GEOMETRY_CACHE.popitem(last=False)'''), +) +for file, symbol, declaration, cls, types, key, result, eviction in specs: + indent = ' ' if file == 'image_quality.py' else ' ' + replacements = [ + ('from collections import OrderedDict\n', ''), + ('from __future__ import annotations', 'from __future__ import annotations\n\nfrom openhcs.core.process_local_cache import RegisteredProcessLocalBoundedCache'), + (declaration, f'''@dataclass +class {cls}(RegisteredProcessLocalBoundedCache[{types}]): + """Process-local numerical geometry with shared bounded storage.""" + + max_entries: int = 16'''), + (f'{symbol}.get({key})', f'{cls}.process_cache().cached_value({key})'), + (f'{indent} {symbol}.move_to_end({key})\n', ''), + (f'{indent}{symbol}[{key}] = {result}\n{indent}{symbol}.move_to_end({key})\n{eviction}', + f'{indent}{cls}.process_cache().store_value({key}, {result})'), + ] + edit('openhcs/processing/backends/cellprofiler/' + file, replacements) + +edit('tests/unit/test_measuregranularity.py', [ + (' GRANULARITY_IMAGE_SERIES_CACHE,', ' GranularityImageSeriesCache,'), + (' GRANULARITY_IMAGE_SERIES_CACHE.clear()', ' cache = GranularityImageSeriesCache.process_cache()\n cache.clear()'), + ('len(GRANULARITY_IMAGE_SERIES_CACHE)', 'len(cache.entries)'), +]) +relative = 'tests/unit/test_cellprofiler_processing_backend.py' +path = str(root / relative) +sources[path] = Path(path).read_text() +changes[path] = sources[path].replace('zernike._ZERNIKE_LABEL_GEOMETRY_CACHE.clear()', 'zernike.ZernikeLabelGeometryCache.process_cache().clear()').replace('len(zernike._ZERNIKE_LABEL_GEOMETRY_CACHE)', 'len(zernike.ZernikeLabelGeometryCache.process_cache().entries)') +assert changes[path] != sources[path] + +receipt = dict( + source_revision='00683dbd3669ff5c8595aa04efcca0a1f9c8bcf4', + decision_authority='User requested misplaced optimization mechanics moved to generic nominal owners.', + census='perf-numerical-cache-owners-before-census-20261001.json', + required=[['BoundedCache', 'LRU lookup, insertion, eviction'], ['SynchronizedBoundedCache', 'lock around bounded operations'], ['ProcessLocalBoundedCache', 'process singleton construction'], ['RegisteredProcessLocalBoundedCache', 'derived discovery for explicit cleanup'], ['numerical cache leaves', 'key/value domain and existing capacity 16']], + forbidden=[['numerical provider module', 'independent OrderedDict eviction loop'], ['generic cache parent', 'numerical key calculation or reconstruction algorithm']], + consumers=['GranularityImageSeriesRequest.series', 'RadialDistributionBackendStrategy.label_geometry', '_radial_spectrum_geometry', 'LegacyFastNumpyShapeZernikeBackendStrategy.zernike_label_geometry'], + counterevidence=['Other lru_cache decorators memoize intrinsic numerical/preparation calculations and are not competing runtime store authorities.', 'Spreadsheet OrderedDict values are output ordering, not caches.'], + open=['All 12 original unprojected classes retained in complete census.', 'Deleted public granularity cache globals are a deliberate internal API break; no legacy alias.', 'Cleanup helper is explicitly callable, not automatically run between wells.', 'MI, dataclass construction, metaclass registration and concurrent mutation require executed tests.'], + payoff='Ownership repair explicitly requested; no runtime gain claimed. Granularity reconstruction dominates this step (~2.22s) and is untouched.', + semantic_scope='Authored revision-checked source patches; NRA preflight does not prove equivalence.', +) +(out / 'perf-numerical-cache-owner-decision-20261001.json').write_text(json.dumps(receipt, indent=2)+'\n') +operations = tuple(PatchTargetOperation( + target=SourceRewriteTarget(file_path=path), + replacements=(SourceTextReplacement(old_source=sources[path], new_source=text),), + rationale='Authorized common cache mechanics migrate to existing nominal owners; intrinsic numerical definitions remain with providers.', +) for path, text in changes.items()) +plan = CodemodPlanDocument(recipes=(RefactorRecipe( + recipe_id='numerical-cache-shared-storage-owner', + reason='Delete four competing bounded storage implementations and derive numerical domains from shared parents.', + operations=operations, +),)) +simulation = plan.simulate(CodemodSourceSnapshot.from_source_mapping(sources)) +assert simulation.is_clean, simulation.simulation_payload() +(out / 'perf-numerical-cache-owner-simulation-20261001.json').write_text(json.dumps(simulation.simulation_payload(), indent=2)+'\n') +(out / 'perf-numerical-cache-owner-transaction-20261001.diff').write_text(simulation.unified_diff(sources)) +print(simulation.apply()) diff --git a/docs/validation/generic_runtime_owners_323_20260930/nra-r1.log b/docs/validation/generic_runtime_owners_323_20260930/nra-r1.log new file mode 100644 index 0000000000..154b8ac1db --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/nra-r1.log @@ -0,0 +1,2 @@ +R1 74eac059f67389ca071055c93fcbdd556ba79f1a: NRA cache=miss, projections=3058, prepare=52.648s, analysis=3.121s +R1 eba8e5c871a84b5ddd2581d7562798223ebd2415: NRA cache=miss, projections=3056, prepare=50.489s, analysis=3.104s diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-bound-runtime-profiler-plan-20261001.log.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-bound-runtime-profiler-plan-20261001.log.gz new file mode 100644 index 0000000000..38bae12efb Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-bound-runtime-profiler-plan-20261001.log.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-bound-runtime-profiler-simulation-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-bound-runtime-profiler-simulation-20261001.json.gz new file mode 100644 index 0000000000..7968263975 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-bound-runtime-profiler-simulation-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-bound-runtime-profiler-transaction-20261001.diff.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-bound-runtime-profiler-transaction-20261001.diff.gz new file mode 100644 index 0000000000..3c60b38126 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-bound-runtime-profiler-transaction-20261001.diff.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-columnar-export-frontier-probe-20260930.json b/docs/validation/generic_runtime_owners_323_20260930/perf-columnar-export-frontier-probe-20260930.json new file mode 100644 index 0000000000..2930f7d699 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-columnar-export-frontier-probe-20260930.json @@ -0,0 +1,118 @@ +[ + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "fixture": "/home/ts/code/projects/openhcs-benchmark-runs/perf-plate-boundary-diagnostic-20260930/ExampleImagingFlowCytometryObjectsInGrid-1115133-140175649535680-000097-spreadsheet.pickle", + "tables": 31, + "rows": 89796, + "carriers": [ + "openhcs.core.measurement_row_materialization.ConcatenatedColumnarRows", + "openhcs.core.measurement_row_materialization.MeasurementProjectedColumnarRows" + ], + "kwargs": { + "delimiter": "", + "add_image_metadata": "False", + "add_image_file_names": "False", + "select_measurements": "False", + "selected_columns": "()", + "calculate_aggregate_means": "False", + "calculate_aggregate_medians": "False", + "calculate_aggregate_standard_deviations": "False", + "output_directory": "''", + "export_all_measurement_types": "False", + "file_selections": "(SpreadsheetFileSelection(subjects=('BF_cells_on_grid', 'SSC'), file_name='BF_cells_on_grid.csv'),)", + "nan_representation": "", + "add_filename_prefix": "False", + "filename_prefix": "'MyExpt_'" + }, + "timings": [ + { + "mapping_csv": 0.8895826921798289, + "column_csv": 0.6970774931833148, + "bundle": 1.5463167941197753 + }, + { + "mapping_csv": 0.8806390082463622, + "column_csv": 0.6915999259799719, + "bundle": 1.440112757962197 + }, + { + "mapping_csv": 0.8824338377453387, + "column_csv": 0.6934090838767588, + "bundle": 1.4530350952409208 + }, + { + "mapping_csv": 0.882154902908951, + "column_csv": 0.6945731760933995, + "bundle": 1.4576297379098833 + }, + { + "mapping_csv": 0.8832375118508935, + "column_csv": 0.6956049990840256, + "bundle": 1.4590663341805339 + } + ], + "medians": { + "mapping_csv": 0.8824338377453387, + "column_csv": 0.6945731760933995, + "bundle": 1.4576297379098833 + } + }, + { + "case": "cp_tutorial_3d_monolayer", + "fixture": "/home/ts/code/projects/openhcs-benchmark-runs/perf-plate-boundary-diagnostic-20260930/cp_tutorial_3d_monolayer-1117601-140663293691584-000104-spreadsheet.pickle", + "tables": 14, + "rows": 590, + "carriers": [ + "openhcs.core.measurement_row_materialization.ConcatenatedColumnarRows", + "openhcs.core.measurement_row_materialization.MeasurementProjectedColumnarRows" + ], + "kwargs": { + "delimiter": "", + "add_image_metadata": "True", + "add_image_file_names": "False", + "select_measurements": "False", + "selected_columns": "()", + "calculate_aggregate_means": "False", + "calculate_aggregate_medians": "False", + "calculate_aggregate_standard_deviations": "False", + "output_directory": "''", + "export_all_measurement_types": "True", + "file_selections": "()", + "nan_representation": "", + "add_filename_prefix": "True", + "filename_prefix": "'3d_monolayer_'" + }, + "timings": [ + { + "mapping_csv": 0.0033728820271790028, + "column_csv": 0.0028793630190193653, + "bundle": 0.013520533218979836 + }, + { + "mapping_csv": 0.0034099621698260307, + "column_csv": 0.002901966217905283, + "bundle": 0.012121559120714664 + }, + { + "mapping_csv": 0.0034123267978429794, + "column_csv": 0.0031471573747694492, + "bundle": 0.012317898217588663 + }, + { + "mapping_csv": 0.003419840708374977, + "column_csv": 0.002910532057285309, + "bundle": 0.012236004229635 + }, + { + "mapping_csv": 0.003414199687540531, + "column_csv": 0.002904138993471861, + "bundle": 0.01233057165518403 + } + ], + "medians": { + "mapping_csv": 0.0034123267978429794, + "column_csv": 0.002904138993471861, + "bundle": 0.012317898217588663 + } + } +] diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-all-consumers-20260930.xml.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-all-consumers-20260930.xml.gz new file mode 100644 index 0000000000..00e53d117e Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-all-consumers-20260930.xml.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-before-census-20260930.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-before-census-20260930.json.gz new file mode 100644 index 0000000000..d870c00d10 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-before-census-20260930.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-focused-20260930.xml.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-focused-20260930.xml.gz new file mode 100644 index 0000000000..796dc98b13 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-focused-20260930.xml.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-nra-transaction-20260930.diff b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-nra-transaction-20260930.diff new file mode 100644 index 0000000000..8ed87673df --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-nra-transaction-20260930.diff @@ -0,0 +1,542 @@ +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/core/measurement_feature_queries.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/core/measurement_feature_queries.py +@@ -31,6 +31,7 @@ + ) + from openhcs.core.process_local_cache import ( + IdentityBoundProcessCache, ++ ProcessLocalBoundedCache, + RegisteredProcessLocalBoundedCache, + identity_owner_tuples_match, + ) +@@ -149,6 +150,15 @@ + "RuntimeObjectLabelMeasurementQuery.label_plane_domains must be " + "canonical positive object-id domains." + ) ++ ++ ++class RuntimeObjectLabelMeasurementQueryCache( ++ ProcessLocalBoundedCache[ ++ RuntimeObjectLabelMeasurementQuery, ++ tuple[np.ndarray, ...], ++ ] ++): ++ """Store-owned label-aligned values keyed by their full nominal query.""" + + + def _diagnostic_value(value: object | None) -> str: +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/core/measurement_row_materialization.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/core/measurement_row_materialization.py +@@ -148,6 +148,23 @@ + [str, tuple[tuple[str, object], ...]], + str, + ] ++ ++ ++class ObjectMeasurementColumnarRows(ColumnarRows, ABC): ++ """Object measurement columns spanning their declared label domain.""" ++ ++ @property ++ def covers_declared_object_measurement_domain(self) -> bool: ++ """Object-measurement carriers span their declared label domain.""" ++ return True ++ ++ def __len__(self) -> int: ++ return self.row_count() ++ ++ ++ def __iter__(self): ++ yield from self.iter_row_mappings() ++ + + + class MeasurementRowDeclaredValue(ABC, metaclass=AutoRegisterMeta): +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_artifact_queries.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_artifact_queries.py +@@ -6,7 +6,6 @@ + from dataclasses import dataclass + from types import MappingProxyType + from typing import TYPE_CHECKING, Any, cast +-from weakref import WeakKeyDictionary + + import numpy as np + +@@ -39,6 +38,7 @@ + resolve_runtime_measurement_lookup_dialect, + ) + from openhcs.core.process_local_cache import ( ++ ProcessLocalBoundedCache, + RegisteredProcessLocalBoundedCache, + identity_owner_tuples_match, + named_identity_owner_tuples_match, +@@ -81,10 +81,13 @@ + if TYPE_CHECKING: + from openhcs.core.runtime_stores import RuntimeValueStore, StoredRuntimeValue + +-_MEASUREMENT_TABLE_CACHE: WeakKeyDictionary[ +- RuntimeValueStore, +- dict[tuple[int, str, str | None], tuple[MeasurementTable, ...]], +-] = WeakKeyDictionary() ++class RuntimeMeasurementTablesQueryCache( ++ ProcessLocalBoundedCache[ ++ tuple[str, str | None], ++ tuple[MeasurementTable, ...], ++ ] ++): ++ """Store-owned measurement tables for one axis and component group.""" + + + MeasurementLabelSliceFeatureBatchCacheValue = tuple[ +@@ -433,20 +436,16 @@ + context: RuntimeArtifactQueryContext, + ) -> tuple[MeasurementTable, ...]: + """Return all measurement tables in a runtime query context.""" +- cache_key = (context.store.revision, context.axis_id, context.group_key) +- store_cache = _MEASUREMENT_TABLE_CACHE.setdefault(context.store, {}) +- cached = store_cache.get(cache_key) ++ cache_key = (context.axis_id, context.group_key) ++ store_cache = context.store.query_cache(RuntimeMeasurementTablesQueryCache) ++ cached = store_cache.cached_value(cache_key) + if cached is not None: + return cached + tables = tuple( + cast(MeasurementTable, record.value.data) + for record in context.find(artifact_type=MeasurementsArtifactType) + ) +- for key in tuple(store_cache): +- if key[0] != context.store.revision: +- del store_cache[key] +- store_cache[cache_key] = tables +- return tables ++ return store_cache.store_value(cache_key, tables) + + + def runtime_measurement_tables_for_object( +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_stores.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_stores.py +@@ -8,7 +8,7 @@ + import inspect + from pathlib import Path + from types import MappingProxyType +-from typing import Any ++from typing import Any, TypeVar, cast + + from python_introspect import RuntimeParameterDeclarationABC + +@@ -26,6 +26,7 @@ + ComponentGroupScope, + ) + from openhcs.core.component_set import ComponentSet ++from openhcs.core.process_local_cache import ProcessLocalBoundedCache + from openhcs.core.function_patterns import InvocationArtifactInputEdgePlan + from openhcs.core.runtime_artifact_values import ( + ArtifactKey, +@@ -811,6 +812,9 @@ + return dict(payload) + + ++StoreQueryCacheT = TypeVar("StoreQueryCacheT", bound=ProcessLocalBoundedCache[Any, Any]) ++ ++ + class RuntimeValueStore: + """Source of truth for validated runtime artifact values in one context.""" + +@@ -822,6 +826,10 @@ + self._observation_records: list[StoredRuntimeValue] = [] + self._current_location_by_key: dict[ArtifactKey, RuntimeArtifactLocation] = {} + self._revision = 0 ++ self._query_caches: dict[ ++ type[ProcessLocalBoundedCache[Any, Any]], ++ ProcessLocalBoundedCache[Any, Any], ++ ] = {} + self._find_cache: dict[ + tuple[ + int, +@@ -839,6 +847,27 @@ + tuple[int, RuntimeArtifactQuery], + tuple[StoredRuntimeValue, ...], + ] = {} ++ ++ def query_cache(self, cache_type: type[StoreQueryCacheT]) -> StoreQueryCacheT: ++ """Return a bounded derived-value cache owned by this store's lifetime. ++ ++ Concrete cache types separate query domains. Every store mutation clears ++ their values; transport reconstructs the store without derived caches. ++ """ ++ cache = self._query_caches.get(cache_type) ++ if cache is None: ++ cache = cache_type() ++ self._query_caches[cache_type] = cache ++ return cast(StoreQueryCacheT, cache) ++ ++ def __getstate__(self) -> dict[str, object]: ++ state = dict(self.__dict__) ++ del state["_query_caches"] ++ return state ++ ++ def __setstate__(self, state: dict[str, object]) -> None: ++ self.__dict__.update(state) ++ self._query_caches = {} + + @staticmethod + def address_matches_plan( +@@ -1098,6 +1127,8 @@ + + def _mark_mutated(self) -> None: + self._revision += 1 ++ for cache in self._query_caches.values(): ++ cache.clear() + self._find_cache.clear() + self._find_matching_cache.clear() + +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/interop/cellprofiler/runtime/object_label_measurements.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/interop/cellprofiler/runtime/object_label_measurements.py +@@ -4,7 +4,6 @@ + + from dataclasses import dataclass + from typing import TYPE_CHECKING, cast +-from weakref import WeakKeyDictionary + + import numpy as np + +@@ -14,6 +13,7 @@ + ObjectLabelsArtifactType, + ) + from openhcs.core.measurement_feature_queries import ( ++ RuntimeObjectLabelMeasurementQueryCache, + MeasurementFeatureQuery, + RuntimeObjectLabelMeasurementQuery, + RuntimeObjectSliceMeasurementQuery, +@@ -34,7 +34,6 @@ + ObjectLabelMeasurementValues, + ) + from openhcs.core.runtime_slice_alignment import RuntimeSliceAlignedValues +-from openhcs.core.runtime_stores import RuntimeValueStore + from openhcs.interop.cellprofiler.measurement_dialect import ( + CELLPROFILER_MEASUREMENT_LOOKUP_DIALECT, + ) +@@ -47,29 +46,6 @@ + + if TYPE_CHECKING: + from openhcs.interop.cellprofiler.runtime.adapter import CellProfilerRuntimeAdapter +- +-ObjectLabelMeasurementValuesProcessCache = dict[ +- RuntimeObjectLabelMeasurementQuery, +- tuple[np.ndarray, ...], +-] +- +-_OBJECT_LABEL_MEASUREMENT_VALUES_PROCESS_CACHE: WeakKeyDictionary[ +- RuntimeValueStore, +- tuple[int, ObjectLabelMeasurementValuesProcessCache], +-] = WeakKeyDictionary() +- +- +-def object_label_measurement_values_cache( +- store: RuntimeValueStore, +-) -> ObjectLabelMeasurementValuesProcessCache: +- """Return label-aligned vectors bound to the store's current revision.""" +- cached_revision = _OBJECT_LABEL_MEASUREMENT_VALUES_PROCESS_CACHE.get(store) +- if cached_revision is not None and cached_revision[0] == store.revision: +- return cached_revision[1] +- cache: ObjectLabelMeasurementValuesProcessCache = {} +- _OBJECT_LABEL_MEASUREMENT_VALUES_PROCESS_CACHE[store] = (store.revision, cache) +- return cache +- + + @dataclass(frozen=True, slots=True, kw_only=True) + class ObjectFeatureMeasurementContext(RuntimeObjectSliceMeasurementQuery): +@@ -242,10 +218,10 @@ + """Return object measurements aligned to this request's label planes.""" + label_domain = self.label_domain() + query = self.measurement_query(adapter, label_domain=label_domain) +- object_label_values_cache = object_label_measurement_values_cache( +- adapter.request.context.runtime_value_store +- ) +- cached = object_label_values_cache.get(query) ++ object_label_values_cache = adapter.request.context.runtime_value_store.query_cache( ++ RuntimeObjectLabelMeasurementQueryCache ++ ) ++ cached = object_label_values_cache.cached_value(query) + if cached is not None: + return cached + child_name = child_count_feature_child_name(self.feature_name) +@@ -299,8 +275,7 @@ + plane_projector=adapter, + dialect=CELLPROFILER_MEASUREMENT_LOOKUP_DIALECT, + ).values_for_labels(self.labels) +- object_label_values_cache[query] = values +- return values ++ return object_label_values_cache.store_value(query, values) + + + @dataclass(frozen=True, slots=True, kw_only=True) +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/interop/cellprofiler/runtime/object_measurement_vectors.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/interop/cellprofiler/runtime/object_measurement_vectors.py +@@ -21,7 +21,10 @@ + MeasurementLabelSliceFeatureQuery, + MeasurementLabelSliceFeatureBatchQuery, + ) +-from openhcs.core.measurement_feature_queries import MeasurementFeatureQuery ++from openhcs.core.measurement_feature_queries import ( ++ MeasurementFeatureQuery, ++ RuntimeObjectLabelMeasurementQueryCache, ++) + from openhcs.core.measurement_row_materialization import measurement_rows + from openhcs.core.runtime_measurements import ( + MeasurementRowAxisField, +@@ -49,7 +52,6 @@ + ) + from openhcs.interop.cellprofiler.runtime.object_label_measurements import ( + ObjectLabelMeasurementSliceRequest, +- object_label_measurement_values_cache, + ) + from openhcs.interop.cellprofiler.runtime.object_measurement_tables import ( + ObjectMeasurementTableIndex, +@@ -597,25 +599,25 @@ + vectors: Mapping[str, tuple[np.ndarray, ...]], + bindings: tuple[CellProfilerObjectMeasurementVectorBinding, ...], + ) -> None: +- process_cache = object_label_measurement_values_cache( +- adapter.request.context.runtime_value_store ++ store_cache = adapter.request.context.runtime_value_store.query_cache( ++ RuntimeObjectLabelMeasurementQueryCache + ) + for binding in bindings: + values = vectors[binding.object_name] + query = binding.measurement_query(adapter) +- process_cache[query] = values ++ store_cache.store_value(query, values) + + def cached_runtime_batch_vectors( + self, + adapter: "CellProfilerRuntimeAdapter", + ) -> dict[str, tuple[np.ndarray, ...]]: +- process_cache = object_label_measurement_values_cache( +- adapter.request.context.runtime_value_store ++ store_cache = adapter.request.context.runtime_value_store.query_cache( ++ RuntimeObjectLabelMeasurementQueryCache + ) + cached_vectors: dict[str, tuple[np.ndarray, ...]] = {} + for binding in self.bindings: + query = binding.measurement_query(adapter) +- cached = process_cache.get(query) ++ cached = store_cache.cached_value(query) + if cached is not None: + cached_vectors[binding.object_name] = cached + return cached_vectors +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/colocalization.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/colocalization.py +@@ -160,8 +160,8 @@ + from openhcs.processing.backends.cellprofiler.granularity import ( + CellProfilerRuntimeProfiler, + ) +-from openhcs.processing.backends.cellprofiler.object_measurement_columnar_rows import ( +- LongObjectMeasurementColumnarRows, ++from openhcs.core.measurement_row_materialization import ( ++ ObjectMeasurementColumnarRows, + ) + from openhcs.processing.backends.lib_registry.unified_registry import ProcessingContract + from openhcs.interop.cellprofiler.runtime.artifact_binding import ( +@@ -2013,7 +2013,7 @@ + + + @dataclass(frozen=True, slots=True) +-class ObjectColocalizationColumnarMeasurements(LongObjectMeasurementColumnarRows): ++class ObjectColocalizationColumnarMeasurements(ObjectMeasurementColumnarRows): + """Columnar object-colocalization rows preserving direct row iteration.""" + + fields: ClassVar[tuple[FieldSpec, ...]] = FieldSpec.from_dataclass_type( +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/granularity.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/granularity.py +@@ -87,8 +87,8 @@ + CellProfilerBackendProvider, + CellProfilerBackendStrategyMixin, + ) +-from openhcs.processing.backends.cellprofiler.object_measurement_columnar_rows import ( +- LongObjectMeasurementColumnarRows, ++from openhcs.core.measurement_row_materialization import ( ++ ObjectMeasurementColumnarRows, + ) + from openhcs.processing.backends.lib_registry.unified_registry import ProcessingContract + from openhcs.processing.backends.cellprofiler._granularity_native import ( +@@ -461,7 +461,7 @@ + + + @dataclass(frozen=True, slots=True) +-class ObjectGranularityMeasurementRows(LongObjectMeasurementColumnarRows): ++class ObjectGranularityMeasurementRows(ObjectMeasurementColumnarRows): + """Columnar object granularity rows over the emitted label-id domain.""" + + fields: ClassVar[tuple[FieldSpec, ...]] = FieldSpec.from_dataclass_type( +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/intensity.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/intensity.py +@@ -314,7 +314,7 @@ + ObjectLabelValue, + object_label_dense_array, + ) +-from openhcs.processing.backends.cellprofiler.object_measurement_columnar_rows import ( ++from openhcs.core.measurement_row_materialization import ( + ObjectMeasurementColumnarRows, + ) + from openhcs.core.runtime_profile import RuntimeProfileLogger +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/intensity_distribution.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/intensity_distribution.py +@@ -113,8 +113,8 @@ + from openhcs.processing.backends.cellprofiler.granularity import ( + CellProfilerRuntimeProfiler, + ) +-from openhcs.processing.backends.cellprofiler.object_measurement_columnar_rows import ( +- WideObjectMeasurementColumnarRows, ++from openhcs.core.measurement_row_materialization import ( ++ ObjectMeasurementColumnarRows, + ) + from openhcs.processing.backends.cellprofiler.secondary import ( + SecondaryPropagationBackendStrategy, +@@ -1465,7 +1465,7 @@ + + @dataclass(slots=True) + class ObjectIntensityDistributionMeasurementColumnarRows( +- WideObjectMeasurementColumnarRows ++ ObjectMeasurementColumnarRows + ): + """Columnar radial intensity-distribution rows.""" + +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/object_measurement_columnar_rows.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/object_measurement_columnar_rows.py +@@ -1,60 +0,0 @@ +-"""Columnar row base classes for CellProfiler object measurements.""" +- +-from __future__ import annotations +- +-from abc import ABC +-from collections.abc import Sequence +- +-from openhcs.core.runtime_measurements import ( +- ObjectMeasurementSliceValueRow, +- ObjectMeasurementValueRow, +-) +-from openhcs.core.runtime_tabular_values import ( +- ColumnarRows, +-) +- +- +-class ObjectMeasurementColumnarRows(ColumnarRows, ABC): +- """Object measurement columns spanning their declared label domain.""" +- +- slice_index: int | None +- +- @property +- def covers_declared_object_measurement_domain(self) -> bool: +- """OpenHCS object-measurement carriers are built on their label domain.""" +- return True +- +- def __len__(self) -> int: +- return self.row_count() +- +- +-class WideObjectMeasurementColumnarRows(ObjectMeasurementColumnarRows, ABC): +- """One object row with a named column for each measured feature.""" +- +- def __iter__(self): +- yield from self.iter_row_mappings() +- +- +-class LongObjectMeasurementColumnarRows(ObjectMeasurementColumnarRows, ABC): +- """One object/feature/value row per measured feature.""" +- +- def __iter__(self): +- row_type = ( +- ObjectMeasurementValueRow +- if self.slice_index is None +- else ObjectMeasurementSliceValueRow +- ) +- columns = self.columns +- slice_values: Sequence[object] | None = columns.get("slice_index") +- for row_index in range(len(self)): +- kwargs = ( +- {} +- if slice_values is None +- else {"slice_index": int(slice_values[row_index])} +- ) +- yield row_type( +- object_label=int(columns["object_label"][row_index]), +- feature_name=str(columns["feature_name"][row_index]), +- result_value=float(columns["result_value"][row_index]), +- **kwargs, +- ) +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/shape.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/shape.py +@@ -457,8 +457,8 @@ + object_label_sparse_ijv_rows, + ) + from openhcs.core.runtime_sparse_labels import SparseIJVLabelRows +-from openhcs.processing.backends.cellprofiler.object_measurement_columnar_rows import ( +- LongObjectMeasurementColumnarRows, ++from openhcs.core.measurement_row_materialization import ( ++ ObjectMeasurementColumnarRows, + ) + from openhcs.processing.backends.analysis.region_properties import ( + LabelRegionPropertiesBackendStrategy, +@@ -559,7 +559,7 @@ + ) + + +-class ShapeObjectMeasurementRows(LongObjectMeasurementColumnarRows): ++class ShapeObjectMeasurementRows(ObjectMeasurementColumnarRows): + """Dense AreaShape rows that already span their declared object domain.""" + + object_row_identity = MeasurementObjectRowIdentity.ROW_SEQUENCE +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/zernike.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/zernike.py +@@ -65,8 +65,8 @@ + from openhcs.processing.backends.cellprofiler.label_geometry import ( + minimum_enclosing_circle_from_labels, + ) +-from openhcs.processing.backends.cellprofiler.object_measurement_columnar_rows import ( +- WideObjectMeasurementColumnarRows, ++from openhcs.core.measurement_row_materialization import ( ++ ObjectMeasurementColumnarRows, + ) + + _INTENSITY_DEBUG_TRACE_DIR_ENV = "OPENHCS_ZERNIKE_INTENSITY_DEBUG_TRACE_DIR" +@@ -652,7 +652,7 @@ + + + @dataclass(slots=True) +-class ObjectIntensityZernikeMeasurementColumnarRows(WideObjectMeasurementColumnarRows): ++class ObjectIntensityZernikeMeasurementColumnarRows(ObjectMeasurementColumnarRows): + """Columnar intensity-Zernike measurement rows.""" + + object_ids: Sequence[int] +--- a/home/ts/code/projects/openhcs-compile-perf/tests/unit/test_cellprofiler_nominal_policy_migration.py ++++ b/home/ts/code/projects/openhcs-compile-perf/tests/unit/test_cellprofiler_nominal_policy_migration.py +@@ -116,7 +116,7 @@ + from openhcs.processing.backends.cellprofiler.intensity import ( + ObjectIntensityMeasurementRows, + ) +- from openhcs.processing.backends.cellprofiler.object_measurement_columnar_rows import ( ++ from openhcs.core.measurement_row_materialization import ( + ObjectMeasurementColumnarRows, + ) + from openhcs.processing.backends.cellprofiler.shape import ( +--- a/home/ts/code/projects/openhcs-compile-perf/tests/unit/test_cellprofiler_runtime_cache_authorities.py ++++ b/home/ts/code/projects/openhcs-compile-perf/tests/unit/test_cellprofiler_runtime_cache_authorities.py +@@ -48,9 +48,9 @@ + from openhcs.core.runtime_relationships import DirectedObjectRelationshipPayload + from openhcs.core.runtime_tabular_values import FieldSpec + from openhcs.core.runtime_stores import RuntimeValueStore ++from openhcs.core.measurement_feature_queries import RuntimeObjectLabelMeasurementQueryCache + from openhcs.interop.cellprofiler.runtime.object_label_measurements import ( + ObjectLabelMeasurementSliceRequest, +- object_label_measurement_values_cache, + ) + + AXIS_ID = "A01" +@@ -238,7 +238,7 @@ + ) + query = request.measurement_query(adapter) + expected = (np.asarray([11.0], dtype=np.float64),) +- object_label_measurement_values_cache(store)[query] = expected ++ store.query_cache(RuntimeObjectLabelMeasurementQueryCache).store_value(query, expected) + + resolved = request.values(adapter) + diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-public-comparison-20260930.json b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-public-comparison-20260930.json new file mode 100644 index 0000000000..83f4540459 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-public-comparison-20260930.json @@ -0,0 +1,308 @@ +{ + "parity": [ + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930", + "label": "main", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930/ExampleImagingFlowCytometryObjectsInGrid/wells_1/workers_1/images_ExampleImagingFlowCytometryObjectsInGrid_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/BF_cells_on_grid.csv", + "sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + } + ], + "exact_label_images": 0 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-ExampleImagingFlowCytometryObjectsInGrid-1-candidate-20260930", + "label": "candidate", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930/ExampleImagingFlowCytometryObjectsInGrid/wells_1/workers_1/images_ExampleImagingFlowCytometryObjectsInGrid_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/BF_cells_on_grid.csv", + "sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + } + ], + "exact_label_images": 0 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-ExampleImagingFlowCytometryObjectsInGrid-2-candidate-20260930", + "label": "candidate", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930/ExampleImagingFlowCytometryObjectsInGrid/wells_1/workers_1/images_ExampleImagingFlowCytometryObjectsInGrid_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/BF_cells_on_grid.csv", + "sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + } + ], + "exact_label_images": 0 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-ExampleImagingFlowCytometryObjectsInGrid-3-main-20260930", + "label": "main", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930/ExampleImagingFlowCytometryObjectsInGrid/wells_1/workers_1/images_ExampleImagingFlowCytometryObjectsInGrid_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/BF_cells_on_grid.csv", + "sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + } + ], + "exact_label_images": 0 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-execution-owner-diagnostic-production-ExampleImagingFlowCytometryObjectsInGrid-20260930", + "label": "execution-owner", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930/ExampleImagingFlowCytometryObjectsInGrid/wells_1/workers_1/images_ExampleImagingFlowCytometryObjectsInGrid_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/BF_cells_on_grid.csv", + "sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + } + ], + "exact_label_images": 0 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-plate-boundary-diagnostic-production-ExampleImagingFlowCytometryObjectsInGrid-20260930", + "label": "plate-boundary", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930/ExampleImagingFlowCytometryObjectsInGrid/wells_1/workers_1/images_ExampleImagingFlowCytometryObjectsInGrid_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/BF_cells_on_grid.csv", + "sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + } + ], + "exact_label_images": 0 + }, + { + "case": "cp_tutorial_3d_monolayer", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-cp_tutorial_3d_monolayer-0-main-20260930", + "label": "main", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-plate-transport-full-candidate-20260929/cp_tutorial_3d_monolayer/wells_1/workers_1/images_3d_monolayer_final_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/3d_monolayer_Cells.csv", + "sha256": "4d8c029000d5886e4cda889fd1c5f7f13ea31330ee34b1737feb190e2079b32d" + }, + { + "path": "results/3d_monolayer_Image.csv", + "sha256": "75ac32ff5ef57bc285ec4eae1c9b501c27a35b486bf35435af5d499d856d34a4" + }, + { + "path": "results/3d_monolayer_Nuclei.csv", + "sha256": "2acbac3e2cfa9b62f17d1fccaf8b079a47076b0ca842f652324cb0acdf2b905c" + }, + { + "path": "results/3d_monolayer_downsizedNuclei.csv", + "sha256": "4b689ed9b94031f1ced06105b2617ccac539d60fece387450d2573695e0aef08" + }, + { + "path": "results/3d_monolayer_erodedDownsizedNuclei.csv", + "sha256": "9d640239186d1e243a251263f250761d8e0aacbd802952eda56d4ba3e4b758e0" + }, + { + "path": "results/3d_monolayer_erodedResizedNuclei.csv", + "sha256": "e49c8600995126ac6f9695896eaf5572567bace3a5872437f2b740ee73af308c" + } + ], + "exact_label_images": 120 + }, + { + "case": "cp_tutorial_3d_monolayer", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-cp_tutorial_3d_monolayer-1-candidate-20260930", + "label": "candidate", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-plate-transport-full-candidate-20260929/cp_tutorial_3d_monolayer/wells_1/workers_1/images_3d_monolayer_final_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/3d_monolayer_Cells.csv", + "sha256": "4d8c029000d5886e4cda889fd1c5f7f13ea31330ee34b1737feb190e2079b32d" + }, + { + "path": "results/3d_monolayer_Image.csv", + "sha256": "75ac32ff5ef57bc285ec4eae1c9b501c27a35b486bf35435af5d499d856d34a4" + }, + { + "path": "results/3d_monolayer_Nuclei.csv", + "sha256": "2acbac3e2cfa9b62f17d1fccaf8b079a47076b0ca842f652324cb0acdf2b905c" + }, + { + "path": "results/3d_monolayer_downsizedNuclei.csv", + "sha256": "4b689ed9b94031f1ced06105b2617ccac539d60fece387450d2573695e0aef08" + }, + { + "path": "results/3d_monolayer_erodedDownsizedNuclei.csv", + "sha256": "9d640239186d1e243a251263f250761d8e0aacbd802952eda56d4ba3e4b758e0" + }, + { + "path": "results/3d_monolayer_erodedResizedNuclei.csv", + "sha256": "e49c8600995126ac6f9695896eaf5572567bace3a5872437f2b740ee73af308c" + } + ], + "exact_label_images": 120 + }, + { + "case": "cp_tutorial_3d_monolayer", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-cp_tutorial_3d_monolayer-2-candidate-20260930", + "label": "candidate", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-plate-transport-full-candidate-20260929/cp_tutorial_3d_monolayer/wells_1/workers_1/images_3d_monolayer_final_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/3d_monolayer_Cells.csv", + "sha256": "4d8c029000d5886e4cda889fd1c5f7f13ea31330ee34b1737feb190e2079b32d" + }, + { + "path": "results/3d_monolayer_Image.csv", + "sha256": "75ac32ff5ef57bc285ec4eae1c9b501c27a35b486bf35435af5d499d856d34a4" + }, + { + "path": "results/3d_monolayer_Nuclei.csv", + "sha256": "2acbac3e2cfa9b62f17d1fccaf8b079a47076b0ca842f652324cb0acdf2b905c" + }, + { + "path": "results/3d_monolayer_downsizedNuclei.csv", + "sha256": "4b689ed9b94031f1ced06105b2617ccac539d60fece387450d2573695e0aef08" + }, + { + "path": "results/3d_monolayer_erodedDownsizedNuclei.csv", + "sha256": "9d640239186d1e243a251263f250761d8e0aacbd802952eda56d4ba3e4b758e0" + }, + { + "path": "results/3d_monolayer_erodedResizedNuclei.csv", + "sha256": "e49c8600995126ac6f9695896eaf5572567bace3a5872437f2b740ee73af308c" + } + ], + "exact_label_images": 120 + }, + { + "case": "cp_tutorial_3d_monolayer", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-cp_tutorial_3d_monolayer-3-main-20260930", + "label": "main", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-plate-transport-full-candidate-20260929/cp_tutorial_3d_monolayer/wells_1/workers_1/images_3d_monolayer_final_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/3d_monolayer_Cells.csv", + "sha256": "4d8c029000d5886e4cda889fd1c5f7f13ea31330ee34b1737feb190e2079b32d" + }, + { + "path": "results/3d_monolayer_Image.csv", + "sha256": "75ac32ff5ef57bc285ec4eae1c9b501c27a35b486bf35435af5d499d856d34a4" + }, + { + "path": "results/3d_monolayer_Nuclei.csv", + "sha256": "2acbac3e2cfa9b62f17d1fccaf8b079a47076b0ca842f652324cb0acdf2b905c" + }, + { + "path": "results/3d_monolayer_downsizedNuclei.csv", + "sha256": "4b689ed9b94031f1ced06105b2617ccac539d60fece387450d2573695e0aef08" + }, + { + "path": "results/3d_monolayer_erodedDownsizedNuclei.csv", + "sha256": "9d640239186d1e243a251263f250761d8e0aacbd802952eda56d4ba3e4b758e0" + }, + { + "path": "results/3d_monolayer_erodedResizedNuclei.csv", + "sha256": "e49c8600995126ac6f9695896eaf5572567bace3a5872437f2b740ee73af308c" + } + ], + "exact_label_images": 120 + }, + { + "case": "cp_tutorial_3d_monolayer", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-execution-owner-diagnostic-production-cp_tutorial_3d_monolayer-20260930", + "label": "execution-owner", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-plate-transport-full-candidate-20260929/cp_tutorial_3d_monolayer/wells_1/workers_1/images_3d_monolayer_final_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/3d_monolayer_Cells.csv", + "sha256": "4d8c029000d5886e4cda889fd1c5f7f13ea31330ee34b1737feb190e2079b32d" + }, + { + "path": "results/3d_monolayer_Image.csv", + "sha256": "75ac32ff5ef57bc285ec4eae1c9b501c27a35b486bf35435af5d499d856d34a4" + }, + { + "path": "results/3d_monolayer_Nuclei.csv", + "sha256": "2acbac3e2cfa9b62f17d1fccaf8b079a47076b0ca842f652324cb0acdf2b905c" + }, + { + "path": "results/3d_monolayer_downsizedNuclei.csv", + "sha256": "4b689ed9b94031f1ced06105b2617ccac539d60fece387450d2573695e0aef08" + }, + { + "path": "results/3d_monolayer_erodedDownsizedNuclei.csv", + "sha256": "9d640239186d1e243a251263f250761d8e0aacbd802952eda56d4ba3e4b758e0" + }, + { + "path": "results/3d_monolayer_erodedResizedNuclei.csv", + "sha256": "e49c8600995126ac6f9695896eaf5572567bace3a5872437f2b740ee73af308c" + } + ], + "exact_label_images": 120 + }, + { + "case": "cp_tutorial_3d_monolayer", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-plate-boundary-diagnostic-production-cp_tutorial_3d_monolayer-20260930", + "label": "plate-boundary", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-plate-transport-full-candidate-20260929/cp_tutorial_3d_monolayer/wells_1/workers_1/images_3d_monolayer_final_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/3d_monolayer_Cells.csv", + "sha256": "4d8c029000d5886e4cda889fd1c5f7f13ea31330ee34b1737feb190e2079b32d" + }, + { + "path": "results/3d_monolayer_Image.csv", + "sha256": "75ac32ff5ef57bc285ec4eae1c9b501c27a35b486bf35435af5d499d856d34a4" + }, + { + "path": "results/3d_monolayer_Nuclei.csv", + "sha256": "2acbac3e2cfa9b62f17d1fccaf8b079a47076b0ca842f652324cb0acdf2b905c" + }, + { + "path": "results/3d_monolayer_downsizedNuclei.csv", + "sha256": "4b689ed9b94031f1ced06105b2617ccac539d60fece387450d2573695e0aef08" + }, + { + "path": "results/3d_monolayer_erodedDownsizedNuclei.csv", + "sha256": "9d640239186d1e243a251263f250761d8e0aacbd802952eda56d4ba3e4b758e0" + }, + { + "path": "results/3d_monolayer_erodedResizedNuclei.csv", + "sha256": "e49c8600995126ac6f9695896eaf5572567bace3a5872437f2b740ee73af308c" + } + ], + "exact_label_images": 120 + } + ], + "means": { + "ExampleImagingFlowCytometryObjectsInGrid": { + "main": { + "compile_seconds": 1.7246606349945068, + "execute_seconds": 18.285399436950684, + "total_seconds": 20.772463601781055 + }, + "candidate": { + "compile_seconds": 1.7278814315795898, + "execute_seconds": 20.32276690006256, + "total_seconds": 22.77059645927511 + } + }, + "cp_tutorial_3d_monolayer": { + "main": { + "compile_seconds": 1.7805291414260864, + "execute_seconds": 8.578970074653625, + "total_seconds": 11.104258916340768 + }, + "candidate": { + "compile_seconds": 1.778443694114685, + "execute_seconds": 8.467295527458191, + "total_seconds": 10.936539251590148 + } + } + }, + "public_observations": 8, + "limits": "Unprofiled CPU5 sequential ABBA, shared current dependency pins and warmed declared kernel cache; mandatory readiness preparation precedes pipeline clocks. Server startup/shutdown excluded. 1w_1t selects InlineWorkerExecutorResources; fork is configured for multiworker processes. ImagingFlow has one requested combined spreadsheet and no persisted label outputs; 3D compares all six complete spreadsheets and120 persisted labels. Diagnostics are timing attribution only. No native CP/scaling refresh or whole-goal completion is claimed." +} diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-public-observations-20260930.json b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-public-observations-20260930.json new file mode 100644 index 0000000000..eb71be869d --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-public-observations-20260930.json @@ -0,0 +1,282 @@ +[ + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "index": 0, + "label": "main", + "source": "/home/ts/code/projects/openhcs", + "source_revision": "447c926346084b5da434edf5bef3a1a602792f5c", + "runtime_import": "/home/ts/code/projects/openhcs/openhcs/core/runtime_stores.py", + "runtime_sha256": "b7de53edda4d2d7abf39d052bf4b2f0079282efb7e1ed332aecc7a3a74ef0438", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.944549322128296", + "prepare_seconds": "0.0", + "execute_seconds": "19.26464295387268", + "total_seconds": "21.96428576670587", + "wells_per_second": "0.051908566506755564", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2545.4765625", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "46fd388a00f03ecb90ebeb942623e8633fe171c18c850c5378932a105109073d" + } + ], + "cli_seconds": 30.683438082691282 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "index": 1, + "label": "candidate", + "source": "/home/ts/code/projects/openhcs-compile-perf", + "source_revision": "e7500ae260305f8e4c7a587a1ab9b68f7e414549", + "runtime_import": "/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_stores.py", + "runtime_sha256": "856c2f201f713304ab63cfbaa4bfaed59841d997b2ed76b6725e95724d580053", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-ExampleImagingFlowCytometryObjectsInGrid-1-candidate-20260930", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.5198655128479004", + "prepare_seconds": "0.0", + "execute_seconds": "19.53387999534607", + "total_seconds": "21.75780025497079", + "wells_per_second": "0.05119310655324232", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2726.0546875", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "8d22604ab07a5075f9f3b912e425037556c915f34741029c817cc9c487c4bb82" + } + ], + "cli_seconds": 54.659147483762354 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "index": 2, + "label": "candidate", + "source": "/home/ts/code/projects/openhcs-compile-perf", + "source_revision": "e7500ae260305f8e4c7a587a1ab9b68f7e414549", + "runtime_import": "/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_stores.py", + "runtime_sha256": "856c2f201f713304ab63cfbaa4bfaed59841d997b2ed76b6725e95724d580053", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-ExampleImagingFlowCytometryObjectsInGrid-2-candidate-20260930", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.9358973503112793", + "prepare_seconds": "0.0", + "execute_seconds": "21.111653804779053", + "total_seconds": "23.783392663579434", + "wells_per_second": "0.047367203405619965", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2233.1640625", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "8d22604ab07a5075f9f3b912e425037556c915f34741029c817cc9c487c4bb82" + } + ], + "cli_seconds": 33.80502866534516 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "index": 3, + "label": "main", + "source": "/home/ts/code/projects/openhcs", + "source_revision": "447c926346084b5da434edf5bef3a1a602792f5c", + "runtime_import": "/home/ts/code/projects/openhcs/openhcs/core/runtime_stores.py", + "runtime_sha256": "b7de53edda4d2d7abf39d052bf4b2f0079282efb7e1ed332aecc7a3a74ef0438", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-ExampleImagingFlowCytometryObjectsInGrid-3-main-20260930", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.5047719478607178", + "prepare_seconds": "0.0", + "execute_seconds": "17.306155920028687", + "total_seconds": "19.58064143685624", + "wells_per_second": "0.05778290711241566", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2603.6640625", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "46fd388a00f03ecb90ebeb942623e8633fe171c18c850c5378932a105109073d" + } + ], + "cli_seconds": 41.53069085069001 + }, + { + "case": "cp_tutorial_3d_monolayer", + "index": 0, + "label": "main", + "source": "/home/ts/code/projects/openhcs", + "source_revision": "447c926346084b5da434edf5bef3a1a602792f5c", + "runtime_import": "/home/ts/code/projects/openhcs/openhcs/core/runtime_stores.py", + "runtime_sha256": "b7de53edda4d2d7abf39d052bf4b2f0079282efb7e1ed332aecc7a3a74ef0438", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-cp_tutorial_3d_monolayer-0-main-20260930", + "rows": [ + { + "case_name": "cp_tutorial_3d_monolayer", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.889394998550415", + "prepare_seconds": "0.0", + "execute_seconds": "8.576169967651367", + "total_seconds": "11.244689151644707", + "wells_per_second": "0.11660216667485844", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "1446.16796875", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "b9f55c7eed6ca5d3a8e901f04d4d7637c1a89d5a41f677682abbb4c5257db6fb" + } + ], + "cli_seconds": 20.699423050973564 + }, + { + "case": "cp_tutorial_3d_monolayer", + "index": 1, + "label": "candidate", + "source": "/home/ts/code/projects/openhcs-compile-perf", + "source_revision": "e7500ae260305f8e4c7a587a1ab9b68f7e414549", + "runtime_import": "/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_stores.py", + "runtime_sha256": "856c2f201f713304ab63cfbaa4bfaed59841d997b2ed76b6725e95724d580053", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-cp_tutorial_3d_monolayer-1-candidate-20260930", + "rows": [ + { + "case_name": "cp_tutorial_3d_monolayer", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.742201566696167", + "prepare_seconds": "0.0", + "execute_seconds": "8.472699880599976", + "total_seconds": "10.930816314183176", + "wells_per_second": "0.11802613264866255", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "1539.53125", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "6e38b252bc64069f348eb68a5e37c6e56e2e6c520c43139de72f14c08025af8b" + } + ], + "cli_seconds": 32.382107578683645 + }, + { + "case": "cp_tutorial_3d_monolayer", + "index": 2, + "label": "candidate", + "source": "/home/ts/code/projects/openhcs-compile-perf", + "source_revision": "e7500ae260305f8e4c7a587a1ab9b68f7e414549", + "runtime_import": "/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_stores.py", + "runtime_sha256": "856c2f201f713304ab63cfbaa4bfaed59841d997b2ed76b6725e95724d580053", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-cp_tutorial_3d_monolayer-2-candidate-20260930", + "rows": [ + { + "case_name": "cp_tutorial_3d_monolayer", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.8146858215332031", + "prepare_seconds": "0.0", + "execute_seconds": "8.461891174316406", + "total_seconds": "10.94226218899712", + "wells_per_second": "0.11817689206819479", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "1414.99609375", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "6e38b252bc64069f348eb68a5e37c6e56e2e6c520c43139de72f14c08025af8b" + } + ], + "cli_seconds": 19.51060658413917 + }, + { + "case": "cp_tutorial_3d_monolayer", + "index": 3, + "label": "main", + "source": "/home/ts/code/projects/openhcs", + "source_revision": "447c926346084b5da434edf5bef3a1a602792f5c", + "runtime_import": "/home/ts/code/projects/openhcs/openhcs/core/runtime_stores.py", + "runtime_sha256": "b7de53edda4d2d7abf39d052bf4b2f0079282efb7e1ed332aecc7a3a74ef0438", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-measurement-runtime-public-cp_tutorial_3d_monolayer-3-main-20260930", + "rows": [ + { + "case_name": "cp_tutorial_3d_monolayer", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.6716632843017578", + "prepare_seconds": "0.0", + "execute_seconds": "8.581770181655884", + "total_seconds": "10.96382868103683", + "wells_per_second": "0.11652607548703271", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "1563.6328125", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "b9f55c7eed6ca5d3a8e901f04d4d7637c1a89d5a41f677682abbb4c5257db6fb" + } + ], + "cli_seconds": 31.77321644499898 + } +] diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-refinement-20260930.diff b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-refinement-20260930.diff new file mode 100644 index 0000000000..a3ef7ebd30 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-refinement-20260930.diff @@ -0,0 +1,212 @@ +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/core/measurement_row_materialization.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/core/measurement_row_materialization.py +@@ -161,10 +161,8 @@ + def __len__(self) -> int: + return self.row_count() + +- + def __iter__(self): + yield from self.iter_row_mappings() +- + + + class MeasurementRowDeclaredValue(ABC, metaclass=AutoRegisterMeta): +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_artifact_queries.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_artifact_queries.py +@@ -80,6 +80,7 @@ + + if TYPE_CHECKING: + from openhcs.core.runtime_stores import RuntimeValueStore, StoredRuntimeValue ++ + + class RuntimeMeasurementTablesQueryCache( + ProcessLocalBoundedCache[ +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/interop/cellprofiler/runtime/object_label_measurements.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/interop/cellprofiler/runtime/object_label_measurements.py +@@ -218,8 +218,10 @@ + """Return object measurements aligned to this request's label planes.""" + label_domain = self.label_domain() + query = self.measurement_query(adapter, label_domain=label_domain) +- object_label_values_cache = adapter.request.context.runtime_value_store.query_cache( +- RuntimeObjectLabelMeasurementQueryCache ++ object_label_values_cache = ( ++ adapter.request.context.runtime_value_store.query_cache( ++ RuntimeObjectLabelMeasurementQueryCache ++ ) + ) + cached = object_label_values_cache.cached_value(query) + if cached is not None: +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/colocalization.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/colocalization.py +@@ -37,6 +37,7 @@ + ConcatenatedColumnarRows, + DataclassMeasurementColumnarRows, + MeasurementProjectedColumnarRows, ++ ObjectMeasurementColumnarRows, + ) + from openhcs.core.pipeline.function_contracts import ( + ObjectLabelInputExecutionMode, +@@ -160,9 +161,6 @@ + from openhcs.processing.backends.cellprofiler.granularity import ( + CellProfilerRuntimeProfiler, + ) +-from openhcs.core.measurement_row_materialization import ( +- ObjectMeasurementColumnarRows, +-) + from openhcs.processing.backends.lib_registry.unified_registry import ProcessingContract + from openhcs.interop.cellprofiler.runtime.artifact_binding import ( + RuntimeInputBindingRequest, +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/granularity.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/granularity.py +@@ -43,6 +43,7 @@ + ) + from openhcs.core.measurement_row_materialization import ( + DataclassMeasurementColumnarRows, ++ ObjectMeasurementColumnarRows, + ) + from openhcs.core.runtime_profile import RuntimeProfileLogger + from openhcs.core.runtime_tabular_values import ( +@@ -87,9 +88,6 @@ + CellProfilerBackendProvider, + CellProfilerBackendStrategyMixin, + ) +-from openhcs.core.measurement_row_materialization import ( +- ObjectMeasurementColumnarRows, +-) + from openhcs.processing.backends.lib_registry.unified_registry import ProcessingContract + from openhcs.processing.backends.cellprofiler._granularity_native import ( + reconstruct_f32 as _reconstruct_f32, +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/intensity.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/intensity.py +@@ -17,6 +17,7 @@ + from openhcs.core.measurement_row_materialization import ( + DataclassMeasurementColumnarRows, + MeasurementProjectedColumnarRows, ++ ObjectMeasurementColumnarRows, + ) + from openhcs.interop.cellprofiler.setting_names import SettingNameFamily + from openhcs.interop.cellprofiler.settings_binder import ( +@@ -314,9 +315,6 @@ + ObjectLabelValue, + object_label_dense_array, + ) +-from openhcs.core.measurement_row_materialization import ( +- ObjectMeasurementColumnarRows, +-) + from openhcs.core.runtime_profile import RuntimeProfileLogger + from openhcs.core.runtime_batch_contracts import RuntimeBatchInvocationRequest + from openhcs.interop.cellprofiler.runtime.measurement_execution_support import ( +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/intensity_distribution.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/intensity_distribution.py +@@ -33,6 +33,7 @@ + from openhcs.core.callable_contract import KeywordRuntimeParameter + from openhcs.core.measurement_row_materialization import ( + MeasurementProjectedColumnarRows, ++ ObjectMeasurementColumnarRows, + ) + from openhcs.core.memory.decorators import numpy + from openhcs.core.pipeline.function_contracts import ( +@@ -112,9 +113,6 @@ + ) + from openhcs.processing.backends.cellprofiler.granularity import ( + CellProfilerRuntimeProfiler, +-) +-from openhcs.core.measurement_row_materialization import ( +- ObjectMeasurementColumnarRows, + ) + from openhcs.processing.backends.cellprofiler.secondary import ( + SecondaryPropagationBackendStrategy, +@@ -1464,9 +1462,7 @@ + + + @dataclass(slots=True) +-class ObjectIntensityDistributionMeasurementColumnarRows( +- ObjectMeasurementColumnarRows +-): ++class ObjectIntensityDistributionMeasurementColumnarRows(ObjectMeasurementColumnarRows): + """Columnar radial intensity-distribution rows.""" + + object_row_identity = MeasurementObjectRowIdentity.LABEL_ID +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/shape.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/shape.py +@@ -448,6 +448,7 @@ + ) + from openhcs.core.measurement_row_materialization import ( + MeasurementProjectedColumnarRows, ++ ObjectMeasurementColumnarRows, + ) + from openhcs.core.runtime_tabular_values import ColumnarRows + from openhcs.core.runtime_object_labels import ( +@@ -457,9 +458,6 @@ + object_label_sparse_ijv_rows, + ) + from openhcs.core.runtime_sparse_labels import SparseIJVLabelRows +-from openhcs.core.measurement_row_materialization import ( +- ObjectMeasurementColumnarRows, +-) + from openhcs.processing.backends.analysis.region_properties import ( + LabelRegionPropertiesBackendStrategy, + ) +--- a/home/ts/code/projects/openhcs-compile-perf/tests/unit/test_cellprofiler_runtime_cache_authorities.py ++++ b/home/ts/code/projects/openhcs-compile-perf/tests/unit/test_cellprofiler_runtime_cache_authorities.py +@@ -48,7 +48,9 @@ + from openhcs.core.runtime_relationships import DirectedObjectRelationshipPayload + from openhcs.core.runtime_tabular_values import FieldSpec + from openhcs.core.runtime_stores import RuntimeValueStore +-from openhcs.core.measurement_feature_queries import RuntimeObjectLabelMeasurementQueryCache ++from openhcs.core.measurement_feature_queries import ( ++ RuntimeObjectLabelMeasurementQueryCache, ++) + from openhcs.interop.cellprofiler.runtime.object_label_measurements import ( + ObjectLabelMeasurementSliceRequest, + ) +@@ -238,7 +240,9 @@ + ) + query = request.measurement_query(adapter) + expected = (np.asarray([11.0], dtype=np.float64),) +- store.query_cache(RuntimeObjectLabelMeasurementQueryCache).store_value(query, expected) ++ store.query_cache(RuntimeObjectLabelMeasurementQueryCache).store_value( ++ query, expected ++ ) + + resolved = request.values(adapter) + +--- a/home/ts/code/projects/openhcs-compile-perf/tests/unit/test_runtime_value_store.py ++++ b/home/ts/code/projects/openhcs-compile-perf/tests/unit/test_runtime_value_store.py +@@ -165,7 +165,9 @@ + store.clear() + else: + worker = RuntimeValueStore() +- worker.record(_runtime_value("worker"), path="/memory/worker.pkl", backend="memory") ++ worker.record( ++ _runtime_value("worker"), path="/memory/worker.pkl", backend="memory" ++ ) + store.merge_observed_values(worker.observed_values) + + assert label_cache.cached_value(query) is None +@@ -212,9 +214,22 @@ + restored = pickle.loads(serialized_without_cache) + assert restored.revision == store.revision + assert len(restored) == len(store) == 1 +- assert restored.observed_values[0].value.data.row_mappings() == value.data.row_mappings() +- assert restored.query_cache(RuntimeObjectLabelMeasurementQueryCache).cached_value(query) is None +- assert restored.query_cache(RuntimeMeasurementTablesQueryCache).cached_value(("A01", "DAPI")) is None ++ assert ( ++ restored.observed_values[0].value.data.row_mappings() ++ == value.data.row_mappings() ++ ) ++ assert ( ++ restored.query_cache(RuntimeObjectLabelMeasurementQueryCache).cached_value( ++ query ++ ) ++ is None ++ ) ++ assert ( ++ restored.query_cache(RuntimeMeasurementTablesQueryCache).cached_value( ++ ("A01", "DAPI") ++ ) ++ is None ++ ) + assert cache.cached_value(query) is values + + diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-unchanged-main-materialization-20260930.xml.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-unchanged-main-materialization-20260930.xml.gz new file mode 100644 index 0000000000..9827bbcb3a Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-measurement-runtime-unchanged-main-materialization-20260930.xml.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-application-20260930.log b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-application-20260930.log new file mode 100644 index 0000000000..e5862874dc --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-application-20260930.log @@ -0,0 +1,14 @@ +Initial declaration-selected rename/move/base simulation passed; no source applied. +Traceback (most recent call last): + File "/tmp/move_generic_numba_preparation_owner_20260930.py", line 93, in + provider = replace_once(provider, identity + '\n\n', '') + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/tmp/move_generic_numba_preparation_owner_20260930.py", line 61, in replace_once + assert text.count(old) == 1, old + ^^^^^^^^^^^^^^^^^^^^ +AssertionError: @property + def identity(self) -> Hashable: + return type(self) + + + diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-application-corrected-20260930.log b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-application-corrected-20260930.log new file mode 100644 index 0000000000..05cfe3c61f --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-application-corrected-20260930.log @@ -0,0 +1,2 @@ +Initial declaration-selected rename/move/base simulation passed; no source applied. +('/home/ts/code/projects/openhcs-compile-perf/openhcs/core/processing_preparation.py', '/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/_backend.py', '/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/_preparation.py') diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-complete-simulation-20260930.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-complete-simulation-20260930.json.gz new file mode 100644 index 0000000000..89479339c6 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-complete-simulation-20260930.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-consumer-test-20260930.diff b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-consumer-test-20260930.diff new file mode 100644 index 0000000000..acdfe30b7d --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-consumer-test-20260930.diff @@ -0,0 +1,50 @@ +--- a/home/ts/code/projects/openhcs-compile-perf/tests/unit/test_cellprofiler_callable_kernel_preparation.py ++++ b/home/ts/code/projects/openhcs-compile-perf/tests/unit/test_cellprofiler_callable_kernel_preparation.py +@@ -39,6 +39,47 @@ + process.__module__ = module.__name__ + process.__openhcs_prepare__ = hook + return process ++ ++ ++def test_generic_kernel_registry_prepares_non_cellprofiler_families_once( ++ monkeypatch, kernel_module, tmp_path ++): ++ from openhcs.core.processing_preparation import ( ++ PersistentNumbaKernelPreparation, ++ RegisteredNumbaKernelPreparation, ++ ) ++ ++ events = [] ++ ++ class FirstKernel(RegisteredNumbaKernelPreparation, metaclass=AutoRegisterMeta): ++ __registry__ = {} ++ ++ def execute(self): ++ events.append("first") ++ ++ class SecondKernel(RegisteredNumbaKernelPreparation, metaclass=AutoRegisterMeta): ++ __registry__ = {} ++ ++ def execute(self): ++ events.append("second") ++ ++ kernel_module.FirstKernel = FirstKernel ++ kernel_module.SecondKernel = SecondKernel ++ kernel_module.__openhcs_prepare__ = lambda: events.append("module") ++ process = declare_callable(kernel_module, lambda: events.append("callable")) ++ monkeypatch.setenv("OPENHCS_CPU_ONLY", "true") ++ monkeypatch.setattr(numba_config, "CACHE_DIR", str(tmp_path / "cache")) ++ # A provider-specific capture flag must not suppress independent kernels. ++ monkeypatch.setenv("OPENHCS_CAPTURE_CELLPROFILER_FIXTURES_DIR", str(tmp_path)) ++ assert FirstKernel.can_prepare_in_child() ++ assert SecondKernel.can_prepare_in_child() ++ assert FirstKernel.__registry__ is not SecondKernel.__registry__ ++ assert "__registry__" not in vars(PersistentNumbaKernelPreparation) ++ assert "__registry__" not in vars(RegisteredNumbaKernelPreparation) ++ ++ prepare_processing_callable(process) ++ prepare_processing_callable(process) ++ assert events == ["first", "second", "module", "callable"] + + + def test_real_declarations_own_independent_registry_obligations(): diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-initial-simulation-20260930.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-initial-simulation-20260930.json.gz new file mode 100644 index 0000000000..8b144a6dc9 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-initial-simulation-20260930.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-transaction-20260930.diff b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-transaction-20260930.diff new file mode 100644 index 0000000000..2de1761043 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-numba-owner-transaction-20260930.diff @@ -0,0 +1,186 @@ +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/core/processing_preparation.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/core/processing_preparation.py +@@ -13,6 +13,7 @@ + from itertools import islice + from multiprocessing.connection import Connection, wait + from multiprocessing.process import BaseProcess ++from pathlib import Path + from threading import Lock + from typing import ClassVar + +@@ -23,6 +24,30 @@ + CompilerPreparedAutoRegisterFamily, + ) + from openhcs.core.function_contract_metadata import FunctionContractAttribute ++from openhcs.utils.environment import OpenHCSProcessEnvironment ++ ++ ++class PersistentNumbaKernelPreparation(CompilerPreparedAutoRegisterFamily): ++ """Admit persistent Numba work only for an empty explicit CPU cache.""" ++ ++ @classmethod ++ def requires_persistent_kernel_cache(cls) -> bool: ++ """Declared pure kernel operations require a persistent Numba cache.""" ++ return True ++ ++ @classmethod ++ def can_prepare_in_child(cls) -> bool: ++ if not OpenHCSProcessEnvironment.cpu_only_mode(): ++ return False ++ if not cls.requires_persistent_kernel_cache(): ++ return False ++ from numba import config as numba_config ++ ++ cache_directory = numba_config.CACHE_DIR ++ return ( ++ bool(cache_directory) ++ and next(Path(cache_directory).rglob("*.nbi"), None) is None ++ ) + + + class PreparationOperation(ABC): +@@ -64,6 +89,33 @@ + with cls._lock: + cls._completed.clear() + AutoRegisterRegistryPreparation.cached_module_registry_families.cache_clear() ++ ++ ++class RegisteredNumbaKernelPreparation( ++ PersistentNumbaKernelPreparation, PreparationOperation ++): ++ """Derive independent pure-kernel obligations from each declared registry. ++ ++ This abstract parent has no registry. Concrete AutoRegisterMeta declarations ++ own their registries; the common parent owns identity, operation derivation ++ and successful parent preparation. ++ """ ++ ++ __registry_key__ = "__name__" ++ __registry__: ClassVar[dict[str, type[RegisteredNumbaKernelPreparation]]] ++ ++ @property ++ def identity(self) -> Hashable: ++ return type(self) ++ ++ @classmethod ++ def cache_preparation_operations(cls) -> tuple[PreparationOperation, ...]: ++ return tuple(declaration() for declaration in cls.__registry__.values()) ++ ++ @classmethod ++ def prepare_registered_family(cls) -> None: ++ for operation in cls.cache_preparation_operations(): ++ operation.prepare() + + + @dataclass(frozen=True, slots=True) +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/_backend.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/_backend.py +@@ -12,15 +12,9 @@ + from metaclass_registry import AutoRegisterMeta + + from openhcs.constants.constants import MemoryType +-from openhcs.core.callable_contract import ( +- CallableContract, +- CompilerPreparedAutoRegisterFamily, +-) ++from openhcs.core.callable_contract import CallableContract ++from openhcs.core.processing_preparation import PersistentNumbaKernelPreparation + from openhcs.core.runtime_plane_projection import RuntimeSliceInvariantValue +-from openhcs.processing.backends.cellprofiler._preparation import ( +- CellProfilerKernelCachePreparationMixin, +-) +- + + class CellProfilerBackendProvider(str, Enum): + """Typed CellProfiler-compatible backend provider identifiers.""" +@@ -280,9 +274,7 @@ + ) + + +-class CellProfilerBackendStrategyMixin( +- CellProfilerKernelCachePreparationMixin, CompilerPreparedAutoRegisterFamily +-): ++class CellProfilerBackendStrategyMixin(PersistentNumbaKernelPreparation): + """Mixin for backend strategies keyed by OpenHCS memory type and provider. + + Concrete strategy families keep their own AutoRegisterMeta registry; this +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/_preparation.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/processing/backends/cellprofiler/_preparation.py +@@ -2,55 +2,12 @@ + + from __future__ import annotations + +-from collections.abc import Hashable +-from pathlib import Path +-from typing import ClassVar +- +-from openhcs.core.callable_contract import CompilerPreparedAutoRegisterFamily +-from openhcs.core.processing_preparation import PreparationOperation +-from openhcs.utils.environment import OpenHCSProcessEnvironment ++from openhcs.core.processing_preparation import RegisteredNumbaKernelPreparation + from openhcs.processing.backends.cellprofiler.perf_fixtures import capture_enabled + + +-class CellProfilerKernelCachePreparationMixin: +- """Admit persistent Numba work only for an empty explicit CPU cache.""" +- +- @classmethod +- def requires_persistent_kernel_cache(cls) -> bool: +- """Declared pure kernel operations require a persistent Numba cache.""" +- return True +- +- @classmethod +- def can_prepare_in_child(cls) -> bool: +- if not OpenHCSProcessEnvironment.cpu_only_mode(): +- return False +- if not cls.requires_persistent_kernel_cache(): +- return False +- from numba import config as numba_config +- +- cache_directory = numba_config.CACHE_DIR +- return ( +- bool(cache_directory) +- and next(Path(cache_directory).rglob("*.nbi"), None) is None +- ) +- +- +-class CellProfilerCallableKernelPreparation( +- CellProfilerKernelCachePreparationMixin, +- PreparationOperation, +- CompilerPreparedAutoRegisterFamily, +-): +- """Own pure kernel work; concrete declarations own independent registries. +- +- This abstract protocol has no registry. AutoRegisterMeta creates one on +- each direct concrete declaration, deriving child work from the existing +- module registry discovery without inspecting callable or module hooks. +- Parent registry preparation owns kernel readiness. Generic callable hooks +- retain their independent completion and effect phase. +- """ +- +- __registry_key__ = "__name__" +- __registry__: ClassVar[dict[str, type[CellProfilerCallableKernelPreparation]]] ++class CellProfilerCallableKernelPreparation(RegisteredNumbaKernelPreparation): ++ """Keep CellProfiler fixture capture in the parent processing hook.""" + + @classmethod + def can_prepare_in_child(cls) -> bool: +@@ -59,17 +16,8 @@ + return False + return super().can_prepare_in_child() + +- @property +- def identity(self) -> Hashable: +- return type(self) +- +- @classmethod +- def cache_preparation_operations(cls) -> tuple[PreparationOperation, ...]: +- return tuple(declaration() for declaration in cls.__registry__.values()) +- + @classmethod + def prepare_registered_family(cls) -> None: + if capture_enabled(): + return +- for operation in cls.cache_preparation_operations(): +- operation.prepare() ++ super().prepare_registered_family() diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-cache-lifetime-refinement-20260930.diff b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-cache-lifetime-refinement-20260930.diff new file mode 100644 index 0000000000..0fda6cc93f --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-cache-lifetime-refinement-20260930.diff @@ -0,0 +1,96 @@ +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/core/measurement_feature_queries.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/core/measurement_feature_queries.py +@@ -31,7 +31,7 @@ + ) + from openhcs.core.process_local_cache import ( + IdentityBoundProcessCache, +- ProcessLocalBoundedCache, ++ BoundedCache, + RegisteredProcessLocalBoundedCache, + identity_owner_tuples_match, + ) +@@ -153,7 +153,7 @@ + + + class RuntimeObjectLabelMeasurementQueryCache( +- ProcessLocalBoundedCache[ ++ BoundedCache[ + RuntimeObjectLabelMeasurementQuery, + tuple[np.ndarray, ...], + ] +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/core/process_local_cache.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/core/process_local_cache.py +@@ -40,8 +40,8 @@ + + + @dataclass(slots=True) +-class ProcessLocalBoundedCache(Generic[CacheKey, CachedValue]): +- """Bounded LRU cache with one singleton instance per concrete subclass.""" ++class BoundedCache(Generic[CacheKey, CachedValue]): ++ """Bounded LRU values with lifetime supplied by their owning consumer.""" + + max_entries: int = 4096 + entries: OrderedDict[CacheKey, CachedValue] = field(default_factory=OrderedDict) +@@ -63,6 +63,11 @@ + def clear(self) -> None: + """Discard all values retained by this process-local cache instance.""" + self.entries.clear() ++ ++ ++@dataclass(slots=True) ++class ProcessLocalBoundedCache(BoundedCache[CacheKey, CachedValue]): ++ """Bounded values with one process-local singleton per concrete subclass.""" + + @classmethod + def process_cache(cls) -> "ProcessLocalBoundedCache[CacheKey, CachedValue]": +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_artifact_queries.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_artifact_queries.py +@@ -38,7 +38,7 @@ + resolve_runtime_measurement_lookup_dialect, + ) + from openhcs.core.process_local_cache import ( +- ProcessLocalBoundedCache, ++ BoundedCache, + RegisteredProcessLocalBoundedCache, + identity_owner_tuples_match, + named_identity_owner_tuples_match, +@@ -83,7 +83,7 @@ + + + class RuntimeMeasurementTablesQueryCache( +- ProcessLocalBoundedCache[ ++ BoundedCache[ + tuple[str, str | None], + tuple[MeasurementTable, ...], + ] +--- a/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_stores.py ++++ b/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_stores.py +@@ -26,7 +26,7 @@ + ComponentGroupScope, + ) + from openhcs.core.component_set import ComponentSet +-from openhcs.core.process_local_cache import ProcessLocalBoundedCache ++from openhcs.core.process_local_cache import BoundedCache + from openhcs.core.function_patterns import InvocationArtifactInputEdgePlan + from openhcs.core.runtime_artifact_values import ( + ArtifactKey, +@@ -812,7 +812,7 @@ + return dict(payload) + + +-StoreQueryCacheT = TypeVar("StoreQueryCacheT", bound=ProcessLocalBoundedCache[Any, Any]) ++StoreQueryCacheT = TypeVar("StoreQueryCacheT", bound=BoundedCache[Any, Any]) + + + class RuntimeValueStore: +@@ -827,8 +827,8 @@ + self._current_location_by_key: dict[ArtifactKey, RuntimeArtifactLocation] = {} + self._revision = 0 + self._query_caches: dict[ +- type[ProcessLocalBoundedCache[Any, Any]], +- ProcessLocalBoundedCache[Any, Any], ++ type[BoundedCache[Any, Any]], ++ BoundedCache[Any, Any], + ] = {} + self._find_cache: dict[ + tuple[ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-global-gc-diagnostic-observations-20260930.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-global-gc-diagnostic-observations-20260930.json.gz new file mode 100644 index 0000000000..44b43d9c0c Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-global-gc-diagnostic-observations-20260930.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-global-gc-overlap-20260930.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-global-gc-overlap-20260930.json.gz new file mode 100644 index 0000000000..f2fcb5577c Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-global-gc-overlap-20260930.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-imaging-confirmation-observations-20260930.json b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-imaging-confirmation-observations-20260930.json new file mode 100644 index 0000000000..b342f9aaf6 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-imaging-confirmation-observations-20260930.json @@ -0,0 +1,126 @@ +[ + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "index": 0, + "label": "candidate", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-imaging-confirmation-0-candidate-20260930", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.974999189376831", + "prepare_seconds": "0.0", + "execute_seconds": "17.312246084213257", + "total_seconds": "19.956717803142965", + "wells_per_second": "0.05776258003355688", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2537.04296875", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "8d22604ab07a5075f9f3b912e425037556c915f34741029c817cc9c487c4bb82" + } + ], + "csv_sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "index": 1, + "label": "main", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-imaging-confirmation-1-main-20260930", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.5193252563476562", + "prepare_seconds": "0.0", + "execute_seconds": "16.02342963218689", + "total_seconds": "18.275223518256098", + "wells_per_second": "0.062408611823729726", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2602.6640625", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "46fd388a00f03ecb90ebeb942623e8633fe171c18c850c5378932a105109073d" + } + ], + "csv_sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "index": 2, + "label": "main", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-imaging-confirmation-2-main-20260930", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.960972547531128", + "prepare_seconds": "0.0", + "execute_seconds": "17.503740549087524", + "total_seconds": "20.144600269384682", + "wells_per_second": "0.05713064571516003", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2541.3984375", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "46fd388a00f03ecb90ebeb942623e8633fe171c18c850c5378932a105109073d" + } + ], + "csv_sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "index": 3, + "label": "candidate", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-imaging-confirmation-3-candidate-20260930", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.5604984760284424", + "prepare_seconds": "0.0", + "execute_seconds": "17.66849160194397", + "total_seconds": "19.967063021846116", + "wells_per_second": "0.05659792711959494", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2402.03125", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "8d22604ab07a5075f9f3b912e425037556c915f34741029c817cc9c487c4bb82" + } + ], + "csv_sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + } +] diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-complete-native-artifact-parity-20260930.json b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-complete-native-artifact-parity-20260930.json new file mode 100644 index 0000000000..3d97717a7c --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-complete-native-artifact-parity-20260930.json @@ -0,0 +1,159 @@ +[ + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "main_revision": "74eac059f67389ca071055c93fcbdd556ba79f1a", + "candidate_revision": "eba8e5c871a84b5ddd2581d7562798223ebd2415", + "exact_images": [ + "results/W001_w1_bf1__qa_checkpoint__declump_response_step8.tif", + "results/W001_w1_bf1__qa_checkpoint__initial_components_step8.tif", + "results/W001_w1_bf1__qa_checkpoint__seed_markers_step8.tif", + "results/W001_w1_bf1__qa_checkpoint__seed_maxima_step8.tif", + "results/W001_w1_bf1__qa_checkpoint__small_removed_objects_step8.tif", + "results/W001_w1_bf1__qa_checkpoint__threshold_support_step8.tif", + "results/W001_w1_bf1__qa_checkpoint__unedited_objects_step8.tif", + "results/W001_w1_bf1_step8.labels.tif" + ], + "exact_native_roi_archives": [ + { + "path": "results/W001_s001_w1_z001_t001_bf1_step8_rois.roi.zip", + "native_roi_count": 986, + "members": 987 + }, + { + "path": "results/W001_s002_w1_z001_t001_bf1_step8_rois.roi.zip", + "native_roi_count": 270, + "members": 271 + } + ], + "normalization": "Only explicit run-directory prefixes in JSON source addresses; ZIP container timestamps are not scientific content. All native ROI members are byte-exact; all TIFF series pixels/dtype/shape/axes and physical/source metadata match." + }, + { + "case": "cp_tutorial_3d_monolayer", + "main_revision": "74eac059f67389ca071055c93fcbdd556ba79f1a", + "candidate_revision": "eba8e5c871a84b5ddd2581d7562798223ebd2415", + "exact_images": [ + "images/W001_s001_w0_z001_t001_CellsLabels.tiff", + "images/W001_s001_w0_z002_t001_CellsLabels.tiff", + "images/W001_s001_w0_z003_t001_CellsLabels.tiff", + "images/W001_s001_w0_z004_t001_CellsLabels.tiff", + "images/W001_s001_w0_z005_t001_CellsLabels.tiff", + "images/W001_s001_w0_z006_t001_CellsLabels.tiff", + "images/W001_s001_w0_z007_t001_CellsLabels.tiff", + "images/W001_s001_w0_z008_t001_CellsLabels.tiff", + "images/W001_s001_w0_z009_t001_CellsLabels.tiff", + "images/W001_s001_w0_z010_t001_CellsLabels.tiff", + "images/W001_s001_w0_z011_t001_CellsLabels.tiff", + "images/W001_s001_w0_z012_t001_CellsLabels.tiff", + "images/W001_s001_w0_z013_t001_CellsLabels.tiff", + "images/W001_s001_w0_z014_t001_CellsLabels.tiff", + "images/W001_s001_w0_z015_t001_CellsLabels.tiff", + "images/W001_s001_w0_z016_t001_CellsLabels.tiff", + "images/W001_s001_w0_z017_t001_CellsLabels.tiff", + "images/W001_s001_w0_z018_t001_CellsLabels.tiff", + "images/W001_s001_w0_z019_t001_CellsLabels.tiff", + "images/W001_s001_w0_z020_t001_CellsLabels.tiff", + "images/W001_s001_w0_z021_t001_CellsLabels.tiff", + "images/W001_s001_w0_z022_t001_CellsLabels.tiff", + "images/W001_s001_w0_z023_t001_CellsLabels.tiff", + "images/W001_s001_w0_z024_t001_CellsLabels.tiff", + "images/W001_s001_w0_z025_t001_CellsLabels.tiff", + "images/W001_s001_w0_z026_t001_CellsLabels.tiff", + "images/W001_s001_w0_z027_t001_CellsLabels.tiff", + "images/W001_s001_w0_z028_t001_CellsLabels.tiff", + "images/W001_s001_w0_z029_t001_CellsLabels.tiff", + "images/W001_s001_w0_z030_t001_CellsLabels.tiff", + "images/W001_s001_w0_z031_t001_CellsLabels.tiff", + "images/W001_s001_w0_z032_t001_CellsLabels.tiff", + "images/W001_s001_w0_z033_t001_CellsLabels.tiff", + "images/W001_s001_w0_z034_t001_CellsLabels.tiff", + "images/W001_s001_w0_z035_t001_CellsLabels.tiff", + "images/W001_s001_w0_z036_t001_CellsLabels.tiff", + "images/W001_s001_w0_z037_t001_CellsLabels.tiff", + "images/W001_s001_w0_z038_t001_CellsLabels.tiff", + "images/W001_s001_w0_z039_t001_CellsLabels.tiff", + "images/W001_s001_w0_z040_t001_CellsLabels.tiff", + "images/W001_s001_w0_z041_t001_CellsLabels.tiff", + "images/W001_s001_w0_z042_t001_CellsLabels.tiff", + "images/W001_s001_w0_z043_t001_CellsLabels.tiff", + "images/W001_s001_w0_z044_t001_CellsLabels.tiff", + "images/W001_s001_w0_z045_t001_CellsLabels.tiff", + "images/W001_s001_w0_z046_t001_CellsLabels.tiff", + "images/W001_s001_w0_z047_t001_CellsLabels.tiff", + "images/W001_s001_w0_z048_t001_CellsLabels.tiff", + "images/W001_s001_w0_z049_t001_CellsLabels.tiff", + "images/W001_s001_w0_z050_t001_CellsLabels.tiff", + "images/W001_s001_w0_z051_t001_CellsLabels.tiff", + "images/W001_s001_w0_z052_t001_CellsLabels.tiff", + "images/W001_s001_w0_z053_t001_CellsLabels.tiff", + "images/W001_s001_w0_z054_t001_CellsLabels.tiff", + "images/W001_s001_w0_z055_t001_CellsLabels.tiff", + "images/W001_s001_w0_z056_t001_CellsLabels.tiff", + "images/W001_s001_w0_z057_t001_CellsLabels.tiff", + "images/W001_s001_w0_z058_t001_CellsLabels.tiff", + "images/W001_s001_w0_z059_t001_CellsLabels.tiff", + "images/W001_s001_w0_z060_t001_CellsLabels.tiff", + "images/W001_s001_w2_z001_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z002_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z003_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z004_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z005_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z006_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z007_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z008_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z009_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z010_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z011_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z012_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z013_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z014_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z015_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z016_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z017_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z018_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z019_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z020_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z021_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z022_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z023_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z024_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z025_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z026_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z027_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z028_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z029_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z030_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z031_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z032_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z033_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z034_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z035_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z036_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z037_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z038_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z039_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z040_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z041_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z042_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z043_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z044_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z045_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z046_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z047_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z048_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z049_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z050_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z051_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z052_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z053_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z054_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z055_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z056_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z057_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z058_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z059_t001_NucleiLabels.tiff", + "images/W001_s001_w2_z060_t001_NucleiLabels.tiff" + ], + "exact_native_roi_archives": [], + "normalization": "Only explicit run-directory prefixes in JSON source addresses; ZIP container timestamps are not scientific content. All native ROI members are byte-exact; all TIFF series pixels/dtype/shape/axes and physical/source metadata match." + } +] diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-complete-public-comparison-20260930.json b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-complete-public-comparison-20260930.json new file mode 100644 index 0000000000..741a18be8a --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-complete-public-comparison-20260930.json @@ -0,0 +1,242 @@ +{ + "parity": [ + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930", + "label": "main", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930/ExampleImagingFlowCytometryObjectsInGrid/wells_1/workers_1/images_ExampleImagingFlowCytometryObjectsInGrid_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/BF_cells_on_grid.csv", + "sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + } + ], + "exact_label_images": 0 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-ExampleImagingFlowCytometryObjectsInGrid-1-candidate-20260930", + "label": "candidate", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930/ExampleImagingFlowCytometryObjectsInGrid/wells_1/workers_1/images_ExampleImagingFlowCytometryObjectsInGrid_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/BF_cells_on_grid.csv", + "sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + } + ], + "exact_label_images": 0 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-ExampleImagingFlowCytometryObjectsInGrid-2-candidate-20260930", + "label": "candidate", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930/ExampleImagingFlowCytometryObjectsInGrid/wells_1/workers_1/images_ExampleImagingFlowCytometryObjectsInGrid_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/BF_cells_on_grid.csv", + "sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + } + ], + "exact_label_images": 0 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-ExampleImagingFlowCytometryObjectsInGrid-3-main-20260930", + "label": "main", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930/ExampleImagingFlowCytometryObjectsInGrid/wells_1/workers_1/images_ExampleImagingFlowCytometryObjectsInGrid_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/BF_cells_on_grid.csv", + "sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + } + ], + "exact_label_images": 0 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-phase-diagnostic-production-main-20260930", + "label": "main-diagnostic", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930/ExampleImagingFlowCytometryObjectsInGrid/wells_1/workers_1/images_ExampleImagingFlowCytometryObjectsInGrid_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/BF_cells_on_grid.csv", + "sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + } + ], + "exact_label_images": 0 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-phase-diagnostic-production-candidate-20260930", + "label": "candidate-diagnostic", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930/ExampleImagingFlowCytometryObjectsInGrid/wells_1/workers_1/images_ExampleImagingFlowCytometryObjectsInGrid_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/BF_cells_on_grid.csv", + "sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + } + ], + "exact_label_images": 0 + }, + { + "case": "cp_tutorial_3d_monolayer", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-cp_tutorial_3d_monolayer-0-main-20260930", + "label": "main", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-plate-transport-full-candidate-20260929/cp_tutorial_3d_monolayer/wells_1/workers_1/images_3d_monolayer_final_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/3d_monolayer_Cells.csv", + "sha256": "4d8c029000d5886e4cda889fd1c5f7f13ea31330ee34b1737feb190e2079b32d" + }, + { + "path": "results/3d_monolayer_Image.csv", + "sha256": "75ac32ff5ef57bc285ec4eae1c9b501c27a35b486bf35435af5d499d856d34a4" + }, + { + "path": "results/3d_monolayer_Nuclei.csv", + "sha256": "2acbac3e2cfa9b62f17d1fccaf8b079a47076b0ca842f652324cb0acdf2b905c" + }, + { + "path": "results/3d_monolayer_downsizedNuclei.csv", + "sha256": "4b689ed9b94031f1ced06105b2617ccac539d60fece387450d2573695e0aef08" + }, + { + "path": "results/3d_monolayer_erodedDownsizedNuclei.csv", + "sha256": "9d640239186d1e243a251263f250761d8e0aacbd802952eda56d4ba3e4b758e0" + }, + { + "path": "results/3d_monolayer_erodedResizedNuclei.csv", + "sha256": "e49c8600995126ac6f9695896eaf5572567bace3a5872437f2b740ee73af308c" + } + ], + "exact_label_images": 120 + }, + { + "case": "cp_tutorial_3d_monolayer", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-cp_tutorial_3d_monolayer-1-candidate-20260930", + "label": "candidate", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-plate-transport-full-candidate-20260929/cp_tutorial_3d_monolayer/wells_1/workers_1/images_3d_monolayer_final_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/3d_monolayer_Cells.csv", + "sha256": "4d8c029000d5886e4cda889fd1c5f7f13ea31330ee34b1737feb190e2079b32d" + }, + { + "path": "results/3d_monolayer_Image.csv", + "sha256": "75ac32ff5ef57bc285ec4eae1c9b501c27a35b486bf35435af5d499d856d34a4" + }, + { + "path": "results/3d_monolayer_Nuclei.csv", + "sha256": "2acbac3e2cfa9b62f17d1fccaf8b079a47076b0ca842f652324cb0acdf2b905c" + }, + { + "path": "results/3d_monolayer_downsizedNuclei.csv", + "sha256": "4b689ed9b94031f1ced06105b2617ccac539d60fece387450d2573695e0aef08" + }, + { + "path": "results/3d_monolayer_erodedDownsizedNuclei.csv", + "sha256": "9d640239186d1e243a251263f250761d8e0aacbd802952eda56d4ba3e4b758e0" + }, + { + "path": "results/3d_monolayer_erodedResizedNuclei.csv", + "sha256": "e49c8600995126ac6f9695896eaf5572567bace3a5872437f2b740ee73af308c" + } + ], + "exact_label_images": 120 + }, + { + "case": "cp_tutorial_3d_monolayer", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-cp_tutorial_3d_monolayer-2-candidate-20260930", + "label": "candidate", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-plate-transport-full-candidate-20260929/cp_tutorial_3d_monolayer/wells_1/workers_1/images_3d_monolayer_final_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/3d_monolayer_Cells.csv", + "sha256": "4d8c029000d5886e4cda889fd1c5f7f13ea31330ee34b1737feb190e2079b32d" + }, + { + "path": "results/3d_monolayer_Image.csv", + "sha256": "75ac32ff5ef57bc285ec4eae1c9b501c27a35b486bf35435af5d499d856d34a4" + }, + { + "path": "results/3d_monolayer_Nuclei.csv", + "sha256": "2acbac3e2cfa9b62f17d1fccaf8b079a47076b0ca842f652324cb0acdf2b905c" + }, + { + "path": "results/3d_monolayer_downsizedNuclei.csv", + "sha256": "4b689ed9b94031f1ced06105b2617ccac539d60fece387450d2573695e0aef08" + }, + { + "path": "results/3d_monolayer_erodedDownsizedNuclei.csv", + "sha256": "9d640239186d1e243a251263f250761d8e0aacbd802952eda56d4ba3e4b758e0" + }, + { + "path": "results/3d_monolayer_erodedResizedNuclei.csv", + "sha256": "e49c8600995126ac6f9695896eaf5572567bace3a5872437f2b740ee73af308c" + } + ], + "exact_label_images": 120 + }, + { + "case": "cp_tutorial_3d_monolayer", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-cp_tutorial_3d_monolayer-3-main-20260930", + "label": "main", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-plate-transport-full-candidate-20260929/cp_tutorial_3d_monolayer/wells_1/workers_1/images_3d_monolayer_final_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/3d_monolayer_Cells.csv", + "sha256": "4d8c029000d5886e4cda889fd1c5f7f13ea31330ee34b1737feb190e2079b32d" + }, + { + "path": "results/3d_monolayer_Image.csv", + "sha256": "75ac32ff5ef57bc285ec4eae1c9b501c27a35b486bf35435af5d499d856d34a4" + }, + { + "path": "results/3d_monolayer_Nuclei.csv", + "sha256": "2acbac3e2cfa9b62f17d1fccaf8b079a47076b0ca842f652324cb0acdf2b905c" + }, + { + "path": "results/3d_monolayer_downsizedNuclei.csv", + "sha256": "4b689ed9b94031f1ced06105b2617ccac539d60fece387450d2573695e0aef08" + }, + { + "path": "results/3d_monolayer_erodedDownsizedNuclei.csv", + "sha256": "9d640239186d1e243a251263f250761d8e0aacbd802952eda56d4ba3e4b758e0" + }, + { + "path": "results/3d_monolayer_erodedResizedNuclei.csv", + "sha256": "e49c8600995126ac6f9695896eaf5572567bace3a5872437f2b740ee73af308c" + } + ], + "exact_label_images": 120 + } + ], + "means": { + "ExampleImagingFlowCytometryObjectsInGrid": { + "main": { + "compile_seconds": 1.740203857421875, + "execute_seconds": 18.20097017288208, + "total_seconds": 20.68897635070607 + }, + "candidate": { + "compile_seconds": 1.732829213142395, + "execute_seconds": 17.05138075351715, + "total_seconds": 19.45638925023377 + } + }, + "cp_tutorial_3d_monolayer": { + "main": { + "compile_seconds": 1.7364786863327026, + "execute_seconds": 8.582533955574036, + "total_seconds": 11.024320675292984 + }, + "candidate": { + "compile_seconds": 1.7398372888565063, + "execute_seconds": 8.30009913444519, + "total_seconds": 10.760253278538585 + } + } + }, + "public_observations": 8, + "limits": "Unprofiled CPU5 sequential ABBA, shared current dependency pins and warmed declared kernel cache; mandatory readiness preparation precedes pipeline clocks. Server startup/shutdown excluded. 1w_1t selects InlineWorkerExecutorResources; fork is configured for multiworker processes. ImagingFlow has one requested combined spreadsheet and no persisted label outputs; 3D compares all six complete spreadsheets and120 persisted labels. Diagnostics are timing attribution only. No native CP/scaling refresh or whole-goal completion is claimed." +} diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-complete-public-observations-20260930.json b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-complete-public-observations-20260930.json new file mode 100644 index 0000000000..1073c59b3e --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-complete-public-observations-20260930.json @@ -0,0 +1,282 @@ +[ + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "index": 0, + "label": "main", + "source": "/home/ts/code/projects/openhcs", + "source_revision": "8e478cb21f89fe74c3d6ead0cb54c67a5e1047dc", + "runtime_import": "/home/ts/code/projects/openhcs/openhcs/core/runtime_stores.py", + "runtime_sha256": "b7de53edda4d2d7abf39d052bf4b2f0079282efb7e1ed332aecc7a3a74ef0438", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.9565770626068115", + "prepare_seconds": "0.0", + "execute_seconds": "16.431968212127686", + "total_seconds": "19.104486318305135", + "wells_per_second": "0.06085698238278879", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2562.51171875", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "db1219c5b159e6833e050878f0ca2fcec519de2c42d21501e3b0fa16a51f7543" + } + ], + "cli_seconds": 28.711489841807634 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "index": 1, + "label": "candidate", + "source": "/home/ts/code/projects/openhcs-compile-perf", + "source_revision": "aff922837632b9336af16f4beb2ad2653a46821e", + "runtime_import": "/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_stores.py", + "runtime_sha256": "5c68d952a8e86d70bb1d3a0b48a0cc6e3bdc04e39057dd8b9391d2ee14ef8167", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-ExampleImagingFlowCytometryObjectsInGrid-1-candidate-20260930", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.5156481266021729", + "prepare_seconds": "0.0", + "execute_seconds": "17.098694324493408", + "total_seconds": "19.284983435180038", + "wells_per_second": "0.05848399772651223", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2584.0546875", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "308b15301ae26e3c386f34a80f73740ce56ce86e06f2619df72958c653664c8a" + } + ], + "cli_seconds": 40.94556597014889 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "index": 2, + "label": "candidate", + "source": "/home/ts/code/projects/openhcs-compile-perf", + "source_revision": "aff922837632b9336af16f4beb2ad2653a46821e", + "runtime_import": "/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_stores.py", + "runtime_sha256": "5c68d952a8e86d70bb1d3a0b48a0cc6e3bdc04e39057dd8b9391d2ee14ef8167", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-ExampleImagingFlowCytometryObjectsInGrid-2-candidate-20260930", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.9500102996826172", + "prepare_seconds": "0.0", + "execute_seconds": "17.004067182540894", + "total_seconds": "19.6277950652875", + "wells_per_second": "0.05880945948195033", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2516.55078125", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "308b15301ae26e3c386f34a80f73740ce56ce86e06f2619df72958c653664c8a" + } + ], + "cli_seconds": 28.650908724870533 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "index": 3, + "label": "main", + "source": "/home/ts/code/projects/openhcs", + "source_revision": "8e478cb21f89fe74c3d6ead0cb54c67a5e1047dc", + "runtime_import": "/home/ts/code/projects/openhcs/openhcs/core/runtime_stores.py", + "runtime_sha256": "b7de53edda4d2d7abf39d052bf4b2f0079282efb7e1ed332aecc7a3a74ef0438", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-ExampleImagingFlowCytometryObjectsInGrid-3-main-20260930", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.5238306522369385", + "prepare_seconds": "0.0", + "execute_seconds": "19.969972133636475", + "total_seconds": "22.273466383107007", + "wells_per_second": "0.050075182544478736", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2130.3984375", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "db1219c5b159e6833e050878f0ca2fcec519de2c42d21501e3b0fa16a51f7543" + } + ], + "cli_seconds": 44.04017790593207 + }, + { + "case": "cp_tutorial_3d_monolayer", + "index": 0, + "label": "main", + "source": "/home/ts/code/projects/openhcs", + "source_revision": "8e478cb21f89fe74c3d6ead0cb54c67a5e1047dc", + "runtime_import": "/home/ts/code/projects/openhcs/openhcs/core/runtime_stores.py", + "runtime_sha256": "b7de53edda4d2d7abf39d052bf4b2f0079282efb7e1ed332aecc7a3a74ef0438", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-cp_tutorial_3d_monolayer-0-main-20260930", + "rows": [ + { + "case_name": "cp_tutorial_3d_monolayer", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.8216681480407715", + "prepare_seconds": "0.0", + "execute_seconds": "8.508339405059814", + "total_seconds": "11.053738381713629", + "wells_per_second": "0.11753174766456909", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "1431.390625", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "9445e2147a0eb20033f983b4ab39e2b853f91533eb3dcbeb4d31416c3eb63b7e" + } + ], + "cli_seconds": 19.692984067834914 + }, + { + "case": "cp_tutorial_3d_monolayer", + "index": 1, + "label": "candidate", + "source": "/home/ts/code/projects/openhcs-compile-perf", + "source_revision": "aff922837632b9336af16f4beb2ad2653a46821e", + "runtime_import": "/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_stores.py", + "runtime_sha256": "5c68d952a8e86d70bb1d3a0b48a0cc6e3bdc04e39057dd8b9391d2ee14ef8167", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-cp_tutorial_3d_monolayer-1-candidate-20260930", + "rows": [ + { + "case_name": "cp_tutorial_3d_monolayer", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.6764357089996338", + "prepare_seconds": "0.0", + "execute_seconds": "8.17212462425232", + "total_seconds": "10.570601303130388", + "wells_per_second": "0.12236719898180598", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "1574.55859375", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "1fb6fe69f4bb6b34967442ed6e6628a5897e330771ab65efe36a9560fd540088" + } + ], + "cli_seconds": 31.47478622291237 + }, + { + "case": "cp_tutorial_3d_monolayer", + "index": 2, + "label": "candidate", + "source": "/home/ts/code/projects/openhcs-compile-perf", + "source_revision": "aff922837632b9336af16f4beb2ad2653a46821e", + "runtime_import": "/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_stores.py", + "runtime_sha256": "5c68d952a8e86d70bb1d3a0b48a0cc6e3bdc04e39057dd8b9391d2ee14ef8167", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-cp_tutorial_3d_monolayer-2-candidate-20260930", + "rows": [ + { + "case_name": "cp_tutorial_3d_monolayer", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.803238868713379", + "prepare_seconds": "0.0", + "execute_seconds": "8.428073644638062", + "total_seconds": "10.949905253946781", + "wells_per_second": "0.11865107522360104", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "1406.6328125", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "1fb6fe69f4bb6b34967442ed6e6628a5897e330771ab65efe36a9560fd540088" + } + ], + "cli_seconds": 19.538009203970432 + }, + { + "case": "cp_tutorial_3d_monolayer", + "index": 3, + "label": "main", + "source": "/home/ts/code/projects/openhcs", + "source_revision": "8e478cb21f89fe74c3d6ead0cb54c67a5e1047dc", + "runtime_import": "/home/ts/code/projects/openhcs/openhcs/core/runtime_stores.py", + "runtime_sha256": "b7de53edda4d2d7abf39d052bf4b2f0079282efb7e1ed332aecc7a3a74ef0438", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-complete-public-cp_tutorial_3d_monolayer-3-main-20260930", + "rows": [ + { + "case_name": "cp_tutorial_3d_monolayer", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.6512892246246338", + "prepare_seconds": "0.0", + "execute_seconds": "8.656728506088257", + "total_seconds": "10.994902968872339", + "wells_per_second": "0.11551708007207369", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "1544.6015625", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "9445e2147a0eb20033f983b4ab39e2b853f91533eb3dcbeb4d31416c3eb63b7e" + } + ], + "cli_seconds": 31.615673600230366 + } +] diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-census-20260930.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-census-20260930.json.gz new file mode 100644 index 0000000000..c2d2136632 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-census-20260930.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-consumers-20260930.xml.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-consumers-20260930.xml.gz new file mode 100644 index 0000000000..6de5fbfeeb Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-consumers-20260930.xml.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-public-comparison-20260930.json b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-public-comparison-20260930.json new file mode 100644 index 0000000000..d1ad1d4231 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-public-comparison-20260930.json @@ -0,0 +1,124 @@ +{ + "parity": [ + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-paired-main-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930", + "label": "main", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-paired-main-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930/ExampleImagingFlowCytometryObjectsInGrid/wells_1/workers_1/images_ExampleImagingFlowCytometryObjectsInGrid_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/BF_cells_on_grid.csv", + "sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + } + ], + "exact_label_images": 0 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-paired-main-public-ExampleImagingFlowCytometryObjectsInGrid-1-candidate-20260930", + "label": "candidate", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-paired-main-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930/ExampleImagingFlowCytometryObjectsInGrid/wells_1/workers_1/images_ExampleImagingFlowCytometryObjectsInGrid_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/BF_cells_on_grid.csv", + "sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c" + } + ], + "exact_label_images": 0 + }, + { + "case": "cp_tutorial_3d_monolayer", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-paired-main-public-cp_tutorial_3d_monolayer-0-main-20260930", + "label": "main", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-plate-transport-full-candidate-20260929/cp_tutorial_3d_monolayer/wells_1/workers_1/images_3d_monolayer_final_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/3d_monolayer_Cells.csv", + "sha256": "4d8c029000d5886e4cda889fd1c5f7f13ea31330ee34b1737feb190e2079b32d" + }, + { + "path": "results/3d_monolayer_Image.csv", + "sha256": "75ac32ff5ef57bc285ec4eae1c9b501c27a35b486bf35435af5d499d856d34a4" + }, + { + "path": "results/3d_monolayer_Nuclei.csv", + "sha256": "2acbac3e2cfa9b62f17d1fccaf8b079a47076b0ca842f652324cb0acdf2b905c" + }, + { + "path": "results/3d_monolayer_downsizedNuclei.csv", + "sha256": "4b689ed9b94031f1ced06105b2617ccac539d60fece387450d2573695e0aef08" + }, + { + "path": "results/3d_monolayer_erodedDownsizedNuclei.csv", + "sha256": "9d640239186d1e243a251263f250761d8e0aacbd802952eda56d4ba3e4b758e0" + }, + { + "path": "results/3d_monolayer_erodedResizedNuclei.csv", + "sha256": "e49c8600995126ac6f9695896eaf5572567bace3a5872437f2b740ee73af308c" + } + ], + "exact_label_images": 120 + }, + { + "case": "cp_tutorial_3d_monolayer", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-paired-main-public-cp_tutorial_3d_monolayer-1-candidate-20260930", + "label": "candidate", + "control": "/home/ts/code/projects/openhcs-benchmark-runs/perf-plate-transport-full-candidate-20260929/cp_tutorial_3d_monolayer/wells_1/workers_1/images_3d_monolayer_final_source_workspace_well_throughput", + "byte_exact_csvs": [ + { + "path": "results/3d_monolayer_Cells.csv", + "sha256": "4d8c029000d5886e4cda889fd1c5f7f13ea31330ee34b1737feb190e2079b32d" + }, + { + "path": "results/3d_monolayer_Image.csv", + "sha256": "75ac32ff5ef57bc285ec4eae1c9b501c27a35b486bf35435af5d499d856d34a4" + }, + { + "path": "results/3d_monolayer_Nuclei.csv", + "sha256": "2acbac3e2cfa9b62f17d1fccaf8b079a47076b0ca842f652324cb0acdf2b905c" + }, + { + "path": "results/3d_monolayer_downsizedNuclei.csv", + "sha256": "4b689ed9b94031f1ced06105b2617ccac539d60fece387450d2573695e0aef08" + }, + { + "path": "results/3d_monolayer_erodedDownsizedNuclei.csv", + "sha256": "9d640239186d1e243a251263f250761d8e0aacbd802952eda56d4ba3e4b758e0" + }, + { + "path": "results/3d_monolayer_erodedResizedNuclei.csv", + "sha256": "e49c8600995126ac6f9695896eaf5572567bace3a5872437f2b740ee73af308c" + } + ], + "exact_label_images": 120 + } + ], + "means": { + "ExampleImagingFlowCytometryObjectsInGrid": { + "main": { + "compile_seconds": 1.5001981258392334, + "execute_seconds": 15.848503589630127, + "total_seconds": 18.06339219212532 + }, + "candidate": { + "compile_seconds": 1.5092723369598389, + "execute_seconds": 16.565940380096436, + "total_seconds": 18.740222160704434 + } + }, + "cp_tutorial_3d_monolayer": { + "main": { + "compile_seconds": 1.655738115310669, + "execute_seconds": 8.36199951171875, + "total_seconds": 10.77700023399666 + }, + "candidate": { + "compile_seconds": 1.6831753253936768, + "execute_seconds": 8.316172122955322, + "total_seconds": 10.753202839754522 + } + } + }, + "public_observations": 4, + "limits": "Unprofiled CPU5 sequential paired qualification after main PR317; two observations per case are parity/source qualification, not statistical performance evidence, shared current dependency pins and warmed declared kernel cache; mandatory readiness preparation precedes pipeline clocks. Server startup/shutdown excluded. 1w_1t selects InlineWorkerExecutorResources; fork is configured for multiworker processes. ImagingFlow has one requested combined spreadsheet and no persisted label outputs; 3D compares all six complete spreadsheets and120 persisted labels. Diagnostics are timing attribution only. No native CP/scaling refresh or whole-goal completion is claimed." +} diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-public-observations-20260930.json b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-public-observations-20260930.json new file mode 100644 index 0000000000..0302c8fa8a --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-public-observations-20260930.json @@ -0,0 +1,142 @@ +[ + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "index": 0, + "label": "main", + "source": "/home/ts/code/projects/openhcs", + "source_revision": "74eac059f67389ca071055c93fcbdd556ba79f1a", + "runtime_import": "/home/ts/code/projects/openhcs/openhcs/core/runtime_stores.py", + "runtime_sha256": "b7de53edda4d2d7abf39d052bf4b2f0079282efb7e1ed332aecc7a3a74ef0438", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-paired-main-public-ExampleImagingFlowCytometryObjectsInGrid-0-main-20260930", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.5001981258392334", + "prepare_seconds": "0.0", + "execute_seconds": "15.848503589630127", + "total_seconds": "18.06339219212532", + "wells_per_second": "0.06309743972637975", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2524.1328125", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "a66d2ec852ae6cdb16bb4c0b70d3f8a32c48b6044ae301be3611fa2db8351560" + } + ], + "cli_seconds": 28.73978745099157 + }, + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "index": 1, + "label": "candidate", + "source": "/home/ts/code/projects/openhcs-compile-perf", + "source_revision": "eba8e5c871a84b5ddd2581d7562798223ebd2415", + "runtime_import": "/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_stores.py", + "runtime_sha256": "5c68d952a8e86d70bb1d3a0b48a0cc6e3bdc04e39057dd8b9391d2ee14ef8167", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-paired-main-public-ExampleImagingFlowCytometryObjectsInGrid-1-candidate-20260930", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.5092723369598389", + "prepare_seconds": "0.0", + "execute_seconds": "16.565940380096436", + "total_seconds": "18.740222160704434", + "wells_per_second": "0.060364819446137516", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2584.3828125", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "03e0512487d859ace264e90f1e50a2b127ebc600e59aedfbc8d65b62e3628556" + } + ], + "cli_seconds": 39.863566623069346 + }, + { + "case": "cp_tutorial_3d_monolayer", + "index": 0, + "label": "main", + "source": "/home/ts/code/projects/openhcs", + "source_revision": "74eac059f67389ca071055c93fcbdd556ba79f1a", + "runtime_import": "/home/ts/code/projects/openhcs/openhcs/core/runtime_stores.py", + "runtime_sha256": "b7de53edda4d2d7abf39d052bf4b2f0079282efb7e1ed332aecc7a3a74ef0438", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-paired-main-public-cp_tutorial_3d_monolayer-0-main-20260930", + "rows": [ + { + "case_name": "cp_tutorial_3d_monolayer", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.655738115310669", + "prepare_seconds": "0.0", + "execute_seconds": "8.36199951171875", + "total_seconds": "10.77700023399666", + "wells_per_second": "0.11958862214696028", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "1550.23828125", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "aea4d49f55e391523f659db6eca1b7a18590833166348a0cba97f1bb5380039b" + } + ], + "cli_seconds": 31.87670122459531 + }, + { + "case": "cp_tutorial_3d_monolayer", + "index": 1, + "label": "candidate", + "source": "/home/ts/code/projects/openhcs-compile-perf", + "source_revision": "eba8e5c871a84b5ddd2581d7562798223ebd2415", + "runtime_import": "/home/ts/code/projects/openhcs-compile-perf/openhcs/core/runtime_stores.py", + "runtime_sha256": "5c68d952a8e86d70bb1d3a0b48a0cc6e3bdc04e39057dd8b9391d2ee14ef8167", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-owners-paired-main-public-cp_tutorial_3d_monolayer-1-candidate-20260930", + "rows": [ + { + "case_name": "cp_tutorial_3d_monolayer", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.6831753253936768", + "prepare_seconds": "0.0", + "execute_seconds": "8.316172122955322", + "total_seconds": "10.753202839754522", + "wells_per_second": "0.12024763138796477", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "1561.3671875", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "5cc07c45ab49b0f6426daf93160288605a5ae84dffd79fe9b75878c5372adf49" + } + ], + "cli_seconds": 33.588328421115875 + } +] diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-r0-benchmark-20260930.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-r0-benchmark-20260930.json.gz new file mode 100644 index 0000000000..c9cefbf2a2 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-r0-benchmark-20260930.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-r0-openhcs-20260930.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-r0-openhcs-20260930.json.gz new file mode 100644 index 0000000000..15451ec237 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-r0-openhcs-20260930.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-r0-scripts-20260930.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-r0-scripts-20260930.json.gz new file mode 100644 index 0000000000..97aa863509 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-r0-scripts-20260930.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-r1-20260930.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-r1-20260930.json.gz new file mode 100644 index 0000000000..9f57ed8cbf Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-owners-paired-main-r1-20260930.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-phase-diagnostic-20260930.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-phase-diagnostic-20260930.json.gz new file mode 100644 index 0000000000..191406a910 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-phase-diagnostic-20260930.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-phase-diagnostic-observations-20260930.json b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-phase-diagnostic-observations-20260930.json new file mode 100644 index 0000000000..d58e1b9a25 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-phase-diagnostic-observations-20260930.json @@ -0,0 +1,64 @@ +[ + { + "label": "candidate", + "source": "/home/ts/code/projects/openhcs-compile-perf", + "revision": "01e8994018c62cb4ea8a57d6786ed3f4f2e8b262", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-phase-diagnostic-production-candidate-20260930", + "csv_sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.9503471851348877", + "prepare_seconds": "0.0", + "execute_seconds": "16.848363876342773", + "total_seconds": "19.500764351338148", + "wells_per_second": "0.05935294413982393", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2514.421875", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "6e456862de003762993c25249e8ed045a41d346aa9ef5a6ca350d655fd61e47f" + } + ] + }, + { + "label": "main", + "source": "/home/ts/code/projects/openhcs", + "revision": "8e478cb21f89fe74c3d6ead0cb54c67a5e1047dc", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-phase-diagnostic-production-main-20260930", + "csv_sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.5249240398406982", + "prepare_seconds": "0.0", + "execute_seconds": "16.572738885879517", + "total_seconds": "18.796802475117147", + "wells_per_second": "0.06034005645572747", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2585.53125", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "db1219c5b159e6833e050878f0ca2fcec519de2c42d21501e3b0fa16a51f7543" + } + ] + } +] diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-query-hash-costs-20260930.json b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-query-hash-costs-20260930.json new file mode 100644 index 0000000000..d4a1f09b0f --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-query-hash-costs-20260930.json @@ -0,0 +1,22 @@ +{ + "main": { + "RuntimeValueStore._mark_mutated": [ + 57, + 0.00012560700997710228 + ] + }, + "candidate": { + "BoundedCache.cached_value": [ + 1623, + 0.0013636727817356586 + ], + "BoundedCache.store_value": [ + 587, + 0.0006533032283186913 + ], + "RuntimeValueStore._mark_mutated": [ + 57, + 0.00012847688049077988 + ] + } +} diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-query-hash-diagnostic-20260930.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-query-hash-diagnostic-20260930.json.gz new file mode 100644 index 0000000000..df813b183b Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-query-hash-diagnostic-20260930.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-query-hash-diagnostic-observations-20260930.json b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-query-hash-diagnostic-observations-20260930.json new file mode 100644 index 0000000000..83feae001a --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-generic-runtime-query-hash-diagnostic-observations-20260930.json @@ -0,0 +1,64 @@ +[ + { + "label": "candidate", + "source": "/home/ts/code/projects/openhcs-compile-perf", + "revision": "eba8e5c871a84b5ddd2581d7562798223ebd2415", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-query-hash-diagnostic-production-candidate-20260930", + "csv_sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "2.079096794128418", + "prepare_seconds": "0.0", + "execute_seconds": "16.885579586029053", + "total_seconds": "19.683796766214073", + "wells_per_second": "0.05922213062958107", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2523.31640625", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "03e0512487d859ace264e90f1e50a2b127ebc600e59aedfbc8d65b62e3628556" + } + ] + }, + { + "label": "main", + "source": "/home/ts/code/projects/openhcs", + "revision": "74eac059f67389ca071055c93fcbdd556ba79f1a", + "directory": "/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-query-hash-diagnostic-production-main-20260930", + "csv_sha256": "517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c", + "rows": [ + { + "case_name": "ExampleImagingFlowCytometryObjectsInGrid", + "mode_name": "1w_1t", + "worker_count": "1", + "well_count": "1", + "compile_seconds": "1.546459674835205", + "prepare_seconds": "0.0", + "execute_seconds": "16.987313270568848", + "total_seconds": "19.22593829082325", + "wells_per_second": "0.05886746091464253", + "successful_wells": "1", + "native_single_sample_execution_seconds": "", + "projected_native_execution_seconds": "", + "projected_execution_speedup": "", + "peak_memory_mb": "2641.8203125", + "status": "success", + "memory_limit_mb": "", + "error_message": "", + "execution_route": "ordinary-zmq-outcomes-v1", + "server_lifecycle": "reused-per-sweep", + "run_input_sha256": "a66d2ec852ae6cdb16bb4c0b70d3f8a32c48b6044ae301be3611fa2db8351560" + } + ] + } +] diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-granularity-active-spectra-production-replay-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-granularity-active-spectra-production-replay-20261001.json.gz new file mode 100644 index 0000000000..b6c5a42543 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-granularity-active-spectra-production-replay-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-granularity-constant-spectra-production-replay-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-granularity-constant-spectra-production-replay-20261001.json.gz new file mode 100644 index 0000000000..dc5c24c7dd Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-granularity-constant-spectra-production-replay-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-granularity-maxtree-admission-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-granularity-maxtree-admission-20261001.json.gz new file mode 100644 index 0000000000..4086527145 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-granularity-maxtree-admission-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-materialization-ack-current-main-corrected-20260930.xml.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-materialization-ack-current-main-corrected-20260930.xml.gz new file mode 100644 index 0000000000..6c1d822980 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-materialization-ack-current-main-corrected-20260930.xml.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-measurement-provenance-frontier-probe-20260930.json b/docs/validation/generic_runtime_owners_323_20260930/perf-measurement-provenance-frontier-probe-20260930.json new file mode 100644 index 0000000000..1b2c27389d --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/perf-measurement-provenance-frontier-probe-20260930.json @@ -0,0 +1,239 @@ +[ + { + "case": "ExampleImagingFlowCytometryObjectsInGrid", + "seconds": 15.902480440679938, + "tables": [ + { + "name": "IdentifyObjectsInGrid_2_measurements", + "rows": 5402, + "seconds": 0.9146803067997098 + }, + { + "name": "MeasureObjectIntensity_3_measurements", + "rows": 1800, + "seconds": 0.30835096491500735 + }, + { + "name": "FilterObjects_4_measurements", + "rows": 6434, + "seconds": 1.1209130799397826 + }, + { + "name": "IdentifyPrimaryObjects_9_measurements", + "rows": 3769, + "seconds": 0.7406154572963715 + }, + { + "name": "MeasureObjectSizeShape_10_measurements", + "rows": 1255, + "seconds": 0.24307905603200197 + }, + { + "name": "FilterObjects_11_measurements", + "rows": 6261, + "seconds": 1.2130544520914555 + }, + { + "name": "MeasureObjectSizeShape_12_measurements", + "rows": 1251, + "seconds": 0.23967546597123146 + }, + { + "name": "ExpandOrShrinkObjects_13_measurements", + "rows": 3476, + "seconds": 0.5791663671843708 + }, + { + "name": "RelateObjects_14_measurements", + "rows": 2409, + "seconds": 0.39704686822369695 + }, + { + "name": "FilterObjects_15_measurements", + "rows": 5853, + "seconds": 1.108292931690812 + }, + { + "name": "IdentifyObjectsInGrid_16_measurements", + "rows": 5402, + "seconds": 1.026462018955499 + }, + { + "name": "ExpandOrShrinkObjects_17_measurements", + "rows": 5402, + "seconds": 1.0228130859322846 + }, + { + "name": "MeasureObjectSizeShape_19_measurements", + "rows": 1800, + "seconds": 0.3441827157512307 + }, + { + "name": "MeasureGranularity_20_measurements", + "rows": 1143, + "seconds": 0.1928273760713637 + }, + { + "name": "MeasureGranularity_20_measurements", + "rows": 1143, + "seconds": 0.1900226939469576 + }, + { + "name": "MeasureGranularity_20_measurements", + "rows": 1143, + "seconds": 0.19123948505148292 + }, + { + "name": "MeasureGranularity_20_measurements", + "rows": 1143, + "seconds": 0.19496121490374207 + }, + { + "name": "MeasureGranularity_20_measurements", + "rows": 1143, + "seconds": 0.19372371397912502 + }, + { + "name": "MeasureGranularity_20_measurements", + "rows": 1143, + "seconds": 0.19216730305925012 + }, + { + "name": "MeasureTexture_21_measurements", + "rows": 8, + "seconds": 0.0015078401193022728 + }, + { + "name": "MeasureTexture_21_measurements", + "rows": 7200, + "seconds": 1.2095914999954402 + }, + { + "name": "MeasureTexture_21_measurements", + "rows": 8, + "seconds": 0.0015176893211901188 + }, + { + "name": "MeasureTexture_21_measurements", + "rows": 7200, + "seconds": 1.2010664553381503 + }, + { + "name": "MeasureTexture_21_measurements", + "rows": 8, + "seconds": 0.0015164860524237156 + }, + { + "name": "MeasureTexture_21_measurements", + "rows": 7200, + "seconds": 1.2162291309796274 + }, + { + "name": "MeasureObjectIntensity_22_measurements", + "rows": 1800, + "seconds": 0.30934798205271363 + }, + { + "name": "MeasureObjectIntensity_22_measurements", + "rows": 1800, + "seconds": 0.31158181885257363 + }, + { + "name": "MeasureObjectIntensity_22_measurements", + "rows": 1800, + "seconds": 0.3125721327960491 + }, + { + "name": "MeasureObjectIntensityDistribution_23_measurements", + "rows": 1800, + "seconds": 0.30725437914952636 + }, + { + "name": "MeasureObjectIntensityDistribution_23_measurements", + "rows": 1800, + "seconds": 0.31161525193601847 + }, + { + "name": "MeasureObjectIntensityDistribution_23_measurements", + "rows": 1800, + "seconds": 0.3054052162915468 + } + ] + }, + { + "case": "cp_tutorial_3d_monolayer", + "seconds": 0.1054967725649476, + "tables": [ + { + "name": "Threshold_4_measurements", + "rows": 1, + "seconds": 0.0002725329250097275 + }, + { + "name": "Watershed_6_measurements", + "rows": 67, + "seconds": 0.0035983570851385593 + }, + { + "name": "ResizeObjects_7_measurements", + "rows": 111, + "seconds": 0.012838078197091818 + }, + { + "name": "ErodeObjects_8_measurements", + "rows": 111, + "seconds": 0.013410675805062056 + }, + { + "name": "ResizeObjects_9_measurements", + "rows": 111, + "seconds": 0.013326278422027826 + }, + { + "name": "Threshold_11_measurements", + "rows": 1, + "seconds": 0.00014399131760001183 + }, + { + "name": "Threshold_18_measurements", + "rows": 1, + "seconds": 0.00013286061584949493 + }, + { + "name": "Watershed_21_measurements", + "rows": 61, + "seconds": 0.0032246927730739117 + }, + { + "name": "MeasureObjectIntensity_22_measurements", + "rows": 22, + "seconds": 0.0012074238620698452 + }, + { + "name": "MeasureObjectIntensity_22_measurements", + "rows": 20, + "seconds": 0.0010956129990518093 + }, + { + "name": "MeasureObjectIntensity_22_measurements", + "rows": 22, + "seconds": 0.0011865240521728992 + }, + { + "name": "MeasureObjectIntensity_22_measurements", + "rows": 20, + "seconds": 0.0010741427540779114 + }, + { + "name": "MeasureObjectSizeShape_23_measurements", + "rows": 22, + "seconds": 0.028056999668478966 + }, + { + "name": "MeasureObjectSizeShape_23_measurements", + "rows": 20, + "seconds": 0.02592860208824277 + } + ] + } +] diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-numerical-cache-owner-simulation-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-numerical-cache-owner-simulation-20261001.json.gz new file mode 100644 index 0000000000..59e36df308 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-numerical-cache-owner-simulation-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-numerical-cache-owner-transaction-20261001.diff.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-numerical-cache-owner-transaction-20261001.diff.gz new file mode 100644 index 0000000000..dd1ad53e98 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-numerical-cache-owner-transaction-20261001.diff.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-numerical-cache-owners-before-census-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-numerical-cache-owners-before-census-20261001.json.gz new file mode 100644 index 0000000000..bfdbaeb39a Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-numerical-cache-owners-before-census-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-numerical-cache-owners-public-comparison-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-numerical-cache-owners-public-comparison-20261001.json.gz new file mode 100644 index 0000000000..5b66a0a1aa Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-numerical-cache-owners-public-comparison-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-numerical-cache-owners-public-observations-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-numerical-cache-owners-public-observations-20261001.json.gz new file mode 100644 index 0000000000..e7a85a53cb Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-numerical-cache-owners-public-observations-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-census-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-census-20261001.json.gz new file mode 100644 index 0000000000..fc9cd5f9ee Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-census-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-combined-tests-20261001.xml.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-combined-tests-20261001.xml.gz new file mode 100644 index 0000000000..01317aff2e Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-combined-tests-20261001.xml.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-decision-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-decision-20261001.json.gz new file mode 100644 index 0000000000..92fb90e14e Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-decision-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-global-gc-diagnostic-observations-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-global-gc-diagnostic-observations-20261001.json.gz new file mode 100644 index 0000000000..bd577cf7fd Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-global-gc-diagnostic-observations-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-global-gc-overlap-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-global-gc-overlap-20261001.json.gz new file mode 100644 index 0000000000..7447a61c6d Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-global-gc-overlap-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-native-artifact-parity-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-native-artifact-parity-20261001.json.gz new file mode 100644 index 0000000000..64c7548874 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-native-artifact-parity-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-r0-benchmark-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-r0-benchmark-20261001.json.gz new file mode 100644 index 0000000000..8ebae02b05 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-r0-benchmark-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-r0-openhcs-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-r0-openhcs-20261001.json.gz new file mode 100644 index 0000000000..013b861ad3 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-r0-openhcs-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-r0-scripts-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-r0-scripts-20261001.json.gz new file mode 100644 index 0000000000..dc89aa25ed Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-r0-scripts-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-r1-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-r1-20261001.json.gz new file mode 100644 index 0000000000..da02b68ed8 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-r1-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-step-deltas-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-step-deltas-20261001.json.gz new file mode 100644 index 0000000000..715b42c8fe Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-closure-step-deltas-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-cpu-timeline-attribution-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-cpu-timeline-attribution-20261001.json.gz new file mode 100644 index 0000000000..7c96f8c9fa Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-cpu-timeline-attribution-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-cpu-timeline-observations-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-cpu-timeline-observations-20261001.json.gz new file mode 100644 index 0000000000..1e1572ede4 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-cpu-timeline-observations-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-fresh-native-fact-parity-20261001.log.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-fresh-native-fact-parity-20261001.log.gz new file mode 100644 index 0000000000..cd56f41e0b Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-fresh-native-fact-parity-20261001.log.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-fresh-native-reference-result-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-fresh-native-reference-result-20261001.json.gz new file mode 100644 index 0000000000..593fc88fdf Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-fresh-native-reference-result-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-fresh-native-table-parity-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-fresh-native-table-parity-20261001.json.gz new file mode 100644 index 0000000000..45f344603d Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-fresh-native-table-parity-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-native-binary-inventory-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-native-binary-inventory-20261001.json.gz new file mode 100644 index 0000000000..3d301c1232 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-native-binary-inventory-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-native-binary-sections-20261001.json.gz b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-native-binary-sections-20261001.json.gz new file mode 100644 index 0000000000..6632fec1e3 Binary files /dev/null and b/docs/validation/generic_runtime_owners_323_20260930/perf-runtime-owner-native-binary-sections-20261001.json.gz differ diff --git a/docs/validation/generic_runtime_owners_323_20260930/phase-diagnostic-sitecustomize.py.txt b/docs/validation/generic_runtime_owners_323_20260930/phase-diagnostic-sitecustomize.py.txt new file mode 100644 index 0000000000..ce6dd100c6 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/phase-diagnostic-sitecustomize.py.txt @@ -0,0 +1,156 @@ +"""Owner-thread diagnostic only: full step, finalization, and progress phases.""" +import functools +import gc +import hashlib +import importlib.abc +import importlib.machinery +import json +import os +import sys +import threading +import time +from pathlib import Path + +active = threading.local() +OUTPUT = Path('/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-phase-diagnostic-20260930') +TARGETS = { + 'openhcs.core.steps.function_runtime', + 'openhcs.core.steps.function_execution', + 'openhcs.core.orchestrator.worker_execution', +} + + +def record(label, seconds, **fields): + if not getattr(active, 'enabled', False): + return + selected = {key: str(value) for key, value in fields.items() + if key in ('function', 'module', 'step', 'step_name', 'count', 'group', 'kind')} + active.events.append({'label': label, 'seconds': seconds, 'fields': selected}) + + +def timed(original, label): + @functools.wraps(original) + def wrapper(*args, **kwargs): + if not getattr(active, 'enabled', False): + return original(*args, **kwargs) + started = time.perf_counter() + try: + return original(*args, **kwargs) + finally: + calls, seconds = active.stats.get(label, (0, 0.0)) + active.stats[label] = (calls + 1, seconds + time.perf_counter() - started) + return wrapper + + +def scoped(original, key_for_call): + @functools.wraps(original) + def wrapper(*args, **kwargs): + assert not getattr(active, 'enabled', False), original.__qualname__ + active.stats = {} + active.events = [] + active.gc_started = {} + active.enabled = True + started = time.perf_counter() + try: + return original(*args, **kwargs) + finally: + seconds = time.perf_counter() - started + active.enabled = False + key, fields = key_for_call(args, kwargs) + label = os.environ['OPENHCS_EXECUTION_DIAGNOSTIC_CASE'] + destination = OUTPUT / f'{label}-{key}.json' + assert not destination.exists(), destination + destination.write_text(json.dumps({ + 'seconds': seconds, 'thread': threading.get_ident(), + 'stats': active.stats, 'events': active.events, **fields, + })) + return wrapper + + +def gc_pause(phase, information): + if not getattr(active, 'enabled', False): + return + generation = information['generation'] + if phase == 'start': + active.gc_started[generation] = time.perf_counter() + elif generation in active.gc_started: + record('owner_thread_gc_pause', time.perf_counter() - active.gc_started.pop(generation), + count=information['collected']) + + +gc.callbacks.append(gc_pause) + + +class PhaseDiagnosticLoader(importlib.abc.Loader): + def __init__(self, loader): + self.loader = loader + + def create_module(self, spec): + return self.loader.create_module(spec) + + def exec_module(self, module): + self.loader.exec_module(module) + expected = Path(os.environ['OPENHCS_DIAGNOSTIC_SOURCE']) / (module.__name__.replace('.', '/') + '.py') + assert Path(module.__file__).resolve() == expected + if module.__name__ == 'openhcs.core.steps.function_runtime': + from openhcs.core import runtime_profile + from openhcs.core.source_image_provenance import SourceImageIdentity + from openhcs.core.runtime_image_values import ImagePayloadMetadata + from numba.core.dispatcher import Dispatcher + runtime_profile.RuntimeProfileLogger.enabled = staticmethod(lambda: getattr(active, 'enabled', False)) + runtime_profile.RuntimeProfileLogger.log = classmethod(lambda cls, logger, label, seconds, **fields: record(label, seconds, **fields)) + module.RuntimeProfileSink.record = classmethod(lambda cls, label, seconds, **fields: record(label, seconds, **fields)) + for owner, name in ((SourceImageIdentity, 'component_metadata_with_missing_from'), + (ImagePayloadMetadata, 'for_leading_source_plane')): + setattr(owner, name, timed(getattr(owner, name), owner.__name__ + '.' + name)) + for name in ('execute', 'invoke', 'load_artifact_inputs', 'save_artifact_outputs', + 'bind_runtime_adapter', 'execution_group_source_payload'): + setattr(module.FunctionCoreExecutor, name, timed(getattr(module.FunctionCoreExecutor, name), 'FunctionCoreExecutor.' + name)) + for name in ('run', '_load_input_stack', '_execute_pattern', '_validate_and_unstack', '_save_outputs', + '_apply_source_image_loading_semantics', '_apply_workspace_source_payload', + '_apply_workspace_source_binding_payload', '_apply_source_binding_payload'): + setattr(module.PatternGroupRuntime, name, timed(getattr(module.PatternGroupRuntime, name), 'PatternGroupRuntime.' + name)) + module.MainFlowMemoryConversion.converted_payload = timed(module.MainFlowMemoryConversion.converted_payload, 'MainFlowMemoryConversion.converted_payload') + original_compile = Dispatcher.compile + + @functools.wraps(original_compile) + def compile_diagnostic(dispatcher, *args, **kwargs): + if not getattr(active, 'enabled', False): + return original_compile(dispatcher, *args, **kwargs) + started = time.perf_counter() + try: + return original_compile(dispatcher, *args, **kwargs) + finally: + record('numba_compile', time.perf_counter() - started, + module=dispatcher.py_func.__module__, function=dispatcher.py_func.__name__) + Dispatcher.compile = compile_diagnostic + elif module.__name__ == 'openhcs.core.steps.function_execution': + def execution_key(args, kwargs): + plan = args[0].plan + return f'step-{plan.step_index}-execution', {'step_index': plan.step_index, 'step_name': plan.step_name} + module.FunctionStepExecutor.run = scoped(module.FunctionStepExecutor.run, execution_key) + elif module.__name__ == 'openhcs.core.orchestrator.worker_execution': + def progress_key(args, kwargs): + plan = kwargs['plan'] + return f'step-{plan.step_index}-progress', {'step_index': plan.step_index, 'step_name': plan.step_name, 'record_count': len(args[0])} + module._runtime_observation_progress_context = scoped(module._runtime_observation_progress_context, progress_key) + emit_sequence = 0 + + def emit_key(args, kwargs): + nonlocal emit_sequence + emit_sequence += 1 + return f'emit-{emit_sequence}', {'step_name': kwargs['step_name'], 'phase': kwargs['phase'].value} + module.emit = scoped(module.emit, emit_key) + + +class PhaseDiagnosticFinder(importlib.abc.MetaPathFinder): + def find_spec(self, fullname, path=None, target=None): + if fullname not in TARGETS: + return None + spec = importlib.machinery.PathFinder.find_spec(fullname, path, target) + assert spec is not None and isinstance(spec.loader, importlib.machinery.SourceFileLoader) + spec.loader = PhaseDiagnosticLoader(spec.loader) + return spec + + +sys.meta_path.insert(0, PhaseDiagnosticFinder()) diff --git a/docs/validation/generic_runtime_owners_323_20260930/prototype_granularity_active_spectra_20261001.cpp.txt b/docs/validation/generic_runtime_owners_323_20260930/prototype_granularity_active_spectra_20261001.cpp.txt new file mode 100644 index 0000000000..d168b48f36 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/prototype_granularity_active_spectra_20261001.cpp.txt @@ -0,0 +1,101 @@ +#include +#include + +enum PixelFlag : uint16_t { SpectraMask=31, HasUp=32, HasDown=64, HasLeft=128, HasRight=256 }; + +static inline void enqueue(uint32_t index, uint16_t active, uint32_t* queue, uint16_t* flags, + uint32_t& tail, uint32_t& count, uint32_t capacity) { + if (!active) return; + if (!(flags[index] & SpectraMask)) { + queue[tail] = index; + if (++tail == capacity) tail = 0; + ++count; + } + flags[index] |= active; +} + +template +static inline uint16_t update(float* out, const float* mask, uint32_t neighbor, + const float (&source)[Levels], uint16_t active) { + float* target = out + static_cast(neighbor) * Levels; + const float bound = mask[neighbor]; + uint16_t changed = 0; + for (uint32_t k=0; k bound ? bound : source[k]; + const bool raised = !(value <= target[k]); + target[k] = raised ? value : target[k]; + changed |= raised ? (1u << k) : 0; + } + return changed; +} + +template +static void reconstruct(const float* __restrict seed, const float* __restrict mask, + float* __restrict out, uint32_t height, uint32_t width, + uint32_t* __restrict queue, uint16_t* __restrict flags, uint64_t* counters) { + const uint32_t capacity = height * width; + std::memcpy(out, seed, static_cast(capacity) * Levels * sizeof(float)); + for (uint32_t row=0; row0 ? HasUp : 0) | (row+10 ? HasLeft : 0) | (col+1(index) * Levels; + for (uint32_t k=0; k0 && values[static_cast(k)-static_cast(width)*Levels]>value) value = values[static_cast(k)-static_cast(width)*Levels]; + if (col>0 && values[static_cast(k)-Levels]>value) value = values[static_cast(k)-Levels]; + if (value>bound) value = bound; + values[k] = value; + } + } + } + uint32_t head=0, tail=0, count=0; + for (uint32_t row=height; row-- > 0;) { + const uint32_t base = row * width; + for (uint32_t col=width; col-- > 0;) { + const uint32_t index = base + col; + const float bound = mask[index]; + float* values = out + static_cast(index) * Levels; + uint16_t active = 0; + for (uint32_t k=0; kvalue) value = values[k+width*Levels]; + if (col+1value) value = values[k+Levels]; + if (value>bound) value = bound; + values[k] = value; + if (row>0 && values[static_cast(k)-static_cast(width)*Levels](k)-static_cast(width)*Levels]0 && values[static_cast(k)-Levels](k)-Levels]0) { + const uint32_t index = queue[head]; + const uint16_t state = flags[index]; + const uint16_t active = state & SpectraMask; + ++counters[0]; + counters[1] += __builtin_popcount(active); + flags[index] = state & ~SpectraMask; + if (++head==capacity) head=0; + --count; + float source[Levels]; + std::memcpy(source,out+static_cast(index)*Levels,sizeof(source)); + if (state&HasUp) enqueue(index-width,update(out,mask,index-width,source,active),queue,flags,tail,count,capacity); + if (state&HasDown) enqueue(index+width,update(out,mask,index+width,source,active),queue,flags,tail,count,capacity); + if (state&HasLeft) enqueue(index-1,update(out,mask,index-1,source,active),queue,flags,tail,count,capacity); + if (state&HasRight) enqueue(index+1,update(out,mask,index+1,source,active),queue,flags,tail,count,capacity); + } +} + +extern "C" void reconstruct_five(const float* seed, const float* mask, float* out, + uint32_t height, uint32_t width, + uint32_t* queue, uint16_t* flags, uint64_t* counters) { + counters[0]=0; counters[1]=0; + reconstruct<5>(seed,mask,out,height,width,queue,flags,counters); +} diff --git a/docs/validation/generic_runtime_owners_323_20260930/prototype_granularity_constant_spectra_20261001.cpp.txt b/docs/validation/generic_runtime_owners_323_20260930/prototype_granularity_constant_spectra_20261001.cpp.txt new file mode 100644 index 0000000000..deb475bec7 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/prototype_granularity_constant_spectra_20261001.cpp.txt @@ -0,0 +1,94 @@ +#include +#include + +enum PixelFlag : uint8_t { Queued=1, HasUp=2, HasDown=4, HasLeft=8, HasRight=16 }; + +static inline void enqueue(uint32_t index, uint32_t* queue, uint8_t* flags, + uint32_t& tail, uint32_t& count, uint32_t capacity) { + if (flags[index] & Queued) return; + flags[index] |= Queued; + queue[tail] = index; + if (++tail == capacity) tail = 0; + ++count; +} + +template +static inline bool update(float* out, const float* mask, uint32_t neighbor, + const float (&source)[Levels]) { + float* target = out + static_cast(neighbor) * Levels; + const float bound = mask[neighbor]; + bool changed = false; + for (uint32_t k=0; k bound ? bound : source[k]; + const bool raised = !(value <= target[k]); + target[k] = raised ? value : target[k]; + changed |= raised; + } + return changed; +} + +template +static void reconstruct(const float* __restrict seed, const float* __restrict mask, + float* __restrict out, uint32_t height, uint32_t width, + uint32_t* __restrict queue, uint8_t* __restrict flags) { + const uint32_t capacity = height * width; + std::memcpy(out, seed, static_cast(capacity) * Levels * sizeof(float)); + for (uint32_t row=0; row0 ? HasUp : 0) | (row+10 ? HasLeft : 0) | (col+1(index) * Levels; + for (uint32_t k=0; k0 && values[static_cast(k)-static_cast(width)*Levels]>value) value = values[static_cast(k)-static_cast(width)*Levels]; + if (col>0 && values[static_cast(k)-Levels]>value) value = values[static_cast(k)-Levels]; + if (value>bound) value = bound; + values[k] = value; + } + } + } + uint32_t head=0, tail=0, count=0; + for (uint32_t row=height; row-- > 0;) { + const uint32_t base = row * width; + for (uint32_t col=width; col-- > 0;) { + const uint32_t index = base + col; + const float bound = mask[index]; + float* values = out + static_cast(index) * Levels; + bool can_raise = false; + for (uint32_t k=0; kvalue) value = values[k+width*Levels]; + if (col+1value) value = values[k+Levels]; + if (value>bound) value = bound; + values[k] = value; + if (row>0 && values[static_cast(k)-static_cast(width)*Levels](k)-static_cast(width)*Levels]0 && values[static_cast(k)-Levels](k)-Levels]0) { + const uint32_t index = queue[head]; + const uint8_t state = flags[index]; + flags[index] = state & ~Queued; + if (++head==capacity) head=0; + --count; + float source[Levels]; + std::memcpy(source,out+static_cast(index)*Levels,sizeof(source)); + if ((state&HasUp) && update(out,mask,index-width,source)) enqueue(index-width,queue,flags,tail,count,capacity); + if ((state&HasDown) && update(out,mask,index+width,source)) enqueue(index+width,queue,flags,tail,count,capacity); + if ((state&HasLeft) && update(out,mask,index-1,source)) enqueue(index-1,queue,flags,tail,count,capacity); + if ((state&HasRight) && update(out,mask,index+1,source)) enqueue(index+1,queue,flags,tail,count,capacity); + } +} + +extern "C" void reconstruct_five(const float* seed, const float* mask, float* out, + uint32_t height, uint32_t width, + uint32_t* queue, uint8_t* flags) { + reconstruct<5>(seed,mask,out,height,width,queue,flags); +} diff --git a/docs/validation/generic_runtime_owners_323_20260930/query-hash-diagnostic-sitecustomize.py.txt b/docs/validation/generic_runtime_owners_323_20260930/query-hash-diagnostic-sitecustomize.py.txt new file mode 100644 index 0000000000..e453975864 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/query-hash-diagnostic-sitecustomize.py.txt @@ -0,0 +1,165 @@ +"""Owner-thread diagnostic only: full step, finalization, and progress phases.""" +import functools +import gc +import hashlib +import importlib.abc +import importlib.machinery +import json +import os +import sys +import threading +import time +from pathlib import Path + +active = threading.local() +OUTPUT = Path('/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-query-hash-diagnostic-20260930') +TARGETS = { + 'openhcs.core.steps.function_runtime', + 'openhcs.core.steps.function_execution', + 'openhcs.core.orchestrator.worker_execution', +} + + +def record(label, seconds, **fields): + if not getattr(active, 'enabled', False): + return + selected = {key: str(value) for key, value in fields.items() + if key in ('function', 'module', 'step', 'step_name', 'count', 'group', 'kind')} + active.events.append({'label': label, 'seconds': seconds, 'fields': selected}) + + +def timed(original, label): + @functools.wraps(original) + def wrapper(*args, **kwargs): + if not getattr(active, 'enabled', False): + return original(*args, **kwargs) + started = time.perf_counter() + try: + return original(*args, **kwargs) + finally: + calls, seconds = active.stats.get(label, (0, 0.0)) + active.stats[label] = (calls + 1, seconds + time.perf_counter() - started) + return wrapper + + +def scoped(original, key_for_call): + @functools.wraps(original) + def wrapper(*args, **kwargs): + assert not getattr(active, 'enabled', False), original.__qualname__ + active.stats = {} + active.events = [] + active.gc_started = {} + active.enabled = True + started = time.perf_counter() + try: + return original(*args, **kwargs) + finally: + seconds = time.perf_counter() - started + active.enabled = False + key, fields = key_for_call(args, kwargs) + label = os.environ['OPENHCS_EXECUTION_DIAGNOSTIC_CASE'] + destination = OUTPUT / f'{label}-{key}.json' + assert not destination.exists(), destination + destination.write_text(json.dumps({ + 'seconds': seconds, 'thread': threading.get_ident(), + 'stats': active.stats, 'events': active.events, **fields, + })) + return wrapper + + +def gc_pause(phase, information): + if not getattr(active, 'enabled', False): + return + generation = information['generation'] + if phase == 'start': + active.gc_started[generation] = time.perf_counter() + elif generation in active.gc_started: + record('owner_thread_gc_pause', time.perf_counter() - active.gc_started.pop(generation), + count=information['collected']) + + +gc.callbacks.append(gc_pause) + + +class PhaseDiagnosticLoader(importlib.abc.Loader): + def __init__(self, loader): + self.loader = loader + + def create_module(self, spec): + return self.loader.create_module(spec) + + def exec_module(self, module): + self.loader.exec_module(module) + expected = Path(os.environ['OPENHCS_DIAGNOSTIC_SOURCE']) / (module.__name__.replace('.', '/') + '.py') + assert Path(module.__file__).resolve() == expected + if module.__name__ == 'openhcs.core.steps.function_runtime': + from openhcs.core import runtime_profile + from openhcs.core.measurement_feature_queries import RuntimeObjectLabelMeasurementQuery + from openhcs.core.runtime_stores import RuntimeValueStore + RuntimeObjectLabelMeasurementQuery.__hash__ = timed(RuntimeObjectLabelMeasurementQuery.__hash__, 'RuntimeObjectLabelMeasurementQuery.__hash__') + RuntimeValueStore._mark_mutated = timed(RuntimeValueStore._mark_mutated, 'RuntimeValueStore._mark_mutated') + if os.environ['OPENHCS_EXECUTION_DIAGNOSTIC_CASE'] == 'candidate': + from openhcs.core.process_local_cache import BoundedCache + BoundedCache.cached_value = timed(BoundedCache.cached_value, 'BoundedCache.cached_value') + BoundedCache.store_value = timed(BoundedCache.store_value, 'BoundedCache.store_value') + RuntimeValueStore.query_cache = timed(RuntimeValueStore.query_cache, 'RuntimeValueStore.query_cache') + from openhcs.core.source_image_provenance import SourceImageIdentity + from openhcs.core.runtime_image_values import ImagePayloadMetadata + from numba.core.dispatcher import Dispatcher + runtime_profile.RuntimeProfileLogger.enabled = staticmethod(lambda: getattr(active, 'enabled', False)) + runtime_profile.RuntimeProfileLogger.log = classmethod(lambda cls, logger, label, seconds, **fields: record(label, seconds, **fields)) + module.RuntimeProfileSink.record = classmethod(lambda cls, label, seconds, **fields: record(label, seconds, **fields)) + for owner, name in ((SourceImageIdentity, 'component_metadata_with_missing_from'), + (ImagePayloadMetadata, 'for_leading_source_plane')): + setattr(owner, name, timed(getattr(owner, name), owner.__name__ + '.' + name)) + for name in ('execute', 'invoke', 'load_artifact_inputs', 'save_artifact_outputs', + 'bind_runtime_adapter', 'execution_group_source_payload'): + setattr(module.FunctionCoreExecutor, name, timed(getattr(module.FunctionCoreExecutor, name), 'FunctionCoreExecutor.' + name)) + for name in ('run', '_load_input_stack', '_execute_pattern', '_validate_and_unstack', '_save_outputs', + '_apply_source_image_loading_semantics', '_apply_workspace_source_payload', + '_apply_workspace_source_binding_payload', '_apply_source_binding_payload'): + setattr(module.PatternGroupRuntime, name, timed(getattr(module.PatternGroupRuntime, name), 'PatternGroupRuntime.' + name)) + module.MainFlowMemoryConversion.converted_payload = timed(module.MainFlowMemoryConversion.converted_payload, 'MainFlowMemoryConversion.converted_payload') + original_compile = Dispatcher.compile + + @functools.wraps(original_compile) + def compile_diagnostic(dispatcher, *args, **kwargs): + if not getattr(active, 'enabled', False): + return original_compile(dispatcher, *args, **kwargs) + started = time.perf_counter() + try: + return original_compile(dispatcher, *args, **kwargs) + finally: + record('numba_compile', time.perf_counter() - started, + module=dispatcher.py_func.__module__, function=dispatcher.py_func.__name__) + Dispatcher.compile = compile_diagnostic + elif module.__name__ == 'openhcs.core.steps.function_execution': + def execution_key(args, kwargs): + plan = args[0].plan + return f'step-{plan.step_index}-execution', {'step_index': plan.step_index, 'step_name': plan.step_name} + module.FunctionStepExecutor.run = scoped(module.FunctionStepExecutor.run, execution_key) + elif module.__name__ == 'openhcs.core.orchestrator.worker_execution': + def progress_key(args, kwargs): + plan = kwargs['plan'] + return f'step-{plan.step_index}-progress', {'step_index': plan.step_index, 'step_name': plan.step_name, 'record_count': len(args[0])} + module._runtime_observation_progress_context = scoped(module._runtime_observation_progress_context, progress_key) + emit_sequence = 0 + + def emit_key(args, kwargs): + nonlocal emit_sequence + emit_sequence += 1 + return f'emit-{emit_sequence}', {'step_name': kwargs['step_name'], 'phase': kwargs['phase'].value} + module.emit = scoped(module.emit, emit_key) + + +class PhaseDiagnosticFinder(importlib.abc.MetaPathFinder): + def find_spec(self, fullname, path=None, target=None): + if fullname not in TARGETS: + return None + spec = importlib.machinery.PathFinder.find_spec(fullname, path, target) + assert spec is not None and isinstance(spec.loader, importlib.machinery.SourceFileLoader) + spec.loader = PhaseDiagnosticLoader(spec.loader) + return spec + + +sys.meta_path.insert(0, PhaseDiagnosticFinder()) diff --git a/docs/validation/generic_runtime_owners_323_20260930/refine_generic_measurement_runtime_owners_20260930.py.txt b/docs/validation/generic_runtime_owners_323_20260930/refine_generic_measurement_runtime_owners_20260930.py.txt new file mode 100644 index 0000000000..c63383ceaf --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/refine_generic_measurement_runtime_owners_20260930.py.txt @@ -0,0 +1,55 @@ +import ast +import json +import re +import subprocess +from pathlib import Path + +from nominal_refactor_advisor.ast_tools import SourceModule, module_syntax_index +from nominal_refactor_advisor.codemod import ( + CodemodPlanDocument, CodemodSourceSnapshot, PatchTargetOperation, + RefactorRecipe, SourceRewriteTarget, SourceTextReplacement, +) + +root = Path('/home/ts/code/projects/openhcs-compile-perf') +runs = root.parent / 'openhcs-benchmark-runs' +sources = {}; changes = {} +for relative in subprocess.check_output(['git','diff','--name-only','--diff-filter=AM'], cwd=root, text=True).splitlines(): + if not relative.endswith('.py'): continue + path = root / relative + original = path.read_text() + text = original + syntax = module_syntax_index(SourceModule.from_source_path(path, text).parse().module) + imports = [node for _,node in syntax.indexed_nodes_of_type(ast.ImportFrom) + if node.module == 'openhcs.core.measurement_row_materialization'] + if relative.startswith('openhcs/processing/backends/cellprofiler/') and len(imports) == 2: + moved, = [node for node in imports if [alias.name for alias in node.names] == ['ObjectMeasurementColumnarRows']] + existing, = [node for node in imports if node is not moved] + lines = text.splitlines(keepends=True) + removed = ''.join(lines[moved.lineno-1:moved.end_lineno]) + existing_text = ''.join(lines[existing.lineno-1:existing.end_lineno]) + assert existing_text.endswith(')\n') + replacement = existing_text[:-2] + ' ObjectMeasurementColumnarRows,\n)\n' + text = text.replace(existing_text, replacement, 1).replace(removed, '', 1) + if relative == 'openhcs/core/measurement_row_materialization.py': + text = text.replace(' return self.row_count()\n\n\n def __iter__', ' return self.row_count()\n\n def __iter__', 1) + text = text.replace(' yield from self.iter_row_mappings()\n\n\n\nclass MeasurementRowDeclaredValue', ' yield from self.iter_row_mappings()\n\n\nclass MeasurementRowDeclaredValue', 1) + # Black only the added/changed source ranges; keep unrelated legacy formatting. + diff = subprocess.check_output(['git','diff','--unified=0','--',relative], cwd=root, text=True) + ranges = [] + for match in re.finditer(r'^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@', diff, re.M): + start = int(match[1]); count = int(match[2] or 1) + if count: ranges.append((max(1,start-3), start+count+3)) + if ranges: + command = ['/home/ts/code/projects/openhcs/.venv/bin/python', '-m', 'black', '--quiet', '--target-version', 'py311'] + for start, end in ranges: + command.extend(['--line-ranges', f'{start}-{end}']) + command.extend(['--stdin-filename', str(path), '-']) + text = subprocess.check_output(command, input=text, text=True, cwd=root) + if text != original: + sources[str(path)] = original; changes[str(path)] = text +operations = tuple(PatchTargetOperation(target=SourceRewriteTarget(file_path=path), replacements=(SourceTextReplacement(old_source=sources[path], new_source=text),), rationale='Consolidate the moved owner import and format only modified ranges; preserve semantic assertions.') for path,text in changes.items()) +plan = CodemodPlanDocument(recipes=(RefactorRecipe(recipe_id='close-generic-measurement-import-migration', reason='All consumers use one nominal core import, without duplicated forwarding declarations.', operations=operations),)) +simulation = plan.simulate(CodemodSourceSnapshot.from_source_mapping(sources)) +assert simulation.is_clean, simulation.simulation_payload() +(runs / 'perf-generic-measurement-runtime-refinement-20260930.diff').write_text(simulation.unified_diff(sources)) +print(simulation.apply()) diff --git a/docs/validation/generic_runtime_owners_323_20260930/replay_granularity_active_spectra_20261001.py.txt b/docs/validation/generic_runtime_owners_323_20260930/replay_granularity_active_spectra_20261001.py.txt new file mode 100644 index 0000000000..0ffffc3af9 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/replay_granularity_active_spectra_20261001.py.txt @@ -0,0 +1,64 @@ +import ctypes +import hashlib +import json +import statistics +import sys +import time +from pathlib import Path + +import numpy as np +from skimage.morphology import disk + +sys.path.insert(0,'/home/ts/code/projects/openhcs-compile-perf') +from openhcs.core.native_threading import configure_native_thread_count +from openhcs.processing.backends.cellprofiler.granularity import ( + granularity_grey_erosion, CppGranularityReconstructionBackendStrategy, +) + +configure_native_thread_count(1) +library=ctypes.CDLL('/tmp/prototype_granularity_active_spectra_20261001.so') +function=library.reconstruct_five +array=np.ctypeslib.ndpointer(flags='C_CONTIGUOUS') +function.argtypes=[array,array,array,ctypes.c_uint32,ctypes.c_uint32,array,array,array] +function.restype=None +reference=CppGranularityReconstructionBackendStrategy() +root=Path('/home/ts/code/projects/openhcs-benchmark-runs') + +last_counts=[] + +def candidate(pixels): + eroded=pixels.copy();seeds=[] + footprint=disk(1,dtype=np.uint8) + for _ in range(5): + eroded=granularity_grey_erosion(eroded,footprint) + seeds.append(eroded) + packed=np.stack(seeds,axis=-1) + output=np.empty_like(packed) + counters=np.zeros(2,np.uint64) + function(packed,pixels,output,*pixels.shape, + np.empty(pixels.size,np.uint32),np.empty(pixels.size,np.uint16),counters) + last_counts[:]=[int(value) for value in counters] + return tuple(np.ascontiguousarray(output[:,:,k]) for k in range(5)) + +def control(pixels): + return reference.reconstruct_series(pixels,5) + +records=[] +for path in sorted((root/'perf-post-hull-granularity-frontier-20260930').glob('*.npy')): + pixels=np.load(path);assert pixels.dtype==np.float32 + digest=hashlib.sha256(pixels.tobytes()).hexdigest() + expected=control(pixels);actual=candidate(pixels) + for x,y in zip(expected,actual,strict=True): + np.testing.assert_array_equal(x,y) + assert x.dtype==y.dtype and y.flags.c_contiguous + samples={'control':[],'candidate':[]};cpu={'control':[],'candidate':[]} + for variant in ('control','candidate','candidate','control')*2: + started=time.perf_counter();cpu_started=time.thread_time() + (control if variant=='control' else candidate)(pixels) + cpu[variant].append(time.thread_time()-cpu_started) + samples[variant].append(time.perf_counter()-started) + assert digest==hashlib.sha256(pixels.tobytes()).hexdigest() + row=dict(source=path.name,sha256=digest,all_outputs_exact=True,queue_pops=last_counts[0],active_field_visits=last_counts[1],all_fields_visits=5*last_counts[0],samples=samples,cpu=cpu, + medians={k:statistics.median(v) for k,v in samples.items()},cpu_medians={k:statistics.median(v) for k,v in cpu.items()}) + records.append(row);print(json.dumps(row),flush=True) + (root/'perf-granularity-active-spectra-production-replay-20261001.json').write_text(json.dumps(records,indent=2)+'\n') diff --git a/docs/validation/generic_runtime_owners_323_20260930/replay_granularity_constant_spectra_20261001.py.txt b/docs/validation/generic_runtime_owners_323_20260930/replay_granularity_constant_spectra_20261001.py.txt new file mode 100644 index 0000000000..30c839bfdd --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/replay_granularity_constant_spectra_20261001.py.txt @@ -0,0 +1,60 @@ +import ctypes +import hashlib +import json +import statistics +import sys +import time +from pathlib import Path + +import numpy as np +from skimage.morphology import disk + +sys.path.insert(0,'/home/ts/code/projects/openhcs-compile-perf') +from openhcs.core.native_threading import configure_native_thread_count +from openhcs.processing.backends.cellprofiler.granularity import ( + granularity_grey_erosion, CppGranularityReconstructionBackendStrategy, +) + +configure_native_thread_count(1) +library=ctypes.CDLL('/tmp/prototype_granularity_constant_spectra_20261001.so') +function=library.reconstruct_five +array=np.ctypeslib.ndpointer(flags='C_CONTIGUOUS') +function.argtypes=[array,array,array,ctypes.c_uint32,ctypes.c_uint32,array,array] +function.restype=None +reference=CppGranularityReconstructionBackendStrategy() +root=Path('/home/ts/code/projects/openhcs-benchmark-runs') + +def candidate(pixels): + eroded=pixels.copy();seeds=[] + footprint=disk(1,dtype=np.uint8) + for _ in range(5): + eroded=granularity_grey_erosion(eroded,footprint) + seeds.append(eroded) + packed=np.stack(seeds,axis=-1) + output=np.empty_like(packed) + function(packed,pixels,output,*pixels.shape, + np.empty(pixels.size,np.uint32),np.empty(pixels.size,np.uint8)) + return tuple(np.ascontiguousarray(output[:,:,k]) for k in range(5)) + +def control(pixels): + return reference.reconstruct_series(pixels,5) + +records=[] +for path in sorted((root/'perf-post-hull-granularity-frontier-20260930').glob('*.npy')): + pixels=np.load(path);assert pixels.dtype==np.float32 + digest=hashlib.sha256(pixels.tobytes()).hexdigest() + expected=control(pixels);actual=candidate(pixels) + for x,y in zip(expected,actual,strict=True): + np.testing.assert_array_equal(x,y) + assert x.dtype==y.dtype and y.flags.c_contiguous + samples={'control':[],'candidate':[]};cpu={'control':[],'candidate':[]} + for variant in ('control','candidate','candidate','control')*2: + started=time.perf_counter();cpu_started=time.thread_time() + (control if variant=='control' else candidate)(pixels) + cpu[variant].append(time.thread_time()-cpu_started) + samples[variant].append(time.perf_counter()-started) + assert digest==hashlib.sha256(pixels.tobytes()).hexdigest() + row=dict(source=path.name,sha256=digest,all_outputs_exact=True,samples=samples,cpu=cpu, + medians={k:statistics.median(v) for k,v in samples.items()},cpu_medians={k:statistics.median(v) for k,v in cpu.items()}) + records.append(row);print(json.dumps(row),flush=True) + (root/'perf-granularity-constant-spectra-production-replay-20261001.json').write_text(json.dumps(records,indent=2)+'\n') diff --git a/docs/validation/generic_runtime_owners_323_20260930/run_generic_runtime_global_gc_diagnostic_20260930.py.txt b/docs/validation/generic_runtime_owners_323_20260930/run_generic_runtime_global_gc_diagnostic_20260930.py.txt new file mode 100644 index 0000000000..63c0a64619 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/run_generic_runtime_global_gc_diagnostic_20260930.py.txt @@ -0,0 +1,41 @@ +import csv +import hashlib +import json +import os +import subprocess +from pathlib import Path + +root = Path('/home/ts/code/projects/openhcs') +candidate = root.parent / 'openhcs-compile-perf' +runs = root.parent / 'openhcs-benchmark-runs' +diagnostics = runs / 'perf-generic-runtime-global-gc-diagnostic-20260930' +diagnostics.mkdir() +observations = [] +for label, source in (('candidate', candidate), ('main', root)): + case = 'ExampleImagingFlowCytometryObjectsInGrid' + revision = subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=source, text=True).strip() + output = runs / f'perf-generic-runtime-global-gc-diagnostic-production-{label}-20260930' + assert not output.exists() + env = dict(os.environ, + PYTHONPATH=f'/tmp/openhcs-generic-runtime-global-gc-site-20260930:{source}', + OPENHCS_EXECUTION_DIAGNOSTIC_CASE=label, + OPENHCS_DIAGNOSTIC_SOURCE=str(source), + OPENHCS_CPU_ONLY='true', + NUMBA_CACHE_DIR='/tmp/openhcs-source-identity-shared-cache-20260930') + command = ['/usr/bin/taskset', '-c', '5', str(root / '.venv/bin/python'), + str(root / 'scripts/benchmark_cppipe_well_throughput.py'), + '--manifest', str(root / 'benchmark/manifests/official30_portable_axis1.json'), + '--mode', '1w_1t', '--case', case, '--output-dir', str(output)] + with output.with_suffix('.log').open('w') as stream: + result = subprocess.run(command, cwd='/tmp', env=env, stdout=stream, stderr=subprocess.STDOUT) + assert result.returncode == 0, (label, result.returncode) + rows = list(csv.DictReader((output / 'well_throughput.csv').open())) + assert len(rows) == 1 and rows[0]['status'] == 'success' and rows[0]['successful_wells'] == '1' + csv_paths = sorted(output.rglob('BF_cells_on_grid.csv')) + assert len(csv_paths) == 1, csv_paths + digest = hashlib.sha256(csv_paths[0].read_bytes()).hexdigest() + assert digest == '517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c', digest + observations.append({'label': label, 'source': str(source), 'revision': revision, + 'directory': str(output), 'csv_sha256': digest, 'rows': rows}) + (runs / 'perf-generic-runtime-global-gc-diagnostic-observations-20260930.json').write_text(json.dumps(observations, indent=2) + '\n') + print(json.dumps(observations[-1]), flush=True) diff --git a/docs/validation/generic_runtime_owners_323_20260930/run_generic_runtime_owners_complete_acceptance_20260930.py.txt b/docs/validation/generic_runtime_owners_323_20260930/run_generic_runtime_owners_complete_acceptance_20260930.py.txt new file mode 100644 index 0000000000..5eab7c6b3e --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/run_generic_runtime_owners_complete_acceptance_20260930.py.txt @@ -0,0 +1,31 @@ +import csv +import hashlib +import json +import os +import subprocess +import time +from pathlib import Path + +root = Path('/home/ts/code/projects/openhcs') +candidate = root.parent / 'openhcs-compile-perf' +runs = root.parent / 'openhcs-benchmark-runs' +observations = [] +for case in ('ExampleImagingFlowCytometryObjectsInGrid', 'cp_tutorial_3d_monolayer'): + for index, label in enumerate(('main', 'candidate', 'candidate', 'main')): + source = candidate if label == 'candidate' else root + destination = runs / f'perf-generic-runtime-owners-complete-public-{case}-{index}-{label}-20260930' + assert not destination.exists(), destination + environment = dict(os.environ, PYTHONPATH=str(source), OPENHCS_CPU_ONLY='true', NUMBA_CACHE_DIR='/tmp/openhcs-source-identity-shared-cache-20260930') + probe = subprocess.check_output([str(root / '.venv/bin/python'), '-c', 'import openhcs.core.runtime_stores as m; print(m.__file__)'], cwd='/tmp', env=environment, text=True).strip() + assert Path(probe).resolve() == source / 'openhcs/core/runtime_stores.py', probe + command = ['/usr/bin/taskset', '-c', '5', str(root / '.venv/bin/python'), str(root / 'scripts/benchmark_cppipe_well_throughput.py'), '--manifest', str(root / 'benchmark/manifests/official30_portable_axis1.json'), '--mode', '1w_1t', '--case', case, '--output-dir', str(destination)] + started = time.perf_counter() + with destination.with_suffix('.log').open('w') as stream: + result = subprocess.run(command, cwd='/tmp', env=environment, stdout=stream, stderr=subprocess.STDOUT) + assert result.returncode == 0, (case, label, result.returncode) + rows = list(csv.DictReader((destination / 'well_throughput.csv').open())) + assert len(rows) == 1 and rows[0]['status'] == 'success' and rows[0]['successful_wells'] == '1', rows + observation = {'case': case, 'index': index, 'label': label, 'source': str(source), 'source_revision': subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=source, text=True).strip(), 'runtime_import': probe, 'runtime_sha256': hashlib.sha256(Path(probe).read_bytes()).hexdigest(), 'directory': str(destination), 'rows': rows, 'cli_seconds': time.perf_counter() - started} + observations.append(observation) + (runs / 'perf-generic-runtime-owners-complete-public-observations-20260930.json').write_text(json.dumps(observations, indent=2) + '\n') + print(json.dumps({'case': case, 'index': index, 'label': label, 'rows': rows}), flush=True) diff --git a/docs/validation/generic_runtime_owners_323_20260930/run_generic_runtime_owners_paired_main_acceptance_20260930.py.txt b/docs/validation/generic_runtime_owners_323_20260930/run_generic_runtime_owners_paired_main_acceptance_20260930.py.txt new file mode 100644 index 0000000000..0721a7944a --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/run_generic_runtime_owners_paired_main_acceptance_20260930.py.txt @@ -0,0 +1,31 @@ +import csv +import hashlib +import json +import os +import subprocess +import time +from pathlib import Path + +root = Path('/home/ts/code/projects/openhcs') +candidate = root.parent / 'openhcs-compile-perf' +runs = root.parent / 'openhcs-benchmark-runs' +observations = [] +for case in ('ExampleImagingFlowCytometryObjectsInGrid', 'cp_tutorial_3d_monolayer'): + for index, label in enumerate(('main', 'candidate')): + source = candidate if label == 'candidate' else root + destination = runs / f'perf-generic-runtime-owners-paired-main-public-{case}-{index}-{label}-20260930' + assert not destination.exists(), destination + environment = dict(os.environ, PYTHONPATH=str(source), OPENHCS_CPU_ONLY='true', NUMBA_CACHE_DIR='/tmp/openhcs-source-identity-shared-cache-20260930') + probe = subprocess.check_output([str(root / '.venv/bin/python'), '-c', 'import openhcs.core.runtime_stores as m; print(m.__file__)'], cwd='/tmp', env=environment, text=True).strip() + assert Path(probe).resolve() == source / 'openhcs/core/runtime_stores.py', probe + command = ['/usr/bin/taskset', '-c', '5', str(root / '.venv/bin/python'), str(root / 'scripts/benchmark_cppipe_well_throughput.py'), '--manifest', str(root / 'benchmark/manifests/official30_portable_axis1.json'), '--mode', '1w_1t', '--case', case, '--output-dir', str(destination)] + started = time.perf_counter() + with destination.with_suffix('.log').open('w') as stream: + result = subprocess.run(command, cwd='/tmp', env=environment, stdout=stream, stderr=subprocess.STDOUT) + assert result.returncode == 0, (case, label, result.returncode) + rows = list(csv.DictReader((destination / 'well_throughput.csv').open())) + assert len(rows) == 1 and rows[0]['status'] == 'success' and rows[0]['successful_wells'] == '1', rows + observation = {'case': case, 'index': index, 'label': label, 'source': str(source), 'source_revision': subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=source, text=True).strip(), 'runtime_import': probe, 'runtime_sha256': hashlib.sha256(Path(probe).read_bytes()).hexdigest(), 'directory': str(destination), 'rows': rows, 'cli_seconds': time.perf_counter() - started} + observations.append(observation) + (runs / 'perf-generic-runtime-owners-paired-main-public-observations-20260930.json').write_text(json.dumps(observations, indent=2) + '\n') + print(json.dumps({'case': case, 'index': index, 'label': label, 'rows': rows}), flush=True) diff --git a/docs/validation/generic_runtime_owners_323_20260930/run_numerical_cache_owners_acceptance_20261001.py.txt b/docs/validation/generic_runtime_owners_323_20260930/run_numerical_cache_owners_acceptance_20261001.py.txt new file mode 100644 index 0000000000..27902922b6 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/run_numerical_cache_owners_acceptance_20261001.py.txt @@ -0,0 +1,31 @@ +import csv +import hashlib +import json +import os +import subprocess +import time +from pathlib import Path + +root = Path('/home/ts/code/projects/openhcs') +candidate = root.parent / 'openhcs-compile-perf' +runs = root.parent / 'openhcs-benchmark-runs' +observations = [] +for case in ('ExampleImagingFlowCytometryObjectsInGrid', 'cp_tutorial_3d_monolayer'): + for index, label in enumerate(('main', 'candidate')): + source = candidate if label == 'candidate' else root + destination = runs / f'perf-numerical-cache-owners-public-{case}-{index}-{label}-20261001' + assert not destination.exists(), destination + environment = dict(os.environ, PYTHONPATH=str(source), OPENHCS_CPU_ONLY='true', NUMBA_CACHE_DIR='/tmp/openhcs-source-identity-shared-cache-20260930') + probe = subprocess.check_output([str(root / '.venv/bin/python'), '-c', 'import openhcs.core.runtime_stores as m; print(m.__file__)'], cwd='/tmp', env=environment, text=True).strip() + assert Path(probe).resolve() == source / 'openhcs/core/runtime_stores.py', probe + command = ['/usr/bin/taskset', '-c', '5', str(root / '.venv/bin/python'), str(root / 'scripts/benchmark_cppipe_well_throughput.py'), '--manifest', str(root / 'benchmark/manifests/official30_portable_axis1.json'), '--mode', '1w_1t', '--case', case, '--output-dir', str(destination)] + started = time.perf_counter() + with destination.with_suffix('.log').open('w') as stream: + result = subprocess.run(command, cwd='/tmp', env=environment, stdout=stream, stderr=subprocess.STDOUT) + assert result.returncode == 0, (case, label, result.returncode) + rows = list(csv.DictReader((destination / 'well_throughput.csv').open())) + assert len(rows) == 1 and rows[0]['status'] == 'success' and rows[0]['successful_wells'] == '1', rows + observation = {'case': case, 'index': index, 'label': label, 'source': str(source), 'source_revision': subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=source, text=True).strip(), 'runtime_import': probe, 'runtime_sha256': hashlib.sha256(Path(probe).read_bytes()).hexdigest(), 'directory': str(destination), 'rows': rows, 'cli_seconds': time.perf_counter() - started} + observations.append(observation) + (runs / 'perf-numerical-cache-owners-public-observations-20261001.json').write_text(json.dumps(observations, indent=2) + '\n') + print(json.dumps({'case': case, 'index': index, 'label': label, 'rows': rows}), flush=True) diff --git a/docs/validation/generic_runtime_owners_323_20260930/run_runtime_owner_closure_global_gc_diagnostic_20261001.py.txt b/docs/validation/generic_runtime_owners_323_20260930/run_runtime_owner_closure_global_gc_diagnostic_20261001.py.txt new file mode 100644 index 0000000000..cc1a8db221 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/run_runtime_owner_closure_global_gc_diagnostic_20261001.py.txt @@ -0,0 +1,41 @@ +import csv +import hashlib +import json +import os +import subprocess +from pathlib import Path + +root = Path('/home/ts/code/projects/openhcs') +candidate = root.parent / 'openhcs-compile-perf' +runs = root.parent / 'openhcs-benchmark-runs' +diagnostics = runs / 'perf-runtime-owner-closure-global-gc-diagnostic-20261001' +diagnostics.mkdir() +observations = [] +for label, source in (('main-a', root), ('candidate-a', candidate), ('candidate-b', candidate), ('main-b', root)): + case = 'ExampleImagingFlowCytometryObjectsInGrid' + revision = subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=source, text=True).strip() + output = runs / f'perf-runtime-owner-closure-global-gc-diagnostic-production-{label}-20261001' + assert not output.exists() + env = dict(os.environ, + PYTHONPATH=f'/tmp/openhcs-runtime-owner-closure-global-gc-site-20261001:{source}', + OPENHCS_EXECUTION_DIAGNOSTIC_CASE=label, + OPENHCS_DIAGNOSTIC_SOURCE=str(source), + OPENHCS_CPU_ONLY='true', + NUMBA_CACHE_DIR='/tmp/openhcs-source-identity-shared-cache-20260930') + command = ['/usr/bin/taskset', '-c', '5', str(root / '.venv/bin/python'), + str(root / 'scripts/benchmark_cppipe_well_throughput.py'), + '--manifest', str(root / 'benchmark/manifests/official30_portable_axis1.json'), + '--mode', '1w_1t', '--case', case, '--output-dir', str(output)] + with output.with_suffix('.log').open('w') as stream: + result = subprocess.run(command, cwd='/tmp', env=env, stdout=stream, stderr=subprocess.STDOUT) + assert result.returncode == 0, (label, result.returncode) + rows = list(csv.DictReader((output / 'well_throughput.csv').open())) + assert len(rows) == 1 and rows[0]['status'] == 'success' and rows[0]['successful_wells'] == '1' + csv_paths = sorted(output.rglob('BF_cells_on_grid.csv')) + assert len(csv_paths) == 1, csv_paths + digest = hashlib.sha256(csv_paths[0].read_bytes()).hexdigest() + assert digest == '517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c', digest + observations.append({'label': label, 'source': str(source), 'revision': revision, + 'directory': str(output), 'csv_sha256': digest, 'rows': rows}) + (runs / 'perf-runtime-owner-closure-global-gc-diagnostic-observations-20261001.json').write_text(json.dumps(observations, indent=2) + '\n') + print(json.dumps(observations[-1]), flush=True) diff --git a/docs/validation/generic_runtime_owners_323_20260930/run_runtime_owner_cpu_timeline_20261001.py.txt b/docs/validation/generic_runtime_owners_323_20260930/run_runtime_owner_cpu_timeline_20261001.py.txt new file mode 100644 index 0000000000..0f5caba061 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/run_runtime_owner_cpu_timeline_20261001.py.txt @@ -0,0 +1,41 @@ +import csv +import hashlib +import json +import os +import subprocess +from pathlib import Path + +root = Path('/home/ts/code/projects/openhcs') +candidate = root.parent / 'openhcs-compile-perf' +runs = root.parent / 'openhcs-benchmark-runs' +diagnostics = runs / 'perf-runtime-owner-cpu-timeline-20261001' +diagnostics.mkdir() +observations = [] +for label, source in (('candidate', candidate), ('main', root)): + case = 'ExampleImagingFlowCytometryObjectsInGrid' + revision = subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=source, text=True).strip() + output = runs / f'perf-runtime-owner-cpu-timeline-production-{label}-20261001' + assert not output.exists() + env = dict(os.environ, + PYTHONPATH=f'/tmp/openhcs-runtime-owner-cpu-timeline-site-20261001:{source}', + OPENHCS_EXECUTION_DIAGNOSTIC_CASE=label, + OPENHCS_DIAGNOSTIC_SOURCE=str(source), + OPENHCS_CPU_ONLY='true', + NUMBA_CACHE_DIR='/tmp/openhcs-source-identity-shared-cache-20260930') + command = ['/usr/bin/taskset', '-c', '5', str(root / '.venv/bin/python'), + str(root / 'scripts/benchmark_cppipe_well_throughput.py'), + '--manifest', str(root / 'benchmark/manifests/official30_portable_axis1.json'), + '--mode', '1w_1t', '--case', case, '--output-dir', str(output)] + with output.with_suffix('.log').open('w') as stream: + result = subprocess.run(command, cwd='/tmp', env=env, stdout=stream, stderr=subprocess.STDOUT) + assert result.returncode == 0, (label, result.returncode) + rows = list(csv.DictReader((output / 'well_throughput.csv').open())) + assert len(rows) == 1 and rows[0]['status'] == 'success' and rows[0]['successful_wells'] == '1' + csv_paths = sorted(output.rglob('BF_cells_on_grid.csv')) + assert len(csv_paths) == 1, csv_paths + digest = hashlib.sha256(csv_paths[0].read_bytes()).hexdigest() + assert digest == '517057a4b018195cc4c57e8503be63a378a8306eb2ecc303d4a025b6eab6dd1c', digest + observations.append({'label': label, 'source': str(source), 'revision': revision, + 'directory': str(output), 'csv_sha256': digest, 'rows': rows}) + (runs / 'perf-runtime-owner-cpu-timeline-observations-20261001.json').write_text(json.dumps(observations, indent=2) + '\n') + print(json.dumps(observations[-1]), flush=True) diff --git a/docs/validation/generic_runtime_owners_323_20260930/run_runtime_owner_fresh_native_reference_20261001.py.txt b/docs/validation/generic_runtime_owners_323_20260930/run_runtime_owner_fresh_native_reference_20261001.py.txt new file mode 100644 index 0000000000..91d588639f --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/run_runtime_owner_fresh_native_reference_20261001.py.txt @@ -0,0 +1,24 @@ +import json +from pathlib import Path + +from benchmark.adapters.openhcs import OpenHCSAdapter +from benchmark.cellprofiler_comparison import load_comparison_cases, _comparison_pipeline_params +from openhcs.core.config import GlobalPipelineConfig +from openhcs.serialization.json import to_jsonable + +runs = Path('/home/ts/code/projects/openhcs-benchmark-runs') +root = Path('/home/ts/code/projects/openhcs') +(case,) = tuple(case for case in load_comparison_cases(root / 'benchmark/manifests/official30_portable_axis1.json') if case.name == 'ExampleImagingFlowCytometryObjectsInGrid') +output = runs / 'perf-runtime-owner-fresh-native-reference-openhcs-20261001' +assert not output.exists() +params = _comparison_pipeline_params(case) +params['equivalence_reference_output_dir'] = str(runs / 'perf-runtime-owner-native-imaging-1w1j-20261001/native_jobs/0/1') +params['materialize_runtime_artifacts'] = False +params['compare_image_outputs'] = False +params['openhcs_timeout_seconds'] = 240 +result = OpenHCSAdapter(global_config=case.effective_global_config(GlobalPipelineConfig(num_workers=1, use_threading=False))).run( + dataset_path=case.dataset_path, pipeline_name=case.name, pipeline_params=params, + metrics=[], output_dir=output) +(runs / 'perf-runtime-owner-fresh-native-reference-result-20261001.json').write_text(json.dumps(to_jsonable(result), indent=2) + '\n') +print(json.dumps(dict(success=result.success, error_message=result.error_message, provenance=result.provenance)), flush=True) +assert result.success diff --git a/docs/validation/generic_runtime_owners_323_20260930/separate_cache_values_from_process_lifetime_20260930.py.txt b/docs/validation/generic_runtime_owners_323_20260930/separate_cache_values_from_process_lifetime_20260930.py.txt new file mode 100644 index 0000000000..17dc0ff15b --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/separate_cache_values_from_process_lifetime_20260930.py.txt @@ -0,0 +1,34 @@ +from pathlib import Path +from nominal_refactor_advisor.codemod import ( + CodemodPlanDocument, CodemodSourceSnapshot, PatchTargetOperation, + RefactorRecipe, SourceRewriteTarget, SourceTextReplacement, +) + +root=Path('/home/ts/code/projects/openhcs-compile-perf') +sources={}; changes={} +path=root/'openhcs/core/process_local_cache.py' +original=path.read_text(); sources[str(path)]=original +text=original.replace('class ProcessLocalBoundedCache(Generic[CacheKey, CachedValue]):\n """Bounded LRU cache with one singleton instance per concrete subclass."""', + 'class BoundedCache(Generic[CacheKey, CachedValue]):\n """Bounded LRU values with lifetime supplied by their owning consumer."""',1) +anchor=' @classmethod\n def process_cache(cls) -> "ProcessLocalBoundedCache[CacheKey, CachedValue]":' +assert text.count(anchor)==1 +text=text.replace(anchor, ''' +@dataclass(slots=True) +class ProcessLocalBoundedCache(BoundedCache[CacheKey, CachedValue]): + """Bounded values with one process-local singleton per concrete subclass.""" + + @classmethod + def process_cache(cls) -> "ProcessLocalBoundedCache[CacheKey, CachedValue]":''',1) +changes[str(path)]=text +for relative in ('openhcs/core/runtime_stores.py','openhcs/core/measurement_feature_queries.py','openhcs/core/runtime_artifact_queries.py'): + path=root/relative; original=path.read_text(); sources[str(path)]=original + text=original.replace('ProcessLocalBoundedCache','BoundedCache') + # Existing registered process-cache families retain their process lifecycle. + text=text.replace('RegisteredBoundedCache','RegisteredProcessLocalBoundedCache') + changes[str(path)]=text +operations=tuple(PatchTargetOperation(target=SourceRewriteTarget(file_path=path),replacements=(SourceTextReplacement(old_source=sources[path],new_source=text),),rationale='Existing cache storage operations move intact to the common value owner; process singleton methods stay on their process owner.') for path,text in changes.items()) +plan=CodemodPlanDocument(recipes=(RefactorRecipe(recipe_id='separate-cache-algorithm-and-lifetime',reason='Store-bound cache domains must inherit values without also inheriting a competing process-singleton API.',operations=operations),)) +simulation=plan.simulate(CodemodSourceSnapshot.from_source_mapping(sources)) +assert simulation.is_clean,simulation.simulation_payload() +Path('/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-runtime-cache-lifetime-refinement-20260930.diff').write_text(simulation.unified_diff(sources)) +print(simulation.apply()) diff --git a/docs/validation/generic_runtime_owners_323_20260930/test_generic_registered_numba_preparation_20260930.py.txt b/docs/validation/generic_runtime_owners_323_20260930/test_generic_registered_numba_preparation_20260930.py.txt new file mode 100644 index 0000000000..b72e564b79 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/test_generic_registered_numba_preparation_20260930.py.txt @@ -0,0 +1,65 @@ +from pathlib import Path + +from nominal_refactor_advisor.codemod import ( + CodemodPlanDocument, CodemodSourceSnapshot, PatchTargetOperation, + RefactorRecipe, SourceRewriteTarget, SourceTextReplacement, +) + +path = Path('/home/ts/code/projects/openhcs-compile-perf/tests/unit/test_cellprofiler_callable_kernel_preparation.py') +original = path.read_text() +test = '''def test_generic_kernel_registry_prepares_non_cellprofiler_families_once( + monkeypatch, kernel_module, tmp_path +): + from openhcs.core.processing_preparation import ( + PersistentNumbaKernelPreparation, + RegisteredNumbaKernelPreparation, + ) + + events = [] + + class FirstKernel(RegisteredNumbaKernelPreparation, metaclass=AutoRegisterMeta): + __registry__ = {} + + def execute(self): + events.append("first") + + class SecondKernel(RegisteredNumbaKernelPreparation, metaclass=AutoRegisterMeta): + __registry__ = {} + + def execute(self): + events.append("second") + + kernel_module.FirstKernel = FirstKernel + kernel_module.SecondKernel = SecondKernel + kernel_module.__openhcs_prepare__ = lambda: events.append("module") + process = declare_callable(kernel_module, lambda: events.append("callable")) + monkeypatch.setenv("OPENHCS_CPU_ONLY", "true") + monkeypatch.setattr(numba_config, "CACHE_DIR", str(tmp_path / "cache")) + # A provider-specific capture flag must not suppress independent kernels. + monkeypatch.setenv("OPENHCS_CAPTURE_CELLPROFILER_FIXTURES_DIR", str(tmp_path)) + assert FirstKernel.can_prepare_in_child() + assert SecondKernel.can_prepare_in_child() + assert FirstKernel.__registry__ is not SecondKernel.__registry__ + assert "__registry__" not in vars(PersistentNumbaKernelPreparation) + assert "__registry__" not in vars(RegisteredNumbaKernelPreparation) + + prepare_processing_callable(process) + prepare_processing_callable(process) + assert events == ["first", "second", "module", "callable"] + + +''' +anchor = 'def test_real_declarations_own_independent_registry_obligations():' +assert original.count(anchor) == 1 +changed = original.replace(anchor, test + anchor, 1) +operation = PatchTargetOperation(target=SourceRewriteTarget(file_path=str(path)), + replacements=(SourceTextReplacement(old_source=original, new_source=changed),), + rationale='Exercise a second nominal provider through the real registry/callable preparation consumer, once-only effect order and independent capture policy.') +plan = CodemodPlanDocument(recipes=(RefactorRecipe( + recipe_id='exercise-generic-numba-registry-consumer', + reason='The moved core family must transfer to independently declared numerical providers.', + operations=(operation,)),)) +simulation = plan.simulate(CodemodSourceSnapshot.from_source_mapping({str(path): original})) +assert simulation.is_clean +Path('/home/ts/code/projects/openhcs-benchmark-runs/perf-generic-numba-owner-consumer-test-20260930.diff').write_text(simulation.unified_diff({str(path): original})) +print(simulation.apply()) diff --git a/docs/validation/generic_runtime_owners_323_20260930/test_shared_numerical_cache_owners_20261001.py.txt b/docs/validation/generic_runtime_owners_323_20260930/test_shared_numerical_cache_owners_20261001.py.txt new file mode 100644 index 0000000000..3a12375e8e --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/test_shared_numerical_cache_owners_20261001.py.txt @@ -0,0 +1,80 @@ +from pathlib import Path +from nominal_refactor_advisor.codemod import ( + CodemodPlanDocument, CodemodSourceSnapshot, PatchTargetOperation, + RefactorRecipe, SourceRewriteTarget, SourceTextReplacement, +) +path = Path('/home/ts/code/projects/openhcs-compile-perf/tests/unit/test_process_local_cache.py') +original = path.read_text() +addition = ''' + +def test_synchronized_process_cache_preserves_lru_and_concurrent_singleton(): + from concurrent.futures import ThreadPoolExecutor + from dataclasses import dataclass + from threading import Barrier + + from openhcs.core.process_local_cache import SynchronizedBoundedCache + + @dataclass + class TestSynchronizedProcessCache( + SynchronizedBoundedCache[str, str], + RegisteredProcessLocalBoundedCache[str, str], + ): + max_entries: int = 2 + + barrier = Barrier(8) + + def obtain_cache(_index): + barrier.wait(timeout=5) + return TestSynchronizedProcessCache.process_cache() + + with ThreadPoolExecutor(max_workers=8) as pool: + caches = tuple(pool.map(obtain_cache, range(8))) + cache = caches[0] + assert all(value is cache for value in caches) + assert cache.max_entries == 2 + cache.store_value("oldest", "first") + cache.store_value("middle", "second") + assert cache.cached_value("oldest") == "first" + cache.store_value("newest", "third") + assert cache.cached_value("middle") is None + assert cache.cached_value("oldest") == "first" + assert cache.cached_value("newest") == "third" + clear_registered_process_local_caches() + assert cache.cached_value("oldest") is None + assert cache.cached_value("newest") is None + + +def test_numerical_cache_domains_keep_capacity_and_join_registered_cleanup(): + from openhcs.processing.backends.cellprofiler.granularity import ( + GranularityImageSeriesCache, + ) + from openhcs.processing.backends.cellprofiler.image_quality import ( + RadialSpectrumGeometryCache, + ) + from openhcs.processing.backends.cellprofiler.intensity_distribution import ( + RadialLabelGeometryCache, + ) + from openhcs.processing.backends.cellprofiler.zernike import ( + ZernikeLabelGeometryCache, + ) + + cache_types = ( + GranularityImageSeriesCache, + RadialSpectrumGeometryCache, + RadialLabelGeometryCache, + ZernikeLabelGeometryCache, + ) + caches = tuple(cls.process_cache() for cls in cache_types) + assert len({id(cache) for cache in caches}) == 4 + for cls, cache in zip(cache_types, caches, strict=True): + assert cache.max_entries == 16 + assert RegisteredProcessLocalBoundedCache.__registry__[cls.__name__] is cls + clear_registered_process_local_caches() + assert all(not cache.entries for cache in caches) +''' +text = original + addition +operation = PatchTargetOperation(target=SourceRewriteTarget(file_path=str(path)), replacements=(SourceTextReplacement(old_source=original, new_source=text),), rationale='Verify executed MI constructor/registry, thread singleton, LRU reuse/eviction and cleanup contracts.') +plan = CodemodPlanDocument(recipes=(RefactorRecipe(recipe_id='shared-cache-behavior-gates', reason='Architecture and runtime behavior require separate execution evidence.', operations=(operation,)),)) +simulation = plan.simulate(CodemodSourceSnapshot.from_source_mapping({str(path):original})) +assert simulation.is_clean, simulation.simulation_payload() +print(simulation.apply()) diff --git a/docs/validation/generic_runtime_owners_323_20260930/validate_generic_runtime_native_artifacts_20260930.py.txt b/docs/validation/generic_runtime_owners_323_20260930/validate_generic_runtime_native_artifacts_20260930.py.txt new file mode 100644 index 0000000000..53bb7ab869 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/validate_generic_runtime_native_artifacts_20260930.py.txt @@ -0,0 +1,87 @@ +import hashlib +import json +import zipfile +from pathlib import Path + +import numpy as np +import tifffile +from polystore.roi import load_rois_from_zip + +runs = Path('/home/ts/code/projects/openhcs-benchmark-runs') +observations = json.loads((runs / 'perf-generic-runtime-owners-paired-main-public-observations-20260930.json').read_text()) +report = [] + + +def normalized_run_addresses(value, run_root): + """Change only the explicitly different, admitted run-directory prefix.""" + prefix = str(run_root) + '/' + if isinstance(value, str): + return '/' + value[len(prefix):] if value.startswith(prefix) else value + if isinstance(value, list): + return [normalized_run_addresses(item, run_root) for item in value] + if isinstance(value, dict): + return {key: normalized_run_addresses(item, run_root) for key, item in value.items()} + return value + + +for case in ('ExampleImagingFlowCytometryObjectsInGrid', 'cp_tutorial_3d_monolayer'): + selected = [row for row in observations if row['case'] == case] + assert [row['label'] for row in selected] == ['main', 'candidate'] + directories = [Path(row['directory']) for row in selected] + image_root = ('images_' + case + '_source_workspace_well_throughput' + if case != 'cp_tutorial_3d_monolayer' + else 'images_3d_monolayer_final_source_workspace_well_throughput') + folders = [directory / case / 'wells_1/workers_1' / image_root for directory in directories] + inventories = [{path.relative_to(folder): path for path in folder.rglob('*') + if path.is_file() and path.suffix.lower() in ('.tif', '.tiff')} + for folder in folders] + assert inventories[0].keys() == inventories[1].keys() + images = [] + for name, control in sorted(inventories[0].items()): + candidate = inventories[1][name] + with tifffile.TiffFile(control) as base, tifffile.TiffFile(candidate) as head: + assert len(base.series) == len(head.series), name + for b, h in zip(base.series, head.series, strict=True): + assert b.shape == h.shape and b.dtype == h.dtype and b.axes == h.axes, name + assert np.array_equal(b.asarray(), h.asarray(), equal_nan=True), name + assert len(base.pages) == len(head.pages), name + for b, h in zip(base.pages, head.pages, strict=True): + for tag in ('XResolution', 'YResolution', 'ResolutionUnit'): + bv = b.tags[tag].value if tag in b.tags else None + hv = h.tags[tag].value if tag in h.tags else None + assert bv == hv, (name, tag) + assert bool(b.description) == bool(h.description), name + if b.description: + bm = normalized_run_addresses(json.loads(b.description), directories[0]) + hm = normalized_run_addresses(json.loads(h.description), directories[1]) + assert bm == hm, (name, 'TIFF description/source metadata') + images.append(str(name)) + roi_inventories = [{path.relative_to(folder): path for path in folder.rglob('*.roi.zip')} + for folder in folders] + assert roi_inventories[0].keys() == roi_inventories[1].keys() + archives = [] + for name, control in sorted(roi_inventories[0].items()): + candidate = roi_inventories[1][name] + base_rois, head_rois = load_rois_from_zip(control), load_rois_from_zip(candidate) + assert len(base_rois) == len(head_rois), name + with zipfile.ZipFile(control) as base, zipfile.ZipFile(candidate) as head: + assert set(base.namelist()) == set(head.namelist()), name + members = [] + for member in sorted(base.namelist()): + b, h = base.read(member), head.read(member) + if member.endswith('.json'): + assert normalized_run_addresses(json.loads(b), directories[0]) == normalized_run_addresses(json.loads(h), directories[1]), (name, member) + else: + assert b == h, (name, member) + members.append(member) + archives.append({'path': str(name), 'native_roi_count': len(base_rois), 'members': len(members)}) + report.append({'case': case, 'main_revision': selected[0]['source_revision'], + 'candidate_revision': selected[1]['source_revision'], + 'exact_images': images, 'exact_native_roi_archives': archives, + 'normalization': 'Only explicit run-directory prefixes in JSON source addresses; ZIP container timestamps are not scientific content. All native ROI members are byte-exact; all TIFF series pixels/dtype/shape/axes and physical/source metadata match.'}) + +destination = runs / 'perf-generic-runtime-owners-complete-native-artifact-parity-20260930.json' +destination.write_text(json.dumps(report, indent=2) + '\n') +print(json.dumps({'exact_images': sum(len(row['exact_images']) for row in report), + 'exact_native_roi_archives': sum(len(row['exact_native_roi_archives']) for row in report), + 'native_rois': sum(archive['native_roi_count'] for row in report for archive in row['exact_native_roi_archives'])})) diff --git a/docs/validation/generic_runtime_owners_323_20260930/validate_generic_runtime_owners_complete_outputs_20260930.py.txt b/docs/validation/generic_runtime_owners_323_20260930/validate_generic_runtime_owners_complete_outputs_20260930.py.txt new file mode 100644 index 0000000000..2f1468dbea --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/validate_generic_runtime_owners_complete_outputs_20260930.py.txt @@ -0,0 +1,50 @@ +import hashlib +import json +import statistics +from pathlib import Path + +import numpy as np +import tifffile + +runs = Path('/home/ts/code/projects/openhcs-benchmark-runs') +observations = json.loads((runs / 'perf-generic-runtime-owners-complete-public-observations-20260930.json').read_text()) +parity = [] +for case in ('ExampleImagingFlowCytometryObjectsInGrid', 'cp_tutorial_3d_monolayer'): + selected = [obs for obs in observations if obs['case'] == case] + assert len(selected) == 4 and [obs['label'] for obs in selected] == ['main','candidate','candidate','main'] + targets = [(Path(obs['directory']), obs['label']) for obs in selected] + if case == 'ExampleImagingFlowCytometryObjectsInGrid': + targets += [(runs / f'perf-generic-runtime-phase-diagnostic-production-{label}-20260930', label + '-diagnostic') for label in ('main', 'candidate')] + if case == 'cp_tutorial_3d_monolayer': + suffix = case + '/wells_1/workers_1/images_3d_monolayer_final_source_workspace_well_throughput' + control = runs / 'perf-plate-transport-full-candidate-20260929' / suffix + expected_csvs, expected_labels = 6,120 + else: + suffix = case + '/wells_1/workers_1/images_' + case + '_source_workspace_well_throughput' + control = Path(selected[0]['directory']) / suffix + expected_csvs, expected_labels = 1,0 + control_csvs = {p.relative_to(control):p for p in control.rglob('*.csv')} + control_labels = {p.relative_to(control):p for p in control.rglob('*Labels.tiff')} + assert len(control_csvs) == expected_csvs and len(control_labels) == expected_labels + for directory,label in targets: + folder = directory / suffix + csvs = {p.relative_to(folder):p for p in folder.rglob('*.csv')} + images = {p.relative_to(folder):p for p in folder.rglob('*Labels.tiff')} + assert csvs.keys() == control_csvs.keys() and images.keys() == control_labels.keys(), directory + for relative,path in csvs.items(): + assert path.read_bytes() == control_csvs[relative].read_bytes(), path + for relative,path in images.items(): + x,y = tifffile.imread(path),tifffile.imread(control_labels[relative]) + assert x.dtype == y.dtype and x.shape == y.shape and np.array_equal(x,y), path + parity.append({'case':case,'directory':str(directory),'label':label,'control':str(control), + 'byte_exact_csvs':[{'path':str(p),'sha256':hashlib.sha256(csvs[p].read_bytes()).hexdigest()} for p in sorted(csvs)], + 'exact_label_images':len(images)}) +means = {case:{label:{key:statistics.mean(float(row[key]) for obs in observations if obs['case']==case and obs['label']==label for row in obs['rows']) + for key in ('compile_seconds','execute_seconds','total_seconds')} + for label in ('main','candidate')} + for case in ('ExampleImagingFlowCytometryObjectsInGrid','cp_tutorial_3d_monolayer')} +report={'parity':parity,'means':means,'public_observations':len(observations), + 'limits':'Unprofiled CPU5 sequential ABBA, shared current dependency pins and warmed declared kernel cache; mandatory readiness preparation precedes pipeline clocks. Server startup/shutdown excluded. 1w_1t selects InlineWorkerExecutorResources; fork is configured for multiworker processes. ImagingFlow has one requested combined spreadsheet and no persisted label outputs; 3D compares all six complete spreadsheets and120 persisted labels. Diagnostics are timing attribution only. No native CP/scaling refresh or whole-goal completion is claimed.'} +destination=runs/'perf-generic-runtime-owners-complete-public-comparison-20260930.json' +destination.write_text(json.dumps(report,indent=2)+'\n') +print(json.dumps({'means':means,'exact_csvs':sum(len(x['byte_exact_csvs']) for x in parity),'exact_labels':sum(x['exact_label_images'] for x in parity)})) diff --git a/docs/validation/generic_runtime_owners_323_20260930/validate_generic_runtime_owners_paired_main_outputs_20260930.py.txt b/docs/validation/generic_runtime_owners_323_20260930/validate_generic_runtime_owners_paired_main_outputs_20260930.py.txt new file mode 100644 index 0000000000..ed11df5793 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/validate_generic_runtime_owners_paired_main_outputs_20260930.py.txt @@ -0,0 +1,48 @@ +import hashlib +import json +import statistics +from pathlib import Path + +import numpy as np +import tifffile + +runs = Path('/home/ts/code/projects/openhcs-benchmark-runs') +observations = json.loads((runs / 'perf-generic-runtime-owners-paired-main-public-observations-20260930.json').read_text()) +parity = [] +for case in ('ExampleImagingFlowCytometryObjectsInGrid', 'cp_tutorial_3d_monolayer'): + selected = [obs for obs in observations if obs['case'] == case] + assert len(selected) == 2 and [obs['label'] for obs in selected] == ['main','candidate'] + targets = [(Path(obs['directory']), obs['label']) for obs in selected] + if case == 'cp_tutorial_3d_monolayer': + suffix = case + '/wells_1/workers_1/images_3d_monolayer_final_source_workspace_well_throughput' + control = runs / 'perf-plate-transport-full-candidate-20260929' / suffix + expected_csvs, expected_labels = 6,120 + else: + suffix = case + '/wells_1/workers_1/images_' + case + '_source_workspace_well_throughput' + control = Path(selected[0]['directory']) / suffix + expected_csvs, expected_labels = 1,0 + control_csvs = {p.relative_to(control):p for p in control.rglob('*.csv')} + control_labels = {p.relative_to(control):p for p in control.rglob('*Labels.tiff')} + assert len(control_csvs) == expected_csvs and len(control_labels) == expected_labels + for directory,label in targets: + folder = directory / suffix + csvs = {p.relative_to(folder):p for p in folder.rglob('*.csv')} + images = {p.relative_to(folder):p for p in folder.rglob('*Labels.tiff')} + assert csvs.keys() == control_csvs.keys() and images.keys() == control_labels.keys(), directory + for relative,path in csvs.items(): + assert path.read_bytes() == control_csvs[relative].read_bytes(), path + for relative,path in images.items(): + x,y = tifffile.imread(path),tifffile.imread(control_labels[relative]) + assert x.dtype == y.dtype and x.shape == y.shape and np.array_equal(x,y), path + parity.append({'case':case,'directory':str(directory),'label':label,'control':str(control), + 'byte_exact_csvs':[{'path':str(p),'sha256':hashlib.sha256(csvs[p].read_bytes()).hexdigest()} for p in sorted(csvs)], + 'exact_label_images':len(images)}) +means = {case:{label:{key:statistics.mean(float(row[key]) for obs in observations if obs['case']==case and obs['label']==label for row in obs['rows']) + for key in ('compile_seconds','execute_seconds','total_seconds')} + for label in ('main','candidate')} + for case in ('ExampleImagingFlowCytometryObjectsInGrid','cp_tutorial_3d_monolayer')} +report={'parity':parity,'means':means,'public_observations':len(observations), + 'limits':'Unprofiled CPU5 sequential paired qualification after main PR317; two observations per case are parity/source qualification, not statistical performance evidence, shared current dependency pins and warmed declared kernel cache; mandatory readiness preparation precedes pipeline clocks. Server startup/shutdown excluded. 1w_1t selects InlineWorkerExecutorResources; fork is configured for multiworker processes. ImagingFlow has one requested combined spreadsheet and no persisted label outputs; 3D compares all six complete spreadsheets and120 persisted labels. Diagnostics are timing attribution only. No native CP/scaling refresh or whole-goal completion is claimed.'} +destination=runs/'perf-generic-runtime-owners-paired-main-public-comparison-20260930.json' +destination.write_text(json.dumps(report,indent=2)+'\n') +print(json.dumps({'means':means,'exact_csvs':sum(len(x['byte_exact_csvs']) for x in parity),'exact_labels':sum(x['exact_label_images'] for x in parity)})) diff --git a/docs/validation/generic_runtime_owners_323_20260930/validate_runtime_owner_closure_native_artifacts_20261001.py.txt b/docs/validation/generic_runtime_owners_323_20260930/validate_runtime_owner_closure_native_artifacts_20261001.py.txt new file mode 100644 index 0000000000..a07c4caf39 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/validate_runtime_owner_closure_native_artifacts_20261001.py.txt @@ -0,0 +1,87 @@ +import hashlib +import json +import zipfile +from pathlib import Path + +import numpy as np +import tifffile +from polystore.roi import load_rois_from_zip + +runs = Path('/home/ts/code/projects/openhcs-benchmark-runs') +observations = json.loads((runs / 'perf-numerical-cache-owners-public-observations-20261001.json').read_text()) +report = [] + + +def normalized_run_addresses(value, run_root): + """Change only the explicitly different, admitted run-directory prefix.""" + prefix = str(run_root) + '/' + if isinstance(value, str): + return '/' + value[len(prefix):] if value.startswith(prefix) else value + if isinstance(value, list): + return [normalized_run_addresses(item, run_root) for item in value] + if isinstance(value, dict): + return {key: normalized_run_addresses(item, run_root) for key, item in value.items()} + return value + + +for case in ('ExampleImagingFlowCytometryObjectsInGrid', 'cp_tutorial_3d_monolayer'): + selected = [row for row in observations if row['case'] == case] + assert [row['label'] for row in selected] == ['main', 'candidate'] + directories = [Path(row['directory']) for row in selected] + image_root = ('images_' + case + '_source_workspace_well_throughput' + if case != 'cp_tutorial_3d_monolayer' + else 'images_3d_monolayer_final_source_workspace_well_throughput') + folders = [directory / case / 'wells_1/workers_1' / image_root for directory in directories] + inventories = [{path.relative_to(folder): path for path in folder.rglob('*') + if path.is_file() and path.suffix.lower() in ('.tif', '.tiff')} + for folder in folders] + assert inventories[0].keys() == inventories[1].keys() + images = [] + for name, control in sorted(inventories[0].items()): + candidate = inventories[1][name] + with tifffile.TiffFile(control) as base, tifffile.TiffFile(candidate) as head: + assert len(base.series) == len(head.series), name + for b, h in zip(base.series, head.series, strict=True): + assert b.shape == h.shape and b.dtype == h.dtype and b.axes == h.axes, name + assert np.array_equal(b.asarray(), h.asarray(), equal_nan=True), name + assert len(base.pages) == len(head.pages), name + for b, h in zip(base.pages, head.pages, strict=True): + for tag in ('XResolution', 'YResolution', 'ResolutionUnit'): + bv = b.tags[tag].value if tag in b.tags else None + hv = h.tags[tag].value if tag in h.tags else None + assert bv == hv, (name, tag) + assert bool(b.description) == bool(h.description), name + if b.description: + bm = normalized_run_addresses(json.loads(b.description), directories[0]) + hm = normalized_run_addresses(json.loads(h.description), directories[1]) + assert bm == hm, (name, 'TIFF description/source metadata') + images.append(str(name)) + roi_inventories = [{path.relative_to(folder): path for path in folder.rglob('*.roi.zip')} + for folder in folders] + assert roi_inventories[0].keys() == roi_inventories[1].keys() + archives = [] + for name, control in sorted(roi_inventories[0].items()): + candidate = roi_inventories[1][name] + base_rois, head_rois = load_rois_from_zip(control), load_rois_from_zip(candidate) + assert len(base_rois) == len(head_rois), name + with zipfile.ZipFile(control) as base, zipfile.ZipFile(candidate) as head: + assert set(base.namelist()) == set(head.namelist()), name + members = [] + for member in sorted(base.namelist()): + b, h = base.read(member), head.read(member) + if member.endswith('.json'): + assert normalized_run_addresses(json.loads(b), directories[0]) == normalized_run_addresses(json.loads(h), directories[1]), (name, member) + else: + assert b == h, (name, member) + members.append(member) + archives.append({'path': str(name), 'native_roi_count': len(base_rois), 'members': len(members)}) + report.append({'case': case, 'main_revision': selected[0]['source_revision'], + 'candidate_revision': selected[1]['source_revision'], + 'exact_images': images, 'exact_native_roi_archives': archives, + 'normalization': 'Only explicit run-directory prefixes in JSON source addresses; ZIP container timestamps are not scientific content. All native ROI members are byte-exact; all TIFF series pixels/dtype/shape/axes and physical/source metadata match.'}) + +destination = runs / 'perf-runtime-owner-closure-native-artifact-parity-20261001.json' +destination.write_text(json.dumps(report, indent=2) + '\n') +print(json.dumps({'exact_images': sum(len(row['exact_images']) for row in report), + 'exact_native_roi_archives': sum(len(row['exact_native_roi_archives']) for row in report), + 'native_rois': sum(archive['native_roi_count'] for row in report for archive in row['exact_native_roi_archives'])})) diff --git a/docs/validation/generic_runtime_owners_323_20260930/validate_runtime_owner_closure_owners_paired_main_outputs_20261001.py.txt b/docs/validation/generic_runtime_owners_323_20260930/validate_runtime_owner_closure_owners_paired_main_outputs_20261001.py.txt new file mode 100644 index 0000000000..da798773f1 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/validate_runtime_owner_closure_owners_paired_main_outputs_20261001.py.txt @@ -0,0 +1,48 @@ +import hashlib +import json +import statistics +from pathlib import Path + +import numpy as np +import tifffile + +runs = Path('/home/ts/code/projects/openhcs-benchmark-runs') +observations = json.loads((runs / 'perf-numerical-cache-owners-public-observations-20261001.json').read_text()) +parity = [] +for case in ('ExampleImagingFlowCytometryObjectsInGrid', 'cp_tutorial_3d_monolayer'): + selected = [obs for obs in observations if obs['case'] == case] + assert len(selected) == 2 and [obs['label'] for obs in selected] == ['main','candidate'] + targets = [(Path(obs['directory']), obs['label']) for obs in selected] + if case == 'cp_tutorial_3d_monolayer': + suffix = case + '/wells_1/workers_1/images_3d_monolayer_final_source_workspace_well_throughput' + control = runs / 'perf-plate-transport-full-candidate-20260929' / suffix + expected_csvs, expected_labels = 6,120 + else: + suffix = case + '/wells_1/workers_1/images_' + case + '_source_workspace_well_throughput' + control = Path(selected[0]['directory']) / suffix + expected_csvs, expected_labels = 1,0 + control_csvs = {p.relative_to(control):p for p in control.rglob('*.csv')} + control_labels = {p.relative_to(control):p for p in control.rglob('*Labels.tiff')} + assert len(control_csvs) == expected_csvs and len(control_labels) == expected_labels + for directory,label in targets: + folder = directory / suffix + csvs = {p.relative_to(folder):p for p in folder.rglob('*.csv')} + images = {p.relative_to(folder):p for p in folder.rglob('*Labels.tiff')} + assert csvs.keys() == control_csvs.keys() and images.keys() == control_labels.keys(), directory + for relative,path in csvs.items(): + assert path.read_bytes() == control_csvs[relative].read_bytes(), path + for relative,path in images.items(): + x,y = tifffile.imread(path),tifffile.imread(control_labels[relative]) + assert x.dtype == y.dtype and x.shape == y.shape and np.array_equal(x,y), path + parity.append({'case':case,'directory':str(directory),'label':label,'control':str(control), + 'byte_exact_csvs':[{'path':str(p),'sha256':hashlib.sha256(csvs[p].read_bytes()).hexdigest()} for p in sorted(csvs)], + 'exact_label_images':len(images)}) +means = {case:{label:{key:statistics.mean(float(row[key]) for obs in observations if obs['case']==case and obs['label']==label for row in obs['rows']) + for key in ('compile_seconds','execute_seconds','total_seconds')} + for label in ('main','candidate')} + for case in ('ExampleImagingFlowCytometryObjectsInGrid','cp_tutorial_3d_monolayer')} +report={'parity':parity,'means':means,'public_observations':len(observations), + 'limits':'Unprofiled CPU5 sequential paired qualification after main PR317; two observations per case are parity/source qualification, not statistical performance evidence, shared current dependency pins and warmed declared kernel cache; mandatory readiness preparation precedes pipeline clocks. Server startup/shutdown excluded. 1w_1t selects InlineWorkerExecutorResources; fork is configured for multiworker processes. ImagingFlow has one requested combined spreadsheet and no persisted label outputs; 3D compares all six complete spreadsheets and120 persisted labels. Diagnostics are timing attribution only. No native CP/scaling refresh or whole-goal completion is claimed.'} +destination=runs/'perf-numerical-cache-owners-public-comparison-20261001.json' +destination.write_text(json.dumps(report,indent=2)+'\n') +print(json.dumps({'means':means,'exact_csvs':sum(len(x['byte_exact_csvs']) for x in parity),'exact_labels':sum(x['exact_label_images'] for x in parity)})) diff --git a/docs/validation/generic_runtime_owners_323_20260930/validated-source-tree-95a98b008.txt b/docs/validation/generic_runtime_owners_323_20260930/validated-source-tree-95a98b008.txt new file mode 100644 index 0000000000..ba6247b4f1 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/validated-source-tree-95a98b008.txt @@ -0,0 +1,1587 @@ +95a98b0083aba2384c271e224746824fc9e40ce5 +100644 blob 2f218231f6d07934a0887826fe7d767413da40dc .github/tests/test_refactor_guardrails.py +100644 blob 02c6cd068587df3b22ed4fd0eb16318fc3bfc43d benchmark/__init__.py +100644 blob 5dc925c7adc2f9c293b381334798ee580cc10f43 benchmark/adapters/__init__.py +100644 blob 48bd1a6f7a136de393189be71c04b7c695dfaaa4 benchmark/adapters/cellprofiler.py +100644 blob 5e3e6bd62d83b1989fdf3469363aefdd4951983e benchmark/adapters/cellprofiler_installation.py +100644 blob f3f176bf5017a6dbf818535e2d6c9ecd57c477ae benchmark/adapters/cppipe_source.py +100644 blob 56874ea2de44ef875f0c5f2afadb0315b786df79 benchmark/adapters/openhcs.py +100644 blob 4bad033093c93ff0a57ee08c5b056be36e9d8b7f benchmark/agent_validation/__init__.py +100644 blob 2fc1db8cb82477bfa1128bcb45b494aff5123347 benchmark/agent_validation/__main__.py +100644 blob 4fc32db5efb0e883481d93d9d6a4f9c136617119 benchmark/agent_validation/challenge_functions.py +100644 blob a04a806ff9231501017ded5a9f643ac874a79b58 benchmark/agent_validation/contracts.py +100644 blob fe0d896a1da54cd486e63a4c3f68438186ec3d30 benchmark/agent_validation/corpus.py +100644 blob 6c7a6efd0e1dbd570982def0a077fc58b9d3d5b9 benchmark/agent_validation/declarations.py +100644 blob cbc3909315ca8a4f050d5eb9e62437915812e9ba benchmark/agent_validation/journal.py +100644 blob f5d39f9513a212a3d39783185a1f182df30c2ae1 benchmark/agent_validation/mcp_attempt_recorder.py +100644 blob d7c8002566d2d29329b53cc3bdaaf9e1d1de361f benchmark/agent_validation/perturbations.py +100644 blob 780dc66f6a0d9cb3b8a3c9a68fd3c5dd601fda0b benchmark/agent_validation/provenance.py +100644 blob b3090a6d57e91c4b79716b869559e555b19b5040 benchmark/agent_validation/scoring.py +100644 blob 5ed5adc7d56b3f53ec7e04e1167b45933345a649 benchmark/agent_validation/tasks.py +100644 blob a7234c9bb8703eb39a40c39b3965c65d8f8ba14c benchmark/annotated_validation.py +100644 blob cd83afea955b7ea5f4f2ed6f5ee2bcbf343326cc benchmark/bioformats_hcs_validation.py +100644 blob 02d4b6cccf978cb5d9e6d692cd76ce064b16e2bf benchmark/cellprofiler_benchmark_cli.py +100644 blob 817ebbf96671c5dbb444b7161bb83bef30421d19 benchmark/cellprofiler_comparison.py +100644 blob ded38131a3876b6a84003e1838da5d8455026228 benchmark/cellprofiler_export_equivalence.py +100644 blob 3729161e4da975168fd9a8163b5c903a40ce5ee0 benchmark/cellprofiler_reference_exports.py +100644 blob 55667147a041ac75eebf72016f171cb2eaedd84c benchmark/cellprofiler_semantics/__init__.py +100644 blob 9c37957abae35dafbe3cc2e7160e87c15aa8c215 benchmark/contracts/comparison_manifest.py +100644 blob d7303e121954a2aa87c5a6b445f19d1b06c2e710 benchmark/contracts/control.py +100644 blob 9859122af454b10f4341d2f4a6dfbd7e552a982b benchmark/contracts/dataset.py +100644 blob c97839f6837055caefd30513cad39bcb9f46e41a benchmark/contracts/manifest_acquisition.py +100644 blob 009409ac0812b0d1537863f2c8d7ce4344fbb748 benchmark/contracts/measured_run_receipt.py +100644 blob 2a0cd577fda90b8e9259ed1da786a34e59c0599a benchmark/contracts/metric.py +100644 blob 21ebe5fd27267b9c9954795efa7652023307b5b2 benchmark/contracts/pipeline.py +100644 blob 4b2de231107bd2d135b50221d86faf11eaff9dc2 benchmark/contracts/run_artifacts.py +100644 blob 94bd8637d063bbaa849ccb697804329be8ce6f6b benchmark/contracts/run_receipt.py +100644 blob 2087431c9cddfeef9874b1dcb7540eadd1ac7e60 benchmark/contracts/tool_adapter.py +100644 blob 9a15e8e4491d666136ee6e52f47c4319bfbe39ea benchmark/contracts/validation.py +100644 blob de932c9e6d889531036d6b7cf9cf698a605c60b0 benchmark/contracts/values.py +100644 blob 4a6202c14af57707a52732a5a41fc47d9974a63a benchmark/control.py +100644 blob b81bc78fbe3efbe3b31e40b2f17842b687d6dacd benchmark/control_service.py +100644 blob a11abceaf1d06bebc1851b9fd56216074890d11b benchmark/converter/__init__.py +100644 blob 5f9f3d52b2a3e890789434cc7dad8946222fe8b9 benchmark/converter/compatibility_matrix.py +100644 blob cf5d3469025f55872f1f45d0ca947e07e369efc7 benchmark/converter/convert.py +100644 blob a85ca61060cb9978ddc28e812474570c3e39680a benchmark/converter/cppipe_corpus.py +100644 blob 0b78c5dd86f0c0a3caa473c976e97b533f4d5faa benchmark/datasets/__init__.py +100644 blob b4ce40802950c0f8adad467d93567e2f12434c39 benchmark/datasets/acquire.py +100644 blob 3f3bf089d9c5ae757cbc0ef6d64caff01e2a2470 benchmark/datasets/bioformats_hcs.py +100644 blob 585f4f8fdd41359a433141f0bf927d406b56378b benchmark/datasets/cache.py +100644 blob ec9fa619abdfc218796448011e03e5aa17854c5d benchmark/datasets/cppipe_case_catalog.py +100644 blob f12ac9ad661ecf44dd5580a668bfa36bae37249c benchmark/datasets/manifest.py +100644 blob a405dc657b9d96d003563ae5b06bfa0dbd46dc75 benchmark/datasets/registry.py +100644 blob 59b02fadd380e77c4d6f142da7dbdb7493c96743 benchmark/datasets/visible_source.py +100644 blob eed1350bf4ef1b40d7a32fb1e0014e8d4f939dd2 benchmark/demos/__init__.py +100644 blob d05bd685f0e7c64c86e43360af2668df900e1d97 benchmark/demos/official30_lab_meeting.py +100644 blob 6f202334c5680901aa27d0c665035fed6769180d benchmark/file_digest.py +100644 blob 8c0270ac2903be3721e5589ba4239a096fc403a8 benchmark/matched_cellprofiler_batch.py +100644 blob 2e232977baa418066e35786825994d57a713ff90 benchmark/mcp_extension.py +100644 blob 891ccebad866012b786203dcc6f1505565f44f90 benchmark/metrics/__init__.py +100644 blob 12aacb17f1721dbca5ea70c2fcb218900a3f6f0f benchmark/metrics/memory.py +100644 blob 6d16876b44bf36fcb3a1e41ac544b1cccc509a5c benchmark/metrics/time.py +100644 blob 84506a936dae5d176b7639261825d7804855bdb2 benchmark/napari_roi_streaming.py +100644 blob 600b4c5ad4c5893d1f69459819fbd5ec5965ffa3 benchmark/native_batch_barrier.py +100644 blob 6d65b7c0c9c4651d29e1f16d2e1711fd286447f1 benchmark/native_cellprofiler_batch_worker.py +100644 blob bce99bf1d7a06f3704b0457392826ee948ebee40 benchmark/native_synthetic_well_scaling.py +100644 blob 46db6511a76d2b61deb6a717f76a92762bdba15b benchmark/openhcs_measured_run.py +100644 blob 2148a1ee4d1503c189108ea0894babd44fa26b14 benchmark/pipelines/__init__.py +100644 blob e3966546ce59d59e2f4f0e58f7bab4904c6d4d23 benchmark/pipelines/bbbc021_nuclei_segmentation.py +100644 blob 13ded176215bbfd1a222d39a8fcb5cc7b41fac89 benchmark/pipelines/bbbc022_nuclei_segmentation.py +100644 blob 6b1215d251fbe5e32f89d7408d09bae677f6ee05 benchmark/pipelines/cellprofiler_nuclei.py +100644 blob bcaca107607085b235beb05b29b256e49c4248f8 benchmark/pipelines/cellprofiler_nuclei_cupy.py +100644 blob b6b9d46786fce1853afb7824d989b49d34cfc25c benchmark/pipelines/cellprofiler_nuclei_gpu.py +100644 blob 1a488a1df8f8a5f7fe084effc24986c9b14f3582 benchmark/pipelines/cellprofiler_preprocess.py +100644 blob 37ae75d9a8edec0488d5155f5270976517896527 benchmark/pipelines/registry.py +100644 blob bce177546709893e7c388f8e822d102e1c78240f benchmark/prepare_blind_neurite.py +100644 blob 8b5778267d9d0098328f17a7809bde8bfaa04434 benchmark/progress.py +100644 blob 099d822f9d6c0e7ff441fe775c68da219be3a6d6 benchmark/reports/__init__.py +100644 blob 02eb7781b58003cdb0ff1867a0d502a4c0186027 benchmark/reports/cppipe_figures.py +100644 blob b33bea957bb29b53a7ea7ddbdfa729dbcd0f5e5b benchmark/reports/cppipe_scaling_figures.py +100644 blob 7742faa8a19d72ec5f46ab1fb667041c0fafc615 benchmark/results/matched_batch_pilot_20260915/pilot_driver.py +100644 blob 64ddbfd46532d17de1405d267ca3f6245312f5d9 benchmark/results/perf_coloc_step_cache_20260929/plot.py +100644 blob 4d762f72e8d02cc320f5a1f4781d05654c78cdb6 benchmark/results/perf_compiled_radial_20260929/analyze.py +100644 blob a65ae0245dfb4c23e91cce0e175287b17841224b benchmark/results/perf_compiled_radial_20260929/check_export_parity.py +100644 blob db218db87e5ee97cd3dc172d67a94b52de5074d1 benchmark/results/perf_compiled_radial_20260929/plot.py +100644 blob baa3aaf805ccc008ab381bfa11325830d1d53bd2 benchmark/results/perf_compiled_radial_20260929/recipes/01_select_compiled_default.py +100644 blob 491347482261a81ecac2e579122203aceb3622e0 benchmark/results/perf_compiled_radial_20260929/recipes/02_share_request_boundary.py +100644 blob f899beb96c243fbd9b8f8cf3129743cf77a4aaa9 benchmark/results/perf_compiled_radial_20260929/recipes/03_share_compiled_normalization.py +100644 blob 1a225cc26510bc1548ec63e0c85af4909be0239d benchmark/results/perf_compiled_radial_20260929/replay_saved_requests.py +100644 blob 6878113cbad4d95d42b4839110cb7b43bd0fcac9 benchmark/results/perf_compiled_radial_20260929/run_pairs.py +100644 blob acb02a78ebff101d6cacf64c52b8794e17a761f6 benchmark/results/perf_fast_poll_20260929/plot.py +100644 blob 3f06f7cb6d5fa11b9ba8667341f2d04a230154fb benchmark/results/perf_fork_compiler_prewarm_20260929/plot.py +100644 blob de5f8ab96a41dfb8c23b7a0f4b8a51ef6fd56cbf benchmark/results/perf_fused_haralick_20260929/apply_fused_haralick_20260929.py +100644 blob 473caaae5a77e83dcc409c2f195b9160cd6f0afd benchmark/results/perf_fused_haralick_20260929/check_haralick_export_parity_20260929.py +100644 blob 5aac21b1177e0597737113bd9d72ffda8f98dea7 benchmark/results/perf_fused_haralick_20260929/paired_prewarmed_haralick_runs_20260929.py +100644 blob eb1b6c3909fe062a74e341c54447743e7661dcd7 benchmark/results/perf_fused_haralick_20260929/plot.py +100644 blob 2769263982e235497c44264bd184d727779abb97 benchmark/results/perf_fused_haralick_20260929/replay_production_fused_haralick_20260929.py +100644 blob 061c66fc52bf9f689364cce87c1f7555ceacb386 benchmark/results/perf_fused_haralick_scaling_20260929/plot.py +100644 blob 552deb8d76ab3e0843ef34c4eb504246c9ba2af6 benchmark/results/perf_granularity_native_sampling_20260930/analyze.py +100644 blob a65ae0245dfb4c23e91cce0e175287b17841224b benchmark/results/perf_granularity_native_sampling_20260930/check_export_parity.py +100644 blob 0b2c7b2147767ea8155b07baa6bbbd3071ba3617 benchmark/results/perf_granularity_native_sampling_20260930/plot.py +100644 blob ea9342b42b364cc66fc4070044a1f9ddcce6df2d benchmark/results/perf_granularity_native_sampling_20260930/recipes/01_own_sampling_grid.py +100644 blob 7b5b57accedca8ed14119154418d7a5f6af97524 benchmark/results/perf_granularity_native_sampling_20260930/recipes/02_migrate_sparse_consumer.py +100644 blob 24003c66e5747b36cf9ac7e32e7c712c2743a5ce benchmark/results/perf_granularity_native_sampling_20260930/replay_saved_inputs.py +100644 blob 82a16051bc11e406730278c2a97e6dd3ecde91ac benchmark/results/perf_granularity_native_sampling_20260930/run_pairs.py +100644 blob b9e64c1a1a3f3207ac2e96e0753cd58b27a2a93c benchmark/results/perf_lazy_cp_registry_20260929/plot.py +100644 blob 5e440495818a317c2a041a2c97798424c0963b06 benchmark/results/perf_lazy_ome_zarr_20260929/plot.py +100644 blob abbdd6bcfa24ae7b584a05a144422acd32892e19 benchmark/results/perf_long_form_export_20260929/plot.py +100644 blob 02f9b11c8c1b8b6ad9cb12fea3ced91d1720a294 benchmark/results/perf_native_batch_durability_20260929/authored_nra_transaction.py +100644 blob 10c0ceb2dcab2954983e547998e7a50dad82cc64 benchmark/results/perf_native_synthetic_scaling_20260929/plot.py +100644 blob 76935e2163ef53de9f420f44086d79a1151bde1f benchmark/results/perf_nominal_preparation_20260929/probe_spawn_cache.py +100644 blob 5166eec1e0f39a27f67aea50429cd93538463584 benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/apply_payload_slice_projection_owner_20260930.py +100644 blob f95c860b86c88e4d70e28c8d6d9b06ee91ebbedd benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/refine_payload_slice_projection_owner_20260930.py +100644 blob edf1c7a0ba6954eb0c8ba90be7a22585ccbb0283 benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/replay_payload_slice_projection_owner_20260930.py +100644 blob 136db976ca79b13d1628619b32d855b7dad5c85a benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/reproduce_profile_thread_contamination_20260930.py +100644 blob 6d2997970a11755168e7e3ce89ba883661862bac benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/retire_unreachable_mask_axis_guard_20260930.py +100644 blob 39d4acf252c98d30ba5f75a1ff0bffa6d0c24883 benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/run_payload_slice_projection_acceptance_20260930.py +100644 blob 205f2339de517401a8ebeed2f078f77cf8553ccd benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/run_runtime_owner_timer_20260930.py +100644 blob 653cb5084332fec307b5454648a0e0d1317a36f1 benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/sitecustomize.py +100644 blob c8bde971fd74f9eeab3d94ba12bf5465b8eb247c benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/validate_payload_slice_projection_outputs_20260930.py +100644 blob aa68f2037f183be8b79c8a068886e490de315d0e benchmark/results/perf_plate_input_transport_20260929/plot.py +100644 blob 23231afc7b225dc402f9896ccfd4e9e04334ad53 benchmark/results/perf_registry_kernel_warming_20260929/probe_catalog_warmup.py +100644 blob 2b6d4a05c90809c3e4b1b10c2713d70de4124e3d benchmark/results/perf_registry_kernel_warming_20260929/probe_spawn_cache.py +100644 blob b89480deff7d514dffaed808bce61bff5fbd1be1 benchmark/results/perf_reused_server_current_20260929/plot.py +100644 blob b10d010fd62b656bf240038bacdc7054549084b5 benchmark/results/perf_runtime_projection_platform_20260930/recipes/replay_runtime_output_projection_production_20260930.py +100644 blob 348cfaf7023a82b0fdfecd29e209af1fb07883b0 benchmark/results/perf_runtime_projection_platform_20260930/recipes/run_runtime_projection_platform_abba_20260930.py +100644 blob 911a67c83bcee385e6be841c1c6bd9845ef7b5f5 benchmark/results/perf_runtime_projection_platform_20260930/recipes/run_runtime_projection_platform_profile_20260930.py +100644 blob 90f5fea786c5295e1038e75e0c936df9175d0c24 benchmark/results/perf_runtime_projection_platform_20260930/recipes/sitecustomize.py +100644 blob b41a0214be86409963e9b1da39b97985ab2d2965 benchmark/results/perf_runtime_projection_platform_20260930/recipes/validate_runtime_projection_platform_20260930.py +100644 blob df97f5c0086c02eb231a4031e5fd00b5cddd4ba5 benchmark/results/perf_scaling_rise_investigation_20260929/analyze.py +100644 blob bbd74976cec6711612648f559b86a0c285bddaa3 benchmark/results/perf_scaling_rise_investigation_20260929/check_export_parity.py +100644 blob f7cc907876a8c525c60228c9db0e6a32940e51f6 benchmark/results/perf_scaling_rise_investigation_20260929/plot.py +100644 blob 46abbb4000c1b619b96e5148c2b413c9df114245 benchmark/results/perf_scaling_rise_investigation_20260929/reproduce_audit_overlap.py +100644 blob d6f854d062e2f8f5010dc8785a75f4e3cb878f80 benchmark/results/perf_scaling_rise_investigation_20260929/reproduced_audit_after.py +100644 blob fa922416b6b9274010000e7d752ca128eabc564c benchmark/results/perf_scaling_rise_investigation_20260929/reproduced_audit_before_expanded.py +100644 blob 1e025c421a466fbfcde750e9bab495d2816bc8e0 benchmark/results/perf_scaling_rise_investigation_20260929/run_clean_pairs.py +100644 blob ab1a189d67a2f3af15b465ffadcd3ef65e53ed57 benchmark/results/perf_single_axis_session_20260929/plot.py +100644 blob 3ab049c152a608dcef15a3a94c4eea232fdad10c benchmark/results/perf_source_header_reuse_20260930/recipes/analyze_source_header_phases_20260930.py +100644 blob 769aa7661b8572997cf5667714fb316f04b545f5 benchmark/results/perf_source_header_reuse_20260930/recipes/replay_production_source_headers_20260930.py +100644 blob cec9dda951e77fa5fc282f0b462bba01de99dfac benchmark/results/perf_source_header_reuse_20260930/recipes/run_source_header_current_main_abba_20260930.py +100644 blob b14f360b6157daaf6702c657cd54c38e37c4c5a6 benchmark/results/perf_source_header_reuse_20260930/recipes/run_source_header_preparation_timing_20260930.py +100644 blob 4e723e53b83ca4c5643b059f1fc81ba37bae2c3f benchmark/results/perf_source_header_reuse_20260930/recipes/validate_source_header_current_main_20260930.py +100644 blob b342f80a499f5375bb700eb1c4cf4f48185313c1 benchmark/results/perf_wide_intensity_distribution_20260929/plot.py +100644 blob d131f3e5b3f2c9300c5d24207af1dbf144f81133 benchmark/results/perf_wide_intensity_distribution_20260929/replay_saved_batch.py +100644 blob 61ce0186d64bb95d2ec26034ac637ee46440c87f benchmark/results/perf_worker_profiling_20260929/authored_nra_transaction.py +100644 blob 6c424571fb8d067a395cd5feb9074a0001099a2c benchmark/runner.py +100644 blob 41872859422a3e77b65d97d2eb0f681456a1bb8d benchmark/runtime_env.py +100644 blob 9c32c3c7bc4cacd7e2b818c4085259fe7be788e8 benchmark/throughput_scaling.py +100644 blob 3a5b3b6e08f2d8017bebca75e878a9926878c405 benchmark/timing.py +100644 blob 08d3af0c7cf98cb43d04a919c7217a5907b59890 benchmark/validation/__init__.py +100644 blob d548ead762366fe8cffd458038c75b9f025d38d6 benchmark/validation/__main__.py +100644 blob 383573bad753e3d4e35b94aab988a94a6952f654 benchmark/validation/corpus.py +100644 blob 7e592c476738b82e241ed6bf1e8f4e5f5cb601dd benchmark/validation/layouts.py +100644 blob 38c5c160a1d6c35a93b37222e1ed1e144d42b464 benchmark/validation/references.py +100644 blob 3e8f45776b29e26a0b0c23a4e7f40fee89d626a7 benchmark/validation/scoring.py +100644 blob 1233e91d9ff7db187340e3abe84722ad1b487ee4 benchmark/well_throughput_scaling.py +100644 blob ba296c237d0bb27ef1f048fa259b237e5cc0b78d docs/__init__.py +100644 blob fcdc7fcc6287b5036a169c8973d6eead677335b3 docs/source/_ext/openhcs_config_reference.py +100644 blob 9b86c30bff061cfc579dd7a7612234d5bb471606 docs/source/_ext/openhcs_gallery.py +100644 blob adb31aae807362b6c1d298925a454d6d4179dfbc docs/source/conf.py +100644 blob 2128b9a1093b72b5af85547444d894aabadd41f6 docs/validation/ack_runtime_parent_20260930/pipeline.py +100644 blob cfd5b6f9f7d1b19da4e917c92c5bc2a5a551e1ff docs/validation/artifact_publication_315_20260930/qualify-original.py +100644 blob 06d2cf9a8b94bb8467e4004b996114ea30dcf5ba docs/validation/artifact_publication_315_20260930/run-bounded-r1.py +100644 blob 94cc198e13382b85fc7115785c278737cd112795 docs/validation/duplicate_editable_metadata_20260930/accept_shared_main.py +100644 blob 1fcc3c9c73fc4294c744b5309eec437570cb615c docs/validation/paired_field_csv_314_20260930/check-installed-parent.py +100644 blob bb5e57f0e4a83cb94d2b68cac3bc9883cc1a9185 docs/validation/paired_field_csv_314_20260930/create-live-fixture.py +100644 blob b30ec89770f11554167bc01677db5b3376c96121 docs/validation/paired_field_csv_314_20260930/pipeline-live-parent.py +100644 blob 2872892f8254ea6b88d0e1efbb7f7aecdb4c897b docs/validation/runtime_bootstrap_20260930/native-attempt01/pipeline.py +100644 blob 66468189fff3aea7e22a0347ed924c93b338f6d4 docs/validation/runtime_bootstrap_20260930/native-attempt02/pipeline.py +100644 blob 8d89630cc331f58a84b149bc1972f5b93fffb257 docs/validation/runtime_bootstrap_20260930/native-attempt03/inspect_volume_fixture_v2.py +100644 blob 9ffae9cc867d25517ec0db4190559af521067bca docs/validation/runtime_bootstrap_20260930/native-attempt03/select_volume_fixture_planes_v2.py +100644 blob 6c809beddaf0009d5a4ea9fbf6f0c86251d1af1d docs/validation/viewer_reset_lifecycle_308_20260930/check-parent-artifacts.py +100644 blob 921a41830f22c9446eef4680b7e42eedf7058174 docs/validation/viewer_reset_lifecycle_308_20260930/mcp-witness.py +100644 blob e9d60f5b4ac1b0479f761a909611f4946c5a5ce0 docs/validation/viewer_reset_lifecycle_308_20260930/pipeline-parent.py +100644 blob 08ee53dfada49729735c5ddd9eefe43e4c173012 docs/validation/viewer_route_spatial_302/pipeline.py +100644 blob 45a3a9fb2582ce7eed4fff91f96256f84a2e63f9 examples/benchmark_example.py +160000 commit b0004daf3223326ac78689ba7b2e68abc18ae298 external/ObjectState +160000 commit dc3417392cef19083a907c8c9b88a15466f81df4 external/PolyStore +160000 commit 409b1e0831f815fa9ef91d4ecc04989f9fbb89c5 external/arraybridge +160000 commit 448cdf07e0a0b513a9c9a8f67e896f601da11771 external/metaclass-registry +160000 commit 792b03413331fdf107e369c924c257a2f0b16126 external/pycodify +160000 commit 3437d1c6fea00ef8bc022068726eb01a14221e45 external/pyqt-reactive +160000 commit 4e8f8bde5f750d9a50eacac80acd3806123addd8 external/python-introspect +160000 commit 9e11f6f2102c2083b3255520a65ccbbeb4144af3 external/zmqruntime +100644 blob 0fc21d6fa3f056051d407874aabdd760615f12e4 openhcs/__init__.py +100644 blob f770716c73ca65ae2fbbde14c6f0ee29cb5d7b03 openhcs/_source_dependencies.py +100644 blob 22fecb741f60120a2bbc51ad8d7fb50804325fb1 openhcs/agent/__init__.py +100644 blob 8f71847d054b61b338d63863bdb7b7573f722508 openhcs/agent/authoring_contexts.py +100644 blob 9b4b2915179d043b34d5bcd598575bf935d4c7f7 openhcs/agent/blind_recipe_audit.py +100644 blob 8ef1b2c7c411d86498b696cb5d1f4b2a1f16771a openhcs/agent/capabilities.py +100644 blob c6c0ca2f2015f5fe91e458e956675cf953c37f73 openhcs/agent/dto/__init__.py +100644 blob 555cef6439276272020f5d214613fdeda7c79860 openhcs/agent/dto/architecture.py +100644 blob 72860f63fd59768f92f89ae4a1b261312b84d05f openhcs/agent/dto/authoring.py +100644 blob e1c4834f45c5e495eaf0ed9bc9873fb4852c2328 openhcs/agent/dto/common.py +100644 blob bbbda5911e7afd499c1f746775c63fd24a09506a openhcs/agent/dto/config.py +100644 blob 3205d01285c1d4af40139e82ec341e36b150146d openhcs/agent/dto/execution.py +100644 blob 8b80141d57b802e3828f2d1b26533cc5ad4bdcec openhcs/agent/dto/execution_connection.py +100644 blob 65c1dffa64a03d33bd86e15b7b07a4d2540ae2a0 openhcs/agent/dto/functions.py +100644 blob 176ce5f3789d2e103eaa1adf065b7dd3d6a49d55 openhcs/agent/dto/knowledge.py +100644 blob 55d947a7c0a35694b47689ebf15135e2e8fb17da openhcs/agent/dto/mcp.py +100644 blob 78f3a4811ef451f9e4e7ab8b9370f6ca3377bfa6 openhcs/agent/dto/pipeline.py +100644 blob 50beb382436bfefcebb8a8fb2242314454e71cd9 openhcs/agent/dto/plate.py +100644 blob 773f3fb9efee16703bada8b9e5a45053838bccec openhcs/agent/dto/ui_bridge.py +100644 blob 2821ba459c5cd309228a78753f5612958cb39d56 openhcs/agent/dto/viewer.py +100644 blob 76fb676373979f1d93c98605529ef8295b293007 openhcs/agent/exceptions.py +100644 blob ea5e1c0602bb20f3fa1e7a6823db2cc1c73156de openhcs/agent/image_analysis_qa.py +100644 blob 6e3179b407f5d89cf508d6aeefc35f14ca5e81e5 openhcs/agent/knowledge_manifest.py +100644 blob 4469485244d2737252b7f8a688f702422e97e81e openhcs/agent/knowledge_manifest_schema.py +100644 blob 55759f5bfc4c381e50edb2c5f9baa6c6ca895ec8 openhcs/agent/path_policy.py +100644 blob 223b73ed899392a0a1f9343d0d9c5fc48d91af1d openhcs/agent/resources/__init__.py +100644 blob f469de15048da629b594f4ebba537b929179920e openhcs/agent/runtime_platform.py +100644 blob 60d3a75aae69c78b12c5781fc15eecce701d57c8 openhcs/agent/services/__init__.py +100644 blob 4d101da75302280cc04926e44271fcd024e01264 openhcs/agent/services/architecture_projection_service.py +100644 blob 9b123d55ce4083cdc61061607e2d956f40e7f4d0 openhcs/agent/services/config_reference_service.py +100644 blob 52477b1ea115eff0973c49f75990902df60ee247 openhcs/agent/services/config_service.py +100644 blob 951e367ad876bfaea695a32c3c04f4ddf51d87e7 openhcs/agent/services/endpoint_function_catalog_service.py +100644 blob d90bbaa8e9def219ae3793c6dc2fbe1b48f03d1c openhcs/agent/services/execution_session_service.py +100644 blob b6fb90483302bf2c70447c9d239a0b0746580ba0 openhcs/agent/services/function_catalog_service.py +100644 blob bb3781d9079f944d68039f118c613f14051cc6de openhcs/agent/services/knowledge_base_service.py +100644 blob ce291578467d595c4d981109aab746e6303c362b openhcs/agent/services/llm_context_service.py +100644 blob 3f4db195bec35cae9ae4d0ab0a93ce085f6211e7 openhcs/agent/services/object_state_field_help_service.py +100644 blob e37ba1d3f52c8a1908b4060bbad48c75506d9caa openhcs/agent/services/object_state_field_projection.py +100644 blob d2eb038cf495cd8baee2793b32e0c9bcc3c22bd9 openhcs/agent/services/pipeline_authoring_service.py +100644 blob dae396298f89cbcb991c9bb0fe6c804ccdfa07e1 openhcs/agent/services/plate_inspection_service.py +100644 blob 5146004fd6c4d0214e4bce40baff9ad38421237a openhcs/agent/services/plate_streaming_service.py +100644 blob ccacf58feab5fa8a0164393ee1db06324333fa59 openhcs/agent/services/runtime_server_service.py +100644 blob 66cffa25d4b644834a97b6f5c374f0e3e97df5cd openhcs/agent/services/selected_plate_service.py +100644 blob 0e5295b83c137111a5d2ced5b3d80f87910b1731 openhcs/agent/services/synthetic_plate_service.py +100644 blob cb1009c78ff499bead8f159daddf833d45b3d065 openhcs/agent/services/ui_bridge_service.py +100644 blob fa4855afeda68b1849d2377ee6f90123ddcf5653 openhcs/agent/services/ui_bridge_transport.py +100644 blob 34bd2463b663a2fb50612e6e510330184df62027 openhcs/agent/services/viewer_endpoint_discovery.py +100644 blob 8d9041ea925b7e645ad101276900085e7819252b openhcs/agent/services/viewer_window_service.py +100644 blob 12e941c1ad46d8378d3d869fcf8e793685fa9f33 openhcs/agent/skill_bundle.py +100644 blob 1d09a8046056f6ca44dede8360a19f2a5c775281 openhcs/agent/skill_sync.py +100644 blob 5bdf73a4df612f9e072b9cb6f6eeb31854916550 openhcs/agent/ui_bridge_actions.py +100644 blob 66d53414b7a9d72c67743e25cc9bb202cbcf99ed openhcs/agent/ui_bridge_environment.py +100644 blob b799ef747f0d52bac0c2396a7d39d741619de69a openhcs/agent/ui_bridge_identities.py +100644 blob 857701dffd4ea4986f1bde9903ee87ee85691709 openhcs/build_utils/__init__.py +100644 blob b515783e4f9964d6a686735707e3f4b279c4802a openhcs/build_utils/zeroc_ice_installer.py +100644 blob 06485b6e6a7af8ad05f20b4aaa02be632bda3121 openhcs/cli.py +100644 blob 2fe4cb2bcd12760f11703e36798af90f696c872d openhcs/components/__init__.py +100644 blob a9049a5f5d9cb32f8f5d7a4d588a133968e01676 openhcs/components/framework.py +100644 blob f68f781eee337f932a6fd36e511e81eb0b9d18cb openhcs/constants/__init__.py +100644 blob 45fa88036c65cd5e24af981ddd5ca418bc61df4e openhcs/constants/constants.py +100644 blob d62c12c6888e2885fbee859f0e1b732bd81edd91 openhcs/constants/input_source.py +100644 blob 13bd04d02f9f9f11ad7e393e210b699176a71ceb openhcs/core/__init__.py +100644 blob a40bdbf15830db49907ce2a6e7fe975d64433973 openhcs/core/alias_property.py +100644 blob bf9e42710bf42880474aae9267a90a361b8bd1b2 openhcs/core/aligned_image_payload.py +100644 blob c9e7660b83cb3fb99f7c3a257cc459b7b72209a5 openhcs/core/artifact_inspection.py +100644 blob bf0fe5952290b8dd4728c697fe9660f701e0f084 openhcs/core/artifact_key_selection.py +100644 blob 7e56929a598f5246ad9700869fb06a299d9c5c4e openhcs/core/artifacts.py +100644 blob 30bd69b3d1991774df0c4cf52854eaf427f415df openhcs/core/autoregister_preparation.py +100644 blob 546e59395206c5feb4dea1fd740828ce79b26cf1 openhcs/core/axis_filter.py +100644 blob ba3047e49c66d098b5ac72688212a7f7de768bb4 openhcs/core/callable_contract.py +100644 blob 986a7157af1a97e3a5e9668c6fc96eb765438f56 openhcs/core/compiled_execution.py +100644 blob 97af35207379ac2730154243e6ed191c0d4436aa openhcs/core/compiled_step_plan.py +100644 blob 78b18d51af6a162efb223a0f7bc99caab22efdf3 openhcs/core/component_group_scope.py +100644 blob c7fb0959867f62fe8f2801ca99599e6cf862c834 openhcs/core/component_set.py +100644 blob 2c3154515bd4e2e74fbb975524a257ec0bb43bd3 openhcs/core/components/__init__.py +100644 blob 2e8a09c2596781cadaa0bbb65a65b0fdbb02f4cd openhcs/core/components/component_values.py +100644 blob a986d7d43aaed14d4ef4de60f3485cd4303eaf01 openhcs/core/components/multiprocessing.py +100644 blob 8589e42041fdc073f19810905610e12f0e874a1a openhcs/core/components/parser_metaprogramming.py +100644 blob 10b835e7fc923298082cc4cc750162fb98682fae openhcs/core/components/validation.py +100644 blob f46fc3e7624fe7d2323fd2a688dc3781e49f40bf openhcs/core/config.py +100644 blob 2c6cdfb23ced0f53f205b893ecd2a530621ebd2d openhcs/core/config_cache.py +100644 blob d8bb11b90b9b170f4ade99396a40b6e16240a39e openhcs/core/config_document.py +100644 blob b3d9879cc28f27c24e5e4bcd20be4d15e43f4e7a openhcs/core/context/__init__.py +100644 blob 187565b391c67526362eafadb6c1a2b7def012a9 openhcs/core/context/processing_context.py +100644 blob 3853cdfbb7161e895f0b47d053ca86f9a15d1671 openhcs/core/debug.py +100644 blob 5e20dad67e05b41d847cb814cf12e1f0711d6f59 openhcs/core/debug_session_projection.py +100644 blob 0827b7232335d28cbe5a7e239d94176c1fd4bb62 openhcs/core/debug_view_models.py +100644 blob 911de491ebfc614ee2322bcb905c5d1a37a98dfe openhcs/core/debug_views.py +100644 blob b111ea3f337b06d7c24204b1efc7d7524edc2c1b openhcs/core/equivalence/__init__.py +100644 blob 9a1502315bca4680bf14370f9de33b524d3901fd openhcs/core/equivalence/arrays.py +100644 blob 8313a60a0f5922b25d14e8276244e6f01286ff07 openhcs/core/equivalence/cells.py +100644 blob 6ee711aca43070611ec52929d8d664b5458f0a20 openhcs/core/equivalence/comparison.py +100644 blob 9ee5c8b600c1eeef609bf09f6a8e67fa9176105a openhcs/core/equivalence/images.py +100644 blob 30d8d5978a99acd7f8fd9ad133900c7340e9c63f openhcs/core/equivalence/keys.py +100644 blob cf23d91b29b8842dc9c89946eab7e9b4c03f4f18 openhcs/core/equivalence/measurement_facts.py +100644 blob 58217e994b978283c9addee32b5f9aba218628a8 openhcs/core/equivalence/measurement_features.py +100644 blob 380743522b7d01f6c7470837dcc471f333abed70 openhcs/core/equivalence/measurement_requirements.py +100644 blob dad91667791b461342bac4c8bc111e3ff993c937 openhcs/core/equivalence/measurement_rows.py +100644 blob dc141546fecb7d02d974ba60d5e4dab7c9d2cf0a openhcs/core/equivalence/object_label_measurements.py +100644 blob 3010c500b74e1eeffb33f843bf955bac567bc7b1 openhcs/core/equivalence/outputs.py +100644 blob 22f86707e167df0dc23b0e9ec733a00b0b3e663c openhcs/core/equivalence/policy.py +100644 blob 1f03d975c89190fe86a41d26783a389c3548493b openhcs/core/equivalence/relationships.py +100644 blob fadbc4e2d667df41b50c164ecaecd5beb06978bf openhcs/core/equivalence/report.py +100644 blob dc1eaea8464511f6615bcb85b1f2d6d956bcd29e openhcs/core/equivalence/tables.py +100644 blob 6ffe97d5271e0fa92d0d09086846e7c3954a602c openhcs/core/execution_state.py +100644 blob 6793a9f484cefdc6193ba27acfba68f6d8639e36 openhcs/core/execution_visualizer.py +100644 blob 036bfd743001f424ca51f6e2d88628704ce86ad0 openhcs/core/framework_device_resolver.py +100644 blob b269577cb82cefb4ff51d1747015e59a452fac38 openhcs/core/function_contract_metadata.py +100644 blob 7f5a771789e74dff841b4986f7f036e78a6f7ce5 openhcs/core/function_patterns.py +100644 blob 48561026c3838225983796c4e2fd9cfca6a24ec3 openhcs/core/function_reference.py +100644 blob 1290f37ad18ec7ee292b3570fd27b4c3f3c53530 openhcs/core/function_step_document.py +100644 blob 4ced68b3b5445e68c5afff79579e2a2835fa4972 openhcs/core/function_step_transport.py +100644 blob a83b2b3bbc88d876ce02452e77e7bdd1eb1e2730 openhcs/core/image_file_serialization.py +100644 blob 63d897543e1df2de9836c3277d47798a982b4934 openhcs/core/image_payload_execution_mode.py +100644 blob 7aa6e98074fc96ec8b61751f360be10dc7523cc5 openhcs/core/image_shapes.py +100644 blob b0e2ee2aa7d4b93ab204b7b76161ab17679d64ee openhcs/core/input_workspace.py +100644 blob 158fed1e68c00d62c6b93904a0b7db79e79d9fef openhcs/core/invocation_artifacts.py +100644 blob abab10fbd0e53ccd4d3dc2c3c7e44f55ade2781f openhcs/core/lazy_gpu_imports.py +100644 blob a218212dd34970b94adeabbf37c13ebf24965d57 openhcs/core/log_utils.py +100644 blob 15acdfb0d78a929e6381bf85e2b1e53565e81b84 openhcs/core/measurement_feature_queries.py +100644 blob f8264e9d8e2ec7db56f444187680e38025689e6f openhcs/core/measurement_image_alignment.py +100644 blob b8177e565d7b1216d4412aa1931269f1ea560ecb openhcs/core/measurement_lookup_dialect.py +100644 blob ac6c9bf6fabc23a3c2a45c972ad9c69e81bb57fb openhcs/core/measurement_row_materialization.py +100644 blob d8d694c0c88e56b2d2336581c4374f4978b52c26 openhcs/core/memory/__init__.py +100644 blob 4131c86f7222110dfc34dc4d95bd4ad39e4fde58 openhcs/core/memory/decorators.py +100644 blob a53fd8276e0e6f932a1686cc9f26e45896e5afa1 openhcs/core/metadata_cache.py +100644 blob ccb219fdc77c9ac829c0e24bc4b71bc4fce43b00 openhcs/core/native_threading.py +100644 blob 203938ad4b1295dafaddc83bef75ec6d0344d277 openhcs/core/orchestrator/__init__.py +100644 blob 938f0f13d9682f8ccc92b24de93bea2fac2e7e85 openhcs/core/orchestrator/analysis_consolidation.py +100644 blob 83faac5838addd42bfe50aa99603ba05eeda4655 openhcs/core/orchestrator/cancellation.py +100644 blob f2e49a305cc00b7fdf3673fa4cee9b3ae981c903 openhcs/core/orchestrator/compiled_plate_execution.py +100644 blob 4f691525ce54ff579014708dd391664375c3f45b openhcs/core/orchestrator/execution_result.py +100644 blob 2169f6ab89ec13c06aca64e488026d2b62342738 openhcs/core/orchestrator/orchestrator.py +100644 blob 7f82c7bafc1c11786762e819195c21cb57daa431 openhcs/core/orchestrator/worker_execution.py +100644 blob 5b3c5880f56c4fcb46264b51f89504668ae91748 openhcs/core/orchestrator/worker_lanes.py +100644 blob a8eb02a6d25d8c58656a0c80e35ec0ab3097fda1 openhcs/core/orchestrator/worker_profiling.py +100644 blob b1c645be4cbd2dc7d5bbda800a499115fffdcf78 openhcs/core/path_cache.py +100644 blob 3df42affbb5c51b8d84bf1fd2df0807c907147c2 openhcs/core/path_pattern_matching.py +100644 blob c906a38e93f9029ea061ee0c5abac43bb0d19229 openhcs/core/pipeline/__init__.py +100644 blob 8f77e5efc2e0b3acb7c1b9ffca2c5edce7bb80dc openhcs/core/pipeline/artifact_planning.py +100644 blob 785b2ef9f364507063a2b7e185ca5746ed401934 openhcs/core/pipeline/compilation_session.py +100644 blob 1aae3ab07394c1a2f596ba6fd7dbf50e6d23a208 openhcs/core/pipeline/compiler.py +100644 blob afd5e4d79b1b31c8608006d3ea62361fb65d0197 openhcs/core/pipeline/framework_device_assignment.py +100644 blob 81b606c4c9a0e780570ca5ec54801c45e5109475 openhcs/core/pipeline/funcstep_contract_validator.py +100644 blob b75413a3a91e5fe4e3a11eb1aa5ad2125498d88a openhcs/core/pipeline/function_contracts.py +100644 blob e3e065b3a27f0ff4d6bd7ec488f8f7ea0323fcfe openhcs/core/pipeline/materialization_flag_planner.py +100644 blob d561ab433d4d0bbdaad1d40760e8e2674d6e632e openhcs/core/pipeline/path_planner.py +100644 blob 151db6c87f807e60646b5f322dd4df664c6a0b2d openhcs/core/pipeline/step_attribute_stripper.py +100644 blob 621373625dd5996ce2f83446c2798a7401303f59 openhcs/core/pipeline/step_snapshot.py +100644 blob 5dc7d2195cc35844f218ab94a9bdada87bc9af41 openhcs/core/pipeline_document.py +100644 blob 1bfa8d22f7f2137b07838e7d9b37dda832c9a58e openhcs/core/pipeline_document_fields.py +100644 blob 1bfbd9d3e6dccffaf4adae6a507345ad2b8d3e86 openhcs/core/plate_file_inventory.py +100644 blob 9d65a9c9a5304d7279ee8285569e24c68837cb81 openhcs/core/plate_image_inventory.py +100644 blob d0105b1e17f8961a1b09fe33b6fb08217737cdb6 openhcs/core/process_local_cache.py +100644 blob e51440b48dd7a71297f683d382a15464d77d0545 openhcs/core/processing_preparation.py +100644 blob fda37b2df9427de30fe58a8ed8542cc695abbd2d openhcs/core/progress/__init__.py +100644 blob cfca139262ac7601c1bc0b210d7c44b1a8430f40 openhcs/core/progress/debug_projection.py +100644 blob 66ecfdef4c1c9cdbb286168387a3c7e03c1d8b63 openhcs/core/progress/emitters.py +100644 blob c47a04bdeaa2c9a33b48157e3341c1f10ac55c4d openhcs/core/progress/exceptions.py +100644 blob 45c1f0eacbb9e27bbefc44685e437d60049f981f openhcs/core/progress/live_measurements.py +100644 blob ddc0acc960689164368d7bd0b79ff6ae267f1fc4 openhcs/core/progress/projection.py +100644 blob 69953ebf312e29902dbd31a1fec01a11d7893449 openhcs/core/progress/registry.py +100644 blob cd9f30c907c85690a59a7a44065122dc4785a13a openhcs/core/progress/runtime_artifacts.py +100644 blob 4e3569d81b58fb58328d08702114224ebf09bda3 openhcs/core/progress/runtime_tree.py +100644 blob e09cda0287560f494c549cb5b19313c2c94ff9c5 openhcs/core/progress/types.py +100644 blob 87ee5f318fd03492dd83b96c6fb181a30ede48d7 openhcs/core/projected_image_output.py +100644 blob 0f362ab6fa5dee5304f2d7da49aef3a3fb1930b5 openhcs/core/public_api.py +100644 blob 2507e463d59bbfab3a9c17c94c610721e2356532 openhcs/core/python_source_literal.py +100644 blob c2776e5b8e0582836dfee55235036c006a437eab openhcs/core/registry_strategies.py +100644 blob f597dd2becc10e79fb3598502d2bd3d9e781fc88 openhcs/core/roi_point_metadata.py +100644 blob 6455aaadf5ef67a325f5a350f4bd424a901ba486 openhcs/core/roi_source_metadata.py +100644 blob 14e0bb43ccb840e0ac54ed6d0f9c03afaced289f openhcs/core/runtime_adapters.py +100644 blob 3583087358d820fb82d76b795d6febc35f8caf65 openhcs/core/runtime_array_values.py +100644 blob 260fd329148120b4ce94820acad900f116a84420 openhcs/core/runtime_artifact_queries.py +100644 blob deb4343b719bf3892a0811c470589b12100bcca9 openhcs/core/runtime_artifact_values.py +100644 blob 6933013d512f4e39c15f4856c642ae4d317dd33f openhcs/core/runtime_batch_contracts.py +100644 blob 244f9edde57e237c2bb56067889faaf8ed69726a openhcs/core/runtime_equivalence.py +100644 blob 8f1c90d4a1ac5cbcf117e4f508771f5da35fc52c openhcs/core/runtime_execution_validation.py +100644 blob 1cc9d503172e568e43f563d8fcd5c8529d4ae330 openhcs/core/runtime_exports.py +100644 blob 6896ea46770754a71db6439f26818472be470b0f openhcs/core/runtime_identifier.py +100644 blob a29901c1c22aee0233d3900fbf3df95080d8633a openhcs/core/runtime_image_loading.py +100644 blob a29f7af3971f839efaec10bf30f0ac0c5d7eb28b openhcs/core/runtime_image_values.py +100644 blob 0c2282fcbdf00d9433e13464d61a73d759b5a363 openhcs/core/runtime_measurements.py +100644 blob 0e7e565e545cc082cee499c3f8342b50e08001ac openhcs/core/runtime_object_label_aggregation.py +100644 blob 31f6da07880ecc4995713d88763b86e90a42ceb8 openhcs/core/runtime_object_label_building.py +100644 blob 34f237842b58705ead808dc5c7f1a216a838002f openhcs/core/runtime_object_label_domains.py +100644 blob 69e07dbd4670c4d79a6d92b3d86ae6af14d204ec openhcs/core/runtime_object_labels.py +100644 blob 44cc127d39b5aef76e786b8139ba3054a42c79c1 openhcs/core/runtime_output_matching.py +100644 blob 1c2f0c35aa8c65414933a2a70003d2f6ed1999d8 openhcs/core/runtime_pattern_cache.py +100644 blob 24602e19943911337a46540531ed7c68a1211c0f openhcs/core/runtime_plane_projection.py +100644 blob cca04bf9344f6780d066fa585a6e6dab4e0407d8 openhcs/core/runtime_profile.py +100644 blob 4abca79cfaa62b785d7ce70ac859499e4803b649 openhcs/core/runtime_relationships.py +100644 blob d848301d2c89b5c98faec45c7a11ba466c480ebb openhcs/core/runtime_slice_alignment.py +100644 blob dbc82ace2019647cc36ae810a0e3a38e90b485f1 openhcs/core/runtime_slice_projection.py +100644 blob 7e2ffb242da3b38345e9edd17729dc2926310d4d openhcs/core/runtime_source_binding_cache.py +100644 blob 4807876c9b1e9772942b53384d54e972505a38e0 openhcs/core/runtime_sparse_labels.py +100644 blob f12cc3abaf74274825bf2ae8310cf82eb223da21 openhcs/core/runtime_spatial_graph.py +100644 blob 25f1e8b9a31edc7eb6c295d03b04f11285d4ee16 openhcs/core/runtime_spatial_grid.py +100644 blob 4b92cb0020b2656eb7b3fcf6a09d6c3aaf792697 openhcs/core/runtime_stack_cache.py +100644 blob d2840af84db4ea70edc366e7ea5171cc08c4711a openhcs/core/runtime_stores.py +100644 blob 354207da603c17cb20faf36b9047f5333f92c4ae openhcs/core/runtime_tabular_values.py +100644 blob 14808cc8325868c588a26ddcb005cb0f58472990 openhcs/core/selection.py +100644 blob 9521180c68ad78acad26df4a89dd00821270dd6a openhcs/core/source_binding_context.py +100644 blob 8a678f7f3750018ef11b4f03ab03dff755735283 openhcs/core/source_binding_selection.py +100644 blob 980da5b2f871706b96821fe9e8c3dc17746ec475 openhcs/core/source_binding_workspace.py +100644 blob 56dead442cc7ac848784ef9d97b8e04b594051ec openhcs/core/source_bindings.py +100644 blob 43042640689e70ed763b641c0504bb3fe07198de openhcs/core/source_bindings_view.py +100644 blob 71ff6ef174fecc47f48277e90cb621d4e6d210d2 openhcs/core/source_image_provenance.py +100644 blob b12f30692fcf069da5c42e56d373ce80a06b08e9 openhcs/core/source_image_semantics.py +100644 blob c1e8a57d362507d4fd061b2130becff1680c4331 openhcs/core/source_load_plan.py +100644 blob 8b973cff4c2e3529968b3399788d3998b5a595b1 openhcs/core/source_matching.py +100644 blob 63c7e4e04972f3dcf1b3045f8321d6afd5dbbbf2 openhcs/core/source_metadata.py +100644 blob 03e7fb852f2f2aaeda963a9b7c1188cf2515535f openhcs/core/source_path_identity.py +100644 blob d3c197b5812fa4b06c5f5607b9ed4f19b3802274 openhcs/core/source_plane_alignment.py +100644 blob 1ef3bb083459a361cb1706e37c515545fc184013 openhcs/core/source_projection.py +100644 blob c61d8b41aa4d6bad237c0009ceea4a7526328bb9 openhcs/core/source_spatial_domain.py +100644 blob 2b0b5f9d192de2237df43d8da0b9e73a6004ba8f openhcs/core/source_tile_geometry.py +100644 blob 84878b885151771209df49f2a6d07493a7d5c48b openhcs/core/source_workspace_projection.py +100644 blob e0a752d6cc48687f4b7397a79dcc63757c63bdfd openhcs/core/step_dependencies.py +100644 blob 6356e5202e5ccc0d365a6bd1360e485b026295e2 openhcs/core/steps/__init__.py +100644 blob e82003ec93139fc911c740f00bbeba3b5054cd52 openhcs/core/steps/abstract.py +100644 blob 71e1ddf9b008934fe995b08be931b7e7ede387a5 openhcs/core/steps/function_artifact_materialization.py +100644 blob e376923be2dad37dfab7145ced750f78bbfffed5 openhcs/core/steps/function_execution.py +100644 blob d2e5e5e38b7803378a1096b36935f75735ee0736 openhcs/core/steps/function_io.py +100644 blob f83da45f2f7ea78ee22e0957b2536b18da75084c openhcs/core/steps/function_output_identity.py +100644 blob ea93bbff1e4f93d9bfa0e8450974ba2db1914b04 openhcs/core/steps/function_output_manifest.py +100644 blob 9fc7cb773d0029d327929b4fff943505a17aa212 openhcs/core/steps/function_outputs.py +100644 blob b547bfa61a8d789f8e307376d2dc97b8c817d074 openhcs/core/steps/function_runtime.py +100644 blob 341e3aaf30c5839072fff5b793c4da796be43d75 openhcs/core/steps/function_step.py +100644 blob 39998938e82599a4ea06bb14ff0763ccc41c58e8 openhcs/core/steps/stream_component_semantics.py +100644 blob 53e4a304acd4660394dcc2eef8e16d3af8ea1ed9 openhcs/core/streaming_config_declarations.py +100644 blob 4ed05c60890648612ca722b413c6992b2296d44a openhcs/core/streaming_config_factory.py +100644 blob ada0f28fecd46611cfed8c822fba1306334729c9 openhcs/core/synthetic_plate_generation.py +100644 blob ba2ca1b2de1571be80cdb63b3571fcf70b390aee openhcs/core/utils.py +100644 blob e01c5c9e95492f7e9bed11b9d04666a0aec5b536 openhcs/core/variable_component_stack_requirement.py +100644 blob bb276dac78c7f7b2a12112b77ddbe0c9f993cbc9 openhcs/core/vfs_protocol.py +100644 blob 104e803526561301ddaa9eb2ca0eff78829041bd openhcs/core/viewer_streaming_service.py +100644 blob c9aabd2da3ce03bb97accb6103244aec814479d2 openhcs/core/virtual_workspace_metadata.py +100644 blob 6734ab9866398b1016d2492a15cd83780f901d32 openhcs/core/worker_start_policy.py +100644 blob 449e793570ceeb759331956987b98e6262bc9500 openhcs/core/xdg_paths.py +100644 blob d2feb694394813f561e6866b65297a0616470c54 openhcs/demo/__init__.py +100644 blob 773c5f763ce94425807bf0f86011579a91d411ab openhcs/demo/basic_pipeline.py +100644 blob c87f8b0ee19b1f29735a36d991990d69a9366c78 openhcs/demo/synthetic_data.py +100644 blob d455cbcd6810eba7f609082bdccb5d88e06bb27f openhcs/demo/synthetic_plate_pipeline.py +100644 blob dc6f4e1f8542a747b0fb787b3e166dbfe91b1c50 openhcs/desktop_deployment.py +100644 blob d703e97c81191befe39bda888eeb8b791002010b openhcs/desktop_deployment_cli.py +100644 blob c6f5e8a998bd6cedae8bccdf22f2ea7580c04e14 openhcs/desktop_installation.py +100755 blob 590f3911641f561fc7b3ee3afddc7c808cb5c46f openhcs/formats/experimental_analysis.py +100644 blob 14f6cd1e808e0c4df36b7d351fc9ed37596b9246 openhcs/formats/experimental_layout_rows.py +100644 blob c31717fed87ee6cd34cb88b1e623becc5baa5961 openhcs/formats/experimental_result_formats.py +100644 blob ef027e72f50f92869eab737ee1974701aa660b21 openhcs/formats/pattern/__init__.py +100644 blob 24d23d807653d1c603b80f1471c2fcd07d0093bf openhcs/formats/pattern/pattern_discovery.py +100644 blob 62e46f86b5aa55b31b91530fd3b4b4f982d40987 openhcs/gui_startup.py +100644 blob 5b318afe5e63d090afeca58fa0685cc74ac5cfa9 openhcs/interop/__init__.py +100644 blob 6941b77ac17120e27ec05166b3c391bff76ca495 openhcs/interop/cellprofiler/__init__.py +100644 blob 7c61aa1e4472572cf99c54f56cc932516801df01 openhcs/interop/cellprofiler/analyst_export.py +100644 blob b09be254e484e52102f9ec16adfa4ab724b83ebc openhcs/interop/cellprofiler/cellprofiler_literals.py +100644 blob 83ac74cfa5d46a8f65a3165a12a4d1b232ff9153 openhcs/interop/cellprofiler/compile_time_contracts.py +100644 blob 6db8aee37d0a7594d27ba965ed66dfdb3a373009 openhcs/interop/cellprofiler/database_column_dialect.py +100644 blob 1c869322a206d95306183fe061a06357cee62229 openhcs/interop/cellprofiler/image_normalization.py +100644 blob ac119612ef22866154799a789274a3cedb6f019a openhcs/interop/cellprofiler/image_set_numbering.py +100644 blob 74c75ade8d7ec89f371f507115b9af8d34102c89 openhcs/interop/cellprofiler/measurement_dialect.py +100644 blob 8d285990a630859bb28f29124c3f41cfce078be1 openhcs/interop/cellprofiler/measurement_lookup.py +100644 blob 546b45a763ba561d6dfdd1fb6f09d6e85bea9867 openhcs/interop/cellprofiler/measurement_scope.py +100644 blob 5f6773a7ea6426e6beb6472e5c254d12425c7313 openhcs/interop/cellprofiler/measurement_semantic_profiles.py +100644 blob 6b7e2540502bc12e0db9196cfc1c41e200633a14 openhcs/interop/cellprofiler/module_artifact_contracts.py +100644 blob 184f7052f14bc1c910bbf9dc13cb4b902c812703 openhcs/interop/cellprofiler/module_artifact_declarations.py +100644 blob 78a23086ea64048f3f5c1d945025c168b929ff16 openhcs/interop/cellprofiler/module_callable_abi.py +100644 blob 0957ca934029d2deece7cc925cdac1db60cef7d7 openhcs/interop/cellprofiler/module_declarations.py +100644 blob 83cd749205d965678e15d4760e7db6158c74dcdb openhcs/interop/cellprofiler/module_measurement_features.py +100644 blob 46b35a0dc51609996bc8922adb392154988a1307 openhcs/interop/cellprofiler/module_settings.py +100644 blob 40d3053f4647752fb61b180455d460c924075c5a openhcs/interop/cellprofiler/module_structuring_element_settings.py +100644 blob 9beee065405cebd25080b2afc63d333ce7c3798d openhcs/interop/cellprofiler/parser.py +100644 blob c40de7969043fe12c7c7ffa0c0419e3d716b407b openhcs/interop/cellprofiler/pipeline_import.py +100644 blob 2535d9b73f8be6359303b29b111fafa11f456b68 openhcs/interop/cellprofiler/plate_workspace.py +100644 blob 6348063603afe362b83d02d321a4a08177d32369 openhcs/interop/cellprofiler/runtime/__init__.py +100644 blob 5549514b430f28c40dd173ea54c99434be800138 openhcs/interop/cellprofiler/runtime/adapter.py +100644 blob 0fbfc14e4151ada49626cf0f15ddc7137f1dbe39 openhcs/interop/cellprofiler/runtime/artifact_binding.py +100644 blob d6667d5f76f4573d7b509cbb0e6990dd00ecfe5e openhcs/interop/cellprofiler/runtime/function_contract_execution.py +100644 blob cfe57fa7b2f85ac9e12181a315f7607473f107cc openhcs/interop/cellprofiler/runtime/invocation.py +100644 blob da54a1e105eed896df88435ef023ee1fe67aba52 openhcs/interop/cellprofiler/runtime/main_flow.py +100644 blob 92c93a7309ad752a2e77c6d5eb05eeb50042dec0 openhcs/interop/cellprofiler/runtime/measurement_execution_support.py +100644 blob 63cacedd723a145f24335139bc7a67b65d15c86a openhcs/interop/cellprofiler/runtime/measurement_recording.py +100644 blob 37a8fdef5d0fb729976b3227211f20430a5a01a9 openhcs/interop/cellprofiler/runtime/measurement_rows.py +100644 blob 9e779196f5f037c05ce22af912d5d5da3cf3fa75 openhcs/interop/cellprofiler/runtime/measurement_source_names.py +100644 blob 840624bfaf4592b2947ed53ec487763a9e51c353 openhcs/interop/cellprofiler/runtime/module_execution.py +100644 blob 5f8eec6c9c7dc517d1c5fb51b1b72ef0e608bc75 openhcs/interop/cellprofiler/runtime/object_input_policies.py +100644 blob 19c2890811ab41f16041c647b0578947595dfac7 openhcs/interop/cellprofiler/runtime/object_label_measurements.py +100644 blob 22d84d37e98f6439fd33788428ed90994c757c40 openhcs/interop/cellprofiler/runtime/object_measurement_execution.py +100644 blob c804da79bead63a179ea2a5f996bc7bfe93113ba openhcs/interop/cellprofiler/runtime/object_measurement_row_completion.py +100644 blob 3879f8902fe43f66aaffb454e451c3b3ee04e792 openhcs/interop/cellprofiler/runtime/object_measurement_row_policies.py +100644 blob 2fd94cf9d8fbbc86462b697da383cadbe52b0c5e openhcs/interop/cellprofiler/runtime/object_measurement_tables.py +100644 blob 858e1e7ce877439370301b98a8f2fbf29d57fb10 openhcs/interop/cellprofiler/runtime/object_measurement_vectors.py +100644 blob 3e85322dfeb20e46527ee4f791927b3f8afd99da openhcs/interop/cellprofiler/runtime/output_contexts.py +100644 blob 559fda7c416b3f8f1d88b90b0a26b866c6208658 openhcs/interop/cellprofiler/runtime/output_record_request.py +100644 blob 8e95504e2704590bee42063c0b207ab122af8a4a openhcs/interop/cellprofiler/runtime/output_recording.py +100644 blob 40a9e40801af2770f5a1506fe9106ebf3784fbe2 openhcs/interop/cellprofiler/runtime/primary_image_input_policies.py +100644 blob 679ade3d0821aae86b4fc4da627300acb1e50290 openhcs/interop/cellprofiler/runtime/profile_fields.py +100644 blob f34f8141084907d196ffd1e2efc57d77c8a8ce69 openhcs/interop/cellprofiler/runtime/relationship_measurement_rows.py +100644 blob 8ae130aa396b8af384ee1b29be93ed96282949b8 openhcs/interop/cellprofiler/runtime/runtime_profile.py +100644 blob 0564658db5c8257df5804839ba7b18bb56084f7c openhcs/interop/cellprofiler/setting_names.py +100644 blob ca16daca80f323ab640baa49e0d5f87f67865b0b openhcs/interop/cellprofiler/settings_binder.py +100644 blob 9108793ffecdead3041f83ec527ca568b30402ed openhcs/interop/cellprofiler/source_metadata.py +100644 blob 99d6a656fc242704bbc915294306d04facc78b62 openhcs/interop/cellprofiler/worm_measurements.py +100644 blob a8510b8aab942de5f5c88273547ee4d5827c5d0c openhcs/interop/cellprofiler_setting_normalization.py +100644 blob 18844345f4dee1dd3a544646a4dca32f809f6a78 openhcs/introspection/__init__.py +100644 blob 43147c49c7fb90024615514214c2692952143a40 openhcs/mcp/__init__.py +100644 blob b6e97b75775098339fc65caab3c15fab558419eb openhcs/mcp/__main__.py +100644 blob 337423b0753d578dba149804e02ea041a14a7fed openhcs/mcp/bootstrap.py +100644 blob ffe96e7a008e19bc53a050e3e7227096beb5ef93 openhcs/mcp/client_registration.py +100644 blob cc6c953ea579882ea31100f00077bec318386798 openhcs/mcp/context.py +100644 blob 429cc126f8ebe07ac9f93a959482e2629db11546 openhcs/mcp/control_timeout.py +100644 blob e041a7cd151bdf7ce06d620558319ebd92f59b97 openhcs/mcp/dev_client.py +100644 blob 9f0a9cca9d0d267dc360f4967b87bc9dc22b4fcf openhcs/mcp/dev_client_commanding.py +100644 blob f9317a06e23ead13a0adec3356d6e49029364e45 openhcs/mcp/dev_client_commands/__init__.py +100644 blob 4c9a92af6183a8241b238577480d91d74ececd86 openhcs/mcp/dev_client_commands/knowledge_pipeline.py +100644 blob 198bd911da3dad9c164ad275ecc8a3150c7cb014 openhcs/mcp/dev_client_commands/plate.py +100644 blob 081d57242d84663249d9ed639a18d8422f466555 openhcs/mcp/dev_client_commands/ui.py +100644 blob 167e8162fb1f1675906f71124f1522b129747389 openhcs/mcp/dev_client_commands/viewer.py +100644 blob 633db24d264c4b5b118aa04eb7125953f9c8fc12 openhcs/mcp/dev_client_core.py +100644 blob 0d31a95517f1417c2bac99ed073d142df2a404d3 openhcs/mcp/dev_client_renderers/__init__.py +100644 blob 9da4f38c383133f8d3724ed2c137ce822ccba7e5 openhcs/mcp/dev_client_renderers/config.py +100644 blob 1d5cbb99470fe0cefdea03f153f2075763039e50 openhcs/mcp/dev_client_renderers/knowledge.py +100644 blob 6104ae3f75a5d31f67524860013f509f0cd27a0f openhcs/mcp/dev_client_renderers/object_state.py +100644 blob 8c0933352e93cb99db71dc94b14416bd6ab99e68 openhcs/mcp/dev_client_renderers/pipeline.py +100644 blob a81e145332b77ae5849b1923261ac49adeca11b1 openhcs/mcp/dev_client_renderers/plate.py +100644 blob a6ea7d8c982f4c993ea9b1e10019df9ae0ca2f3b openhcs/mcp/dev_client_renderers/ui_bridge.py +100644 blob ac86b13d0b52cd31fb36c3021dd84aa62dd0d682 openhcs/mcp/dev_client_renderers/viewer.py +100644 blob c193e50f7699de8b07dfe1855cecca16faec2e38 openhcs/mcp/dev_client_rendering.py +100644 blob 8cc234b34a5811120ac89978a98a82fec3eaded0 openhcs/mcp/http.py +100644 blob a88c05d0c659f5e33144ede81708849e4eca96dd openhcs/mcp/http_auth.py +100644 blob ecd2e759e4b309677cafbb4e8e13c7bbb55e78ae openhcs/mcp/installed_demo.py +100644 blob 61466a5f0a79c7acc000ea5b927c1fbd180eacd6 openhcs/mcp/lifecycle.py +100644 blob d51f3d8ccbe5f6a3dc4347495e42dbc494a61388 openhcs/mcp/memory_diagnostic.py +100644 blob e10fde93ee35ed9c626a22247dbcd4b9f81bbaf6 openhcs/mcp/memory_diagnostic_launch.py +100644 blob 7038d8fd82169ffca3ca955cc6a850764f8dd7f4 openhcs/mcp/server.py +100644 blob 1e4d0895d3ac1314957e13da7d12ca9aaab4b765 openhcs/mcp/socket.py +100644 blob 7fd7fb7c3c686fdbb181c9621f5fa6615bbb17a1 openhcs/mcp/stdio.py +100644 blob d885a34a780b227b005fe418ca53661d2650152b openhcs/microscopes/__init__.py +100644 blob d739c298f72c6fedbb50a57e8cf09cf94f0b2ed4 openhcs/microscopes/bioformats.py +100644 blob 0554c1f85d1d13e8df73354bd9b783a921fe3418 openhcs/microscopes/bioformats_adapter.py +100644 blob 65ef76419f01407e0e3b526c4df0c23e540fd82a openhcs/microscopes/bioformats_well_key.py +100644 blob 687e7583848ba4e21861ac66d4c53e0a55e59806 openhcs/microscopes/exceptions.py +100644 blob 4c89e0e243dc74aa48f481d863400871efac8e33 openhcs/microscopes/handler_registry_service.py +100644 blob 60a8c209468cd7505749e2df644107449a792fec openhcs/microscopes/imagexpress.py +100644 blob 63523da1a67ee5b1672545660d568db096d9d564 openhcs/microscopes/imagexpress_source_metadata.py +100644 blob 4223bec70d7b7eb7a390ca3234596090ca4d5d63 openhcs/microscopes/microscope_base.py +100644 blob 941953a2bc78590af0e5c622810fbf36c96ad0dc openhcs/microscopes/microscope_interfaces.py +100644 blob ff52391f1a1259d4f1fe82f4c14aecfc75a5ffd4 openhcs/microscopes/omero.py +100644 blob 09f2b77e65e6635349eed51c6180ca453fbe3a81 openhcs/microscopes/openhcs.py +100644 blob 2b14efe966a5737c1d5f6cd5391f20dfbb3dd056 openhcs/microscopes/opera_phenix.py +100644 blob a2148049b2df3f4543e4b7b8c6a582af2cb1debc openhcs/microscopes/opera_phenix_xml_parser.py +100644 blob d6af813a8a340f4b9e117a9c123cddebd4a719e9 openhcs/microscopes/source_bindings_handler.py +100644 blob 4b55ccf08b1a3e7949607e07811d2f5803abcfd0 openhcs/microscopes/source_schema.py +100644 blob fdaac2113d333c8232ab1099ac4581b60e6d7c7f openhcs/microscopes/tiff_metadata_mixin.py +100644 blob 4358aa30b2098bf7f8ff5b6d1d70f0a66d3573a1 openhcs/napari_roi_manager/__init__.py +100644 blob 46dde4039b66d0d6fe286389da3297acb7663a72 openhcs/napari_roi_manager/_dataclasses.py +100644 blob 7ca04689a6fd4137bebbf1f3a938ea418b03b4ae openhcs/napari_roi_manager/ij/__init__.py +100644 blob d9b33fc01d0a38e42a63301d1878efc0e30a9724 openhcs/napari_roi_manager/ij/_convert.py +100644 blob 59f5d22474bce33d2687fd22c940562d9b820460 openhcs/napari_roi_manager/widgets/__init__.py +100644 blob 92b085e24c45fac3b21136667d957cff0989bd63 openhcs/napari_roi_manager/widgets/_dialogs.py +100644 blob 93fa2d14a156cc0fbf6e7c26f9467877c1bb54b7 openhcs/napari_roi_manager/widgets/_roi_manager.py +100644 blob 68846d54b9e28c017ed1ff4cc2c5d35b44fdd9de openhcs/omero/plugin/omero_openhcs/__init__.py +100644 blob c467417833217a009e7d666e218d98cfa95b14cf openhcs/omero/plugin/omero_openhcs/apps.py +100644 blob fde8c671c0c647429fff7aa9388ab167f2e56320 openhcs/omero/plugin/omero_openhcs/urls.py +100644 blob 9e5b07afcbb5b3974c22d4eb9eee14e31a2041ec openhcs/omero/plugin/omero_openhcs/views.py +100644 blob 05841afc9d5bee24b89ad049c2f9bedb840c398f openhcs/omero/plugin/setup.py +100644 blob 78c12f4e089ed0e35e6918cc0c759edc75b625ea openhcs/processing/__init__.py +100644 blob e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 openhcs/processing/backends/__init__.py +100644 blob dd09c87d9b71eebaa1a1373af42af6b993f60872 openhcs/processing/backends/analysis/__init__.py +100644 blob 0e3dcc04ddf5be0643e7d2bf3c1b6aa8daec1025 openhcs/processing/backends/analysis/cache_utils.py +100644 blob 2ee84776fb805d00c5720fda6de32c9fe3e2138d openhcs/processing/backends/analysis/cell_counting_common.py +100644 blob 52d3e76af8fc48785b6743633b5fe75b7f1f16f8 openhcs/processing/backends/analysis/cell_counting_cpu.py +100644 blob 31427ece41f45de5007e37b3971c858c3e5dbf20 openhcs/processing/backends/analysis/cell_counting_cupy.py +100644 blob c639fe8c0100442c0461dbf65d2153e5e6ad122d openhcs/processing/backends/analysis/cell_counting_pyclesperanto.py +100644 blob 29d2b866cb30a06d5c49f4f521a10b2e8ec21cf1 openhcs/processing/backends/analysis/cell_counting_pyclesperanto_simple.py +100644 blob e2c80ee6f9dd45a01c5bc6a477adbb7ce7b22579 openhcs/processing/backends/analysis/consolidate_analysis_results.py +100644 blob 4be8f851494d308758295b3ab4a5c5c2dd2c7393 openhcs/processing/backends/analysis/consolidate_special_outputs.py +100644 blob 1f8a06ccb8a0150a1dba262466fdc204884ee6e3 openhcs/processing/backends/analysis/count_cells_simple.py +100644 blob 599539da954e6a224beeaaef9da487a4d13ae17e openhcs/processing/backends/analysis/dxf_mask_pipeline.py +100644 blob e58aa3fc9f6e08f72cfbb7b844f4b2a3a656b34f openhcs/processing/backends/analysis/focus_analyzer.py +100644 blob cc5cbefc33b1c2001298ecb62f8bc7b291d316d4 openhcs/processing/backends/analysis/hmm_axon.py +100644 blob 3edd6598fa7a19ed35651d7467e6458d8eded3ac openhcs/processing/backends/analysis/hmm_axon_torbi.py +100644 blob e4a0f6db969233c1a54965b8d020a94324e4b6e1 openhcs/processing/backends/analysis/metaxpress_utils.py +100644 blob e4c892a60960fee7d0616c21e50923b9a7b96ac1 openhcs/processing/backends/analysis/multi_template_matching.py +100644 blob 69097f969b7b0b4ff686801c54c213f59030e6d3 openhcs/processing/backends/analysis/neurite_outgrowth.py +100644 blob 37df38fbcec3c36db3a531f57a9ed0d3340be10d openhcs/processing/backends/analysis/region_properties.py +100644 blob 8b8c5ed2ca7fd00031ee63704e25802d83a8a190 openhcs/processing/backends/analysis/self_supervised_segmentation_3d.py +100644 blob 934bbff9b5239c5c0f18303f89ff3c0055ed89c3 openhcs/processing/backends/analysis/skan_axon_analysis.py +100644 blob 6f75bae50641177f7ad26b5f1a710d43737436d3 openhcs/processing/backends/analysis/skeletonize_and_save.py +100644 blob adc3401014a6687f86bb23c1ecf7dba269b281db openhcs/processing/backends/analysis/straighten_object_3d.py +100644 blob 5c5aa58b70b41b142c14d2d4714b5eb10dc2d444 openhcs/processing/backends/analysis/test_simple_implementation.py +100644 blob 2f7c0232fb8a0337b9668b09fafc345b774c9e32 openhcs/processing/backends/assemblers/__init__.py +100644 blob 95213d40c65f9a5aae42fba0bd9997d55cee97a9 openhcs/processing/backends/assemblers/assemble_stack_cpu.py +100644 blob 51a82f6c1eb318549d89062e5eda7dd6c0924e86 openhcs/processing/backends/assemblers/assemble_stack_cupy.py +100644 blob d0154da1e83451cb2a04df3ca44283461ce3b7ea openhcs/processing/backends/assemblers/blending.py +100644 blob 07e15485c7f575583466c18d8e18a6e786a21fef openhcs/processing/backends/assemblers/self_supervised_stitcher.py +100644 blob 6f8fdec8e377c22c3c9bc464e6b19dc551844db9 openhcs/processing/backends/cellprofiler/__init__.py +100644 blob e37742d5b15e533ace30050942018bd5c654c139 openhcs/processing/backends/cellprofiler/_backend.py +100644 blob 933a8a3795b9dd487195ed682d7195e87286e267 openhcs/processing/backends/cellprofiler/_preparation.py +100644 blob 9ef9b11ba2ce8f5df3dbe0fce95ed400a7188880 openhcs/processing/backends/cellprofiler/alignment.py +100644 blob e2dd3dac21b4fd0784c7dbd4645aa5e4d3fc1a78 openhcs/processing/backends/cellprofiler/alignment_mutual_information_offset.py +100644 blob 44049e52b8228f9d188edee8846d1c36c608486c openhcs/processing/backends/cellprofiler/area_occupied.py +100644 blob a9bae1830bf65e0cc7f08e8ee046e8478019f3f7 openhcs/processing/backends/cellprofiler/calculate_statistics.py +100644 blob cfa57a57771782fa38065821cf0f9d14f4629a05 openhcs/processing/backends/cellprofiler/classification.py +100644 blob 12e4d220ff5c81efdb956bc0b2625b0294d140b5 openhcs/processing/backends/cellprofiler/colocalization.py +100644 blob bab4be6bee8972fe85f598a70b10287582301558 openhcs/processing/backends/cellprofiler/colocalization_costes.py +100644 blob 1e2bbb7797af6fda71783f1bf4fa7ce023bc11bc openhcs/processing/backends/cellprofiler/colocalization_costes_prefix.py +100644 blob 1675a35307698b0f846b4ef74172e407d90825a9 openhcs/processing/backends/cellprofiler/colocalization_costes_prefix_numba_pearson.py +100644 blob 1c3ebb32745bad21f59f5d4b51711b989be75857 openhcs/processing/backends/cellprofiler/color.py +100644 blob 62fd7e1ba9491ba6a47d5f7791552e9dbaba139a openhcs/processing/backends/cellprofiler/crop.py +100644 blob 28c40ce4f4ca21e5200a4c756a90184e2627d2fd openhcs/processing/backends/cellprofiler/display_modules.py +100644 blob a9bb05ccac93a6ee0fa9e5c14194484bdf05f2af openhcs/processing/backends/cellprofiler/distance_propagation_numba.py +100644 blob 30bc44280dc9eb74ef676295b83071c45bbc2a22 openhcs/processing/backends/cellprofiler/edge.py +100644 blob d96af6072222657701b3f3f4269709e3ca3ceadb openhcs/processing/backends/cellprofiler/edit_objects.py +100644 blob 271424c2ce56c001780bd2f6c3cdb5c3721ecb3a openhcs/processing/backends/cellprofiler/enum_attributes.py +100644 blob 2234aaa77f54ec7e9b47125c6bd28b5ec836a85a openhcs/processing/backends/cellprofiler/export_to_database.py +100644 blob b8f6bd7bdaed683b67694c2b0ae56fcbeaefdd11 openhcs/processing/backends/cellprofiler/feature_enhancement.py +100644 blob d35aafb21e8f98f9c285432745193820a8e0e22f openhcs/processing/backends/cellprofiler/flagging.py +100644 blob 187d4d972da1a04d14772f60e0e8b512280ba4c6 openhcs/processing/backends/cellprofiler/gaussian_filter.py +100644 blob 01dc63bb86bd2ce2edf270a1cf20b16d077ec979 openhcs/processing/backends/cellprofiler/granularity.py +100644 blob 6610ca5eab4e8495f5287078c28665d1a6c25ad9 openhcs/processing/backends/cellprofiler/grid.py +100644 blob db2ba6b1f3bb3f86eb847440cd6a30f7f20afdd0 openhcs/processing/backends/cellprofiler/illumination.py +100644 blob 61bdddcca51cd235da11bc4fb5719dbbf6ffb7ff openhcs/processing/backends/cellprofiler/image_geometry.py +100644 blob d0a1a8834fcd808220d2fda266aa4c38c76aee7f openhcs/processing/backends/cellprofiler/image_math.py +100644 blob e4338ba2f8bc78c75ef575fada11a116ecd0ff93 openhcs/processing/backends/cellprofiler/image_quality.py +100644 blob 06c55e7479039671838596a772c8476cdb24dac2 openhcs/processing/backends/cellprofiler/imagej_macro.py +100644 blob 8fc913576d58cec1fd713022f97e1f8da0c383d7 openhcs/processing/backends/cellprofiler/infrastructure.py +100644 blob cbb6dbcde05b6258cdd94e50482df505511e521b openhcs/processing/backends/cellprofiler/intensity.py +100644 blob c9c89ba06d54155f70de6641b6ab65e60e47d068 openhcs/processing/backends/cellprofiler/intensity_distribution.py +100644 blob 2cef276048a33337346b91012ef1443c666b7d61 openhcs/processing/backends/cellprofiler/intensity_object_quantiles_numba.py +100644 blob 0cc202fd17b9560bc7ced872e1f694b4396a2efa openhcs/processing/backends/cellprofiler/label_geometry.py +100644 blob 2dff878b3aa6e8057822cc999c0e72308a80be01 openhcs/processing/backends/cellprofiler/manual_objects.py +100644 blob 2aa947615101841cf74f2bd90c68872d864f49bf openhcs/processing/backends/cellprofiler/maxima.py +100644 blob 16d8192ad53b8c7b043fdd851ed410c5167e4f15 openhcs/processing/backends/cellprofiler/measurement_math.py +100644 blob 5562ceb4399b2a3f77b165b503e9938994b7e049 openhcs/processing/backends/cellprofiler/medial_axis.py +100644 blob ca24bd2c001f18b5ceb4666c330262a5158bf651 openhcs/processing/backends/cellprofiler/median_filter.py +100644 blob 9aca5367c2107ec46ed37274e744223684cf24f5 openhcs/processing/backends/cellprofiler/morphology.py +100644 blob 11b18b4a1ef0f2f00662ff1757020788df462f99 openhcs/processing/backends/cellprofiler/neighbors.py +100644 blob 4da1708f23b64d1133673b5199960cb704f8b10f openhcs/processing/backends/cellprofiler/object_filtering.py +100644 blob 2ec98235ff889570cbd1260d2b59c24b05330849 openhcs/processing/backends/cellprofiler/object_images.py +100644 blob f7204c73abc3ba593e8f060f99150183f6a6ad39 openhcs/processing/backends/cellprofiler/object_overlap.py +100644 blob cdaeb5cefd0a5242ec72337520f3e4dc3322c6b2 openhcs/processing/backends/cellprofiler/outlines.py +100644 blob 4b0e9396043b2a77032d7a8e0867471f02572bb7 openhcs/processing/backends/cellprofiler/perf_fixtures.py +100644 blob 253aac98d389b9993e5d0c4fd59e029bb5aa0c5b openhcs/processing/backends/cellprofiler/primary_object_diagnostics.py +100644 blob 70c083129a3ef493e9e4aa20c0acd1c257b90519 openhcs/processing/backends/cellprofiler/primary_objects.py +100644 blob d5f9781295390fa9f8694361edc1225378033818 openhcs/processing/backends/cellprofiler/projection.py +100644 blob a775ecd7c2ae4e7af8bdec291f9eadd3a2d76628 openhcs/processing/backends/cellprofiler/relationships.py +100644 blob 796419fcbf71ee254e90df86a85d5cba9836d5c8 openhcs/processing/backends/cellprofiler/save_images.py +100644 blob 63c481fbde837bbf2355f3fd2a332c685ad197ef openhcs/processing/backends/cellprofiler/secondary.py +100644 blob 7a5ced09ad6dc3164521c12490cb281bfa61ae7e openhcs/processing/backends/cellprofiler/shape.py +100644 blob 947ca74c014e6f92d2f034f5275d00cce9d11b14 openhcs/processing/backends/cellprofiler/skeleton.py +100644 blob 0b803b2294a7be62347d68d04a77ed9124333cdb openhcs/processing/backends/cellprofiler/smoothing.py +100644 blob f30171726b5781724e2b7c2e1b60edca6e328e80 openhcs/processing/backends/cellprofiler/spreadsheet_export.py +100644 blob 54870cfcf302757c935bed17facd3cc1e34b342d openhcs/processing/backends/cellprofiler/structuring_elements.py +100644 blob 28050c06e689350792d197908e3a3581d2435640 openhcs/processing/backends/cellprofiler/texture.py +100644 blob 534560c8edefe95024c4206d09944c2b1648dcf7 openhcs/processing/backends/cellprofiler/thresholding.py +100644 blob 8b3634eecee01ba9769dc6c3519cc537dd7f42f1 openhcs/processing/backends/cellprofiler/thresholding_threshold_numba_diagnostics.py +100644 blob 0112751f4d96d2d2bee486bf719f6c06784375b8 openhcs/processing/backends/cellprofiler/thresholding_threshold_numba_diagnostics_quantized.py +100644 blob 73093e0ccd08304e8d1b5467fb2f5b161287bab5 openhcs/processing/backends/cellprofiler/thresholding_threshold_numba_otsu.py +100644 blob ec386f6b50f82becff383363f6bb26c62bf99db5 openhcs/processing/backends/cellprofiler/thresholding_threshold_numba_otsu_histogram_multiotsu.py +100644 blob c04117b1000bddd5f3166da242d44562849e1f87 openhcs/processing/backends/cellprofiler/thresholding_threshold_numba_otsu_weighted.py +100644 blob 3a36e51e4edf87841e6f6c71d0bb93cc4278ee35 openhcs/processing/backends/cellprofiler/tracking.py +100644 blob 09e8bfafe437b366a8ff3455f88a952c36cfb333 openhcs/processing/backends/cellprofiler/watershed.py +100644 blob c9af20347de195c223bb52ca03cf1e4d0e7ca80d openhcs/processing/backends/cellprofiler/worm_geometry.py +100644 blob c35e5eb206c7df4e1d68dc3ba94a7f289116b60f openhcs/processing/backends/cellprofiler/worms.py +100644 blob 7a45afc829bae632434a9a62dd65a693dd6454b2 openhcs/processing/backends/cellprofiler/zernike.py +100644 blob 03663ad92d28c3bf59f6eb713a10586a483d7313 openhcs/processing/backends/enhance/__init__.py +100644 blob f117e97d6a8b17cfdf246c1cc18af0964c612bc0 openhcs/processing/backends/enhance/basic_processor_cupy.py +100644 blob 02620abe29ff107409219d8a8425236bed54995f openhcs/processing/backends/enhance/basic_processor_jax.py +100644 blob 28bc2de3c6af4b197b4ef9b2a7c8a176a58820fd openhcs/processing/backends/enhance/basic_processor_numpy.py +100644 blob 913273eca542c376eba9dc3fa1d7f1aedae63e2f openhcs/processing/backends/enhance/cupy_clahe.py +100644 blob b92eea4ed660d0c33931a485cd7ebe8aac36282e openhcs/processing/backends/enhance/deconvolution.py +100644 blob ab7049e8048893edc7a0e56dcbe77096bb99a368 openhcs/processing/backends/enhance/dl_edof_unsupervised.py +100644 blob ea53c8a072a5efb8c98dd26f1d95bbc39feff0ea openhcs/processing/backends/enhance/flatfield.py +100644 blob a26d1c4091b6818d9d82316020be9ccb89d835ad openhcs/processing/backends/enhance/focus_torch.py +100644 blob 110c46a5cf800b555ce95f45c2843e49dcaabd72 openhcs/processing/backends/enhance/jax_nlm_processor.py +100644 blob 02a2f04e43a95d8fe8e146117d2e52e4c19e4ef0 openhcs/processing/backends/enhance/n2v2_processor_torch.py +100644 blob ff15c8aaf0176cec74a0fa5d382028deda87098f openhcs/processing/backends/enhance/self_supervised_2d_deconvolution.py +100644 blob 688228377f1de34375b0624e39332cfc59b4a0f7 openhcs/processing/backends/enhance/self_supervised_3d_deconvolution.py +100644 blob c81b93b842f83c4ed6ba39f62a5a804344fccb92 openhcs/processing/backends/enhance/torch_nlm_processor.py +100644 blob 3b45e246f511eb2a6cd36aa30f25b7f481d7d536 openhcs/processing/backends/experimental_analysis/__init__.py +100644 blob 5c539cf45240053dc0406064b061fe5317d44441 openhcs/processing/backends/experimental_analysis/unified_analysis_engine.py +100644 blob c2434ed79057229d2de33253e9f0c4e67242397f openhcs/processing/backends/lib_registry/cupy_registry.py +100644 blob d9599bf810f66f83e4f7cf08b2e583cbbeaf4fcc openhcs/processing/backends/lib_registry/openhcs_registry.py +100644 blob 40267442a91ab533b4bb1df6fbab3b0c3373a943 openhcs/processing/backends/lib_registry/pyclesperanto_registry.py +100644 blob 536d827d7072b429b3e48db7a9c4b6991d55a7af openhcs/processing/backends/lib_registry/registry_service.py +100644 blob 9021f71dd2aa7eba3542ea31820957a83a08f029 openhcs/processing/backends/lib_registry/scikit_image_registry.py +100644 blob 9cca8159f8a65ee281fc9f752de20eb2cc771308 openhcs/processing/backends/lib_registry/unified_registry.py +100644 blob 2cafbb0733c6404d51d139ea3713775a890f9d21 openhcs/processing/backends/numpy_runtime.py +100644 blob 58a4adbeaaedc48da41a1e262c66b3e16f3f08d1 openhcs/processing/backends/pos_gen/__init__.py +100644 blob 4ce92bb77e9644bf8c667f0eef3a23a9e9604db9 openhcs/processing/backends/pos_gen/acquisition_positions.py +100644 blob 7d91f49eac4bcbef08027e8216b5e4d7336b2b98 openhcs/processing/backends/pos_gen/ashlar_config.py +100644 blob 3a273ac1d578c77316304234baca6319e0352dc3 openhcs/processing/backends/pos_gen/ashlar_main_cpu.py +100644 blob add8fef0cec4d60300048c5fbb081d692e43cdb5 openhcs/processing/backends/pos_gen/ashlar_main_gpu.py +100644 blob 998d5b8f65685d0024bad214aa0320625dd9e8f2 openhcs/processing/backends/pos_gen/mist/__init__.py +100644 blob 7c274781c1fad039ee7482dc228afb4b6caa8e34 openhcs/processing/backends/pos_gen/mist/boruvka_mst.py +100644 blob 84ac0bd498d894cb9b4ba05e7e90a679b38312ad openhcs/processing/backends/pos_gen/mist/gpu_kernels.py +100644 blob 8dd1bda7f9805436dc67525c3662c6f3c5699c1e openhcs/processing/backends/pos_gen/mist/mist_main.py +100644 blob dbb9ca786ff1c477bf095924e1eefe7b066962de openhcs/processing/backends/pos_gen/mist/phase_correlation.py +100644 blob d1b8b621a66be068904425c391b892686c1dcbe6 openhcs/processing/backends/pos_gen/mist/position_reconstruction.py +100644 blob 5a1fd794ab8fc69416426dc3f1735dc432e54034 openhcs/processing/backends/pos_gen/mist/quality_metrics.py +100644 blob 894bb42b695e42c0c96e4fa0ada245d09f08b0a5 openhcs/processing/backends/pos_gen/mist_processor_cupy.py +100644 blob 370f74a56d1917c79b4fbadc51fe7c847c4a7a01 openhcs/processing/backends/pos_gen/tile_position_artifacts.py +100644 blob 7fe1bd42a787495e77d5ed92c9b4d23118db61ad openhcs/processing/backends/processors/__init__.py +100644 blob 2ea268c5248d863b11d5f743c1155cd3aed1d8d3 openhcs/processing/backends/processors/cupy_processor.py +100644 blob bcf496e7b6111791a847cb3f746a26bf99ae31f3 openhcs/processing/backends/processors/jax_processor.py +100644 blob 58d7847411becdc3b9a46ee41e61b48960078563 openhcs/processing/backends/processors/method_axes.py +100644 blob 5a467e0c0c32a7ccd2519839eb6056bb6936b33f openhcs/processing/backends/processors/numpy_processor.py +100644 blob fb28b5992ac20930ed6620812be6e53e56c84c64 openhcs/processing/backends/processors/percentile_utils.py +100644 blob baccd7347482420807b3afe4437ed964807982eb openhcs/processing/backends/processors/pyclesperanto_processor.py +100644 blob f9a7394275ca947697ab5685c5acf4f7d369a130 openhcs/processing/backends/processors/tensorflow_processor.py +100644 blob cdfa43e13b3abdd0127fabd57e1be1cd0d4a758f openhcs/processing/backends/processors/torch_processor.py +100644 blob 073063d41d22eb5cfc3dbe43318e0fd06e24e7bc openhcs/processing/custom_functions/__init__.py +100644 blob 151259b07ef055549c9fa80e561628a58013eac7 openhcs/processing/custom_functions/events.py +100644 blob 817cbe7737d95492a771498c9304a13dd353e04e openhcs/processing/custom_functions/manager.py +100644 blob 6ee7dcd4344efc942b7548fed2d6a68e945e863d openhcs/processing/custom_functions/runtime_registry.py +100644 blob d28ffb3ebb556b93506d0096b614c73255bbd523 openhcs/processing/custom_functions/signals.py +100644 blob 43c271b9d93465a6a34bcfa6889ae01730308078 openhcs/processing/custom_functions/source_namespace.py +100644 blob efee064eb1772a4359fea6f0ebb996471f03db26 openhcs/processing/custom_functions/templates.py +100644 blob 2bfe204cda9de2a30421517c5bf7bd9d365932d4 openhcs/processing/custom_functions/validation.py +100644 blob 394e9bc2043492d16d34e4815cbb6e0fb886c42b openhcs/processing/func_registry.py +100644 blob a8e58d6dded8ca3f27efc73898d20c227d98dc9f openhcs/processing/materialization/__init__.py +100644 blob ccc305285d4ffe7b9f6265055129569b18c09ee5 openhcs/processing/materialization/constants.py +100644 blob cfa1841f984664580068297b56dab9e550cc5944 openhcs/processing/materialization/core.py +100644 blob d29b4e8f5fddebf3a36e36a74ef2e440a75eb7e1 openhcs/processing/materialization/options.py +100644 blob 85e9b481e8c12714f8faefbd2cc48d6a8570ce76 openhcs/processing/materialization/path_scopes.py +100644 blob 8408c47ceb46ad9387f44a7668b324be113da52f openhcs/processing/materialization/presets.py +100644 blob d2dce06c48c1df97f43880be792ab3f04a26822c openhcs/processing/presets/__init__.py +100644 blob 6ff8cc2699b39feb13f3b473c55ee3b1e1700acd openhcs/processing/presets/demo_contribution.py +100644 blob e996c15de1999613d59b42cbf35b59a01b3a0605 openhcs/processing/presets/mfd_specs.py +100644 blob f8bea827c82378c995987732a89646b72869fc27 openhcs/processing/presets/pipelines/10x_mfd_crop_analyze.py +100644 blob 78ad1b0aa05654d36806a42e2eebebce52fe46f4 openhcs/processing/presets/pipelines/10x_mfd_crop_analyze_dapi-fitc-cy5.py +100644 blob b605b9b0e7e1856fef259cf0df6b304a5f3d78b5 openhcs/processing/presets/pipelines/10x_mfd_stitch_ashlar_cpu.py +100644 blob ab86eb0cf5e598b4c6579c7d6eaec24939fafc39 openhcs/processing/presets/pipelines/10x_mfd_stitch_gpu.py +100755 blob 170e2510f17b6fb0c6fd8a6eeba23543535e6fbf openhcs/processing/presets/pipelines/cy5_axon_cell_body_crop_analysis.py +100755 blob 2effc552b80cf08c0434d467d74a4ec18b3e33e5 openhcs/processing/presets/pipelines/cy5_ctb_cell_count.py +100644 blob a9896b3930b33036638af8536b16e6e6c7d592ca openhcs/processing/presets/pipelines/czi_brain_axon_cellbody.py +100644 blob 6c3696f63cba85f512835295a221b91828ee4b81 openhcs/processing/presets/pipelines/imx_96_well_neurite_outgrowth_pipeline_cpu.py +100755 blob 7a03e90dd33ecea5b5003d3606bfa5f50d1cb80b openhcs/processing/presets/pipelines/imx_96_well_neurite_outgrowth_pipeline_gpu.py +100644 blob 3434bf4d5148396cdf8fe3b125cd266ed21b9ed8 openhcs/processing/presets/pipelines/loose_operaphenix_neurite_outgrowth.py +100644 blob f73f534ad63d588fe9918d6068297dbc38d325f1 openhcs/processing/presets/pipelines/loose_operaphenix_neurite_outgrowth_metaxpress.py +100644 blob f97743b06879a3af020f895880d1b36755b04033 openhcs/processing/presets/pipelines/neuroncyto_ii_crossover_neurite_outgrowth.py +100755 blob e171c96bb2a913b0241b9e90203aa3e706f28515 openhcs/processing/presets/pipelines/test.py +100644 blob 82ea9a85f2aed1647d1f2851dd1b8852d217865d openhcs/pyqt_gui/__init__.py +100644 blob da81b2ef682fd670bafcd89538157a4d327fe8cf openhcs/pyqt_gui/__main__.py +100644 blob da386d227110d01a2265bad20bc8b1334c0ae444 openhcs/pyqt_gui/app.py +100644 blob 079af1312e6e318611f807ef94837710f0d9abbc openhcs/pyqt_gui/branding.py +100644 blob eca20f9cc567a63c5c1bbf054c357e1cf1d31463 openhcs/pyqt_gui/config.py +100644 blob f6e4bd81fafec561cfc006f7b7fbc11349fc4a8b openhcs/pyqt_gui/dialogs/custom_function_manager_dialog.py +100644 blob 8fcb6c9836feafc855aa6a97cee04d7e76b36932 openhcs/pyqt_gui/dialogs/function_selector_dialog.py +100644 blob 43e91c21b85c54ad97363a8f8f246de0702bb857 openhcs/pyqt_gui/dialogs/metadata_viewer_dialog.py +100644 blob 9af8701a49a3b35988e00befe4e72cef44c32da1 openhcs/pyqt_gui/launch.py +100644 blob 79a7d7219a1845255e1045ee859675e639a95a4a openhcs/pyqt_gui/main.py +100644 blob bc2f7b0c361dba634feba8f9cbb5eb26b9eb67d4 openhcs/pyqt_gui/services/__init__.py +100644 blob b77aee859b3c00a853a6c903bc68a65b0afa6878 openhcs/pyqt_gui/services/code_document_normalization.py +100644 blob b7fed8685bc14d0a11ff07307c88c62e9a130ae7 openhcs/pyqt_gui/services/config_window_code_document.py +100644 blob dd90f63debe36dfd7667b1b7ca02086cb435e9e6 openhcs/pyqt_gui/services/desktop_restart.py +100644 blob 3b2c3a837c3cc8c62c94eab7e8c635a521718e43 openhcs/pyqt_gui/services/desktop_restart_worker.py +100644 blob 1e03a55acdb2b15bf74719d339bcc3f5a046c6d4 openhcs/pyqt_gui/services/desktop_update.py +100644 blob b30ccfb23634bf2d853a9cdf24bbc98003c9da18 openhcs/pyqt_gui/services/desktop_update_worker.py +100644 blob 6126b9447c336fd4e3e6c0d65af1b149cb8678d0 openhcs/pyqt_gui/services/embedded_code_documents.py +100644 blob 810a14079cc3d125fed1887d3b858d3b86a7efba openhcs/pyqt_gui/services/function_step_code_document.py +100644 blob b888ce021de97eba3b9aa68ae12d8ec1ddc72b74 openhcs/pyqt_gui/services/history_migration.py +100644 blob 5291dceda777df23c0adffff2dd40870119882e8 openhcs/pyqt_gui/services/logging_config.py +100644 blob 752c2b59edebadea70738a2efafae94ad4f08715 openhcs/pyqt_gui/services/main_window_workflows.py +100644 blob 8a573ddf5c2efa8dcc5c288c31258775db3b0cff openhcs/pyqt_gui/services/pipeline_object_state_binding.py +100644 blob a801c7d30f3ceb9fe7d767e4a8b097aa4e8b66cc openhcs/pyqt_gui/services/plate_manager_batch_workflow.py +100644 blob e2a3c31428974b4b7f50069b03985c81363b179e openhcs/pyqt_gui/services/plate_manager_root_state.py +100644 blob 0bf5ea79225dbf19f365c67c33d6f9be2ce953bb openhcs/pyqt_gui/services/plate_manager_row.py +100644 blob 9974fddefdaac74661be2827a06cf88fce70dc35 openhcs/pyqt_gui/services/plate_manager_state_projection.py +100644 blob 1cbc75ff3b34e425feb42671038794b5062a10d5 openhcs/pyqt_gui/services/reactor_providers.py +100644 blob 45d65792b706c6ac19c0eef974c4555b06d1e5d5 openhcs/pyqt_gui/services/service_adapter.py +100644 blob d6a5cfa87f7dcfc2b338dfea4d551956f7ad9584 openhcs/pyqt_gui/services/step_scope_identity.py +100644 blob 067bf0f85f8eb6648b08b4fb23e3d6036cbf3aaf openhcs/pyqt_gui/services/time_travel_navigation.py +100644 blob 5157332071bb5f1208595bd2f5223dec52da2bd4 openhcs/pyqt_gui/services/ui_agent_bridge.py +100644 blob cc6ee9240cf5ef3286f137b99647ee9f5d8d6b3d openhcs/pyqt_gui/services/ui_bridge_composition.py +100644 blob ca033a007d097206e4cfe8cffd3ecc090c246a0e openhcs/pyqt_gui/services/ui_bridge_contracts.py +100644 blob 171969e65ec4912a59ad2754bdbcaa571b4b0054 openhcs/pyqt_gui/services/ui_bridge_live_overview.py +100644 blob da3958dcc2366b233ee189d940083a33ea43e163 openhcs/pyqt_gui/services/ui_bridge_object_state.py +100644 blob 760a0a1e17964c196d9ab4553d4c1876e0e395e8 openhcs/pyqt_gui/services/ui_bridge_object_state_scope_policy.py +100644 blob 0b36957d9bd6440863c3a7f28987d55b05d38873 openhcs/pyqt_gui/services/ui_bridge_pipeline_editor.py +100644 blob bd0f0e3dfe674e72c4e8e9b9293ebd95e2755e19 openhcs/pyqt_gui/services/ui_bridge_plate_manager.py +100644 blob 8f4feca7bb477bb26a17541061555c780f961979 openhcs/pyqt_gui/services/ui_bridge_registry.py +100644 blob a84711d751c00d067c18a9ab2a9e7de49b382798 openhcs/pyqt_gui/services/ui_bridge_server.py +100644 blob 05d00b6b6feba3611cc7596d25d04ecce2cd2d39 openhcs/pyqt_gui/services/ui_bridge_windows.py +100644 blob 59a60a848ee331a8d3eff3a01739dfa91e80d49d openhcs/pyqt_gui/services/ui_window_ids.py +100644 blob b607b7ee9af9ed123dd6082658aa7fafb60bbd03 openhcs/pyqt_gui/services/window_config.py +100644 blob f392b15d6bebaf94d7df3bc5b527a4135d401d3a openhcs/pyqt_gui/services/window_handlers.py +100644 blob 164fa7ef54c4ce585981838dd6fe9122565c2e8c openhcs/pyqt_gui/services/zmq_version_restart.py +100644 blob 6d6a772a10cc7cbc28956ef3c267c125220d6789 openhcs/pyqt_gui/ui_tab_identities.py +100644 blob b22dc70c0f73a7182843b94e4d5543d9a9b3560b openhcs/pyqt_gui/utils/__init__.py +100644 blob b878bd7587cb6d09d8b851be1c5c69b1a39d5f37 openhcs/pyqt_gui/widgets/__init__.py +100644 blob 783c1da07398be427c946e8ff1b45d263aaac6d3 openhcs/pyqt_gui/widgets/artifact_plan_view.py +100644 blob 69934c10e1dc210eb356dffc4db057a84a281500 openhcs/pyqt_gui/widgets/config_preview_formatters.py +100644 blob 433fe92d944a5cf846a25fe6c38ac3896a53ec0d openhcs/pyqt_gui/widgets/debug_toolbar.py +100644 blob 6c92831bcba67c2bc19ab5ef7904bc2dd6987bd1 openhcs/pyqt_gui/widgets/image_browser.py +100644 blob 2662a7fe8a40a289c22f15cb4d959ef5734bf87d openhcs/pyqt_gui/widgets/pipeline_editor.py +100644 blob cb8be747da24a2182aa1a4f14c6a688d1f85bc7e openhcs/pyqt_gui/widgets/plate_manager.py +100644 blob e8cc6f17feb549222aadb41cbe8637693a4a12f3 openhcs/pyqt_gui/widgets/shared/__init__.py +100644 blob be8274dc5418db5a837f36ce898cd87cbe585709 openhcs/pyqt_gui/widgets/shared/openhcs_manager_mixins.py +100644 blob 088af711ee7a6a5efa008674c9cd3ef7d9c9aaec openhcs/pyqt_gui/widgets/shared/plate_view_widget.py +100644 blob a6b7da3abb2696d372f16064703d5d2fd69ef1bb openhcs/pyqt_gui/widgets/shared/server_browser/__init__.py +100644 blob e7046d8bb53bc68c12391bcf41fc7af6bf0d4ab9 openhcs/pyqt_gui/widgets/shared/server_browser/live_tree_sync.py +100644 blob aab2b38c6e99f1fc40086979ac302a48c85152f3 openhcs/pyqt_gui/widgets/shared/server_browser/presentation_models.py +100644 blob b1a1e522d3f6eed54c71dc9ecdaeab0c8816f22c openhcs/pyqt_gui/widgets/shared/server_browser/progress_projection.py +100644 blob 0ed9259f71cfda809877bd1daad5970e4c3c9b65 openhcs/pyqt_gui/widgets/shared/server_browser/progress_tree_builder.py +100644 blob ab909cedde74d4001e5ad48e5cb68a32eac7962a openhcs/pyqt_gui/widgets/shared/services/batch_context.py +100644 blob e5f2169cc66a5eb4936ab93f9491a4fa2cc6a576 openhcs/pyqt_gui/widgets/shared/services/batch_workflow_components.py +100644 blob fc1595df6c4c6308bdfa7fabb138d6a27fbc412f openhcs/pyqt_gui/widgets/shared/services/compile_batch_workflow_service.py +100644 blob 7e9e8f1fb666e0bc38c920506ec5fd3c831882d8 openhcs/pyqt_gui/widgets/shared/services/compile_workflow_service.py +100644 blob a97022bb9fc4cceca40def4b022ec28350bee506 openhcs/pyqt_gui/widgets/shared/services/debug_progress_service.py +100644 blob 8f38e47e53787e35db2dbe4e3d1517be7a8a0520 openhcs/pyqt_gui/widgets/shared/services/debug_session_projection.py +100644 blob 86349b6a98ab6d38784df949c955f23c0c4f618d openhcs/pyqt_gui/widgets/shared/services/debug_workflow_service.py +100644 blob f6a3c601d61d5498bb2ec45a80e60fc881cc1756 openhcs/pyqt_gui/widgets/shared/services/execution_control_service.py +100644 blob 48b4f6f9f60ca566e261caf61c576158ce976769 openhcs/pyqt_gui/widgets/shared/services/execution_server_status_presenter.py +100644 blob 193f7970dba77a59148e79e66b21f2c73ea16820 openhcs/pyqt_gui/widgets/shared/services/execution_state.py +100644 blob 6e96d00055411bd5e3cdb2c28a3ffe6137febd5d openhcs/pyqt_gui/widgets/shared/services/execution_submission_service.py +100644 blob dbe1657c0c98623678443c2a628aa92b6108fe20 openhcs/pyqt_gui/widgets/shared/services/gui_event_bus_broadcast.py +100644 blob afac4f61ae8a4134e37ad7ef0048ef531a3dfa3f openhcs/pyqt_gui/widgets/shared/services/live_measurement_progress_service.py +100644 blob 674b313fe4c95c6d4c8c0df3de87c10900df1b54 openhcs/pyqt_gui/widgets/shared/services/pipeline_debug_actions.py +100644 blob 930ba13ab7dc00ac46c136d9b781e740d98c4cd8 openhcs/pyqt_gui/widgets/shared/services/pipeline_editor_workflows.py +100644 blob cc9d7800090fa862c70d907a7b1cb1b790384f6d openhcs/pyqt_gui/widgets/shared/services/plate_config_resolver.py +100644 blob 7af63ba8f10b3d9cab01c97bc0aea5dfd31f9173 openhcs/pyqt_gui/widgets/shared/services/plate_manager_workflows.py +100644 blob 69154212da89e1f008a6cc4bd5f9be7229630f03 openhcs/pyqt_gui/widgets/shared/services/plate_pipeline_request_builder.py +100644 blob d08759971ed044b4a5d100102f957df350988a96 openhcs/pyqt_gui/widgets/shared/services/plate_status_presenter.py +100644 blob c59e3bfd49dc80ed139dc050edb490ad6d6525ee openhcs/pyqt_gui/widgets/shared/services/progress_batch_reset.py +100644 blob 8529f045a3a9c012d5cc02361fbe270a69ae3540 openhcs/pyqt_gui/widgets/shared/services/progress_workflow_service.py +100644 blob e4838b52ea82edd68852c663e27eb7897934b2ea openhcs/pyqt_gui/widgets/shared/services/qt_widget_edit_commit.py +100644 blob 36c49a19d3a61e2fbddda264bdf6bb81b9e52f83 openhcs/pyqt_gui/widgets/shared/services/runtime_artifact_progress_service.py +100644 blob f3877f264af12e4e44fb8bc2e953eff09cfdc041 openhcs/pyqt_gui/widgets/shared/services/widget_action_dispatch.py +100644 blob d0ebfb996ad83c87b22591d030a8e7f52b226037 openhcs/pyqt_gui/widgets/shared/services/zmq_client_service.py +100644 blob a2505a5aa778dd42e385fb6d9f635739758ccc9c openhcs/pyqt_gui/widgets/shared/time_travel_widget.py +100644 blob 3f0f181d3f4a5f478b61a600c5f192cf502a2570 openhcs/pyqt_gui/widgets/shared/zmq_server_manager.py +100644 blob 5fe669561237afc864fc960dad262f35e5bb5d7f openhcs/pyqt_gui/widgets/source_bindings_editor.py +100644 blob 29e5f5fa27e29cc38471ed8d9774d8289379e736 openhcs/pyqt_gui/widgets/step_parameter_editor.py +100644 blob c7a7e38fdf321a8a69c9344c1c9f5719f3005a15 openhcs/pyqt_gui/windows/__init__.py +100644 blob 5e8c252dd782b6942bb71ec7b57acbccaed5b25b openhcs/pyqt_gui/windows/about_window.py +100644 blob 21c79189d40a4016a32dab2b968951bc4178f992 openhcs/pyqt_gui/windows/config_edit_session.py +100644 blob 8887b717dc66d325db4c60b4aaf60048b400c5f6 openhcs/pyqt_gui/windows/config_window.py +100644 blob 1501b23c584614af8ac03f444a6212e982d9aafa openhcs/pyqt_gui/windows/debug_inspector_window.py +100644 blob 46eccfe9be1766af6ab40bbcdbb83fef84b6772d openhcs/pyqt_gui/windows/dual_editor_session.py +100644 blob 02dd99e126ff188bb77e32f75e2c286c5a1b446b openhcs/pyqt_gui/windows/dual_editor_tab_builder.py +100644 blob 2e19b0ddd6b9cf0768250f87952891fc0f47ed1c openhcs/pyqt_gui/windows/dual_editor_window.py +100644 blob 3e9de46cba8e6c6c2e81ff1ac046a233e2108946 openhcs/pyqt_gui/windows/help_window.py +100644 blob a7d34283c39cd20ddd7f73212f714d31a841a667 openhcs/pyqt_gui/windows/live_measurements_window.py +100644 blob 0b913d394c472a6703da31facb63ee843fef6e6e openhcs/pyqt_gui/windows/managed_windows.py +100644 blob 9973a47db2306d72d99927aec91a17cb0eeafe56 openhcs/pyqt_gui/windows/plate_viewer_window.py +100644 blob 24b231a243cbc8762ac882092c8d3ee8579b755c openhcs/pyqt_gui/windows/snapshot_browser_window.py +100644 blob 70a7ca0f5d5db5cf335725fbb76fb6847f5a1bc7 openhcs/pyqt_gui/windows/synthetic_plate_generator_window.py +100644 blob b718f1ecb0e2e3920452431976e11772cfc83bd2 openhcs/resources/__init__.py +100644 blob 2e4f77b86926d26a5a2c801abd79f588867cc577 openhcs/resources/brand.py +100644 blob a80475dfbae28cd8fe0e2a09b5b17ff747faf6d4 openhcs/resources/windows/__init__.py +100644 blob 373c9821be1bd923bb41bed5ce1a6b6c4c1d5838 openhcs/runtime/environment_provenance.py +100644 blob 7810f2edcd447c460c1a5bbddd0a89255ce648fa openhcs/runtime/fiji_macro_runtime.py +100644 blob bf1fc21183f37fb5ada7f06b4915f9669f4ce674 openhcs/runtime/fiji_stream_visualizer.py +100644 blob 82f602b53f209126649de3076d629faa7ae6dfca openhcs/runtime/fiji_viewer_server.py +100644 blob cd5e090f6389d5c6de17b8c89f69dc5735d19701 openhcs/runtime/function_catalog_preparation.py +100644 blob 17916eeac25867e46752900fccb21807c57c1243 openhcs/runtime/import_authority.py +100644 blob c1309477beb3cc17ae84197b1f55c841584640ff openhcs/runtime/napari_orthogonal_widget.py +100644 blob c7cd97eb1543d5a17fd054aa8add7665eba5f1d1 openhcs/runtime/napari_stream_visualizer.py +100644 blob 61c304ecf2db2a59543201dd6dd2da96a81dac9c openhcs/runtime/napari_streaming_handlers.py +100644 blob 6057d7c5c2767c25473c0855f8c73a4fda43a28a openhcs/runtime/napari_swc_reader.py +100644 blob 7301a4d65c8e5998db088a4cc9feb0de061ebfd0 openhcs/runtime/napari_viewer_server.py +100644 blob 07198c23c437d775b807843e0e99026a6e135f18 openhcs/runtime/omero_instance_manager.py +100644 blob b2714800aac06a621550b1209b414c7737cdc34a openhcs/runtime/viewer_component_system.py +100644 blob 023ebbcac7c9d550688fdef1cfdd7289f93f8932 openhcs/runtime/viewer_controls.py +100644 blob 4df0827453a1032136af19d04cd9860b841e4520 openhcs/runtime/viewer_measurements.py +100644 blob 39e6e7abbbe696156cf67ecda912f99fa0e39eeb openhcs/runtime/viewer_protocol.py +100644 blob 843a9296c74dd5c4d859f7707dd68cdc3923bc08 openhcs/runtime/zmq_application.py +100644 blob f20ef7f6d5c65b47b7ee37ac3a48a2e3a1a07962 openhcs/runtime/zmq_compilation.py +100644 blob 3285aeefb0a22e196da500a22446f1de67d361f0 openhcs/runtime/zmq_config.py +100644 blob c2c09965467ebe8fcc9a6d62db95a572b808c312 openhcs/runtime/zmq_control.py +100644 blob b01d9599125557937758274bf9598f72fc19f8a9 openhcs/runtime/zmq_execution_client.py +100644 blob fecffce4120f276f9a748a98f027bdfc30e59860 openhcs/runtime/zmq_execution_observation.py +100644 blob ce858a0a2f027833056d779aae3658a4433610aa openhcs/runtime/zmq_execution_server.py +100644 blob 477fd88c7ede02d33d151e802b7e1165f58da363 openhcs/runtime/zmq_execution_server_launcher.py +100644 blob db76c61f2f66167c08839605324ffe9d7003c00d openhcs/runtime/zmq_execution_signature.py +100644 blob 1f555953f45dfa1e2973cc04aaacf8d231d6ec74 openhcs/runtime/zmq_orchestrator_environment.py +100644 blob c7b22ceb7d06b154ae72a9c0879d6a31ddd4f0e7 openhcs/runtime/zmq_progress.py +100644 blob 1475f718dacdbd663da7f77855702ca6fc59c158 openhcs/runtime/zmq_server_hooks.py +100644 blob 7da7cc1ca98180a2818dedad179b222681556699 openhcs/runtime/zmq_worker_execution.py +100644 blob a955ce8f6ec5956a2fb5968f13fd042c7f4c9413 openhcs/serialization/__init__.py +100644 blob 392de3473765297d90b2897b482b1238c3bb0486 openhcs/serialization/json.py +100644 blob 7ce679c45ba144998ef63f7b63a84079ca151b52 openhcs/serialization/pycodify_formatters.py +100644 blob 0c8a5c31288c822cddb00f35166622c6a7da1f61 openhcs/serialization/source_path_factoring.py +100644 blob 2c77a132726df0b26d25ad154413b6a225025e2b openhcs/ui/shared/__init__.py +100644 blob 9c72d1a5d68d726b965fb9227c4a3d6e28819fea openhcs/ui/shared/code_editor_form_updater.py +100644 blob f9ee4b4f1da14308aaa5eaca23077f4af50ee048 openhcs/ui/shared/pattern_data_manager.py +100644 blob 8df81e5e139c47f94153f25dd1d17c67ae9089b2 openhcs/ui/shared/pattern_file_service.py +100644 blob cb9e47acba6940822163ed43fee924436cef7614 openhcs/ui/shared/plate_manager_code_document.py +100644 blob 4fd2b2680d9d6b47bf75ae4aea6f1328f5a25102 openhcs/ui/shared/plate_scope_identity.py +100644 blob 38ca51f16c7c2288ab21b548503be69dd8926290 openhcs/utils/environment.py +100644 blob 377896e6105e8bce8b880512a2130b30ee76a7dc openhcs/utils/import_utils.py +100644 blob 3156362eeec15fdfd708331d7e26a0c134d3833f openhcs/utils/performance_monitor.py +100644 blob 27456f1e1fdf7ad875bc167fa44c285a8b0e6273 openhcs/utils/pipeline_migration.py +100644 blob 41caf87c07b85e9fbd78233df2764372d0fff06e openhcs/utils/recache_function_registry.py +100644 blob 0a859c0712560de3cfe0e6d8aab49137875f392d openhcs/validation/__init__.py +100644 blob 5e461e920b4e3d4ee89fe50a4fa69db2baf2181b openhcs/validation/ast_validator.py +100644 blob a59e294c2b49f82969f8085cb8c1f6aa39affe2b openhcs/validation/validate.py +100644 blob 5254fc4556d58103f070ad28dccdbe1529f369cd packaging/mcpb/openhcs/server/main.py +100644 blob 1fd7b4c998d8faa72a7f054cbe66a91f0b084b2c paper/build_docx_from_markdown.py +100644 blob fe8465d890f6326a319f4aae748f1d7758aa0b2b paper/build_paper.py +100644 blob 71cb29d179b6e23fa1d1b35625bea05caf75c675 paper/figures/build_slas_agent.py +100644 blob a993da114cfd2a7611d480420d1399c9ae4b680e paper/figures/build_slas_benchmark.py +100644 blob 738840623263b13eaeaaa0bfc887ddc954a6402d paper/figures/build_slas_cellprofiler.py +100644 blob d8eece5b32662fbe1c36eef1944fced6f129bf57 paper/figures/build_slas_compiler.py +100644 blob e3209f3d49cc2de0a06af489d01c58533cee831d paper/figures/build_slas_complex_workflows.py +100644 blob f3219f9ea78d1f7aa7ed03c1b0b2d4ffa883db84 paper/figures/build_slas_extension.py +100644 blob f04802386018e2963fe7a9bac24777eb0c861432 paper/figures/build_slas_independent_validation.py +100644 blob 537145378b299d7a7500ffaad08c97bb07d6a3eb paper/figures/build_slas_outputs.py +100644 blob 25377725a4d5c0dba9c3190933e3d7fc6a62ff69 paper/figures/build_slas_processes.py +100644 blob 102f818f5391aa33da090ddb1aade0e75cc24b61 paper/figures/build_slas_runtime.py +100644 blob 495c97800c805c46a6ea385719b65b97d78ce819 paper/figures/build_slas_visual_story.py +100644 blob 6d4c0e8d1ebf1dda3a1a6ee8fd1e249e170a027e paper/figures/capture_slas_authoring.py +100644 blob a44c45f21659b1a440a2d4bc208b63de0a45a42e paper/figures/render_diagrams.py +100644 blob 4c8bb350d08e9f65693dfcaeb1ae1350db7c5e8c paper/figures/slas/cellprofiler_translation_imported.py +100644 blob c4b550b0956eb956a94284e9ee9fff1f2257d09a paper/figures/slas/custom_signal_example.py +100644 blob 68f6e5662d77a04b3d29999a6be1c672ff2d158b paper/figures/validate_slas_roundtrip.py +100644 blob ff043c8bda043c26f0ff4c44e733400e5ba111b9 paper/supplementary/cp_tutorial_3d_monolayer_imported.py +100644 blob 53c3ff5ae3ab4cb4d72d30708772a7c1fe292162 paper/supplementary/cp_tutorial_advanced_segmentation_final_imported.py +100644 blob eb1c53b737017d6a2cd4abdd80c3214c8b1a7307 paper/supplementary/independent_validation/bbbc007_frozen_pipeline.py +100644 blob acbb9f32130694332366c7b82ddec6d3852e89a4 paper/supplementary/independent_validation/bbbc013_frozen_pipeline.py +100644 blob e90c669499719da95251c21d02f05ee3b3a608ff paper/supplementary/independent_validation/bbbc039_frozen_pipeline.py +100644 blob 29298369aae0e49c328244b72efad0256716ae69 paper/test_build_paper.py +100644 blob 33fc6500a5854ddc46c362b4030ae991206aea77 paper/test_build_regressions.py +100644 blob 22b12a5265b1543309726c48ee4b6931df6bda12 scripts/annotate_wells_with_experimental_metadata.py +100644 blob 65081edc41f5fe3f1f097e2f930cdeed216880c5 scripts/benchmark_cellprofiler_fixtures.py +100644 blob ec2da5a6067db6034128691be2475f90a0a27d2a scripts/benchmark_cellprofiler_vs_openhcs.py +100644 blob 8ac95419807513575437c6bc68336ed680088732 scripts/benchmark_cppipe_throughput_scaling.py +100644 blob accdb6e5ea635b50a0f6dc2ff88c78fd730a70f7 scripts/benchmark_cppipe_well_throughput.py +100644 blob 21fe7fdb623b9825d450d64ca73289aa1f9f3566 scripts/build_hosted_mcp_plugin.py +100644 blob 62cc57527182d038259f32dc00f075b475438ee7 scripts/build_mcp_knowledge_assets.py +100644 blob f882b23b699f881fb7e424422a4626c740cc71b0 scripts/build_website.py +100755 blob 3ec6921dd7b4df94a672ea7209d7f32e19569e6e scripts/capture_media_gallery.py +100644 blob 3bba3192c92c6f007ec7d65f3c350edac3a1a39d scripts/check_mcp_memory_ownership.py +100644 blob abc301fe8d4203a9015e618cf660d424436b6e01 scripts/check_refactor_r1.py +100644 blob ee9d2838cce3e6ffba238e0cc82632e053aa2a45 scripts/codemods/audit_cellprofiler_declaration_semantics.py +100644 blob 1b1da77529a1c73d9f8ffb45d84ac700dc8b30d8 scripts/codemods/collapse_cellprofiler_artifact_binding_declarations.py +100644 blob 3244962307818d9773f9074efa3546ac7f08885b scripts/codemods/collapse_cellprofiler_artifact_output_hooks.py +100644 blob 76ac27caabb2ae5ba0dd50e48edc6c9f92844b7c scripts/codemods/delete_cellprofiler_special_input_policy.py +100644 blob b5ebd4d4e92d754e51abddf7724d0f61fdd60f9e scripts/codemods/delete_cellprofiler_typed_artifact_mixins.py +100644 blob f659abaee3b906f5fd4d78f5cedad492c55be1c5 scripts/codemods/migrate_runtime_input_binding_request_api.py +100644 blob a1a29a51ec970b3ecb4977b958c7cc35ff7f0246 scripts/codemods/order_cellprofiler_setting_binding_declarations.py +100644 blob 44ca43b9d1a6713c8a212d1219266584a8aabd5d scripts/codemods/replace_cellprofiler_typed_binding_queries.py +100644 blob 978b332f925bb5807aef01596d393873515064b4 scripts/codemods/split_cellprofiler_module_measurement_owner.py +100644 blob 406084a6ea9eefaecaad3d815815ad32db6983f4 scripts/codemods/split_cellprofiler_module_settings_owner.py +100644 blob 2bc59f6a9a205bcbe547a2c30946b8523224292f scripts/dev_install.py +100644 blob 156d789970381d026830db06633708b616ae5266 scripts/figures/generate_automated_plots.py +100644 blob 7da64d82fe69263d4874d5b794db54f44b5d394b scripts/figures/generate_figure_mosaics.py +100644 blob 1cdb8b4832d7050982b396e9657a6bc55a6b3af8 scripts/figures/generate_figure_overlays.py +100644 blob 757c540d2ab03a1de33a0221b5d5bd11606b1206 scripts/figures/generate_xy_xz_composite_figures.py +100644 blob af4f8e32e0677b559b4eccb6631cd1ecddcf06cc scripts/figures/orthogonal_projections/__init__.py +100644 blob d999315c3f3fe62c7f2c58b8b4a47c5a9d85e898 scripts/figures/orthogonal_projections/cli.py +100644 blob 33a5c996c6a0edcd3946457dd73fdb42897c4832 scripts/figures/orthogonal_projections/composer.py +100644 blob e721856f78fe475e0cb4083af4f268b5a33199b9 scripts/figures/orthogonal_projections/constants.py +100644 blob a57d0f2bbe40046425c0da953d0514d400aae35a scripts/figures/orthogonal_projections/discovery.py +100644 blob 2de132e1f20b3ba5c090b72ca258e8bebb1b7a2c scripts/figures/orthogonal_projections/exporters/__init__.py +100644 blob 6bfc1fe7381e1381719ec96410bad9d5824ff643 scripts/figures/orthogonal_projections/exporters/assets.py +100644 blob d213b2ae094a9252e026b68e45378f8beb051631 scripts/figures/orthogonal_projections/exporters/grouping.py +100644 blob abfe358c86fabe0aaaab868fed354988b2b71ca6 scripts/figures/orthogonal_projections/exporters/layouts.py +100644 blob 75f0fe1047a8c526b4a1128e2156a2fd314b4c5e scripts/figures/orthogonal_projections/exporters/models.py +100644 blob 1a2dfd2b5ca3102d41720d912e3e844d1a48702e scripts/figures/orthogonal_projections/exporters/powerpoint.py +100644 blob 01770119e862f1e86a50fcb7b4c5ca9bfd0eccc8 scripts/figures/orthogonal_projections/exporters/service.py +100644 blob f642579f615776f99f0e4f4e8efaa4233f1318dd scripts/figures/orthogonal_projections/io_handler.py +100644 blob 816d8b916cf1465ed635c7750b177345bb9ae56c scripts/figures/orthogonal_projections/labeling.py +100644 blob 5b7b068bb080a493de33b65d2bd4efc2bbbb57ad scripts/figures/orthogonal_projections/mosaic.py +100644 blob 498ecbaadfb3c4729abb058fd15faee4c2e58a41 scripts/gallery_catalog.py +100755 blob 45b88aafe5e7a6858eadaffb27303f339e968195 scripts/generate_brand_svgs.py +100644 blob 9268f024f4a08147aa1942ad5a47e45527919c28 scripts/generate_cppipe_benchmark_figures.py +100644 blob 804b0e038d9aea511bc088ee3cef7b1b38c78a92 scripts/generate_cppipe_throughput_figures.py +100644 blob 930ef59050725cf25098578a4c11fc6481176981 scripts/generate_lab_meeting_deck.py +100644 blob 21d65255de594ec60ad11660fc6eb495fcbe50ff scripts/generate_lab_meeting_summary_figures.py +100644 blob bd0c89fdc5f441a6522f34acab6e81c553ed4238 scripts/install_ci_candidate.py +100644 blob 51fbd94b2eedb0fcb5e55492fa2d7821a0184b56 scripts/install_omero_deps.py +100644 blob 695d60b3259b6969f67c052e00d05deb5eec4c11 scripts/master_multi_plate_demo.py +100644 blob a4d07e607d70b46bcee77843b0907013c5bc82ec scripts/mcp_assay_showcase.py +100755 blob 6493345dd03851101568dcca42340dcf8a3938e0 scripts/mcp_thesis_demo_live.py +100644 blob 98ec6045e686c06bb49d238120ba92cc51db1d14 scripts/migrate_cellprofiler_function_facade.py +100644 blob eda2c72c431325ffb6fe7dd5d7b6de66b7b400ab scripts/napari-plugins/napari_orthogonal_projections.py +100644 blob 8cf6e5a2f588d2015067486ad639fa11611c572e scripts/prepare_cellprofiler_benchmark_datasets.py +100644 blob e79b61c24effd93160281bc454be3da28f20991c scripts/prepare_cellprofiler_reference_exports.py +100644 blob dd3a559ac81208c55fe0cad4d8b14d27b640d380 scripts/prototype_flatten_object_state.py +100644 blob ece79e8175583d34778e7090cccf3084f756e7cb scripts/prototype_unified_none_forcing.py +100755 blob b8b6bf111732747adbaf4f6c810ea8aad37a49f7 scripts/release.py +100755 blob c9e71bf9ac685ae08e173da0014dea07395b10d1 scripts/release_readiness.py +100644 blob 78f8a399a69f40e0cfa7e23eff62867e87f28701 scripts/render_installer_contract.py +100644 blob 9e71eb3b52dab9485cb29542bdad2cb28fd84b35 scripts/resolve_successful_job_baseline.py +100644 blob e74c55daca2dd7516a5e23c99be864fc48a44d97 scripts/run_cellprofiler_cppipe_parity.py +100755 blob 9319a31ce945bda2f9160611862266c17f64df92 scripts/run_experimental_analysis.py +100644 blob f12044896f3cbd47a9b43ff8df86c8780efada57 scripts/run_installed_tests.py +100644 blob 23552e5fd8ca677f4c93c773b4f267f4419c75c2 scripts/smoke_installed_desktop.py +100644 blob 63bcf564bc9835d098678d47762605a6fd35e625 scripts/smoke_installed_gui.py +100644 blob a27b06a935c42f5e657dad339d415e83cf6f074e scripts/smoke_installed_mcp.py +100644 blob 84a9f5ec5c2788d66556a08f334e30eec125b5f4 scripts/smoke_native_granularity_wheel.py +100644 blob 5552925c90b6de14aaaa31e72f830f5f1d9dcc26 scripts/smoke_owner_quickstarts.py +100644 blob 2c87e1d5aafaab395121e865f41966ed479009c9 scripts/smoke_staged_desktop_update.py +100644 blob 9ec63f7fd306ae7ad12798011334e2a6e17dff45 scripts/stage_ci_candidate_version.py +100644 blob 81d5db9b5893073bde213d6cad3551563fc18c94 scripts/summarize_cellprofiler_reference_export_run.py +100644 blob 37d5e5e88d9aa05ca13e3d41108e2056051fbe18 scripts/summarize_cellprofiler_reference_inventory.py +100644 blob 231b412840a61d88311c0d74106b4df26ac28003 scripts/summarize_runtime_image_pair_receipts.py +100644 blob 0ea620402ab5be68f9ff4f01de5d15f72ed721ab scripts/summarize_runtime_profile.py +100644 blob 6f12c20692af8e8c1a91cf6e75ca715502adf461 scripts/sync_mcp_release_metadata.py +100644 blob ad8152a2dca0c232f1b273b2fca0258217ce9d3d scripts/test_real_global_config.py +100644 blob 8205bb185dd485646ac9c5efc3983c6c4a62d8e9 scripts/validate_docs.py +100644 blob d03a490c59072da95bbd50b1ae2bc2a6fb9a1862 scripts/validate_local_release_floors.py +100644 blob 3efe95c7f0411ab9e11c44b27344dfdc48893ec5 scripts/validate_wheel_deployment.py +100644 blob 4037ee1fd8f1977df1bed39794d92a384098aabf scripts/verify_existing_imagej_bundle.py +100755 blob 102f0a8867bca49453a62c464dbe0c40d497392b scripts/verify_release_ready.py +100755 blob 6dda218e92ab9a03b84b1412b9b54c8e0dd04f64 scripts/wait_for_pypi_release.py +100644 blob 41990ef6340dc41e559b4407a614dea461b90b0b scripts/website_gallery_projection.py +100644 blob 9273f90ab9ced966c979663a3b7c14a4bec8ad34 setup.py +100644 blob 65140f2e3919fe56b74572d1518910df4a331030 tests/__init__.py +100644 blob 1333c85ee07af95ce4f4865876084bff2ec62390 tests/conftest.py +100644 blob 07d76b903a700ba1c682206ef4b25490fdf388e0 tests/core/test_alias_property.py +100644 blob cea1be974fa35fbea50ce354e21f59e7cec20257 tests/diagnostics/centrosome_watershed_reference_worker.py +100644 blob c7e40e5aa93468efdf654ae5953132f2db872555 tests/diagnostics/check_centrosome_watershed_reference.py +100644 blob a09cb6e5873843b9c076e65f5a8b3072328bc3df tests/diagnostics/check_custom_registration_live.py +100644 blob 0ad003a6936ee712d63eca215f74a3f3c3e23ac5 tests/diagnostics/check_owned_bootstrap_live.py +100644 blob 9fa35d7fe3771216a2e5b8d7db131d612782da87 tests/diagnostics/check_viewer_feature_measurement_live.py +100644 blob 93a92114f1ecc9fdd6a8a1d9d448e9723f15a7af tests/diagnostics/create_native_point_viewer_fixture.py +100644 blob 1909929737d1337cb97bd092609d52af11114b3c tests/diagnostics/create_native_result_reopening_fixture.py +100644 blob f8c833dff2b1f850e1f79bb69607874ce203e15b tests/diagnostics/create_orthogonal_viewer_fixture.py +100644 blob c9d495650982ba257e138bf9c3ac8110f16307e1 tests/diagnostics/owned_bootstrap_readback.py +100644 blob 98b95ddadd4499c705baccb45ab80a9bd365b069 tests/diagnostics/registration_probe_source.py +100644 blob 05e2ebf82b17f23737efdc69046c1757c1293d17 tests/diagnostics/volume_projection_fixture.py +100644 blob c2e6d77665fc759617d9136bfd581215a3cf52b4 tests/installer/test_installed_desktop_smoke.py +100644 blob 0fcf2de68bcec5b912f255ea4c7c65daa5068c2e tests/installer/test_installer_branding.py +100644 blob f66fa6f28e42036175a51fe0fa19b556967cf478 tests/installer/test_installer_contract.py +100644 blob ec5d994ffe964d97a07b8db511b35834800b9808 tests/installer/test_installer_signing.py +100644 blob 75567786d958f058f0e20903ef2049d53d98713e tests/installer/test_macos_dmg_lifecycle.py +100644 blob fe5f4f01fae2f69ec39b994c4165b0053612a363 tests/installer/test_macos_simple_installer.py +100644 blob b5c971f768ac5b771e02da330f523324afe40f5f tests/installer/test_windows_simple_installer.py +100644 blob a853fdb53056ea381e191450ece90fd7f6d0458b tests/integration/conftest.py +100644 blob 5e46effb97d6490e2304fa85881ae8f63e454c95 tests/integration/helpers/__init__.py +100644 blob 21a31b444abdade0eb91271cf82ae75bef617450 tests/integration/helpers/fixture_utils.py +100755 blob bd1f3ac2339a4e1562f0c0e298deba08ef3800f3 tests/integration/helpers/omero_utils.py +100644 blob 66421391821aed9c4f83a116a4d83a74c89037ac tests/integration/test_agent_observation_export_zmq.py +100644 blob 2d2f3da32e0ecb42afc5b351766a0fbafff4bb40 tests/integration/test_benchmark_openhcs_adapter_cppipe.py +100644 blob 2dbe39259c871ff25ae153f00aeec406e733120f tests/integration/test_bioformats_handler_runtime.py +100644 blob 0968698a1280bdd5fae4506cb20af865a25c4166 tests/integration/test_bioformats_imagexpress_synthetic.py +100644 blob f1b9b351311aa41231ec8d0b7e70cbe5e09dd402 tests/integration/test_cellprofiler_generated_pipeline.py +100644 blob bc9cd1df986394ff65e593e8a6d6d7579a5ce921 tests/integration/test_cellprofiler_official30_zmq.py +100644 blob 59c840578c1f013430e24e1082887533a4e99154 tests/integration/test_chained_callable_lineage_journey.py +100644 blob 317bf0469a5d5324e292b886667b156876f681f6 tests/integration/test_compiled_artifact_inspection.py +100644 blob bb25df9c4a8985ae6236c67968855b172c1fe9d8 tests/integration/test_count_cells_simple_dual_channel.py +100644 blob f0f67b247dbd74e18c5713e0c4f62311f7d3a97a tests/integration/test_custom_source_transport.py +100644 blob a01fe828b9434c8c5fd707b82387cb1035c9895c tests/integration/test_generated_source_relative_paths.py +100644 blob a82354e8581a8df7e13c13df003f4a6068b7ae66 tests/integration/test_main.py +100644 blob bbcf1dd880d8752a2fc55c011181d79cd0613505 tests/integration/test_measurement_declaration_journey.py +100644 blob 143033fdd8ceb25d953bb0079c1c283a4b93994e tests/integration/test_neurite_outgrowth_synthetic_plate.py +100644 blob c73c3577a2b2008822376c755ab01e8e7d2fc1f2 tests/integration/test_primary_segmentation_diagnostics_journey.py +100644 blob f8858301d9131549e1af8939b7865bea28b13b63 tests/integration/test_source_store_code_mode_zmq.py +100644 blob 5bcf304f78c89d1526412210a2b8ea08866ff01a tests/ome_zarr_fixture.py +100644 blob bf440eb7bb2de2f7034f7e58cb2880a4f530da2a tests/pyqt_gui/conftest.py +100644 blob 301bd43ac999c1179ff05c58abd7e97551eab590 tests/pyqt_gui/integration/test_end_to_end_workflow_foundation.py +100644 blob 3cba66aee673dcea1cdb0b7a23a1eda49d0a8421 tests/pyqt_gui/test_code_document_normalization.py +100644 blob c9fc5311426cebf1942122dfa64b36eaabe82d4e tests/pyqt_gui/test_dual_editor_window_context.py +100644 blob 0d67ca993eb9faa727d2d257023f3175a4a421c9 tests/pyqt_gui/test_image_browser_filter_controller.py +100644 blob b82f64d0a93fd5b0bafc54bc1a9e27aa5ba7333d tests/pyqt_gui/test_managed_windows.py +100644 blob 65ede639fc19b996528c955ba4bac1cf02e25ff0 tests/pytest_integration_options.py +100644 blob 476b34bf9934ba21f6b795eac0eb4e6068f18e60 tests/runtime_diagnostics/orthogonal_class_census.py +100644 blob 385200404366f63d30fc6d0b1a1260a16ed6f601 tests/runtime_diagnostics/orthogonal_native_7d.py +100644 blob 4ace90a25b317611504c2e1ec2616b3fcc79aaf8 tests/unit/agent/test_agent_serialization.py +100644 blob 3c4a2c7704db551420e4e282e97600e3df7a922d tests/unit/agent/test_agent_services.py +100644 blob 08439f8d4839b92565019793a2504e1451eb2059 tests/unit/agent/test_agent_services_package.py +100644 blob eb34f4e65c9116b9af92e28a5415dc11f97ae54e tests/unit/agent/test_analysis_knowledge_transfer.py +100644 blob 7d87ddc9ce158b282bcd085ee354e94f8a4d8289 tests/unit/agent/test_architecture_projection_service.py +100644 blob f8e275499a35cbf3c3ef36005c7423389c140077 tests/unit/agent/test_artifact_plan_renderer.py +100644 blob 0ea7fc8146b6289976a55613655b354642ba6550 tests/unit/agent/test_blind_recipe_audit.py +100644 blob 258a7d60ab802e3ca9af03079b0b845f15ab60ca tests/unit/agent/test_callable_artifact_reference.py +100644 blob 08163b733f93829df0602107142fe19476b13e9b tests/unit/agent/test_capabilities.py +100644 blob c163ea6cdc00bd5334be2e7f79fcb14bc5d20c69 tests/unit/agent/test_compile_inspection_declared_callable.py +100644 blob b25b02e5279a7d87d0b0e5e93146ffd6827b7376 tests/unit/agent/test_config_reference_service.py +100644 blob d249a61144a4edfcfeb344d585bf37ba6f3810f0 tests/unit/agent/test_config_schema_authority.py +100644 blob bb865ab7252225ac184e485070144564df1370eb tests/unit/agent/test_custom_registration_admission.py +100644 blob 2004f395f06a10bc67999567db647c89f4cb3cb6 tests/unit/agent/test_hosted_mcp_semantic_ownership.py +100644 blob ff73c8ec308f4978b9f0c9f2692ecf85df1a378a tests/unit/agent/test_image_analysis_qa.py +100644 blob f95b91fc848723c12f229612ad85797e98ab3283 tests/unit/agent/test_knowledge_base_service.py +100644 blob 973cdcac9891340375668244819d8a3ec348a2f9 tests/unit/agent/test_mcp_bounded_discovery.py +100644 blob 395cfbcfd6f6449aaf981eb64a0cb0bda14ff5ff tests/unit/agent/test_mcp_capability_discovery_and_widget_projection.py +100644 blob b8994c015affb38afa3faeecde1497d807744fa9 tests/unit/agent/test_mcp_cellprofiler_function_contract_friction.py +100644 blob 3bc53e0dc3fbf33ccc3667d9d76e6e343f271bbb tests/unit/agent/test_mcp_client_registration.py +100644 blob 6177e5a5f6566a6eb75777ae0a5cc8b9d77bbfd8 tests/unit/agent/test_mcp_dev_client_config_renderer.py +100644 blob 7d88fb30c1e71415931e12fe75d5dd57d577e715 tests/unit/agent/test_mcp_dev_client_runtime_debug_renderer.py +100644 blob e735bff31895f1c87c15a75568697614cf6b106b tests/unit/agent/test_mcp_dev_client_transport_failures.py +100644 blob 5bc22215c56f3f32454a30a627f3921d20bea54c tests/unit/agent/test_mcp_diagnostics.py +100644 blob b89d4bb5e1c26c6917c8a3b784d9138b28ed230e tests/unit/agent/test_mcp_distribution_runtime.py +100644 blob 5d8e4e4ba0a0d8dabecba911f9175fa98288f4ae tests/unit/agent/test_mcp_http.py +100644 blob c9db6eab4afc9ce8d7a5d847d63114bf6ca24ba7 tests/unit/agent/test_mcp_http_auth.py +100644 blob 437a6142acd9449427557b264f8ef977cea56f7c tests/unit/agent/test_mcp_lifecycle.py +100644 blob 35ab70061f65d9ac1596ae5830adf9b98e7a0b5e tests/unit/agent/test_mcp_self_description_contracts.py +100644 blob 516adb033933a95e87beec58a051b8d5c7626966 tests/unit/agent/test_mcp_server.py +100644 blob 72cbcde7d9f5059b60f1eb201c0d0c606072eaf3 tests/unit/agent/test_mcp_skill_registration.py +100644 blob b12207e20ada825b4155c10af1003c176a8794c9 tests/unit/agent/test_mcp_stdio_transport.py +100644 blob a014698f51f72336ecefe787b8319585452033ac tests/unit/agent/test_object_state_field_help_service.py +100644 blob b21a7f02709eaaf9b5ea6ccc0bc3c2dc7e78c720 tests/unit/agent/test_official30_knowledge_examples.py +100644 blob 440fee653fc47dacf033254af7b9ddb87059e691 tests/unit/agent/test_owned_bootstrap_readback.py +100644 blob 5847958513d52168a317b26f68152d7b8a105984 tests/unit/agent/test_owned_runtime_bootstrap.py +100644 blob 65550bfaca15cb49ab736729e783a1c475c8da74 tests/unit/agent/test_path_policy.py +100644 blob 96e7f58c85f4720111ace1f6e524ef4afdc5d818 tests/unit/agent/test_plate_inspection_cold_runtime.py +100644 blob ba09552d2508024a83812d34c90752e15d903117 tests/unit/agent/test_plate_inspection_service.py +100644 blob 98adf66c606ec454afe54df110118ec521295bad tests/unit/agent/test_plate_streaming_service.py +100644 blob ae363487b1a0f6f92c9b213b76c2e1fac3b26d29 tests/unit/agent/test_progressive_authoring_context.py +100644 blob f774d323ec3e3530860c1759a02549314af49500 tests/unit/agent/test_runtime_debug_inspection.py +100644 blob 4c1beccdbf892b0974bc4fb47e9b082231d6b641 tests/unit/agent/test_skill_sync.py +100644 blob 55268e267d79d69c2ffd617903cee98852ae6aaf tests/unit/agent/test_synthetic_plate_mcp_progress.py +100644 blob ebf0436e0ad8767f9a1d797b518d4f7a741d4b4c tests/unit/agent/test_ui_bridge_service.py +100644 blob 86e48c9d0d1beeb9c3ab2f26c18fdfd8ef354f01 tests/unit/agent/test_user_facing_help_projection.py +100644 blob 64fd76585adec94bd281c1007baf2f26dd4ad043 tests/unit/benchmark/test_agent_validation_attempt_recorder.py +100644 blob 562b6ae75c33376bdc9f2136f9dafccaeed07a72 tests/unit/benchmark/test_agent_validation_corpus.py +100644 blob ada603d79e78509e4c3eb8ff20d35dcfd0c3e410 tests/unit/bioformats_fixture.py +100644 blob bddc25eedc105d69aecb2772a179fac9864e9a5b tests/unit/bioformats_imagexpress_fixture.py +100644 blob c387ce86f446accbf7b751a1799fd99e2f30bf84 tests/unit/cellprofiler_runtime_test_support.py +100644 blob 96975c3f7109df493ff9f5c16869b6b0ff13261c tests/unit/core/test_config_cache.py +100644 blob 529fbc6acc4963030eef6962085349262058628e tests/unit/progress/test_debug_projection.py +100644 blob 614a6af92a23b67be673632ee0cd8d88cf960a7b tests/unit/progress/test_live_measurements.py +100644 blob 2e88550c001d71cce5592d887a37c1abd59aac62 tests/unit/progress/test_projection.py +100644 blob 1dc4ecdafedb2f0f550e1d1ea081707db9f2ea3d tests/unit/progress/test_registry_channel_keying.py +100644 blob cee57099f70e681ccdc7c333e72b380e9ce4f2e0 tests/unit/pyqt_gui/test_about_window.py +100644 blob 79575ae12d76601c4d63fa20e3bfd034e51cd4c5 tests/unit/pyqt_gui/test_application_cleanup.py +100644 blob d2118a1674466a5fa17cf48f2b9aef983e4eca2c tests/unit/pyqt_gui/test_batch_workflow_compile_engine.py +100644 blob 8f0bcd3e765053a75eab44a39fef0bb20faf4b43 tests/unit/pyqt_gui/test_branding.py +100644 blob 415bc3f21bae19bacb17bc4aebd7f740d14495ed tests/unit/pyqt_gui/test_cellprofiler_parameter_help.py +100644 blob bf4f91826f70ee26d6fe3cbadcae54275017e819 tests/unit/pyqt_gui/test_code_document_catalog_imports.py +100644 blob 5a03009629d1b6cca41f20d3767d6bcc241e2cd0 tests/unit/pyqt_gui/test_code_editor_form_updater.py +100644 blob 9d49871d7944e670d5f1b2c7ae082d991e0fb341 tests/unit/pyqt_gui/test_compile_terminal_supersession.py +100644 blob b9808c72a51c422b1eda8f760a01fcdf866f3918 tests/unit/pyqt_gui/test_concurrent_initialization_progress.py +100644 blob 38e314f3403bd38bafa0e86c20143eed9c3d9542 tests/unit/pyqt_gui/test_config_preview_formatters.py +100644 blob 37ef1e64cb1883d719af390ad7fe47f41c6f1443 tests/unit/pyqt_gui/test_config_window_state_resolution.py +100644 blob cb8cdcff9fa40aac1a7e83a5abf7d382e7876a83 tests/unit/pyqt_gui/test_config_window_transaction.py +100644 blob f645cb2548e4944d11d3de966c7a0b970bfc161f tests/unit/pyqt_gui/test_debug_inspector_window.py +100644 blob 89bdea1baff47abfc6a0cd1b91a725b7cc8c9198 tests/unit/pyqt_gui/test_debug_toolbar.py +100644 blob e303cc6973833b26019ca0346a8d86124c09b9a5 tests/unit/pyqt_gui/test_desktop_history_upgrade.py +100644 blob e9ddbbb4e852a3534265e5cb2d9e71889bc305a2 tests/unit/pyqt_gui/test_desktop_restart.py +100644 blob aab92ede88742b72359d1ec7767f332f04eff62e tests/unit/pyqt_gui/test_desktop_restart_worker.py +100644 blob cb7f113413e5a15e0872cc9d6df266493d46edac tests/unit/pyqt_gui/test_desktop_update.py +100644 blob 97bdf241f9435a0133260be536dc937cde4bf500 tests/unit/pyqt_gui/test_desktop_update_worker.py +100644 blob 2919cb0ef2ea8ced0eeaac3476d4bf1d96f3776c tests/unit/pyqt_gui/test_dual_editor_window_artifact_refresh.py +100644 blob 3fe6de1fc352800f832c68b87f23625459f309ca tests/unit/pyqt_gui/test_durable_decorated_history.py +100644 blob 89b2014c1a14e13b46ca7e0811a5cf666f008021 tests/unit/pyqt_gui/test_enableable_function_ui.py +100644 blob 3af50abe54756fbbf1a9a139acf3d7f9d9f295dc tests/unit/pyqt_gui/test_execution_server_status_presenter.py +100644 blob ca09e9848a9a060fb7f1f0d2762139313419ce24 tests/unit/pyqt_gui/test_execution_server_summary.py +100644 blob 3cb54910b5076d96c7608e1c6b495f96e0e9b8b5 tests/unit/pyqt_gui/test_function_catalog_form_materialization.py +100644 blob 5a1bfbf2240218487a2e83de351dd43f6da96d10 tests/unit/pyqt_gui/test_function_catalog_projection.py +100644 blob 8568d7efb6abef3464985e8641babe66c357108b tests/unit/pyqt_gui/test_function_selector_column_presentation.py +100644 blob b2f866d428a13814be180d2378fec3cfbc1adc19 tests/unit/pyqt_gui/test_function_step_code_document.py +100644 blob 79df6d1365c95b8ce1e4d4ef6d60fd461006df10 tests/unit/pyqt_gui/test_gui_startup_progress.py +100644 blob e9844d3e09d6fc4a0594508681e717c8a62766d2 tests/unit/pyqt_gui/test_image_browser_column_presentation.py +100644 blob 075257fa0b96e0eaddfdbc53c770cfc9c3134e54 tests/unit/pyqt_gui/test_image_browser_streaming_config.py +100644 blob d3f2790bb3321aa2ab5e1e782a92a7fa08218cca tests/unit/pyqt_gui/test_interval_snapshot_poller.py +100644 blob 0e3f802b4079910101b904b25020197e64aff05d tests/unit/pyqt_gui/test_live_measurements_window.py +100644 blob ffa0f52523e55c756ced45cf2d340805a7daf00f tests/unit/pyqt_gui/test_live_server_tree_sync.py +100644 blob 6b9c4e137ba22e17868dd391b7f72953940a0039 tests/unit/pyqt_gui/test_logging_config.py +100644 blob 4f8dc6ef7965a8d16bf4b0040613dd1da3e9f79a tests/unit/pyqt_gui/test_main_config_propagation.py +100644 blob 4fcc4f88788174bacee8260b83a04ea24ab43f13 tests/unit/pyqt_gui/test_main_status_bar.py +100644 blob aa56e5977401878b59caba5970e98b454c97a833 tests/unit/pyqt_gui/test_main_window_embedded_layout.py +100644 blob 6e0fc3c541576b4828b14311b00a37a5fa4f3e98 tests/unit/pyqt_gui/test_main_window_file_actions.py +100644 blob dfbac882a4af12b7b95636923b0f32f1eb13f829 tests/unit/pyqt_gui/test_main_window_time_travel_workflow.py +100644 blob 59887d6f04453406253eaf3a4f32590114fc9aa5 tests/unit/pyqt_gui/test_main_zmq_window_routing.py +100644 blob b9a9fa47ba6c743c65b11c5792513003af845d24 tests/unit/pyqt_gui/test_object_state_callable_preview.py +100644 blob d89f466bea4636ba064a57672070bbadf4c5a5d6 tests/unit/pyqt_gui/test_parameter_form_manager_cross_window.py +100644 blob e54ca5807689bc3c236a6f76ee1cf62b172e196c tests/unit/pyqt_gui/test_pipeline_code_document_transactionality.py +100644 blob 49ece3938ce1e5440161720d1a08c6dd033cc32d tests/unit/pyqt_gui/test_pipeline_editor_auto_load.py +100644 blob 348b4557776a325f19098ac18bfb4e9d470c9fe2 tests/unit/pyqt_gui/test_pipeline_editor_widget.py +100644 blob 2676716f073664cecf942cd5b94850b5820be6de tests/unit/pyqt_gui/test_pipeline_history_occurrence_restart_regression.py +100644 blob f063079cec3e5694863f916b5380f6f6a0bdbe61 tests/unit/pyqt_gui/test_plate_compile_connection_action.py +100644 blob 1abbc2c78b88fa97beac238fcea1ac45c1308f7f tests/unit/pyqt_gui/test_plate_manager_cppipe_import.py +100644 blob 44e909796675da147252f0e42e45adf64db53fe6 tests/unit/pyqt_gui/test_plate_manager_widget.py +100644 blob 390df8ead0b7dddede61e43009c722bbb9baca46 tests/unit/pyqt_gui/test_plate_scope_identity.py +100644 blob c0bb26b673c5eaacbadbce169803b858f5574ab5 tests/unit/pyqt_gui/test_plate_status_presenter.py +100644 blob dd7effd9c5f3cc7cfff185e01690539321af6bed tests/unit/pyqt_gui/test_plate_view_grid_model.py +100644 blob 5ff4c08d0b1e54e90085b6f5f399b27152957a6b tests/unit/pyqt_gui/test_plate_viewer_lifecycle.py +100644 blob ca3d8e181803991d75dda4e92041d5a45f0055ec tests/unit/pyqt_gui/test_progress_topology_state.py +100644 blob 286556e2f3e469853ee99646744f419582dce198 tests/unit/pyqt_gui/test_progress_tree_aggregation.py +100644 blob 04fb88f82c46a96bbcb0a3742fae71cd5ad2ae26 tests/unit/pyqt_gui/test_reactor_providers.py +100644 blob b6905a600a3cd4eb1da5945fad397804286290fb tests/unit/pyqt_gui/test_server_row_presenter.py +100644 blob 1bafae854d0b1a697108873c27c58b3daf90adaf tests/unit/pyqt_gui/test_snapshot_browser_window.py +100644 blob 75ab576226d52ff3996f34d65b3e5f1e5d8854d6 tests/unit/pyqt_gui/test_source_binding_preview_policy.py +100644 blob a6c1e7fe9e768eb02eba8c60ff5d2cb1bdea493c tests/unit/pyqt_gui/test_source_bindings_editor.py +100644 blob 87a72099fe4818bc5ec72b9e59b4fbd3ad3c02c3 tests/unit/pyqt_gui/test_source_bindings_preview_surface.py +100644 blob 4c77346bdf03401776cef84f9484b723772014b4 tests/unit/pyqt_gui/test_step_code_widget_roundtrip.py +100644 blob 1eacc2271a0a5aebb45a60efce8873334f7d67c3 tests/unit/pyqt_gui/test_synthetic_plate_pipeline_document.py +100644 blob aceee3c79b021a4934e5fb33be4740cc51c443db tests/unit/pyqt_gui/test_system_monitor_widget.py +100644 blob 38171c0936c9cbc5c08284c3b0fe7de709e992be tests/unit/pyqt_gui/test_time_travel_viewport_context.py +100644 blob 3d628eaf1c594d8290085f981230bf21dabab17d tests/unit/pyqt_gui/test_tree_rebuild_coordinator.py +100644 blob 6ce25b1d3251b735d9d1400eb270f3acd7b2416c tests/unit/pyqt_gui/test_tree_state_adapter.py +100644 blob 39e51897ac3937cae1acf2db5a2c0b3e43c96342 tests/unit/pyqt_gui/test_ui_agent_bridge.py +100644 blob d68860d015a8f0790c504e9929ac42dd96fb7757 tests/unit/pyqt_gui/test_ui_bridge_lifecycle_config.py +100644 blob f3503d1cc15152b2298daa89418d0956c91dcd5e tests/unit/pyqt_gui/test_ui_bridge_live_measurements.py +100644 blob 083515e28ec9604609c60608e46833c791abe120 tests/unit/pyqt_gui/test_ui_bridge_live_overview.py +100644 blob 3f2544eb0ea4d12716e818b29056af644df374ea tests/unit/pyqt_gui/test_ui_bridge_object_state_mutation.py +100644 blob 5c578edc5846825a03911ff55a01785ecd50bf5d tests/unit/pyqt_gui/test_ui_bridge_preview_disclosure.py +100644 blob c50df0d0272d51f20531912011a1e3cf94e473c2 tests/unit/pyqt_gui/test_ui_bridge_registry_cache.py +100644 blob 7ba3d8ba578cde8f2e8345ecf5e75ecb38dc3fb3 tests/unit/pyqt_gui/test_ui_config_lifecycle.py +100644 blob 2a01ffd5ea3fb00e48ef02b4efead3e465e4780b tests/unit/pyqt_gui/test_ui_config_widget_projection.py +100644 blob b63ade45a7869c4c3465db5d785d322f9d314442 tests/unit/pyqt_gui/test_ui_window_flash_snapshot.py +100644 blob a39381a48e9215ba41a9b0f234ab12ad534847b9 tests/unit/pyqt_gui/test_user_facing_help_surfaces.py +100644 blob 577951e0a7e6465c86853e3ebd250cce751dfd92 tests/unit/pyqt_gui/test_widget_action_dispatch.py +100644 blob 49c6fce50ae1b78fc6cae84690883987e4b63f88 tests/unit/pyqt_gui/test_zmq_client_service.py +100644 blob 6c3a3221c08824372c90e5986cb7bf47234332f2 tests/unit/pyqt_gui/test_zmq_server_info.py +100644 blob f8a534e24886c3bc98de5e6c248458971585e1d7 tests/unit/pyqt_gui/test_zmq_version_restart.py +100644 blob c7453561f03c35fbbb31c28865eb5747fed6c488 tests/unit/test_ack_return_route_journey.py +100644 blob f47d6070ff1b50b01600c43531ef4149d726d5db tests/unit/test_acquisition_calibration_pipeline_journey.py +100644 blob 4e0d4c2bb9e4e451edb68bd5d6e3581f3f765e02 tests/unit/test_aligned_image_payload_device.py +100644 blob d86066c90b21bb1da5026989bf6d4e30858a0eab tests/unit/test_aligned_image_payload_registry.py +100644 blob b4e4e05b039d051bdc1368b3ecd2f05a322e08d3 tests/unit/test_aligned_main_flow_projection.py +100644 blob 191f1c0a98d689ad8b002e86abd0213f1e4bc76f tests/unit/test_aligned_output_projection.py +100644 blob 549da7213f41c2b0e499a7623c46e4ad69044ed0 tests/unit/test_annotated_validation.py +100644 blob b83c5943c619deeccea5a685528624df9b22e277 tests/unit/test_artifact_declaration_step_context.py +100644 blob 2fafc18b1819d22b0ba9e5118563d1a49f8472cc tests/unit/test_artifact_input_edge_cardinality.py +100644 blob 7f66f530ce4bbb9a9bdbbc53529544a381c31a9d tests/unit/test_artifact_input_parameter_normalization.py +100644 blob 80a6e8e6e4b57f6b70dc209081f5696e51508015 tests/unit/test_artifact_input_projection_plan.py +100644 blob b317d95fd67918c1a7ab4cc5535ab5b9e25d1260 tests/unit/test_artifact_output_materialization_planner.py +100644 blob 48b69abc57b7bc87b152fcc99e8213d050168a7c tests/unit/test_artifact_output_ownership.py +100644 blob 464d91dd1f8eeef624829d84d4ecf9c88516fe8c tests/unit/test_artifact_plan_view.py +100644 blob c89ca1cd1dc7c8568574869d677bccf9f30004e0 tests/unit/test_artifact_publication_journey.py +100644 blob db6e37dd1c754d8c8c733944ebaef8f2ba67bfee tests/unit/test_artifact_spec_collection.py +100644 blob 93b418bfa96b331d348483e4a8103bb048b2fc7a tests/unit/test_ashlar_request_records.py +100644 blob efcc9ccd8086311066486a448e1ccaf64ac5cd23 tests/unit/test_assembly_acquisition_placement.py +100644 blob 69cf03db787f76ad4222066fb305dc7939a88fb9 tests/unit/test_ast_validator_registry.py +100644 blob d5298c7dc86c654e1de7e01371625d1573095019 tests/unit/test_batch_submit_wait_engine.py +100644 blob 833e0e14348e538e132d0c2c84df051b20857dd9 tests/unit/test_benchmark_control.py +100644 blob 55102fec42e645bbeba65cea62ad03333845cc86 tests/unit/test_benchmark_manifests.py +100644 blob 4fa75dcbc35f808d7970f6d3332c1472653f5d13 tests/unit/test_benchmark_pipeline_registry.py +100644 blob 2081d32d8436d94b50507f5c5ac37388778ad626 tests/unit/test_benchmark_progress.py +100644 blob 2456962945737a3bb50e0266e4816647f8c6f4b2 tests/unit/test_benchmark_timing.py +100644 blob 713e6475e7b1e7c27ee141f374cc2e4aac52ed65 tests/unit/test_benchmark_visible_source.py +100644 blob f1356eda51773b68815b85655a77f24a9b7b6edc tests/unit/test_bioformats_hcs_validation.py +100644 blob 8413fa584d9315f4cd3ae5860547e9d7340ec28e tests/unit/test_bioformats_java_adapter.py +100644 blob 4b304185c4d4a3c3176906fd8fb237ebae6fb88e tests/unit/test_bioformats_microscope_handler.py +100644 blob de4daac745e634f6f28bd2d2b156a0ca7e18c757 tests/unit/test_bioformats_spw_projector.py +100644 blob 22fdc7c46d112a8a404ffa834a923e1df9224e6c tests/unit/test_bioformats_storage_backend.py +100644 blob 3c0a6c573645c83e56f8039e52ec524fb9c0753a tests/unit/test_brand_assets.py +100644 blob f8fafaa71ced353c37d177895f0517d1c4254da4 tests/unit/test_build_hosted_mcp_plugin.py +100644 blob 258f8e6bbd529d2a68bec150c70732ad083a7ddd tests/unit/test_build_mcp_knowledge_assets.py +100644 blob 526f7f91f5d09429bf355a347d8a45dcf5e5a136 tests/unit/test_build_website.py +100644 blob a51e8f18edd3648cbdd0ded831975699a0a27013 tests/unit/test_callable_contract.py +100644 blob d5853ed757ae1191a918ac5ba6b4bb82ca90b27b tests/unit/test_callable_request_binding.py +100644 blob c4afbb1cda5b1b802d6e16210237cdb057e240d3 tests/unit/test_capture_media_gallery.py +100644 blob 80f9e05874895f2a206fc8e4e549c31702a87765 tests/unit/test_cell_counting_cpu.py +100644 blob ff055b0cf50f5fa2f370cb6650b4b8146c21b6bc tests/unit/test_cell_counting_cpu_artifact_contract.py +100644 blob c72b5d4b4114662fb02783af0c100e4df1d29946 tests/unit/test_cell_counting_cupy.py +100644 blob afe8d73571e5a49301e63e1bf1fb05ae2469ce41 tests/unit/test_cellprofiler_adapter.py +100644 blob f502cbbfb1f2be39d77bf374aab742919755b6a4 tests/unit/test_cellprofiler_adaptive_guide_threshold.py +100644 blob 89390f33703ac1c97a348419fdcd378125430f25 tests/unit/test_cellprofiler_analyst_export.py +100644 blob 2ba3901aa30f8d2fbf75725588344a79e55208d7 tests/unit/test_cellprofiler_area_occupied.py +100644 blob c144bafde03c8e1026dd41a26f983a48714f5063 tests/unit/test_cellprofiler_artifact_activation_identity.py +100644 blob 6b6f2fb3187c69d329e9138e3b44dd07ba228007 tests/unit/test_cellprofiler_artifact_declarations.py +100644 blob 42b49b8e97bbf2b99569375ea23a97047079461f tests/unit/test_cellprofiler_artifact_identity_reconstruction.py +100644 blob 2ddf7c714824fdd6fb1d225910147e9db4683482 tests/unit/test_cellprofiler_backend_leaf_wrapper_deletion.py +100644 blob 9e7819635801a4de9ea99a06c881d188e32029c2 tests/unit/test_cellprofiler_backend_public_api.py +100644 blob 1c47b5bcb74139afbe31b160e7cf865d7ff4751c tests/unit/test_cellprofiler_backend_selection.py +100644 blob 7bb3435d1a6c8eb9437ce21c80221781504fd40b tests/unit/test_cellprofiler_callable_kernel_preparation.py +100644 blob e104ebf1a806698768007f2edd2101cd6f767807 tests/unit/test_cellprofiler_centrosome_independence.py +100644 blob ee8ff224914e15c365208e720b19f4a2d41d3d3d tests/unit/test_cellprofiler_closing_hotpath.py +100644 blob 08323bf0a50254e3722967c0c699c9c02ae00dbc tests/unit/test_cellprofiler_combineobjects_source_scope.py +100644 blob 7b320f769eaa2a97e7d49c2554ff215bfb4493fe tests/unit/test_cellprofiler_comparison.py +100644 blob 512fccfbd07bed229c9f9e2609be4c578714955c tests/unit/test_cellprofiler_compatibility_matrix.py +100644 blob 06f9ddb436bf72072c5376b46d157ec8180c2919 tests/unit/test_cellprofiler_conditional_analysis_images.py +100644 blob a441aa438881b61067186788b29951a3c86c092e tests/unit/test_cellprofiler_conditional_measurement_outputs.py +100644 blob 84e9c3f73d5103dc7dd9f7261fbc4ef7b8e61551 tests/unit/test_cellprofiler_conditional_named_images.py +100644 blob c07c1b331b94ea68773270b1c1fb92bb46b120aa tests/unit/test_cellprofiler_conditional_topology_declarations.py +100644 blob cb937cbda3b5598bf0cb39b1daa00ab738c20e1e tests/unit/test_cellprofiler_converter_cli.py +100644 blob 32f5048dd3e6c2a4a68e0a7d7d38d7a4ac4e8935 tests/unit/test_cellprofiler_display_manual_projection_declarations.py +100644 blob 606576c8e609c0fd177909ef658f2f25ed88c038 tests/unit/test_cellprofiler_display_plate_map.py +100644 blob 9125e789026051db47e8d5a8ee5266ed55a5cbf3 tests/unit/test_cellprofiler_display_runtime_payload.py +100644 blob 6d29760c6676bd81fcfa094a7b76041ce7250cc4 tests/unit/test_cellprofiler_export_equivalence.py +100644 blob 1617ca8a64729a17f63efd8f12f3d27b39ca31c6 tests/unit/test_cellprofiler_export_measurement_outputs.py +100644 blob 18a8a28398b56c237c054153fc16ef5f056248be tests/unit/test_cellprofiler_export_to_database.py +100644 blob 7383f3e6f19094b1c2965539fe6dbb239f7ff90b tests/unit/test_cellprofiler_extended_relationship_topology.py +100644 blob 2a61995cecab3e92e8bebe224e83f3d026184325 tests/unit/test_cellprofiler_function_contract_execution.py +100644 blob 51553ffdf81efdba32185ce1c1001ba6bcb3f225 tests/unit/test_cellprofiler_generated_pipeline_execution.py +100644 blob 76177753ec368c273c3cf78859e54acc65ae9e3b tests/unit/test_cellprofiler_generic_special_input_binding.py +100644 blob dbf8842f1f19ed9f3f72b4d48ed976806dc9cc9a tests/unit/test_cellprofiler_identify_secondary_replacement_primary.py +100644 blob 67a42b012e29e941cec319b1aadc1818ce9531e4 tests/unit/test_cellprofiler_identify_tertiary_output_abi.py +100644 blob 83094de3347a258e02578827c59611a69d7acb84 tests/unit/test_cellprofiler_image_geometry_cardinality.py +100644 blob f6d472972d7f5f5dbeb27bc0bbee8b5e95f352cd tests/unit/test_cellprofiler_image_math_hotpath.py +100644 blob 3b2902f444a7ccd3d13c4f3962d7d17229e24ce3 tests/unit/test_cellprofiler_image_math_mask_metadata.py +100644 blob 82ca7f16e4d2e64d302cbf7d0c3f71f900d6c231 tests/unit/test_cellprofiler_image_math_operand_axes.py +100644 blob 483e2eaabb1f4f3ebc9214af6aef2fb5e85c962c tests/unit/test_cellprofiler_image_math_public_roundtrip.py +100644 blob 1c9a01eacdd95cd67520df7b057ba60c2dd6b512 tests/unit/test_cellprofiler_image_output_metadata.py +100644 blob 64165a06391e31113dc0de079c86dd9a5525e3a1 tests/unit/test_cellprofiler_image_quality.py +100644 blob 57d97f3dcbb5d237e6fbf1df738556fceeeeb331 tests/unit/test_cellprofiler_interop_import_records.py +100644 blob 3c82f60d089ddb6d33971ff12ff0a9e17ccc480f tests/unit/test_cellprofiler_interop_namespace.py +100644 blob 82dcd52d5dc1639fd8bbf7ae8e4712cf1fc2897b tests/unit/test_cellprofiler_kernel_preparation.py +100644 blob bc6e58ac70ae1698a05ae0d154143182ba2b1e64 tests/unit/test_cellprofiler_label_hull.py +100644 blob c7986e94d945340de783346406fea4d094d372f8 tests/unit/test_cellprofiler_library_loading.py +100644 blob 6799ca54da560a256167110a686bb080a5129eb0 tests/unit/test_cellprofiler_library_untangleworms.py +100644 blob eabbde32185537552b42526da1dce424dc478817 tests/unit/test_cellprofiler_measure_image_skeleton_contract.py +100644 blob 94b3edb8de529fd1ff5e16a5374ddc08d40852a5 tests/unit/test_cellprofiler_measurement_math.py +100644 blob 40f0b199c1d27cab6feaca6ebef56f48909f6163 tests/unit/test_cellprofiler_measurement_projector_cleanup.py +100644 blob 6aee8a97caa6f95e8badec6a8e1c92a78dd8d1bb tests/unit/test_cellprofiler_measurement_rows.py +100644 blob b03af8ce1e5e90c378f55cd5b1ad114480ab4bc0 tests/unit/test_cellprofiler_measurement_slice_consumers.py +100644 blob 142e37def2f4bdf81b69bed8b2fa2ba88b83406e tests/unit/test_cellprofiler_measurement_source_group_scope.py +100644 blob be4807a7c5e8dfb4e04ab9db1c1c82f2bc3bc7c9 tests/unit/test_cellprofiler_measurement_source_names.py +100644 blob 9fec67a7f35f65ac10784d4011eeddcca472c7c0 tests/unit/test_cellprofiler_medial_axis_contract.py +100644 blob 0ae63472948a8ff1963ab9aedb84670dd350d6b9 tests/unit/test_cellprofiler_module_execution.py +100644 blob 6a5209eaafdad8ef61426fd1d0faef7c50c0ecbd tests/unit/test_cellprofiler_module_execution_semantics.py +100644 blob 2d6db1eb706d72312b26efb1abe67dd8b5d8d043 tests/unit/test_cellprofiler_module_function_resolution.py +100644 blob a6198aae1f7744759bb410a3d8a66b0374596a07 tests/unit/test_cellprofiler_module_measurement_features.py +100644 blob ee0b533bc942aa03d47c296baaed3947b6f57845 tests/unit/test_cellprofiler_module_measurement_scopes.py +100644 blob f444e5ca87bcfe29c8fad2c38559998a1aa783b0 tests/unit/test_cellprofiler_module_processing_config.py +100644 blob 2a400718e61e479bf2dd8863ec08d87c330e42e4 tests/unit/test_cellprofiler_morphology.py +100644 blob 904e5852b5286ad73f0bc1679d6f59c4c38204aa tests/unit/test_cellprofiler_morphology_public_contracts.py +100644 blob 2a2d824df92df0b4946ea97cac1d96bbd6db0c01 tests/unit/test_cellprofiler_neighbors_contract.py +100644 blob 2e7681ec8afd900419a6da9c94b47569fb945f3e tests/unit/test_cellprofiler_nominal_policy_migration.py +100644 blob df58559417e517a9a2dc85351b622421a6e5cc65 tests/unit/test_cellprofiler_object_intensity_hotpath.py +100644 blob 8e55da8f9df623c6ba29cdeadad9256d34549a0f tests/unit/test_cellprofiler_object_label_payload_inputs.py +100644 blob 104e5dd4a5b88a575bb14a45d45beb43a05f422d tests/unit/test_cellprofiler_object_measurement_schema.py +100644 blob 1c2406778a794e719b4134843f27e045901815d8 tests/unit/test_cellprofiler_object_morphology_hotpath.py +100644 blob d9b804b851db23bab13137ab9865db8c4ad64f63 tests/unit/test_cellprofiler_output_cardinality_declarations.py +100644 blob 3f33d40f8f348a45b7414ddaa10639e5317f2c95 tests/unit/test_cellprofiler_output_record_occurrence.py +100644 blob 698d2131c395367a4446e4c2ac9f7fac55e9225d tests/unit/test_cellprofiler_output_recording.py +100644 blob d687c1079b8c50c8acf4599cacd208f851a50259 tests/unit/test_cellprofiler_pipeline_import.py +100644 blob 561070ca4bb101a845d436098f85bcf157d8b013 tests/unit/test_cellprofiler_pixel_classification_entropy_parity.py +100644 blob a76af4f08743da116a604d672433da58b1123086 tests/unit/test_cellprofiler_plate_workspace.py +100644 blob 18404e339922ac9115804490cadb4f9ebafa6e03 tests/unit/test_cellprofiler_primary_object_performance_kernels.py +100644 blob 6e1647f1b574da35e97a6e0d8fb806ab1da8238f tests/unit/test_cellprofiler_prior_measurement_output_relations.py +100644 blob 3aa43fc9aa27a6518a98e43b045723e328ce84f0 tests/unit/test_cellprofiler_processing_backend.py +100644 blob 81219be64ca04123b139021a06b86c127c62d45a tests/unit/test_cellprofiler_producer_row_schema_authority.py +100644 blob 98118557b5e1ba8b07e36cb959cff33fff45948e tests/unit/test_cellprofiler_projection_backend.py +100644 blob 73c03c7160e18972f37a60402a78b93c8b170101 tests/unit/test_cellprofiler_public_boundary_contracts.py +100644 blob f55e1cb67b8fc8ba1be836f3775b8216d646e8b0 tests/unit/test_cellprofiler_reference_exports.py +100644 blob 74ee1d575a25b3e71f305af13d66bb8524eb5069 tests/unit/test_cellprofiler_relationship_contracts.py +100644 blob 50b5a8ccf326ee7429942e38dfe9ee18f40a9936 tests/unit/test_cellprofiler_relationship_hook_caller.py +100644 blob 3d3293300578a3716bbbb9674b38e813611e71a9 tests/unit/test_cellprofiler_repeated_row_declarations.py +100644 blob 14d411f019f03bc0f075112f2b8cd48fff923e10 tests/unit/test_cellprofiler_rescale_intensity_hotpath.py +100644 blob d8a11cce5ebd2851c1f241089d9a4d27d144a85e tests/unit/test_cellprofiler_resize_hotpath.py +100644 blob c5a86f3d1b0c7fb286ae7d1953958c76c9cd2130 tests/unit/test_cellprofiler_runtime_adapter.py +100644 blob 53243627dfd1f8379714ff85e698efdc4004d4b7 tests/unit/test_cellprofiler_runtime_binding_identity.py +100644 blob 108d2cb0e1fc02047edcd763e440ae39bf5e12b9 tests/unit/test_cellprofiler_runtime_cache_authorities.py +100644 blob e435baed1fce8c66f35efe65f71c17f552c2fcc7 tests/unit/test_cellprofiler_runtime_callable_introspection.py +100644 blob 4902047a6f2224724e4fad81829c3fe52b1b843c tests/unit/test_cellprofiler_runtime_input_binding_contract.py +100644 blob a6162bab2b81c17424aba5c652092fd6097c8033 tests/unit/test_cellprofiler_save_images.py +100644 blob a5e98f9eefebf43d0cef43ee627a21dfdbd77ea5 tests/unit/test_cellprofiler_save_images_hotpath.py +100644 blob 1331d81e37d12e404d7c4cc9462f822a0c86157e tests/unit/test_cellprofiler_secondary_distance_backend.py +100644 blob 266dee616788ec0dd532ae89ca13877e1f9d0a35 tests/unit/test_cellprofiler_shape_hotpath.py +100644 blob c5b44a9f57062a79a8be95031ca3123f7981ae09 tests/unit/test_cellprofiler_source_bindings.py +100644 blob 31e3832db2085b91decdcb404e3eec76c38c735b tests/unit/test_cellprofiler_source_bindings_ingestion.py +100644 blob a7dc1764a257505f10d47ff3175fd843d2fb50d8 tests/unit/test_cellprofiler_special_io_declarations.py +100644 blob 47782563378ee6abb86503cbbd55ea6e8248f4fa tests/unit/test_cellprofiler_spreadsheet_export.py +100644 blob 1c48cb79723e0fb6745b3efc40cece05b9c6b37f tests/unit/test_cellprofiler_static_deletion_gates.py +100644 blob 1d91e594c0edbea4436cf49777a0859b2e9dbae4 tests/unit/test_cellprofiler_strategy_registries.py +100644 blob 3ce92c887627085c34f7d8d61b5300bb4cbd8174 tests/unit/test_cellprofiler_threshold_hotpath.py +100644 blob 32fadaec7aa74d6ff7ee2ed748fa86a520e6c0f0 tests/unit/test_cellprofiler_threshold_measurement_feature_parity.py +100644 blob 16dda647fc6bf3b0be781d57982e6a4dc66b0f83 tests/unit/test_cellprofiler_thresholding.py +100644 blob 9b962deba3bb29e855ad8186fb04198d057f9f54 tests/unit/test_cellprofiler_trackobjects.py +100644 blob 63ed0ec6cb1eed1d1aacea60cac17b369de0040d tests/unit/test_cellprofiler_uncovered_image_measurement_contracts.py +100644 blob cde5e96836d3f3d6a6d9721bab1afd1d6e7c0efa tests/unit/test_cellprofiler_uncovered_object_output_contracts.py +100644 blob 1b3375b793f9f4ce13ea34c98234563faebf4487 tests/unit/test_cellprofiler_watershed_3d.py +100644 blob 2490a4b503a00b21f238f7e2f49ec92cf46446b7 tests/unit/test_cellprofiler_watershed_hotpath.py +100644 blob cdd19f4020c1eb9e9fa402c993e2ae308b668737 tests/unit/test_cellprofiler_watershed_provider.py +100644 blob 5353f96483dfd55df549ab3d8c24050794edb2f2 tests/unit/test_cellprofiler_watershed_residual_hotpath.py +100644 blob 840c7e90c52fa94269a3c309aa36dd6cd9623752 tests/unit/test_cellprofiler_worm_external_resources.py +100644 blob fae7fb70298fa1299bc167600f3f1012557ddc9c tests/unit/test_cellprofiler_worm_geometry.py +100644 blob 24bddef26101d281f681d6358e807eb85f3e9f12 tests/unit/test_cellprofiler_worm_measurements.py +100644 blob f659aca9be5cec14074f993e58fe456ea046394a tests/unit/test_ci_action_pinning.py +100644 blob dd2a2af8d15ae640e78f8aff5bfe66a8124c68cf tests/unit/test_ci_package_boundaries.py +100644 blob 3e2e401a8725a8051207ef22751fe08e8a64f79e tests/unit/test_cli.py +100644 blob a742425a78bf29c82c12f69da6ed3f40ceb3d39c tests/unit/test_code_mode_path_artifact_architecture.py +100644 blob 58408bda252689f0adc849bdbc536b33aab83e18 tests/unit/test_columnar_row_schema_authority.py +100644 blob 06bf63cb633d47522c221ae861df5504a7cae8e2 tests/unit/test_comparison_manifest_acquisition.py +100644 blob 88369a524d9597141a59385573102023113a683b tests/unit/test_compilation_paths.py +100644 blob d2656e432fd0a49414c22c905d46fb6bbf849902 tests/unit/test_compilation_session.py +100644 blob 29f7bbd1c49b4b07be0b54e9f043d655cde6b49b tests/unit/test_compiled_execution.py +100644 blob 2d57a9f307392b6d1ccb382ff3e10d227d0d6f23 tests/unit/test_compiler_auto_materialization_policy.py +100644 blob 157caefc6228d18af6ff0a77db0974efad7087ba tests/unit/test_config_document.py +100644 blob 356a249b33754896e4fbb0fd53755502b2d8982e tests/unit/test_configuration_consumer_coverage.py +100644 blob a3e3fdf1961be94645f60eeb59718e2c797dd404 tests/unit/test_configuration_mirror_deletion.py +100644 blob 143dce5fbe74843709b03369bd9269e76652162a tests/unit/test_core_config_annotation_validation.py +100644 blob b2d5ef007b67d9b85ad64513dbc3d1f5aca03b4b tests/unit/test_costes_parent_mean_qualification.py +100644 blob e705888be0787394ed352b78474c826ec0f29801 tests/unit/test_count_cells_simple.py +100644 blob 1b195cc2e8892c1ff51fb6447e4f5fee9ea27366 tests/unit/test_cppipe_corpus.py +100644 blob a734d03e2270a917a499e7ace148445511620ab1 tests/unit/test_cppipe_execution_validation.py +100644 blob 387cc88df71706d6943aab3cd1f049b281f27ffa tests/unit/test_cppipe_parser.py +100644 blob 8302c15205ec7b09a585d34055901e36043a6b1c tests/unit/test_custom_function_events.py +100644 blob 70163268dbed68422c6fc48f9e1b223bfc220f5a tests/unit/test_custom_function_lifecycle.py +100644 blob f8fbd7c542d3af25639ede11f81bcdb56dcc3573 tests/unit/test_czi_brain_axon_cellbody_demo.py +100644 blob 8b32b7c6a69d62d0f3e3c548278776621dfe6443 tests/unit/test_czi_zarr_source_audit.py +100644 blob 754c3b85d30d8a3c490ded8665e1f43ac50a0b32 tests/unit/test_dataset_acquisition_infra.py +100644 blob 5d62ac03dd2d8006ea56b4bb67d5ab310319677a tests/unit/test_dataset_registry.py +100644 blob 4c6ece9111916c16bd0c9d696a9e1f976d9f7b7e tests/unit/test_debug_runtime.py +100644 blob 880f195b760ca03603a6b5015b59b60b1b9189e6 tests/unit/test_debug_views.py +100644 blob c5c4ed52267994df335430d7b7ec45f4f179a2bc tests/unit/test_derived_runtime_image_provenance.py +100644 blob 69271b630c4b36afc994fa61deec8486fadfedde tests/unit/test_desktop_deployment.py +100644 blob 6b28f79c9b6affd9ff94e100cba759a6d39c8887 tests/unit/test_documented_dimensionality.py +100644 blob bd19c886d800eabfa1e29cea1bee0ddd430b5505 tests/unit/test_enableable_function_identity.py +100644 blob 198e073877ee535d45046b4935cd5ee44f030511 tests/unit/test_exception_traceback_compatibility.py +100644 blob a31017d1b8e95bd88947cc7c29d512a6fcf0dafa tests/unit/test_execution_server_startup_preparation.py +100644 blob fa133b0b50b462152b577d8713df3da96d0259d1 tests/unit/test_execution_status_poller.py +100644 blob 993b300b3e476e7ed95685087392f7d970c43851 tests/unit/test_expandorshrinkobjects.py +100644 blob 53053c760816d038f31af95e3edd9dbee6139d5b tests/unit/test_experimental_analysis_engine.py +100644 blob 5dc5cf43377d325130749734c734969816dca442 tests/unit/test_experimental_layout_rows.py +100644 blob 38036267b22166f8776ce51e11ead35e6cfff65d tests/unit/test_fiji_test_environment.py +100644 blob 22ce0a127c87fccb4bfb82b0dc7cef86bc98e5f5 tests/unit/test_fiji_viewer_server.py +100644 blob 0f8556052a0e273648ab3912ec49fa2cf38a8555 tests/unit/test_fiji_viewer_server_launch_config.py +100644 blob d4ee275f12bc831ee12ed0d245bf4bddaf605f5d tests/unit/test_file_materialization_options.py +100644 blob c4f146de2833cfb4774769ac1b1a724d7deee677 tests/unit/test_fork_compiler_preparation.py +100644 blob 31aca0a2cbf555c1b071ce8e751da38786169162 tests/unit/test_framework_device_resolver.py +100644 blob c5e341073be17a3d1407e4cc7636f2ad7a0d4c13 tests/unit/test_framework_execution_scope.py +100644 blob 140aea754e3be87beefa27d3e6fb258ec0a097d2 tests/unit/test_func_registry_projection.py +100644 blob 73b9e88ef157e83ff7bf7e03b9b1a92ead90e717 tests/unit/test_funcstep_contract_validator.py +100644 blob 1559f16542621c730a0fddce59ed557a36d72767 tests/unit/test_function_artifact_materialization.py +100644 blob b6627f4cfab5b4345e713ec810414c6ae89e1dd8 tests/unit/test_function_artifact_materialization_io_hotpath.py +100644 blob e10ad5c99521100a94fda4d74325d67ae05dee0a tests/unit/test_function_artifact_outputs.py +100644 blob 25927712bc3e2b379521d587de00a4433b4fb626 tests/unit/test_function_catalog_zmq.py +100644 blob 7396d972c6b59355751483c8b597d6ad33bb8c13 tests/unit/test_function_execution_lifecycle_anchors.py +100644 blob 0198cf7446cd3e6366028e7747098f2851f5bd86 tests/unit/test_function_invocation_callable_resolver.py +100644 blob b53923824821fa0db6784ee7909c50a898e3e578 tests/unit/test_function_io.py +100644 blob d2b55b26fd719e3ee956a44f4491ef7bf3356961 tests/unit/test_function_output_manifest_input_scope.py +100644 blob ebd66c519f2a1eabede3527dff9466c3232f1320 tests/unit/test_function_outputs.py +100644 blob e9da0944c6c6c100e07be11c26b30ed59d42931f tests/unit/test_function_patterns.py +100644 blob 16c3548d10e10e35dd7b9319b1a05ad6497027f4 tests/unit/test_function_reference_identity.py +100644 blob 1d4c2ead7d6602e42e2c95f7746e47599180d19b tests/unit/test_function_runtime_source_projection.py +100644 blob 1d73aadc15492515a28a7d31148815ad40b08509 tests/unit/test_function_step_document.py +100644 blob 1af5495d0424203b10c52501c7b726e06b9575f5 tests/unit/test_function_step_execution_plan.py +100644 blob 9836d217d2e52c464a65db62e76a9a2c4c351619 tests/unit/test_function_step_execution_scope.py +100644 blob b50344fffb260ae9f3129004c63f3c4bff11194d tests/unit/test_function_step_transport.py +100644 blob 33453a5fefd540c2a62bbb31936103231ea2ed4e tests/unit/test_git_hook_submodule_safety.py +100644 blob 292f239a38861ea137cbc9e59ccace13b36eda72 tests/unit/test_haralick_feature_arithmetic.py +100644 blob af9132d1305614697dd4564f837d35991e4b75e4 tests/unit/test_hosted_mcp_container.py +100644 blob b9dcee0ffe6a340ba1556e6862334caebbc9ac95 tests/unit/test_image_file_serialization.py +100644 blob 7c42a5fa1dacdc9531db2a45672d0e89018956ae tests/unit/test_image_output_context_projection_proof.py +100644 blob 7e1b10c630c99773b25da28965ccab050d8b3a12 tests/unit/test_image_plane_contracts.py +100644 blob 4027933d56ff0124a1d9f30cdf3534dab05f4638 tests/unit/test_implicit_main_flow_compilation.py +100644 blob a68860364dc8281e48a49b3ed9f540faa1edd722 tests/unit/test_import_utils.py +100644 blob 5ac6ad7253f0c7dd0e49fa37467668f6ee855ceb tests/unit/test_independent_validation.py +100644 blob 3e947c774b3299d070dbbc7e22786e46cca168ab tests/unit/test_install_ci_candidate.py +100644 blob 40e4453edffdedf601517b21a944c66b300f9aef tests/unit/test_installed_mcp_demo.py +100644 blob b987982643b02d273bfd8070a79bbc1cf48fb85a tests/unit/test_invocation_contract_provider.py +100644 blob 43cea99fbd812b795121a25fafc9a15d430a778a tests/unit/test_invocation_input_source_context_identity.py +100644 blob 9c0c028a0b1af0c41d38320efa937f0dff9c2a61 tests/unit/test_label_area_perimeter_performance.py +100644 blob 617f012344b2a3163cca5af8f4459f98ba8c5b0e tests/unit/test_library_registry_discovery.py +100644 blob 9fee42897dc6707d774da032550a3269f2ed3d11 tests/unit/test_loose_operaphenix_neurite_example.py +100644 blob 0f41e4a76f045c80f2c3f69c77f660d6c2a4d0b3 tests/unit/test_loose_operaphenix_neurite_metaxpress_example.py +100644 blob 67826d576a1a7ce334e7932f111d0b2e39f079d7 tests/unit/test_master_multi_plate_demo.py +100644 blob e6f77c8bb9ccd768ab0c1a422236f7222cd2656b tests/unit/test_matched_cellprofiler_batch.py +100644 blob cf0bfe960ba11fc49fd43435b04a823500a4e392 tests/unit/test_materialization_api.py +100644 blob f1669802a08aa0c8d55a6ef541e8ebfcf3685313 tests/unit/test_materialization_core.py +100644 blob fb5272643357733ca4b3a693c7fcd82f03546bf4 tests/unit/test_materialization_filter_inheritance.py +100644 blob af35fdca9a28f795fc676dbb43630a62c83ed739 tests/unit/test_materialization_flag_planner.py +100644 blob 5fd4e2d79f1551654f50d81717d55e32c449fd2e tests/unit/test_materialization_source_extension.py +100644 blob 438cb2c8450788d051c27e6a48ffdf7d9c64344b tests/unit/test_mcp_assay_showcase.py +100644 blob b240b6f91f88cfe27220bc25efed1655efdff96c tests/unit/test_mcp_dev_client_persistent_session.py +100644 blob 851a746845054009df17e4eeb998b1581ce98b74 tests/unit/test_mcp_memory_diagnostic.py +100644 blob 878b576c5b149edb300530a9c8c287b905f3f661 tests/unit/test_mcp_release_workflow.py +100644 blob 0ec5bf2123782ca886793011973c1d5438607b03 tests/unit/test_mcp_thesis_demo_live.py +100644 blob 82c417de8ec0df9deee2a330dae5f25bc5b3b9ec tests/unit/test_measuregranularity.py +100644 blob 8d1735fa73f629d02cce4c1d0d21c4aba8755670 tests/unit/test_measurement_axis_field_projection_performance.py +100644 blob c45f956e8f65260d3ff2866d1e4d8b43020be590 tests/unit/test_measurement_image_alignment.py +100644 blob 6ce34fab28d33fc8150b34199e1b51f79e7aeee5 tests/unit/test_measurement_image_plane_projection.py +100644 blob 1de36425ee74272f6fbc3a74b446d234f7b5adf5 tests/unit/test_measurement_lookup_dialect_performance.py +100644 blob 78deaa89e506bc52d071e7cd2f935b499d8408bd tests/unit/test_measurement_output_coalescing.py +100644 blob 3a3a2b054bc7969a87d02f238b35dca58a9ea662 tests/unit/test_measurement_row_materialization.py +100644 blob 926c93d25c4aa473028ac21e924a6073ae66ca75 tests/unit/test_measureobjectintensitydistribution.py +100644 blob aff98833ee3bf3eb7fe856f39eb94ade63f6995a tests/unit/test_memory_type_authority.py +100644 blob cde163ef2f6f28986f1822143547580fa49f0560 tests/unit/test_metrics_memory.py +100644 blob dc4f7abe6e2090c32ed51c9baec76d190f81b7e0 tests/unit/test_mfd_preset_specs.py +100644 blob 5aa119b3d894ad4a8e9d1ecc2e5bf98e6af55f8d tests/unit/test_microscope_handler_identity.py +100644 blob 217e66961f6ae9b8f09bb8ae6717087e6cda281c tests/unit/test_microscope_virtual_workspace_metadata.py +100644 blob 08a1b221502eb463ac59034b910247fdb7aebda0 tests/unit/test_multi_template_matching.py +100644 blob 29d84378e26e6e985295ad15e751d6b7bba67a9d tests/unit/test_named_checkpoint_publication.py +100644 blob 091b8594541d42e0d5434853abda6f7fdefdaaa5 tests/unit/test_napari_accepted_work_settlement.py +100644 blob a055d3e3302acefc1b82d563076528056f1c7e6b tests/unit/test_napari_orthogonal_navigation.py +100644 blob d4e86d5a8af519ed41917184004533d7d051d7ca tests/unit/test_napari_reset_transitions.py +100644 blob cf281d0c6b28a902c91f4d35fb2f572aa50cb80d tests/unit/test_napari_roi_manager_integration.py +100644 blob e0e4d9663c5fcda235c9cbfa2f9f8e310ac0771d tests/unit/test_napari_shared_axis_navigation.py +100644 blob 02f482287632cfc2c46f0d4affcabf42f7c29ecb tests/unit/test_napari_streaming_handlers.py +100644 blob 3e75aba0aff48d0aac4947f977cfb73416dcaf0e tests/unit/test_napari_swc_reader.py +100644 blob 7a4cbfdcabb4c383913f30a9e7ec63fd5e09c4c5 tests/unit/test_napari_transport_ownership.py +100644 blob cc6877220d6b14881c3dc4b23a53259e57a0cf3e tests/unit/test_native_batch_barrier.py +100644 blob a7e9fc13548af8b4aeb665a340484a4dbc9a0a58 tests/unit/test_native_synthetic_well_scaling.py +100644 blob 7b49e14fee54d4ac9376f9df11f3376e798d9896 tests/unit/test_native_tabular.py +100644 blob b0d7104fd9e2c16736a903e7818465c114025ddb tests/unit/test_native_threading.py +100644 blob ef0afa21f4c613124def925e40981c07958d622b tests/unit/test_native_viewer_presentation.py +100644 blob 0a36a378a51c461d1cc9e3210cb88e598cdafba6 tests/unit/test_native_worker_durable_evidence.py +100644 blob 76c9879662cec927bdd5b670e780c4e0906c6b59 tests/unit/test_neurite_outgrowth.py +100644 blob 182820ed2c5416f1bacdc5bb013c890a64b07202 tests/unit/test_neuroncyto_ii_neurite_demo.py +100644 blob 76fa88c8792c9a00bc17b7b9af5431bacba49fe2 tests/unit/test_nlm_slice_contract.py +100644 blob d140652fa78b21c77f72edf86ee9677ed2c9d017 tests/unit/test_nominal_contract_architecture.py +100644 blob fdc45c95e6c671e954612f16ee27edb0c13f50bc tests/unit/test_nonpersistent_viewer_state_evidence.py +100644 blob 2cacc711c7fd69f6747e6eeb84e78ab0732d1d1e tests/unit/test_numpy_runtime_capabilities.py +100644 blob b12327215df55fc53929d2179ebd3a7f4727de13 tests/unit/test_official30_lab_meeting_demo.py +100644 blob 11f74e7cab86cea2fb09e6fd577f94602a1fe052 tests/unit/test_omero_instance_manager.py +100644 blob e383d2b8f761c91fe6ebac583c6cf86ed0610faf tests/unit/test_omero_microscope_metadata.py +100644 blob 383c8d8fbe1d900632b18eadbeeaf43faf72c117 tests/unit/test_openhcs_adapter.py +100644 blob d01a215d926ddce8249ff8fe8da96219352c94e8 tests/unit/test_openhcs_measured_run.py +100644 blob 465670c00e01b888203d904d41d9ee31e86183c0 tests/unit/test_orchestrator_execution_result.py +100644 blob b26ec32794a812d8f61d6a188838bd595c019018 tests/unit/test_orchestrator_lane_planning.py +100644 blob 03c2211141a3c43bf466232a88535e081c9d7c6b tests/unit/test_path_planner_axis_source_scope.py +100644 blob ba182ad70a91821daf85b71a7d8fe9095de86f62 tests/unit/test_path_planner_materialization.py +100644 blob fc677b518fa60ab44acf669517d6aec8c97242eb tests/unit/test_pattern_data_manager.py +100644 blob 7df244dfc0a7b8c4521e460c42d3fa1622eb6d15 tests/unit/test_persisted_image_metadata.py +100644 blob 9dd251927c6ddd1a9b714753c0ef1a7fd76066b1 tests/unit/test_persisted_semantic_metadata.py +100644 blob 33e78ad5f0b73b2631eb241585011bd820de3782 tests/unit/test_pipeline_definition.py +100644 blob 6ac305f5e61dd7f94f8beee0483915bca9e8249f tests/unit/test_pipeline_demo_contribution.py +100644 blob 4b58a23201b9997c2253598fcd049ad93f9d78aa tests/unit/test_pipeline_document.py +100644 blob e0dc6c586a8e22c62e746c8fd1e2a3cc32786e4d tests/unit/test_plane_store_sources.py +100644 blob fabf48fe17092243d7c4ac2f70b50c5f587dd739 tests/unit/test_plate_image_inventory.py +100644 blob 8232ddca811a1395e361a028aeaa370da8a8157e tests/unit/test_plate_manager_code_document.py +100644 blob 258892ccea1f78809c31fa53ca0459cf6fc8c857 tests/unit/test_polystore_disk_symlink.py +100644 blob 75fcbb1b4dbe3826392d02474ba8145a7de3e433 tests/unit/test_prepare_blind_neurite.py +100644 blob 517ae75b4b6ef6646ac312ba84de7d299fdaca9e tests/unit/test_primary_image_carrier_compile_gate.py +100644 blob 55534f1546f5d4a673212c75531fef9e548e42b2 tests/unit/test_primary_object_diagnostics.py +100644 blob 77f0c8b27aebabd6e75869446f499e9dc5218dc6 tests/unit/test_process_environment.py +100644 blob 1f0758f01a01df1bdfe15f8cdc19112e90196856 tests/unit/test_process_local_cache.py +100644 blob b221965354d7a77193f0eaf27618ec30d566f41b tests/unit/test_processing_preparation.py +100644 blob 4c76f45c320abc03433995d65b19b18ea3541a2a tests/unit/test_processor_method_strategies.py +100644 blob 25583a614424e30907c58435463fbb8ed902761d tests/unit/test_produced_plate_source_selection.py +100644 blob 91192c4fa8e1c056eb35909856b3aae4ee0d3977 tests/unit/test_projected_image_output.py +100644 blob 8a264d457ef0c62cd94ba79c37a775354762cef3 tests/unit/test_pycodify_formatters.py +100644 blob 16dba0261f6a13b893bcfc6c515b55893598e611 tests/unit/test_registry_owner_iteration.py +100644 blob ff38e90f8a1aa876e705d61d476e46283d36e8d1 tests/unit/test_release_readiness.py +100644 blob 404494825e3ac274d53d5ef23b4aef9b276e6358 tests/unit/test_repository_layout.py +100644 blob a62970c7468417c885d3883a9841413ec6a5fc23 tests/unit/test_returned_output_abi.py +100644 blob 10dbabf88ba4464e65791af9c4d66ad384cf51df tests/unit/test_roi_source_metadata.py +100644 blob 20c9490db7d0ec36d1619bebc315a4c4b60876a2 tests/unit/test_routed_channel_selection.py +100644 blob 0cb1384007e9a277dc69ef8c4905fab7b510fad9 tests/unit/test_routed_composite_execution.py +100644 blob ba7c2e308c17f509fe1f1fbfa87f1a1508f17cbb tests/unit/test_runner_cellprofiler_compatibility.py +100644 blob 28595b345a3b2417c7459ec6095135de3fe6b372 tests/unit/test_runtime_adapter_source_artifacts.py +100644 blob 105607d76d636223260e42c64d7b9c30d5a911ff tests/unit/test_runtime_artifact_queries.py +100644 blob 496d59aa51602501ec527445d5820c543e0abe3c tests/unit/test_runtime_callable_resolution.py +100644 blob 9d6c4040f06899b2ed6d1758ec5ba61cf8b7c47c tests/unit/test_runtime_equivalence.py +100644 blob 8c310d43e3f7c7d65057d47bac814e88ba3b0f6a tests/unit/test_runtime_equivalence_package.py +100644 blob 077d4a5e4171033de517aaec53cbc4c7a288a89c tests/unit/test_runtime_execution_validation.py +100644 blob 3e14b1eb6499b317d39ef9819a786cfb267c5032 tests/unit/test_runtime_exports.py +100644 blob d0b80fbb6a4789992e9f7c2945433fa6fe5fd62b tests/unit/test_runtime_image_singleton_alignment.py +100644 blob 168ff7b0b4afe7ef32258de29a66090d7b877b18 tests/unit/test_runtime_import_authority.py +100644 blob 5abd648bda9485be69d233f004c208c5e2b60fba tests/unit/test_runtime_object_label_domain_transitions.py +100644 blob 74eb8a2e32e43eeea35b16a69e54f6f87b996bbc tests/unit/test_runtime_output_matching.py +100644 blob 99525c15de8c1f4530b7644fa3e7aa17fca68cdf tests/unit/test_runtime_profile.py +100644 blob 4211090b099c2be92c27368afb24b7255a9f8cd6 tests/unit/test_runtime_semantics.py +100644 blob 78aec1511f54d8d51cced51c8d4b4d777f06dc07 tests/unit/test_runtime_slice_projection.py +100644 blob 32a560f00f9b9fa6396be4ce4b232ab0acb2439d tests/unit/test_runtime_sparse_labels.py +100644 blob 78470ea371a000c4d8295082d87bbf926866b31c tests/unit/test_runtime_stack_cache_lifetime.py +100644 blob 7d04e130d965dd016b1251c69558f9ea1229938a tests/unit/test_runtime_tabular_values.py +100644 blob cd053fb9017708ed20f0b1a13532d9b0c9d5b241 tests/unit/test_runtime_value_store.py +100644 blob abe53ac83c3fc77e077d6dd8f19c770a680d46b7 tests/unit/test_runtime_values.py +100644 blob 67e045c4bc43c20d143644ac2b11aa1dd358aaf2 tests/unit/test_self_supervised_stitcher.py +100644 blob 67a666c24e346295b3e7e182034e5bf83cb58646 tests/unit/test_settings_binder.py +100644 blob 175c970aa12c981948249c97a907f9ee18cfabde tests/unit/test_skan_axon_artifact_contract.py +100644 blob cd3d85274191bd282e33910e7abf31c3105923cd tests/unit/test_skeletonize_and_save.py +100644 blob 5a378c4850be95c8316aa9ddd40c6ba1d65ca1a5 tests/unit/test_smoke_installed_gui.py +100644 blob ec5753cadf2f0a4572871f00096f375374343e73 tests/unit/test_smoke_installed_mcp.py +100644 blob 32436c252706ce09b51f306c8e28b0ccdc80939c tests/unit/test_source_binding_workspace.py +100644 blob 26df00c4c487c52d51aa58e0cf524f034e45a61a tests/unit/test_source_bindings.py +100644 blob 323f0322e5a63e20385113c323ca227bd0ea00a7 tests/unit/test_source_bindings_view.py +100644 blob f79d80899b8d512e90a889299e976756b7724791 tests/unit/test_source_bound_matched_image_set_anchors.py +100644 blob eae9118787ab6677a17ff76309e23cfd249ac76e tests/unit/test_source_image_provenance.py +100644 blob bf3e167d5007a42da20f83e8595237a66135575e tests/unit/test_source_image_provenance_hotpath.py +100644 blob b163730e829527b88c749206ffc66baa52df15f3 tests/unit/test_source_image_set_identity_policy.py +100644 blob 5243b09e56ec8cafcdec4c9ccbfdf14f1e563cb9 tests/unit/test_source_matching.py +100644 blob f4d338b4a21b35a9e713cacf72e49ef0e2dac881 tests/unit/test_source_path_factoring.py +100644 blob a2a590d50a85494ea83b043e27f84fbd68a985be tests/unit/test_source_projection.py +100644 blob 269f5e6a09ff22722b995d80a80b49e035985627 tests/unit/test_source_spatial_domain.py +100644 blob 4368d969679fd45b34e64ea3fc343a3e0424234d tests/unit/test_source_tile_geometry.py +100644 blob 6dc0145d26e7b259e64ffd94241948d3ef04d8a2 tests/unit/test_spatial_graph_materialization.py +100644 blob 632605501e4e305be3210d30967151a32c478092 tests/unit/test_stage_ci_candidate_version.py +100644 blob ddbf5ca4cbe97bfb9d76f9af7e9b640ac72cb605 tests/unit/test_step_snapshot.py +100644 blob d65078b4ab745da782b33651283df4eaf70b085b tests/unit/test_stream_component_semantics.py +100644 blob 2e7b98e48d971e3fdc940e830d3a748e8edde12a tests/unit/test_streaming_config_factory_registry.py +100644 blob 588da9dde323ef93f9251a72930b9bad09f5aa38 tests/unit/test_streaming_service.py +100644 blob e3de9ac3853e2de7d7584fe15c6d7fde4ec54640 tests/unit/test_successful_job_baseline.py +100644 blob 730f62799be88e40f9cf7f42eae94f31c3776df1 tests/unit/test_sync_mcp_release_metadata.py +100644 blob 3437193519dc8280953fbede9e953196c269f78f tests/unit/test_synthetic_generator_randomness.py +100644 blob 980fc4554e778520a181fadb34865fca82079be4 tests/unit/test_synthetic_imagexpress_bioformats_compatibility.py +100644 blob 472a81eec66d69336fe38fa84b4d4cc30ea5323e tests/unit/test_template_crop_pipeline_execution.py +100644 blob 5c4f670f95485a748a84b77125c461fb98ea98a5 tests/unit/test_tiff_metadata_mixin.py +100644 blob 7ada403ad4b5c23b9ad08b26153273ed30d8e047 tests/unit/test_tiff_output_compression.py +100644 blob 540772d58db9abc544e4b4d299a52dd128591272 tests/unit/test_time_travel_navigation.py +100644 blob 66f6f1d70cf15a0b9a0781038efa443294a3e021 tests/unit/test_ui_zmq_config_authority.py +100644 blob acafac1954adcc3549015e0636d505fd40e4ba85 tests/unit/test_unified_registry_runtime_payloads.py +100644 blob 8b3dc9f47402f0ada8c0de23cd3544029e62802d tests/unit/test_validate_documentation_audit.py +100644 blob 4d80ff06feb7070a8768b73a54db6d0fa25ef3ba tests/unit/test_validate_local_release_floors.py +100644 blob 40b1de24a8bbc8d10214526fd067137a1548f448 tests/unit/test_validate_wheel_deployment.py +100644 blob 10167c9c0a6368986ef9353ea5ad9f206aa98aae tests/unit/test_viewer_channel_display_metadata.py +100644 blob 0af191c811b20bf3a868210f5cd8665e31f07e0a tests/unit/test_viewer_feature_measurement.py +100644 blob 4428c562ac60dd3058fe0ccbb5293b579c1013f5 tests/unit/test_viewer_listener_binding.py +100644 blob 7c9cd31268bd36e2b1de2e22672f5d038e549692 tests/unit/test_viewer_protocol.py +100644 blob bad15efcafd185687b2089c4483b4a509659d501 tests/unit/test_viewer_receipt_replay.py +100644 blob d0d004d2a2611399008c235544e75f1552c15891 tests/unit/test_viewer_result_element_selection.py +100644 blob 8813b6eee1bee658920f0145ab083c8e9c7acc82 tests/unit/test_viewer_source_projection_chain.py +100644 blob 418674246c01c18262f232019a15e16efa95136c tests/unit/test_volume_projection_fixture.py +100644 blob afd8f2e7efba1f07a3efb7b61d66f1cc207e6592 tests/unit/test_wait_for_pypi_release.py +100644 blob 7628addf81f152cf5f14714ad70d65b155709ff5 tests/unit/test_well_filter_processor.py +100644 blob 2ab8ddd50e0886238225935753ffa2c035cb4c25 tests/unit/test_well_throughput_scaling.py +100644 blob 0ba78f569b28ec65be6ab05c5bf98771466e746a tests/unit/test_worker_profiling.py +100644 blob 53450c19f06b797df0f1d16855df4c1ebb038c53 tests/unit/test_worker_start_policy.py +100644 blob a467dfae1c1f24a35d5db9eb68e34679c430c310 tests/unit/test_yeast_output_identity.py +100644 blob a2804c29bd6d30bd995f094f5134ec30551c3137 tests/unit/test_zarr_config_owner.py +100644 blob f71ffd793ce15f285e7e9ceab929eadead59cf6f tests/unit/test_zmq_application.py +100644 blob 252c76b642ea3adacc298c976c1f2126ddd8a4c0 tests/unit/test_zmq_compilation.py +100644 blob 445a09764faa151dbd5c112043b249e878c71d3d tests/unit/test_zmq_compilation_identity.py +100644 blob 476ccabb38441468b917037f29e36e57b7722a24 tests/unit/test_zmq_compiled_pipeline_run.py +100644 blob 45e8070fa379c57a9be17370aad4184dd8e67c8f tests/unit/test_zmq_execution_server.py +100644 blob d5c58ede8d8bbd5f88a41d40bab95658696b095d tests/unit/test_zmq_execution_server_process.py +100644 blob c93eab23f10968a9e7e747a53354bd35dc3012a7 tests/unit/test_zmq_orchestrator_environment.py +100644 blob 3edbb443cb40b7da7e905f2a2fa4cc0b4c60b9fc tests/unit/test_zmq_port_pair_authority.py +100644 blob 16ee0d55bff4f7ae665c84718d384a4ac0e7a839 tests/unit/test_zmq_progress.py +100644 blob f358c89ca1373cac5e5c2e59e1047f61b9e487ec tests/unit/test_zmq_runtime_outcome_export.py +100644 blob 0b4c857c7878248de60675902ae96a00f75c8dcc tests/unit/test_zmq_submission_timeout.py +100644 blob 4569f25ddaf400b62a9737884a1419cf1143c6aa tools/reproduce_issue257_filename_identity.py +100644 blob e6e4b5a7e3e12e86a559404e1d6b260ce17e35e7 website/assets/agent/cold-start-workflow-pipeline.py diff --git a/docs/validation/generic_runtime_owners_323_20260930/validated-source-tree.txt b/docs/validation/generic_runtime_owners_323_20260930/validated-source-tree.txt new file mode 100644 index 0000000000..088fbd2fa8 --- /dev/null +++ b/docs/validation/generic_runtime_owners_323_20260930/validated-source-tree.txt @@ -0,0 +1,1585 @@ +100644 blob 2f218231f6d07934a0887826fe7d767413da40dc .github/tests/test_refactor_guardrails.py +100644 blob 02c6cd068587df3b22ed4fd0eb16318fc3bfc43d benchmark/__init__.py +100644 blob 5dc925c7adc2f9c293b381334798ee580cc10f43 benchmark/adapters/__init__.py +100644 blob 48bd1a6f7a136de393189be71c04b7c695dfaaa4 benchmark/adapters/cellprofiler.py +100644 blob 5e3e6bd62d83b1989fdf3469363aefdd4951983e benchmark/adapters/cellprofiler_installation.py +100644 blob f3f176bf5017a6dbf818535e2d6c9ecd57c477ae benchmark/adapters/cppipe_source.py +100644 blob 56874ea2de44ef875f0c5f2afadb0315b786df79 benchmark/adapters/openhcs.py +100644 blob 4bad033093c93ff0a57ee08c5b056be36e9d8b7f benchmark/agent_validation/__init__.py +100644 blob 2fc1db8cb82477bfa1128bcb45b494aff5123347 benchmark/agent_validation/__main__.py +100644 blob 4fc32db5efb0e883481d93d9d6a4f9c136617119 benchmark/agent_validation/challenge_functions.py +100644 blob a04a806ff9231501017ded5a9f643ac874a79b58 benchmark/agent_validation/contracts.py +100644 blob fe0d896a1da54cd486e63a4c3f68438186ec3d30 benchmark/agent_validation/corpus.py +100644 blob 6c7a6efd0e1dbd570982def0a077fc58b9d3d5b9 benchmark/agent_validation/declarations.py +100644 blob cbc3909315ca8a4f050d5eb9e62437915812e9ba benchmark/agent_validation/journal.py +100644 blob f5d39f9513a212a3d39783185a1f182df30c2ae1 benchmark/agent_validation/mcp_attempt_recorder.py +100644 blob d7c8002566d2d29329b53cc3bdaaf9e1d1de361f benchmark/agent_validation/perturbations.py +100644 blob 780dc66f6a0d9cb3b8a3c9a68fd3c5dd601fda0b benchmark/agent_validation/provenance.py +100644 blob b3090a6d57e91c4b79716b869559e555b19b5040 benchmark/agent_validation/scoring.py +100644 blob 5ed5adc7d56b3f53ec7e04e1167b45933345a649 benchmark/agent_validation/tasks.py +100644 blob a7234c9bb8703eb39a40c39b3965c65d8f8ba14c benchmark/annotated_validation.py +100644 blob cd83afea955b7ea5f4f2ed6f5ee2bcbf343326cc benchmark/bioformats_hcs_validation.py +100644 blob 02d4b6cccf978cb5d9e6d692cd76ce064b16e2bf benchmark/cellprofiler_benchmark_cli.py +100644 blob 817ebbf96671c5dbb444b7161bb83bef30421d19 benchmark/cellprofiler_comparison.py +100644 blob ded38131a3876b6a84003e1838da5d8455026228 benchmark/cellprofiler_export_equivalence.py +100644 blob 3729161e4da975168fd9a8163b5c903a40ce5ee0 benchmark/cellprofiler_reference_exports.py +100644 blob 55667147a041ac75eebf72016f171cb2eaedd84c benchmark/cellprofiler_semantics/__init__.py +100644 blob 9c37957abae35dafbe3cc2e7160e87c15aa8c215 benchmark/contracts/comparison_manifest.py +100644 blob d7303e121954a2aa87c5a6b445f19d1b06c2e710 benchmark/contracts/control.py +100644 blob 9859122af454b10f4341d2f4a6dfbd7e552a982b benchmark/contracts/dataset.py +100644 blob c97839f6837055caefd30513cad39bcb9f46e41a benchmark/contracts/manifest_acquisition.py +100644 blob 009409ac0812b0d1537863f2c8d7ce4344fbb748 benchmark/contracts/measured_run_receipt.py +100644 blob 2a0cd577fda90b8e9259ed1da786a34e59c0599a benchmark/contracts/metric.py +100644 blob 21ebe5fd27267b9c9954795efa7652023307b5b2 benchmark/contracts/pipeline.py +100644 blob 4b2de231107bd2d135b50221d86faf11eaff9dc2 benchmark/contracts/run_artifacts.py +100644 blob 94bd8637d063bbaa849ccb697804329be8ce6f6b benchmark/contracts/run_receipt.py +100644 blob 2087431c9cddfeef9874b1dcb7540eadd1ac7e60 benchmark/contracts/tool_adapter.py +100644 blob 9a15e8e4491d666136ee6e52f47c4319bfbe39ea benchmark/contracts/validation.py +100644 blob de932c9e6d889531036d6b7cf9cf698a605c60b0 benchmark/contracts/values.py +100644 blob 4a6202c14af57707a52732a5a41fc47d9974a63a benchmark/control.py +100644 blob b81bc78fbe3efbe3b31e40b2f17842b687d6dacd benchmark/control_service.py +100644 blob a11abceaf1d06bebc1851b9fd56216074890d11b benchmark/converter/__init__.py +100644 blob 5f9f3d52b2a3e890789434cc7dad8946222fe8b9 benchmark/converter/compatibility_matrix.py +100644 blob cf5d3469025f55872f1f45d0ca947e07e369efc7 benchmark/converter/convert.py +100644 blob a85ca61060cb9978ddc28e812474570c3e39680a benchmark/converter/cppipe_corpus.py +100644 blob 0b78c5dd86f0c0a3caa473c976e97b533f4d5faa benchmark/datasets/__init__.py +100644 blob b4ce40802950c0f8adad467d93567e2f12434c39 benchmark/datasets/acquire.py +100644 blob 3f3bf089d9c5ae757cbc0ef6d64caff01e2a2470 benchmark/datasets/bioformats_hcs.py +100644 blob 585f4f8fdd41359a433141f0bf927d406b56378b benchmark/datasets/cache.py +100644 blob ec9fa619abdfc218796448011e03e5aa17854c5d benchmark/datasets/cppipe_case_catalog.py +100644 blob f12ac9ad661ecf44dd5580a668bfa36bae37249c benchmark/datasets/manifest.py +100644 blob a405dc657b9d96d003563ae5b06bfa0dbd46dc75 benchmark/datasets/registry.py +100644 blob 59b02fadd380e77c4d6f142da7dbdb7493c96743 benchmark/datasets/visible_source.py +100644 blob eed1350bf4ef1b40d7a32fb1e0014e8d4f939dd2 benchmark/demos/__init__.py +100644 blob d05bd685f0e7c64c86e43360af2668df900e1d97 benchmark/demos/official30_lab_meeting.py +100644 blob 6f202334c5680901aa27d0c665035fed6769180d benchmark/file_digest.py +100644 blob 8c0270ac2903be3721e5589ba4239a096fc403a8 benchmark/matched_cellprofiler_batch.py +100644 blob 2e232977baa418066e35786825994d57a713ff90 benchmark/mcp_extension.py +100644 blob 891ccebad866012b786203dcc6f1505565f44f90 benchmark/metrics/__init__.py +100644 blob 12aacb17f1721dbca5ea70c2fcb218900a3f6f0f benchmark/metrics/memory.py +100644 blob 6d16876b44bf36fcb3a1e41ac544b1cccc509a5c benchmark/metrics/time.py +100644 blob 84506a936dae5d176b7639261825d7804855bdb2 benchmark/napari_roi_streaming.py +100644 blob 600b4c5ad4c5893d1f69459819fbd5ec5965ffa3 benchmark/native_batch_barrier.py +100644 blob 6d65b7c0c9c4651d29e1f16d2e1711fd286447f1 benchmark/native_cellprofiler_batch_worker.py +100644 blob bce99bf1d7a06f3704b0457392826ee948ebee40 benchmark/native_synthetic_well_scaling.py +100644 blob 46db6511a76d2b61deb6a717f76a92762bdba15b benchmark/openhcs_measured_run.py +100644 blob 2148a1ee4d1503c189108ea0894babd44fa26b14 benchmark/pipelines/__init__.py +100644 blob e3966546ce59d59e2f4f0e58f7bab4904c6d4d23 benchmark/pipelines/bbbc021_nuclei_segmentation.py +100644 blob 13ded176215bbfd1a222d39a8fcb5cc7b41fac89 benchmark/pipelines/bbbc022_nuclei_segmentation.py +100644 blob 6b1215d251fbe5e32f89d7408d09bae677f6ee05 benchmark/pipelines/cellprofiler_nuclei.py +100644 blob bcaca107607085b235beb05b29b256e49c4248f8 benchmark/pipelines/cellprofiler_nuclei_cupy.py +100644 blob b6b9d46786fce1853afb7824d989b49d34cfc25c benchmark/pipelines/cellprofiler_nuclei_gpu.py +100644 blob 1a488a1df8f8a5f7fe084effc24986c9b14f3582 benchmark/pipelines/cellprofiler_preprocess.py +100644 blob 37ae75d9a8edec0488d5155f5270976517896527 benchmark/pipelines/registry.py +100644 blob bce177546709893e7c388f8e822d102e1c78240f benchmark/prepare_blind_neurite.py +100644 blob 8b5778267d9d0098328f17a7809bde8bfaa04434 benchmark/progress.py +100644 blob 099d822f9d6c0e7ff441fe775c68da219be3a6d6 benchmark/reports/__init__.py +100644 blob 02eb7781b58003cdb0ff1867a0d502a4c0186027 benchmark/reports/cppipe_figures.py +100644 blob b33bea957bb29b53a7ea7ddbdfa729dbcd0f5e5b benchmark/reports/cppipe_scaling_figures.py +100644 blob 7742faa8a19d72ec5f46ab1fb667041c0fafc615 benchmark/results/matched_batch_pilot_20260915/pilot_driver.py +100644 blob 64ddbfd46532d17de1405d267ca3f6245312f5d9 benchmark/results/perf_coloc_step_cache_20260929/plot.py +100644 blob 4d762f72e8d02cc320f5a1f4781d05654c78cdb6 benchmark/results/perf_compiled_radial_20260929/analyze.py +100644 blob a65ae0245dfb4c23e91cce0e175287b17841224b benchmark/results/perf_compiled_radial_20260929/check_export_parity.py +100644 blob db218db87e5ee97cd3dc172d67a94b52de5074d1 benchmark/results/perf_compiled_radial_20260929/plot.py +100644 blob baa3aaf805ccc008ab381bfa11325830d1d53bd2 benchmark/results/perf_compiled_radial_20260929/recipes/01_select_compiled_default.py +100644 blob 491347482261a81ecac2e579122203aceb3622e0 benchmark/results/perf_compiled_radial_20260929/recipes/02_share_request_boundary.py +100644 blob f899beb96c243fbd9b8f8cf3129743cf77a4aaa9 benchmark/results/perf_compiled_radial_20260929/recipes/03_share_compiled_normalization.py +100644 blob 1a225cc26510bc1548ec63e0c85af4909be0239d benchmark/results/perf_compiled_radial_20260929/replay_saved_requests.py +100644 blob 6878113cbad4d95d42b4839110cb7b43bd0fcac9 benchmark/results/perf_compiled_radial_20260929/run_pairs.py +100644 blob acb02a78ebff101d6cacf64c52b8794e17a761f6 benchmark/results/perf_fast_poll_20260929/plot.py +100644 blob 3f06f7cb6d5fa11b9ba8667341f2d04a230154fb benchmark/results/perf_fork_compiler_prewarm_20260929/plot.py +100644 blob de5f8ab96a41dfb8c23b7a0f4b8a51ef6fd56cbf benchmark/results/perf_fused_haralick_20260929/apply_fused_haralick_20260929.py +100644 blob 473caaae5a77e83dcc409c2f195b9160cd6f0afd benchmark/results/perf_fused_haralick_20260929/check_haralick_export_parity_20260929.py +100644 blob 5aac21b1177e0597737113bd9d72ffda8f98dea7 benchmark/results/perf_fused_haralick_20260929/paired_prewarmed_haralick_runs_20260929.py +100644 blob eb1b6c3909fe062a74e341c54447743e7661dcd7 benchmark/results/perf_fused_haralick_20260929/plot.py +100644 blob 2769263982e235497c44264bd184d727779abb97 benchmark/results/perf_fused_haralick_20260929/replay_production_fused_haralick_20260929.py +100644 blob 061c66fc52bf9f689364cce87c1f7555ceacb386 benchmark/results/perf_fused_haralick_scaling_20260929/plot.py +100644 blob 552deb8d76ab3e0843ef34c4eb504246c9ba2af6 benchmark/results/perf_granularity_native_sampling_20260930/analyze.py +100644 blob a65ae0245dfb4c23e91cce0e175287b17841224b benchmark/results/perf_granularity_native_sampling_20260930/check_export_parity.py +100644 blob 0b2c7b2147767ea8155b07baa6bbbd3071ba3617 benchmark/results/perf_granularity_native_sampling_20260930/plot.py +100644 blob ea9342b42b364cc66fc4070044a1f9ddcce6df2d benchmark/results/perf_granularity_native_sampling_20260930/recipes/01_own_sampling_grid.py +100644 blob 7b5b57accedca8ed14119154418d7a5f6af97524 benchmark/results/perf_granularity_native_sampling_20260930/recipes/02_migrate_sparse_consumer.py +100644 blob 24003c66e5747b36cf9ac7e32e7c712c2743a5ce benchmark/results/perf_granularity_native_sampling_20260930/replay_saved_inputs.py +100644 blob 82a16051bc11e406730278c2a97e6dd3ecde91ac benchmark/results/perf_granularity_native_sampling_20260930/run_pairs.py +100644 blob b9e64c1a1a3f3207ac2e96e0753cd58b27a2a93c benchmark/results/perf_lazy_cp_registry_20260929/plot.py +100644 blob 5e440495818a317c2a041a2c97798424c0963b06 benchmark/results/perf_lazy_ome_zarr_20260929/plot.py +100644 blob abbdd6bcfa24ae7b584a05a144422acd32892e19 benchmark/results/perf_long_form_export_20260929/plot.py +100644 blob 02f9b11c8c1b8b6ad9cb12fea3ced91d1720a294 benchmark/results/perf_native_batch_durability_20260929/authored_nra_transaction.py +100644 blob 10c0ceb2dcab2954983e547998e7a50dad82cc64 benchmark/results/perf_native_synthetic_scaling_20260929/plot.py +100644 blob 76935e2163ef53de9f420f44086d79a1151bde1f benchmark/results/perf_nominal_preparation_20260929/probe_spawn_cache.py +100644 blob 5166eec1e0f39a27f67aea50429cd93538463584 benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/apply_payload_slice_projection_owner_20260930.py +100644 blob f95c860b86c88e4d70e28c8d6d9b06ee91ebbedd benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/refine_payload_slice_projection_owner_20260930.py +100644 blob edf1c7a0ba6954eb0c8ba90be7a22585ccbb0283 benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/replay_payload_slice_projection_owner_20260930.py +100644 blob 136db976ca79b13d1628619b32d855b7dad5c85a benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/reproduce_profile_thread_contamination_20260930.py +100644 blob 6d2997970a11755168e7e3ce89ba883661862bac benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/retire_unreachable_mask_axis_guard_20260930.py +100644 blob 39d4acf252c98d30ba5f75a1ff0bffa6d0c24883 benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/run_payload_slice_projection_acceptance_20260930.py +100644 blob 205f2339de517401a8ebeed2f078f77cf8553ccd benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/run_runtime_owner_timer_20260930.py +100644 blob 653cb5084332fec307b5454648a0e0d1317a36f1 benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/sitecustomize.py +100644 blob c8bde971fd74f9eeab3d94ba12bf5465b8eb247c benchmark/results/perf_payload_slice_projection_owner_20260930/recipes/validate_payload_slice_projection_outputs_20260930.py +100644 blob aa68f2037f183be8b79c8a068886e490de315d0e benchmark/results/perf_plate_input_transport_20260929/plot.py +100644 blob 23231afc7b225dc402f9896ccfd4e9e04334ad53 benchmark/results/perf_registry_kernel_warming_20260929/probe_catalog_warmup.py +100644 blob 2b6d4a05c90809c3e4b1b10c2713d70de4124e3d benchmark/results/perf_registry_kernel_warming_20260929/probe_spawn_cache.py +100644 blob b89480deff7d514dffaed808bce61bff5fbd1be1 benchmark/results/perf_reused_server_current_20260929/plot.py +100644 blob b10d010fd62b656bf240038bacdc7054549084b5 benchmark/results/perf_runtime_projection_platform_20260930/recipes/replay_runtime_output_projection_production_20260930.py +100644 blob 348cfaf7023a82b0fdfecd29e209af1fb07883b0 benchmark/results/perf_runtime_projection_platform_20260930/recipes/run_runtime_projection_platform_abba_20260930.py +100644 blob 911a67c83bcee385e6be841c1c6bd9845ef7b5f5 benchmark/results/perf_runtime_projection_platform_20260930/recipes/run_runtime_projection_platform_profile_20260930.py +100644 blob 90f5fea786c5295e1038e75e0c936df9175d0c24 benchmark/results/perf_runtime_projection_platform_20260930/recipes/sitecustomize.py +100644 blob b41a0214be86409963e9b1da39b97985ab2d2965 benchmark/results/perf_runtime_projection_platform_20260930/recipes/validate_runtime_projection_platform_20260930.py +100644 blob df97f5c0086c02eb231a4031e5fd00b5cddd4ba5 benchmark/results/perf_scaling_rise_investigation_20260929/analyze.py +100644 blob bbd74976cec6711612648f559b86a0c285bddaa3 benchmark/results/perf_scaling_rise_investigation_20260929/check_export_parity.py +100644 blob f7cc907876a8c525c60228c9db0e6a32940e51f6 benchmark/results/perf_scaling_rise_investigation_20260929/plot.py +100644 blob 46abbb4000c1b619b96e5148c2b413c9df114245 benchmark/results/perf_scaling_rise_investigation_20260929/reproduce_audit_overlap.py +100644 blob d6f854d062e2f8f5010dc8785a75f4e3cb878f80 benchmark/results/perf_scaling_rise_investigation_20260929/reproduced_audit_after.py +100644 blob fa922416b6b9274010000e7d752ca128eabc564c benchmark/results/perf_scaling_rise_investigation_20260929/reproduced_audit_before_expanded.py +100644 blob 1e025c421a466fbfcde750e9bab495d2816bc8e0 benchmark/results/perf_scaling_rise_investigation_20260929/run_clean_pairs.py +100644 blob ab1a189d67a2f3af15b465ffadcd3ef65e53ed57 benchmark/results/perf_single_axis_session_20260929/plot.py +100644 blob 3ab049c152a608dcef15a3a94c4eea232fdad10c benchmark/results/perf_source_header_reuse_20260930/recipes/analyze_source_header_phases_20260930.py +100644 blob 769aa7661b8572997cf5667714fb316f04b545f5 benchmark/results/perf_source_header_reuse_20260930/recipes/replay_production_source_headers_20260930.py +100644 blob cec9dda951e77fa5fc282f0b462bba01de99dfac benchmark/results/perf_source_header_reuse_20260930/recipes/run_source_header_current_main_abba_20260930.py +100644 blob b14f360b6157daaf6702c657cd54c38e37c4c5a6 benchmark/results/perf_source_header_reuse_20260930/recipes/run_source_header_preparation_timing_20260930.py +100644 blob 4e723e53b83ca4c5643b059f1fc81ba37bae2c3f benchmark/results/perf_source_header_reuse_20260930/recipes/validate_source_header_current_main_20260930.py +100644 blob b342f80a499f5375bb700eb1c4cf4f48185313c1 benchmark/results/perf_wide_intensity_distribution_20260929/plot.py +100644 blob d131f3e5b3f2c9300c5d24207af1dbf144f81133 benchmark/results/perf_wide_intensity_distribution_20260929/replay_saved_batch.py +100644 blob 61ce0186d64bb95d2ec26034ac637ee46440c87f benchmark/results/perf_worker_profiling_20260929/authored_nra_transaction.py +100644 blob 6c424571fb8d067a395cd5feb9074a0001099a2c benchmark/runner.py +100644 blob 41872859422a3e77b65d97d2eb0f681456a1bb8d benchmark/runtime_env.py +100644 blob 9c32c3c7bc4cacd7e2b818c4085259fe7be788e8 benchmark/throughput_scaling.py +100644 blob 3a5b3b6e08f2d8017bebca75e878a9926878c405 benchmark/timing.py +100644 blob 08d3af0c7cf98cb43d04a919c7217a5907b59890 benchmark/validation/__init__.py +100644 blob d548ead762366fe8cffd458038c75b9f025d38d6 benchmark/validation/__main__.py +100644 blob 383573bad753e3d4e35b94aab988a94a6952f654 benchmark/validation/corpus.py +100644 blob 7e592c476738b82e241ed6bf1e8f4e5f5cb601dd benchmark/validation/layouts.py +100644 blob 38c5c160a1d6c35a93b37222e1ed1e144d42b464 benchmark/validation/references.py +100644 blob 3e8f45776b29e26a0b0c23a4e7f40fee89d626a7 benchmark/validation/scoring.py +100644 blob 1233e91d9ff7db187340e3abe84722ad1b487ee4 benchmark/well_throughput_scaling.py +100644 blob ba296c237d0bb27ef1f048fa259b237e5cc0b78d docs/__init__.py +100644 blob fcdc7fcc6287b5036a169c8973d6eead677335b3 docs/source/_ext/openhcs_config_reference.py +100644 blob 9b86c30bff061cfc579dd7a7612234d5bb471606 docs/source/_ext/openhcs_gallery.py +100644 blob adb31aae807362b6c1d298925a454d6d4179dfbc docs/source/conf.py +100644 blob 2128b9a1093b72b5af85547444d894aabadd41f6 docs/validation/ack_runtime_parent_20260930/pipeline.py +100644 blob cfd5b6f9f7d1b19da4e917c92c5bc2a5a551e1ff docs/validation/artifact_publication_315_20260930/qualify-original.py +100644 blob 06d2cf9a8b94bb8467e4004b996114ea30dcf5ba docs/validation/artifact_publication_315_20260930/run-bounded-r1.py +100644 blob 94cc198e13382b85fc7115785c278737cd112795 docs/validation/duplicate_editable_metadata_20260930/accept_shared_main.py +100644 blob 1fcc3c9c73fc4294c744b5309eec437570cb615c docs/validation/paired_field_csv_314_20260930/check-installed-parent.py +100644 blob bb5e57f0e4a83cb94d2b68cac3bc9883cc1a9185 docs/validation/paired_field_csv_314_20260930/create-live-fixture.py +100644 blob b30ec89770f11554167bc01677db5b3376c96121 docs/validation/paired_field_csv_314_20260930/pipeline-live-parent.py +100644 blob 2872892f8254ea6b88d0e1efbb7f7aecdb4c897b docs/validation/runtime_bootstrap_20260930/native-attempt01/pipeline.py +100644 blob 66468189fff3aea7e22a0347ed924c93b338f6d4 docs/validation/runtime_bootstrap_20260930/native-attempt02/pipeline.py +100644 blob 8d89630cc331f58a84b149bc1972f5b93fffb257 docs/validation/runtime_bootstrap_20260930/native-attempt03/inspect_volume_fixture_v2.py +100644 blob 9ffae9cc867d25517ec0db4190559af521067bca docs/validation/runtime_bootstrap_20260930/native-attempt03/select_volume_fixture_planes_v2.py +100644 blob 6c809beddaf0009d5a4ea9fbf6f0c86251d1af1d docs/validation/viewer_reset_lifecycle_308_20260930/check-parent-artifacts.py +100644 blob 921a41830f22c9446eef4680b7e42eedf7058174 docs/validation/viewer_reset_lifecycle_308_20260930/mcp-witness.py +100644 blob e9d60f5b4ac1b0479f761a909611f4946c5a5ce0 docs/validation/viewer_reset_lifecycle_308_20260930/pipeline-parent.py +100644 blob 08ee53dfada49729735c5ddd9eefe43e4c173012 docs/validation/viewer_route_spatial_302/pipeline.py +100644 blob 45a3a9fb2582ce7eed4fff91f96256f84a2e63f9 examples/benchmark_example.py +160000 commit b0004daf3223326ac78689ba7b2e68abc18ae298 external/ObjectState +160000 commit dc3417392cef19083a907c8c9b88a15466f81df4 external/PolyStore +160000 commit 409b1e0831f815fa9ef91d4ecc04989f9fbb89c5 external/arraybridge +160000 commit 448cdf07e0a0b513a9c9a8f67e896f601da11771 external/metaclass-registry +160000 commit 792b03413331fdf107e369c924c257a2f0b16126 external/pycodify +160000 commit 3437d1c6fea00ef8bc022068726eb01a14221e45 external/pyqt-reactive +160000 commit 4e8f8bde5f750d9a50eacac80acd3806123addd8 external/python-introspect +160000 commit 9e11f6f2102c2083b3255520a65ccbbeb4144af3 external/zmqruntime +100644 blob 0fc21d6fa3f056051d407874aabdd760615f12e4 openhcs/__init__.py +100644 blob f770716c73ca65ae2fbbde14c6f0ee29cb5d7b03 openhcs/_source_dependencies.py +100644 blob 22fecb741f60120a2bbc51ad8d7fb50804325fb1 openhcs/agent/__init__.py +100644 blob 8f71847d054b61b338d63863bdb7b7573f722508 openhcs/agent/authoring_contexts.py +100644 blob 9b4b2915179d043b34d5bcd598575bf935d4c7f7 openhcs/agent/blind_recipe_audit.py +100644 blob 8ef1b2c7c411d86498b696cb5d1f4b2a1f16771a openhcs/agent/capabilities.py +100644 blob c6c0ca2f2015f5fe91e458e956675cf953c37f73 openhcs/agent/dto/__init__.py +100644 blob 555cef6439276272020f5d214613fdeda7c79860 openhcs/agent/dto/architecture.py +100644 blob 72860f63fd59768f92f89ae4a1b261312b84d05f openhcs/agent/dto/authoring.py +100644 blob e1c4834f45c5e495eaf0ed9bc9873fb4852c2328 openhcs/agent/dto/common.py +100644 blob bbbda5911e7afd499c1f746775c63fd24a09506a openhcs/agent/dto/config.py +100644 blob 3205d01285c1d4af40139e82ec341e36b150146d openhcs/agent/dto/execution.py +100644 blob 8b80141d57b802e3828f2d1b26533cc5ad4bdcec openhcs/agent/dto/execution_connection.py +100644 blob 65c1dffa64a03d33bd86e15b7b07a4d2540ae2a0 openhcs/agent/dto/functions.py +100644 blob 176ce5f3789d2e103eaa1adf065b7dd3d6a49d55 openhcs/agent/dto/knowledge.py +100644 blob 55d947a7c0a35694b47689ebf15135e2e8fb17da openhcs/agent/dto/mcp.py +100644 blob 78f3a4811ef451f9e4e7ab8b9370f6ca3377bfa6 openhcs/agent/dto/pipeline.py +100644 blob 50beb382436bfefcebb8a8fb2242314454e71cd9 openhcs/agent/dto/plate.py +100644 blob 773f3fb9efee16703bada8b9e5a45053838bccec openhcs/agent/dto/ui_bridge.py +100644 blob 2821ba459c5cd309228a78753f5612958cb39d56 openhcs/agent/dto/viewer.py +100644 blob 76fb676373979f1d93c98605529ef8295b293007 openhcs/agent/exceptions.py +100644 blob ea5e1c0602bb20f3fa1e7a6823db2cc1c73156de openhcs/agent/image_analysis_qa.py +100644 blob 6e3179b407f5d89cf508d6aeefc35f14ca5e81e5 openhcs/agent/knowledge_manifest.py +100644 blob 4469485244d2737252b7f8a688f702422e97e81e openhcs/agent/knowledge_manifest_schema.py +100644 blob 55759f5bfc4c381e50edb2c5f9baa6c6ca895ec8 openhcs/agent/path_policy.py +100644 blob 223b73ed899392a0a1f9343d0d9c5fc48d91af1d openhcs/agent/resources/__init__.py +100644 blob f469de15048da629b594f4ebba537b929179920e openhcs/agent/runtime_platform.py +100644 blob 60d3a75aae69c78b12c5781fc15eecce701d57c8 openhcs/agent/services/__init__.py +100644 blob 4d101da75302280cc04926e44271fcd024e01264 openhcs/agent/services/architecture_projection_service.py +100644 blob 9b123d55ce4083cdc61061607e2d956f40e7f4d0 openhcs/agent/services/config_reference_service.py +100644 blob 52477b1ea115eff0973c49f75990902df60ee247 openhcs/agent/services/config_service.py +100644 blob 951e367ad876bfaea695a32c3c04f4ddf51d87e7 openhcs/agent/services/endpoint_function_catalog_service.py +100644 blob d90bbaa8e9def219ae3793c6dc2fbe1b48f03d1c openhcs/agent/services/execution_session_service.py +100644 blob b6fb90483302bf2c70447c9d239a0b0746580ba0 openhcs/agent/services/function_catalog_service.py +100644 blob bb3781d9079f944d68039f118c613f14051cc6de openhcs/agent/services/knowledge_base_service.py +100644 blob ce291578467d595c4d981109aab746e6303c362b openhcs/agent/services/llm_context_service.py +100644 blob 3f4db195bec35cae9ae4d0ab0a93ce085f6211e7 openhcs/agent/services/object_state_field_help_service.py +100644 blob e37ba1d3f52c8a1908b4060bbad48c75506d9caa openhcs/agent/services/object_state_field_projection.py +100644 blob d2eb038cf495cd8baee2793b32e0c9bcc3c22bd9 openhcs/agent/services/pipeline_authoring_service.py +100644 blob dae396298f89cbcb991c9bb0fe6c804ccdfa07e1 openhcs/agent/services/plate_inspection_service.py +100644 blob 5146004fd6c4d0214e4bce40baff9ad38421237a openhcs/agent/services/plate_streaming_service.py +100644 blob ccacf58feab5fa8a0164393ee1db06324333fa59 openhcs/agent/services/runtime_server_service.py +100644 blob 66cffa25d4b644834a97b6f5c374f0e3e97df5cd openhcs/agent/services/selected_plate_service.py +100644 blob 0e5295b83c137111a5d2ced5b3d80f87910b1731 openhcs/agent/services/synthetic_plate_service.py +100644 blob cb1009c78ff499bead8f159daddf833d45b3d065 openhcs/agent/services/ui_bridge_service.py +100644 blob fa4855afeda68b1849d2377ee6f90123ddcf5653 openhcs/agent/services/ui_bridge_transport.py +100644 blob 34bd2463b663a2fb50612e6e510330184df62027 openhcs/agent/services/viewer_endpoint_discovery.py +100644 blob 8d9041ea925b7e645ad101276900085e7819252b openhcs/agent/services/viewer_window_service.py +100644 blob 12e941c1ad46d8378d3d869fcf8e793685fa9f33 openhcs/agent/skill_bundle.py +100644 blob 1d09a8046056f6ca44dede8360a19f2a5c775281 openhcs/agent/skill_sync.py +100644 blob 5bdf73a4df612f9e072b9cb6f6eeb31854916550 openhcs/agent/ui_bridge_actions.py +100644 blob 66d53414b7a9d72c67743e25cc9bb202cbcf99ed openhcs/agent/ui_bridge_environment.py +100644 blob b799ef747f0d52bac0c2396a7d39d741619de69a openhcs/agent/ui_bridge_identities.py +100644 blob 857701dffd4ea4986f1bde9903ee87ee85691709 openhcs/build_utils/__init__.py +100644 blob b515783e4f9964d6a686735707e3f4b279c4802a openhcs/build_utils/zeroc_ice_installer.py +100644 blob 06485b6e6a7af8ad05f20b4aaa02be632bda3121 openhcs/cli.py +100644 blob 2fe4cb2bcd12760f11703e36798af90f696c872d openhcs/components/__init__.py +100644 blob a9049a5f5d9cb32f8f5d7a4d588a133968e01676 openhcs/components/framework.py +100644 blob f68f781eee337f932a6fd36e511e81eb0b9d18cb openhcs/constants/__init__.py +100644 blob 45fa88036c65cd5e24af981ddd5ca418bc61df4e openhcs/constants/constants.py +100644 blob d62c12c6888e2885fbee859f0e1b732bd81edd91 openhcs/constants/input_source.py +100644 blob 13bd04d02f9f9f11ad7e393e210b699176a71ceb openhcs/core/__init__.py +100644 blob a40bdbf15830db49907ce2a6e7fe975d64433973 openhcs/core/alias_property.py +100644 blob bf9e42710bf42880474aae9267a90a361b8bd1b2 openhcs/core/aligned_image_payload.py +100644 blob c9e7660b83cb3fb99f7c3a257cc459b7b72209a5 openhcs/core/artifact_inspection.py +100644 blob bf0fe5952290b8dd4728c697fe9660f701e0f084 openhcs/core/artifact_key_selection.py +100644 blob 7e56929a598f5246ad9700869fb06a299d9c5c4e openhcs/core/artifacts.py +100644 blob 30bd69b3d1991774df0c4cf52854eaf427f415df openhcs/core/autoregister_preparation.py +100644 blob 546e59395206c5feb4dea1fd740828ce79b26cf1 openhcs/core/axis_filter.py +100644 blob ba3047e49c66d098b5ac72688212a7f7de768bb4 openhcs/core/callable_contract.py +100644 blob 986a7157af1a97e3a5e9668c6fc96eb765438f56 openhcs/core/compiled_execution.py +100644 blob 97af35207379ac2730154243e6ed191c0d4436aa openhcs/core/compiled_step_plan.py +100644 blob 78b18d51af6a162efb223a0f7bc99caab22efdf3 openhcs/core/component_group_scope.py +100644 blob c7fb0959867f62fe8f2801ca99599e6cf862c834 openhcs/core/component_set.py +100644 blob 2c3154515bd4e2e74fbb975524a257ec0bb43bd3 openhcs/core/components/__init__.py +100644 blob 2e8a09c2596781cadaa0bbb65a65b0fdbb02f4cd openhcs/core/components/component_values.py +100644 blob a986d7d43aaed14d4ef4de60f3485cd4303eaf01 openhcs/core/components/multiprocessing.py +100644 blob 8589e42041fdc073f19810905610e12f0e874a1a openhcs/core/components/parser_metaprogramming.py +100644 blob 10b835e7fc923298082cc4cc750162fb98682fae openhcs/core/components/validation.py +100644 blob f46fc3e7624fe7d2323fd2a688dc3781e49f40bf openhcs/core/config.py +100644 blob 2c6cdfb23ced0f53f205b893ecd2a530621ebd2d openhcs/core/config_cache.py +100644 blob d8bb11b90b9b170f4ade99396a40b6e16240a39e openhcs/core/config_document.py +100644 blob b3d9879cc28f27c24e5e4bcd20be4d15e43f4e7a openhcs/core/context/__init__.py +100644 blob 187565b391c67526362eafadb6c1a2b7def012a9 openhcs/core/context/processing_context.py +100644 blob 3853cdfbb7161e895f0b47d053ca86f9a15d1671 openhcs/core/debug.py +100644 blob 5e20dad67e05b41d847cb814cf12e1f0711d6f59 openhcs/core/debug_session_projection.py +100644 blob 0827b7232335d28cbe5a7e239d94176c1fd4bb62 openhcs/core/debug_view_models.py +100644 blob 911de491ebfc614ee2322bcb905c5d1a37a98dfe openhcs/core/debug_views.py +100644 blob b111ea3f337b06d7c24204b1efc7d7524edc2c1b openhcs/core/equivalence/__init__.py +100644 blob 9a1502315bca4680bf14370f9de33b524d3901fd openhcs/core/equivalence/arrays.py +100644 blob 8313a60a0f5922b25d14e8276244e6f01286ff07 openhcs/core/equivalence/cells.py +100644 blob 6ee711aca43070611ec52929d8d664b5458f0a20 openhcs/core/equivalence/comparison.py +100644 blob 9ee5c8b600c1eeef609bf09f6a8e67fa9176105a openhcs/core/equivalence/images.py +100644 blob 30d8d5978a99acd7f8fd9ad133900c7340e9c63f openhcs/core/equivalence/keys.py +100644 blob cf23d91b29b8842dc9c89946eab7e9b4c03f4f18 openhcs/core/equivalence/measurement_facts.py +100644 blob 58217e994b978283c9addee32b5f9aba218628a8 openhcs/core/equivalence/measurement_features.py +100644 blob 380743522b7d01f6c7470837dcc471f333abed70 openhcs/core/equivalence/measurement_requirements.py +100644 blob dad91667791b461342bac4c8bc111e3ff993c937 openhcs/core/equivalence/measurement_rows.py +100644 blob dc141546fecb7d02d974ba60d5e4dab7c9d2cf0a openhcs/core/equivalence/object_label_measurements.py +100644 blob 3010c500b74e1eeffb33f843bf955bac567bc7b1 openhcs/core/equivalence/outputs.py +100644 blob 22f86707e167df0dc23b0e9ec733a00b0b3e663c openhcs/core/equivalence/policy.py +100644 blob 1f03d975c89190fe86a41d26783a389c3548493b openhcs/core/equivalence/relationships.py +100644 blob fadbc4e2d667df41b50c164ecaecd5beb06978bf openhcs/core/equivalence/report.py +100644 blob dc1eaea8464511f6615bcb85b1f2d6d956bcd29e openhcs/core/equivalence/tables.py +100644 blob 6ffe97d5271e0fa92d0d09086846e7c3954a602c openhcs/core/execution_state.py +100644 blob 6793a9f484cefdc6193ba27acfba68f6d8639e36 openhcs/core/execution_visualizer.py +100644 blob 036bfd743001f424ca51f6e2d88628704ce86ad0 openhcs/core/framework_device_resolver.py +100644 blob b269577cb82cefb4ff51d1747015e59a452fac38 openhcs/core/function_contract_metadata.py +100644 blob 7f5a771789e74dff841b4986f7f036e78a6f7ce5 openhcs/core/function_patterns.py +100644 blob 48561026c3838225983796c4e2fd9cfca6a24ec3 openhcs/core/function_reference.py +100644 blob 1290f37ad18ec7ee292b3570fd27b4c3f3c53530 openhcs/core/function_step_document.py +100644 blob 4ced68b3b5445e68c5afff79579e2a2835fa4972 openhcs/core/function_step_transport.py +100644 blob a83b2b3bbc88d876ce02452e77e7bdd1eb1e2730 openhcs/core/image_file_serialization.py +100644 blob 63d897543e1df2de9836c3277d47798a982b4934 openhcs/core/image_payload_execution_mode.py +100644 blob 7aa6e98074fc96ec8b61751f360be10dc7523cc5 openhcs/core/image_shapes.py +100644 blob b0e2ee2aa7d4b93ab204b7b76161ab17679d64ee openhcs/core/input_workspace.py +100644 blob 158fed1e68c00d62c6b93904a0b7db79e79d9fef openhcs/core/invocation_artifacts.py +100644 blob abab10fbd0e53ccd4d3dc2c3c7e44f55ade2781f openhcs/core/lazy_gpu_imports.py +100644 blob a218212dd34970b94adeabbf37c13ebf24965d57 openhcs/core/log_utils.py +100644 blob 15acdfb0d78a929e6381bf85e2b1e53565e81b84 openhcs/core/measurement_feature_queries.py +100644 blob f8264e9d8e2ec7db56f444187680e38025689e6f openhcs/core/measurement_image_alignment.py +100644 blob b8177e565d7b1216d4412aa1931269f1ea560ecb openhcs/core/measurement_lookup_dialect.py +100644 blob ac6c9bf6fabc23a3c2a45c972ad9c69e81bb57fb openhcs/core/measurement_row_materialization.py +100644 blob d8d694c0c88e56b2d2336581c4374f4978b52c26 openhcs/core/memory/__init__.py +100644 blob 4131c86f7222110dfc34dc4d95bd4ad39e4fde58 openhcs/core/memory/decorators.py +100644 blob a53fd8276e0e6f932a1686cc9f26e45896e5afa1 openhcs/core/metadata_cache.py +100644 blob ccb219fdc77c9ac829c0e24bc4b71bc4fce43b00 openhcs/core/native_threading.py +100644 blob 203938ad4b1295dafaddc83bef75ec6d0344d277 openhcs/core/orchestrator/__init__.py +100644 blob 938f0f13d9682f8ccc92b24de93bea2fac2e7e85 openhcs/core/orchestrator/analysis_consolidation.py +100644 blob 83faac5838addd42bfe50aa99603ba05eeda4655 openhcs/core/orchestrator/cancellation.py +100644 blob f2e49a305cc00b7fdf3673fa4cee9b3ae981c903 openhcs/core/orchestrator/compiled_plate_execution.py +100644 blob 4f691525ce54ff579014708dd391664375c3f45b openhcs/core/orchestrator/execution_result.py +100644 blob 2169f6ab89ec13c06aca64e488026d2b62342738 openhcs/core/orchestrator/orchestrator.py +100644 blob 7f82c7bafc1c11786762e819195c21cb57daa431 openhcs/core/orchestrator/worker_execution.py +100644 blob 5b3c5880f56c4fcb46264b51f89504668ae91748 openhcs/core/orchestrator/worker_lanes.py +100644 blob a8eb02a6d25d8c58656a0c80e35ec0ab3097fda1 openhcs/core/orchestrator/worker_profiling.py +100644 blob b1c645be4cbd2dc7d5bbda800a499115fffdcf78 openhcs/core/path_cache.py +100644 blob 3df42affbb5c51b8d84bf1fd2df0807c907147c2 openhcs/core/path_pattern_matching.py +100644 blob c906a38e93f9029ea061ee0c5abac43bb0d19229 openhcs/core/pipeline/__init__.py +100644 blob 8f77e5efc2e0b3acb7c1b9ffca2c5edce7bb80dc openhcs/core/pipeline/artifact_planning.py +100644 blob 785b2ef9f364507063a2b7e185ca5746ed401934 openhcs/core/pipeline/compilation_session.py +100644 blob 1aae3ab07394c1a2f596ba6fd7dbf50e6d23a208 openhcs/core/pipeline/compiler.py +100644 blob afd5e4d79b1b31c8608006d3ea62361fb65d0197 openhcs/core/pipeline/framework_device_assignment.py +100644 blob 81b606c4c9a0e780570ca5ec54801c45e5109475 openhcs/core/pipeline/funcstep_contract_validator.py +100644 blob b75413a3a91e5fe4e3a11eb1aa5ad2125498d88a openhcs/core/pipeline/function_contracts.py +100644 blob e3e065b3a27f0ff4d6bd7ec488f8f7ea0323fcfe openhcs/core/pipeline/materialization_flag_planner.py +100644 blob d561ab433d4d0bbdaad1d40760e8e2674d6e632e openhcs/core/pipeline/path_planner.py +100644 blob 151db6c87f807e60646b5f322dd4df664c6a0b2d openhcs/core/pipeline/step_attribute_stripper.py +100644 blob 621373625dd5996ce2f83446c2798a7401303f59 openhcs/core/pipeline/step_snapshot.py +100644 blob 5dc7d2195cc35844f218ab94a9bdada87bc9af41 openhcs/core/pipeline_document.py +100644 blob 1bfa8d22f7f2137b07838e7d9b37dda832c9a58e openhcs/core/pipeline_document_fields.py +100644 blob 1bfbd9d3e6dccffaf4adae6a507345ad2b8d3e86 openhcs/core/plate_file_inventory.py +100644 blob 9d65a9c9a5304d7279ee8285569e24c68837cb81 openhcs/core/plate_image_inventory.py +100644 blob f3c77946dd65fbb0d83449049e34ba255fed7ec5 openhcs/core/process_local_cache.py +100644 blob e51440b48dd7a71297f683d382a15464d77d0545 openhcs/core/processing_preparation.py +100644 blob fda37b2df9427de30fe58a8ed8542cc695abbd2d openhcs/core/progress/__init__.py +100644 blob cfca139262ac7601c1bc0b210d7c44b1a8430f40 openhcs/core/progress/debug_projection.py +100644 blob 66ecfdef4c1c9cdbb286168387a3c7e03c1d8b63 openhcs/core/progress/emitters.py +100644 blob c47a04bdeaa2c9a33b48157e3341c1f10ac55c4d openhcs/core/progress/exceptions.py +100644 blob 45c1f0eacbb9e27bbefc44685e437d60049f981f openhcs/core/progress/live_measurements.py +100644 blob ddc0acc960689164368d7bd0b79ff6ae267f1fc4 openhcs/core/progress/projection.py +100644 blob 69953ebf312e29902dbd31a1fec01a11d7893449 openhcs/core/progress/registry.py +100644 blob cd9f30c907c85690a59a7a44065122dc4785a13a openhcs/core/progress/runtime_artifacts.py +100644 blob 4e3569d81b58fb58328d08702114224ebf09bda3 openhcs/core/progress/runtime_tree.py +100644 blob e09cda0287560f494c549cb5b19313c2c94ff9c5 openhcs/core/progress/types.py +100644 blob 87ee5f318fd03492dd83b96c6fb181a30ede48d7 openhcs/core/projected_image_output.py +100644 blob 0f362ab6fa5dee5304f2d7da49aef3a3fb1930b5 openhcs/core/public_api.py +100644 blob 2507e463d59bbfab3a9c17c94c610721e2356532 openhcs/core/python_source_literal.py +100644 blob c2776e5b8e0582836dfee55235036c006a437eab openhcs/core/registry_strategies.py +100644 blob f597dd2becc10e79fb3598502d2bd3d9e781fc88 openhcs/core/roi_point_metadata.py +100644 blob 6455aaadf5ef67a325f5a350f4bd424a901ba486 openhcs/core/roi_source_metadata.py +100644 blob 14e0bb43ccb840e0ac54ed6d0f9c03afaced289f openhcs/core/runtime_adapters.py +100644 blob 3583087358d820fb82d76b795d6febc35f8caf65 openhcs/core/runtime_array_values.py +100644 blob 260fd329148120b4ce94820acad900f116a84420 openhcs/core/runtime_artifact_queries.py +100644 blob deb4343b719bf3892a0811c470589b12100bcca9 openhcs/core/runtime_artifact_values.py +100644 blob 6933013d512f4e39c15f4856c642ae4d317dd33f openhcs/core/runtime_batch_contracts.py +100644 blob 244f9edde57e237c2bb56067889faaf8ed69726a openhcs/core/runtime_equivalence.py +100644 blob 8f1c90d4a1ac5cbcf117e4f508771f5da35fc52c openhcs/core/runtime_execution_validation.py +100644 blob 1cc9d503172e568e43f563d8fcd5c8529d4ae330 openhcs/core/runtime_exports.py +100644 blob 6896ea46770754a71db6439f26818472be470b0f openhcs/core/runtime_identifier.py +100644 blob a29901c1c22aee0233d3900fbf3df95080d8633a openhcs/core/runtime_image_loading.py +100644 blob a29f7af3971f839efaec10bf30f0ac0c5d7eb28b openhcs/core/runtime_image_values.py +100644 blob 0c2282fcbdf00d9433e13464d61a73d759b5a363 openhcs/core/runtime_measurements.py +100644 blob 0e7e565e545cc082cee499c3f8342b50e08001ac openhcs/core/runtime_object_label_aggregation.py +100644 blob 31f6da07880ecc4995713d88763b86e90a42ceb8 openhcs/core/runtime_object_label_building.py +100644 blob 34f237842b58705ead808dc5c7f1a216a838002f openhcs/core/runtime_object_label_domains.py +100644 blob 69e07dbd4670c4d79a6d92b3d86ae6af14d204ec openhcs/core/runtime_object_labels.py +100644 blob 44cc127d39b5aef76e786b8139ba3054a42c79c1 openhcs/core/runtime_output_matching.py +100644 blob 1c2f0c35aa8c65414933a2a70003d2f6ed1999d8 openhcs/core/runtime_pattern_cache.py +100644 blob 24602e19943911337a46540531ed7c68a1211c0f openhcs/core/runtime_plane_projection.py +100644 blob 7b9ae1ced455369ab3c45cf8ef4100ab88e6d9e9 openhcs/core/runtime_profile.py +100644 blob 4abca79cfaa62b785d7ce70ac859499e4803b649 openhcs/core/runtime_relationships.py +100644 blob d848301d2c89b5c98faec45c7a11ba466c480ebb openhcs/core/runtime_slice_alignment.py +100644 blob dbc82ace2019647cc36ae810a0e3a38e90b485f1 openhcs/core/runtime_slice_projection.py +100644 blob 7e2ffb242da3b38345e9edd17729dc2926310d4d openhcs/core/runtime_source_binding_cache.py +100644 blob 4807876c9b1e9772942b53384d54e972505a38e0 openhcs/core/runtime_sparse_labels.py +100644 blob f12cc3abaf74274825bf2ae8310cf82eb223da21 openhcs/core/runtime_spatial_graph.py +100644 blob 25f1e8b9a31edc7eb6c295d03b04f11285d4ee16 openhcs/core/runtime_spatial_grid.py +100644 blob 4b92cb0020b2656eb7b3fcf6a09d6c3aaf792697 openhcs/core/runtime_stack_cache.py +100644 blob d2840af84db4ea70edc366e7ea5171cc08c4711a openhcs/core/runtime_stores.py +100644 blob 354207da603c17cb20faf36b9047f5333f92c4ae openhcs/core/runtime_tabular_values.py +100644 blob 14808cc8325868c588a26ddcb005cb0f58472990 openhcs/core/selection.py +100644 blob 9521180c68ad78acad26df4a89dd00821270dd6a openhcs/core/source_binding_context.py +100644 blob 8a678f7f3750018ef11b4f03ab03dff755735283 openhcs/core/source_binding_selection.py +100644 blob 980da5b2f871706b96821fe9e8c3dc17746ec475 openhcs/core/source_binding_workspace.py +100644 blob 56dead442cc7ac848784ef9d97b8e04b594051ec openhcs/core/source_bindings.py +100644 blob 43042640689e70ed763b641c0504bb3fe07198de openhcs/core/source_bindings_view.py +100644 blob 71ff6ef174fecc47f48277e90cb621d4e6d210d2 openhcs/core/source_image_provenance.py +100644 blob b12f30692fcf069da5c42e56d373ce80a06b08e9 openhcs/core/source_image_semantics.py +100644 blob c1e8a57d362507d4fd061b2130becff1680c4331 openhcs/core/source_load_plan.py +100644 blob 8b973cff4c2e3529968b3399788d3998b5a595b1 openhcs/core/source_matching.py +100644 blob 63c7e4e04972f3dcf1b3045f8321d6afd5dbbbf2 openhcs/core/source_metadata.py +100644 blob 03e7fb852f2f2aaeda963a9b7c1188cf2515535f openhcs/core/source_path_identity.py +100644 blob d3c197b5812fa4b06c5f5607b9ed4f19b3802274 openhcs/core/source_plane_alignment.py +100644 blob 1ef3bb083459a361cb1706e37c515545fc184013 openhcs/core/source_projection.py +100644 blob c61d8b41aa4d6bad237c0009ceea4a7526328bb9 openhcs/core/source_spatial_domain.py +100644 blob 2b0b5f9d192de2237df43d8da0b9e73a6004ba8f openhcs/core/source_tile_geometry.py +100644 blob 84878b885151771209df49f2a6d07493a7d5c48b openhcs/core/source_workspace_projection.py +100644 blob e0a752d6cc48687f4b7397a79dcc63757c63bdfd openhcs/core/step_dependencies.py +100644 blob 6356e5202e5ccc0d365a6bd1360e485b026295e2 openhcs/core/steps/__init__.py +100644 blob e82003ec93139fc911c740f00bbeba3b5054cd52 openhcs/core/steps/abstract.py +100644 blob 71e1ddf9b008934fe995b08be931b7e7ede387a5 openhcs/core/steps/function_artifact_materialization.py +100644 blob e376923be2dad37dfab7145ced750f78bbfffed5 openhcs/core/steps/function_execution.py +100644 blob d2e5e5e38b7803378a1096b36935f75735ee0736 openhcs/core/steps/function_io.py +100644 blob f83da45f2f7ea78ee22e0957b2536b18da75084c openhcs/core/steps/function_output_identity.py +100644 blob ea93bbff1e4f93d9bfa0e8450974ba2db1914b04 openhcs/core/steps/function_output_manifest.py +100644 blob 9fc7cb773d0029d327929b4fff943505a17aa212 openhcs/core/steps/function_outputs.py +100644 blob b547bfa61a8d789f8e307376d2dc97b8c817d074 openhcs/core/steps/function_runtime.py +100644 blob 341e3aaf30c5839072fff5b793c4da796be43d75 openhcs/core/steps/function_step.py +100644 blob 39998938e82599a4ea06bb14ff0763ccc41c58e8 openhcs/core/steps/stream_component_semantics.py +100644 blob 53e4a304acd4660394dcc2eef8e16d3af8ea1ed9 openhcs/core/streaming_config_declarations.py +100644 blob 4ed05c60890648612ca722b413c6992b2296d44a openhcs/core/streaming_config_factory.py +100644 blob ada0f28fecd46611cfed8c822fba1306334729c9 openhcs/core/synthetic_plate_generation.py +100644 blob ba2ca1b2de1571be80cdb63b3571fcf70b390aee openhcs/core/utils.py +100644 blob e01c5c9e95492f7e9bed11b9d04666a0aec5b536 openhcs/core/variable_component_stack_requirement.py +100644 blob bb276dac78c7f7b2a12112b77ddbe0c9f993cbc9 openhcs/core/vfs_protocol.py +100644 blob 104e803526561301ddaa9eb2ca0eff78829041bd openhcs/core/viewer_streaming_service.py +100644 blob c9aabd2da3ce03bb97accb6103244aec814479d2 openhcs/core/virtual_workspace_metadata.py +100644 blob 6734ab9866398b1016d2492a15cd83780f901d32 openhcs/core/worker_start_policy.py +100644 blob 449e793570ceeb759331956987b98e6262bc9500 openhcs/core/xdg_paths.py +100644 blob d2feb694394813f561e6866b65297a0616470c54 openhcs/demo/__init__.py +100644 blob 773c5f763ce94425807bf0f86011579a91d411ab openhcs/demo/basic_pipeline.py +100644 blob c87f8b0ee19b1f29735a36d991990d69a9366c78 openhcs/demo/synthetic_data.py +100644 blob d455cbcd6810eba7f609082bdccb5d88e06bb27f openhcs/demo/synthetic_plate_pipeline.py +100644 blob dc6f4e1f8542a747b0fb787b3e166dbfe91b1c50 openhcs/desktop_deployment.py +100644 blob d703e97c81191befe39bda888eeb8b791002010b openhcs/desktop_deployment_cli.py +100644 blob c6f5e8a998bd6cedae8bccdf22f2ea7580c04e14 openhcs/desktop_installation.py +100755 blob 590f3911641f561fc7b3ee3afddc7c808cb5c46f openhcs/formats/experimental_analysis.py +100644 blob 14f6cd1e808e0c4df36b7d351fc9ed37596b9246 openhcs/formats/experimental_layout_rows.py +100644 blob c31717fed87ee6cd34cb88b1e623becc5baa5961 openhcs/formats/experimental_result_formats.py +100644 blob ef027e72f50f92869eab737ee1974701aa660b21 openhcs/formats/pattern/__init__.py +100644 blob 24d23d807653d1c603b80f1471c2fcd07d0093bf openhcs/formats/pattern/pattern_discovery.py +100644 blob 62e46f86b5aa55b31b91530fd3b4b4f982d40987 openhcs/gui_startup.py +100644 blob 5b318afe5e63d090afeca58fa0685cc74ac5cfa9 openhcs/interop/__init__.py +100644 blob 6941b77ac17120e27ec05166b3c391bff76ca495 openhcs/interop/cellprofiler/__init__.py +100644 blob 7c61aa1e4472572cf99c54f56cc932516801df01 openhcs/interop/cellprofiler/analyst_export.py +100644 blob b09be254e484e52102f9ec16adfa4ab724b83ebc openhcs/interop/cellprofiler/cellprofiler_literals.py +100644 blob 83ac74cfa5d46a8f65a3165a12a4d1b232ff9153 openhcs/interop/cellprofiler/compile_time_contracts.py +100644 blob 6db8aee37d0a7594d27ba965ed66dfdb3a373009 openhcs/interop/cellprofiler/database_column_dialect.py +100644 blob 1c869322a206d95306183fe061a06357cee62229 openhcs/interop/cellprofiler/image_normalization.py +100644 blob ac119612ef22866154799a789274a3cedb6f019a openhcs/interop/cellprofiler/image_set_numbering.py +100644 blob 74c75ade8d7ec89f371f507115b9af8d34102c89 openhcs/interop/cellprofiler/measurement_dialect.py +100644 blob 8d285990a630859bb28f29124c3f41cfce078be1 openhcs/interop/cellprofiler/measurement_lookup.py +100644 blob 546b45a763ba561d6dfdd1fb6f09d6e85bea9867 openhcs/interop/cellprofiler/measurement_scope.py +100644 blob 5f6773a7ea6426e6beb6472e5c254d12425c7313 openhcs/interop/cellprofiler/measurement_semantic_profiles.py +100644 blob 6b7e2540502bc12e0db9196cfc1c41e200633a14 openhcs/interop/cellprofiler/module_artifact_contracts.py +100644 blob 184f7052f14bc1c910bbf9dc13cb4b902c812703 openhcs/interop/cellprofiler/module_artifact_declarations.py +100644 blob 78a23086ea64048f3f5c1d945025c168b929ff16 openhcs/interop/cellprofiler/module_callable_abi.py +100644 blob 0957ca934029d2deece7cc925cdac1db60cef7d7 openhcs/interop/cellprofiler/module_declarations.py +100644 blob 83cd749205d965678e15d4760e7db6158c74dcdb openhcs/interop/cellprofiler/module_measurement_features.py +100644 blob 46b35a0dc51609996bc8922adb392154988a1307 openhcs/interop/cellprofiler/module_settings.py +100644 blob 40d3053f4647752fb61b180455d460c924075c5a openhcs/interop/cellprofiler/module_structuring_element_settings.py +100644 blob 9beee065405cebd25080b2afc63d333ce7c3798d openhcs/interop/cellprofiler/parser.py +100644 blob c40de7969043fe12c7c7ffa0c0419e3d716b407b openhcs/interop/cellprofiler/pipeline_import.py +100644 blob 2535d9b73f8be6359303b29b111fafa11f456b68 openhcs/interop/cellprofiler/plate_workspace.py +100644 blob 6348063603afe362b83d02d321a4a08177d32369 openhcs/interop/cellprofiler/runtime/__init__.py +100644 blob 5549514b430f28c40dd173ea54c99434be800138 openhcs/interop/cellprofiler/runtime/adapter.py +100644 blob 0fbfc14e4151ada49626cf0f15ddc7137f1dbe39 openhcs/interop/cellprofiler/runtime/artifact_binding.py +100644 blob d6667d5f76f4573d7b509cbb0e6990dd00ecfe5e openhcs/interop/cellprofiler/runtime/function_contract_execution.py +100644 blob cfe57fa7b2f85ac9e12181a315f7607473f107cc openhcs/interop/cellprofiler/runtime/invocation.py +100644 blob da54a1e105eed896df88435ef023ee1fe67aba52 openhcs/interop/cellprofiler/runtime/main_flow.py +100644 blob 92c93a7309ad752a2e77c6d5eb05eeb50042dec0 openhcs/interop/cellprofiler/runtime/measurement_execution_support.py +100644 blob 63cacedd723a145f24335139bc7a67b65d15c86a openhcs/interop/cellprofiler/runtime/measurement_recording.py +100644 blob 37a8fdef5d0fb729976b3227211f20430a5a01a9 openhcs/interop/cellprofiler/runtime/measurement_rows.py +100644 blob 9e779196f5f037c05ce22af912d5d5da3cf3fa75 openhcs/interop/cellprofiler/runtime/measurement_source_names.py +100644 blob 840624bfaf4592b2947ed53ec487763a9e51c353 openhcs/interop/cellprofiler/runtime/module_execution.py +100644 blob 5f8eec6c9c7dc517d1c5fb51b1b72ef0e608bc75 openhcs/interop/cellprofiler/runtime/object_input_policies.py +100644 blob 19c2890811ab41f16041c647b0578947595dfac7 openhcs/interop/cellprofiler/runtime/object_label_measurements.py +100644 blob 22d84d37e98f6439fd33788428ed90994c757c40 openhcs/interop/cellprofiler/runtime/object_measurement_execution.py +100644 blob c804da79bead63a179ea2a5f996bc7bfe93113ba openhcs/interop/cellprofiler/runtime/object_measurement_row_completion.py +100644 blob 3879f8902fe43f66aaffb454e451c3b3ee04e792 openhcs/interop/cellprofiler/runtime/object_measurement_row_policies.py +100644 blob 2fd94cf9d8fbbc86462b697da383cadbe52b0c5e openhcs/interop/cellprofiler/runtime/object_measurement_tables.py +100644 blob 858e1e7ce877439370301b98a8f2fbf29d57fb10 openhcs/interop/cellprofiler/runtime/object_measurement_vectors.py +100644 blob 3e85322dfeb20e46527ee4f791927b3f8afd99da openhcs/interop/cellprofiler/runtime/output_contexts.py +100644 blob 559fda7c416b3f8f1d88b90b0a26b866c6208658 openhcs/interop/cellprofiler/runtime/output_record_request.py +100644 blob 8e95504e2704590bee42063c0b207ab122af8a4a openhcs/interop/cellprofiler/runtime/output_recording.py +100644 blob 40a9e40801af2770f5a1506fe9106ebf3784fbe2 openhcs/interop/cellprofiler/runtime/primary_image_input_policies.py +100644 blob 679ade3d0821aae86b4fc4da627300acb1e50290 openhcs/interop/cellprofiler/runtime/profile_fields.py +100644 blob f34f8141084907d196ffd1e2efc57d77c8a8ce69 openhcs/interop/cellprofiler/runtime/relationship_measurement_rows.py +100644 blob 8ae130aa396b8af384ee1b29be93ed96282949b8 openhcs/interop/cellprofiler/runtime/runtime_profile.py +100644 blob 0564658db5c8257df5804839ba7b18bb56084f7c openhcs/interop/cellprofiler/setting_names.py +100644 blob ca16daca80f323ab640baa49e0d5f87f67865b0b openhcs/interop/cellprofiler/settings_binder.py +100644 blob 9108793ffecdead3041f83ec527ca568b30402ed openhcs/interop/cellprofiler/source_metadata.py +100644 blob 99d6a656fc242704bbc915294306d04facc78b62 openhcs/interop/cellprofiler/worm_measurements.py +100644 blob a8510b8aab942de5f5c88273547ee4d5827c5d0c openhcs/interop/cellprofiler_setting_normalization.py +100644 blob 18844345f4dee1dd3a544646a4dca32f809f6a78 openhcs/introspection/__init__.py +100644 blob 43147c49c7fb90024615514214c2692952143a40 openhcs/mcp/__init__.py +100644 blob b6e97b75775098339fc65caab3c15fab558419eb openhcs/mcp/__main__.py +100644 blob 337423b0753d578dba149804e02ea041a14a7fed openhcs/mcp/bootstrap.py +100644 blob ffe96e7a008e19bc53a050e3e7227096beb5ef93 openhcs/mcp/client_registration.py +100644 blob cc6c953ea579882ea31100f00077bec318386798 openhcs/mcp/context.py +100644 blob 429cc126f8ebe07ac9f93a959482e2629db11546 openhcs/mcp/control_timeout.py +100644 blob e041a7cd151bdf7ce06d620558319ebd92f59b97 openhcs/mcp/dev_client.py +100644 blob 9f0a9cca9d0d267dc360f4967b87bc9dc22b4fcf openhcs/mcp/dev_client_commanding.py +100644 blob f9317a06e23ead13a0adec3356d6e49029364e45 openhcs/mcp/dev_client_commands/__init__.py +100644 blob 4c9a92af6183a8241b238577480d91d74ececd86 openhcs/mcp/dev_client_commands/knowledge_pipeline.py +100644 blob 198bd911da3dad9c164ad275ecc8a3150c7cb014 openhcs/mcp/dev_client_commands/plate.py +100644 blob 081d57242d84663249d9ed639a18d8422f466555 openhcs/mcp/dev_client_commands/ui.py +100644 blob 167e8162fb1f1675906f71124f1522b129747389 openhcs/mcp/dev_client_commands/viewer.py +100644 blob 633db24d264c4b5b118aa04eb7125953f9c8fc12 openhcs/mcp/dev_client_core.py +100644 blob 0d31a95517f1417c2bac99ed073d142df2a404d3 openhcs/mcp/dev_client_renderers/__init__.py +100644 blob 9da4f38c383133f8d3724ed2c137ce822ccba7e5 openhcs/mcp/dev_client_renderers/config.py +100644 blob 1d5cbb99470fe0cefdea03f153f2075763039e50 openhcs/mcp/dev_client_renderers/knowledge.py +100644 blob 6104ae3f75a5d31f67524860013f509f0cd27a0f openhcs/mcp/dev_client_renderers/object_state.py +100644 blob 8c0933352e93cb99db71dc94b14416bd6ab99e68 openhcs/mcp/dev_client_renderers/pipeline.py +100644 blob a81e145332b77ae5849b1923261ac49adeca11b1 openhcs/mcp/dev_client_renderers/plate.py +100644 blob a6ea7d8c982f4c993ea9b1e10019df9ae0ca2f3b openhcs/mcp/dev_client_renderers/ui_bridge.py +100644 blob ac86b13d0b52cd31fb36c3021dd84aa62dd0d682 openhcs/mcp/dev_client_renderers/viewer.py +100644 blob c193e50f7699de8b07dfe1855cecca16faec2e38 openhcs/mcp/dev_client_rendering.py +100644 blob 8cc234b34a5811120ac89978a98a82fec3eaded0 openhcs/mcp/http.py +100644 blob a88c05d0c659f5e33144ede81708849e4eca96dd openhcs/mcp/http_auth.py +100644 blob ecd2e759e4b309677cafbb4e8e13c7bbb55e78ae openhcs/mcp/installed_demo.py +100644 blob 61466a5f0a79c7acc000ea5b927c1fbd180eacd6 openhcs/mcp/lifecycle.py +100644 blob d51f3d8ccbe5f6a3dc4347495e42dbc494a61388 openhcs/mcp/memory_diagnostic.py +100644 blob e10fde93ee35ed9c626a22247dbcd4b9f81bbaf6 openhcs/mcp/memory_diagnostic_launch.py +100644 blob 7038d8fd82169ffca3ca955cc6a850764f8dd7f4 openhcs/mcp/server.py +100644 blob 1e4d0895d3ac1314957e13da7d12ca9aaab4b765 openhcs/mcp/socket.py +100644 blob 7fd7fb7c3c686fdbb181c9621f5fa6615bbb17a1 openhcs/mcp/stdio.py +100644 blob d885a34a780b227b005fe418ca53661d2650152b openhcs/microscopes/__init__.py +100644 blob d739c298f72c6fedbb50a57e8cf09cf94f0b2ed4 openhcs/microscopes/bioformats.py +100644 blob 0554c1f85d1d13e8df73354bd9b783a921fe3418 openhcs/microscopes/bioformats_adapter.py +100644 blob 65ef76419f01407e0e3b526c4df0c23e540fd82a openhcs/microscopes/bioformats_well_key.py +100644 blob 687e7583848ba4e21861ac66d4c53e0a55e59806 openhcs/microscopes/exceptions.py +100644 blob 4c89e0e243dc74aa48f481d863400871efac8e33 openhcs/microscopes/handler_registry_service.py +100644 blob 60a8c209468cd7505749e2df644107449a792fec openhcs/microscopes/imagexpress.py +100644 blob 63523da1a67ee5b1672545660d568db096d9d564 openhcs/microscopes/imagexpress_source_metadata.py +100644 blob 4223bec70d7b7eb7a390ca3234596090ca4d5d63 openhcs/microscopes/microscope_base.py +100644 blob 941953a2bc78590af0e5c622810fbf36c96ad0dc openhcs/microscopes/microscope_interfaces.py +100644 blob ff52391f1a1259d4f1fe82f4c14aecfc75a5ffd4 openhcs/microscopes/omero.py +100644 blob 09f2b77e65e6635349eed51c6180ca453fbe3a81 openhcs/microscopes/openhcs.py +100644 blob 2b14efe966a5737c1d5f6cd5391f20dfbb3dd056 openhcs/microscopes/opera_phenix.py +100644 blob a2148049b2df3f4543e4b7b8c6a582af2cb1debc openhcs/microscopes/opera_phenix_xml_parser.py +100644 blob d6af813a8a340f4b9e117a9c123cddebd4a719e9 openhcs/microscopes/source_bindings_handler.py +100644 blob 4b55ccf08b1a3e7949607e07811d2f5803abcfd0 openhcs/microscopes/source_schema.py +100644 blob fdaac2113d333c8232ab1099ac4581b60e6d7c7f openhcs/microscopes/tiff_metadata_mixin.py +100644 blob 4358aa30b2098bf7f8ff5b6d1d70f0a66d3573a1 openhcs/napari_roi_manager/__init__.py +100644 blob 46dde4039b66d0d6fe286389da3297acb7663a72 openhcs/napari_roi_manager/_dataclasses.py +100644 blob 7ca04689a6fd4137bebbf1f3a938ea418b03b4ae openhcs/napari_roi_manager/ij/__init__.py +100644 blob d9b33fc01d0a38e42a63301d1878efc0e30a9724 openhcs/napari_roi_manager/ij/_convert.py +100644 blob 59f5d22474bce33d2687fd22c940562d9b820460 openhcs/napari_roi_manager/widgets/__init__.py +100644 blob 92b085e24c45fac3b21136667d957cff0989bd63 openhcs/napari_roi_manager/widgets/_dialogs.py +100644 blob 93fa2d14a156cc0fbf6e7c26f9467877c1bb54b7 openhcs/napari_roi_manager/widgets/_roi_manager.py +100644 blob 68846d54b9e28c017ed1ff4cc2c5d35b44fdd9de openhcs/omero/plugin/omero_openhcs/__init__.py +100644 blob c467417833217a009e7d666e218d98cfa95b14cf openhcs/omero/plugin/omero_openhcs/apps.py +100644 blob fde8c671c0c647429fff7aa9388ab167f2e56320 openhcs/omero/plugin/omero_openhcs/urls.py +100644 blob 9e5b07afcbb5b3974c22d4eb9eee14e31a2041ec openhcs/omero/plugin/omero_openhcs/views.py +100644 blob 05841afc9d5bee24b89ad049c2f9bedb840c398f openhcs/omero/plugin/setup.py +100644 blob 78c12f4e089ed0e35e6918cc0c759edc75b625ea openhcs/processing/__init__.py +100644 blob e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 openhcs/processing/backends/__init__.py +100644 blob dd09c87d9b71eebaa1a1373af42af6b993f60872 openhcs/processing/backends/analysis/__init__.py +100644 blob 0e3dcc04ddf5be0643e7d2bf3c1b6aa8daec1025 openhcs/processing/backends/analysis/cache_utils.py +100644 blob 2ee84776fb805d00c5720fda6de32c9fe3e2138d openhcs/processing/backends/analysis/cell_counting_common.py +100644 blob 52d3e76af8fc48785b6743633b5fe75b7f1f16f8 openhcs/processing/backends/analysis/cell_counting_cpu.py +100644 blob 31427ece41f45de5007e37b3971c858c3e5dbf20 openhcs/processing/backends/analysis/cell_counting_cupy.py +100644 blob c639fe8c0100442c0461dbf65d2153e5e6ad122d openhcs/processing/backends/analysis/cell_counting_pyclesperanto.py +100644 blob 29d2b866cb30a06d5c49f4f521a10b2e8ec21cf1 openhcs/processing/backends/analysis/cell_counting_pyclesperanto_simple.py +100644 blob e2c80ee6f9dd45a01c5bc6a477adbb7ce7b22579 openhcs/processing/backends/analysis/consolidate_analysis_results.py +100644 blob 4be8f851494d308758295b3ab4a5c5c2dd2c7393 openhcs/processing/backends/analysis/consolidate_special_outputs.py +100644 blob 1f8a06ccb8a0150a1dba262466fdc204884ee6e3 openhcs/processing/backends/analysis/count_cells_simple.py +100644 blob 599539da954e6a224beeaaef9da487a4d13ae17e openhcs/processing/backends/analysis/dxf_mask_pipeline.py +100644 blob e58aa3fc9f6e08f72cfbb7b844f4b2a3a656b34f openhcs/processing/backends/analysis/focus_analyzer.py +100644 blob cc5cbefc33b1c2001298ecb62f8bc7b291d316d4 openhcs/processing/backends/analysis/hmm_axon.py +100644 blob 3edd6598fa7a19ed35651d7467e6458d8eded3ac openhcs/processing/backends/analysis/hmm_axon_torbi.py +100644 blob e4a0f6db969233c1a54965b8d020a94324e4b6e1 openhcs/processing/backends/analysis/metaxpress_utils.py +100644 blob e4c892a60960fee7d0616c21e50923b9a7b96ac1 openhcs/processing/backends/analysis/multi_template_matching.py +100644 blob 69097f969b7b0b4ff686801c54c213f59030e6d3 openhcs/processing/backends/analysis/neurite_outgrowth.py +100644 blob 37df38fbcec3c36db3a531f57a9ed0d3340be10d openhcs/processing/backends/analysis/region_properties.py +100644 blob 8b8c5ed2ca7fd00031ee63704e25802d83a8a190 openhcs/processing/backends/analysis/self_supervised_segmentation_3d.py +100644 blob 934bbff9b5239c5c0f18303f89ff3c0055ed89c3 openhcs/processing/backends/analysis/skan_axon_analysis.py +100644 blob 6f75bae50641177f7ad26b5f1a710d43737436d3 openhcs/processing/backends/analysis/skeletonize_and_save.py +100644 blob adc3401014a6687f86bb23c1ecf7dba269b281db openhcs/processing/backends/analysis/straighten_object_3d.py +100644 blob 5c5aa58b70b41b142c14d2d4714b5eb10dc2d444 openhcs/processing/backends/analysis/test_simple_implementation.py +100644 blob 2f7c0232fb8a0337b9668b09fafc345b774c9e32 openhcs/processing/backends/assemblers/__init__.py +100644 blob 95213d40c65f9a5aae42fba0bd9997d55cee97a9 openhcs/processing/backends/assemblers/assemble_stack_cpu.py +100644 blob 51a82f6c1eb318549d89062e5eda7dd6c0924e86 openhcs/processing/backends/assemblers/assemble_stack_cupy.py +100644 blob d0154da1e83451cb2a04df3ca44283461ce3b7ea openhcs/processing/backends/assemblers/blending.py +100644 blob 07e15485c7f575583466c18d8e18a6e786a21fef openhcs/processing/backends/assemblers/self_supervised_stitcher.py +100644 blob 6f8fdec8e377c22c3c9bc464e6b19dc551844db9 openhcs/processing/backends/cellprofiler/__init__.py +100644 blob e37742d5b15e533ace30050942018bd5c654c139 openhcs/processing/backends/cellprofiler/_backend.py +100644 blob 933a8a3795b9dd487195ed682d7195e87286e267 openhcs/processing/backends/cellprofiler/_preparation.py +100644 blob 9ef9b11ba2ce8f5df3dbe0fce95ed400a7188880 openhcs/processing/backends/cellprofiler/alignment.py +100644 blob e2dd3dac21b4fd0784c7dbd4645aa5e4d3fc1a78 openhcs/processing/backends/cellprofiler/alignment_mutual_information_offset.py +100644 blob 44049e52b8228f9d188edee8846d1c36c608486c openhcs/processing/backends/cellprofiler/area_occupied.py +100644 blob a9bae1830bf65e0cc7f08e8ee046e8478019f3f7 openhcs/processing/backends/cellprofiler/calculate_statistics.py +100644 blob cfa57a57771782fa38065821cf0f9d14f4629a05 openhcs/processing/backends/cellprofiler/classification.py +100644 blob 01144a6bb7d33c61f8d4c5f9c01cdf7be6b5ea86 openhcs/processing/backends/cellprofiler/colocalization.py +100644 blob bab4be6bee8972fe85f598a70b10287582301558 openhcs/processing/backends/cellprofiler/colocalization_costes.py +100644 blob 1e2bbb7797af6fda71783f1bf4fa7ce023bc11bc openhcs/processing/backends/cellprofiler/colocalization_costes_prefix.py +100644 blob 1675a35307698b0f846b4ef74172e407d90825a9 openhcs/processing/backends/cellprofiler/colocalization_costes_prefix_numba_pearson.py +100644 blob 1c3ebb32745bad21f59f5d4b51711b989be75857 openhcs/processing/backends/cellprofiler/color.py +100644 blob 62fd7e1ba9491ba6a47d5f7791552e9dbaba139a openhcs/processing/backends/cellprofiler/crop.py +100644 blob 28c40ce4f4ca21e5200a4c756a90184e2627d2fd openhcs/processing/backends/cellprofiler/display_modules.py +100644 blob a9bb05ccac93a6ee0fa9e5c14194484bdf05f2af openhcs/processing/backends/cellprofiler/distance_propagation_numba.py +100644 blob 30bc44280dc9eb74ef676295b83071c45bbc2a22 openhcs/processing/backends/cellprofiler/edge.py +100644 blob d96af6072222657701b3f3f4269709e3ca3ceadb openhcs/processing/backends/cellprofiler/edit_objects.py +100644 blob 271424c2ce56c001780bd2f6c3cdb5c3721ecb3a openhcs/processing/backends/cellprofiler/enum_attributes.py +100644 blob 2234aaa77f54ec7e9b47125c6bd28b5ec836a85a openhcs/processing/backends/cellprofiler/export_to_database.py +100644 blob b8f6bd7bdaed683b67694c2b0ae56fcbeaefdd11 openhcs/processing/backends/cellprofiler/feature_enhancement.py +100644 blob d35aafb21e8f98f9c285432745193820a8e0e22f openhcs/processing/backends/cellprofiler/flagging.py +100644 blob 187d4d972da1a04d14772f60e0e8b512280ba4c6 openhcs/processing/backends/cellprofiler/gaussian_filter.py +100644 blob 51040bd940312fb8634a20bbac90e350ca0cd3da openhcs/processing/backends/cellprofiler/granularity.py +100644 blob 6610ca5eab4e8495f5287078c28665d1a6c25ad9 openhcs/processing/backends/cellprofiler/grid.py +100644 blob fe9baadda663133277008bfc58cebdd9bf8721de openhcs/processing/backends/cellprofiler/illumination.py +100644 blob 61bdddcca51cd235da11bc4fb5719dbbf6ffb7ff openhcs/processing/backends/cellprofiler/image_geometry.py +100644 blob d0a1a8834fcd808220d2fda266aa4c38c76aee7f openhcs/processing/backends/cellprofiler/image_math.py +100644 blob 7f6f0af6ab2568c7c0d8766aa68d56afd324e508 openhcs/processing/backends/cellprofiler/image_quality.py +100644 blob 06c55e7479039671838596a772c8476cdb24dac2 openhcs/processing/backends/cellprofiler/imagej_macro.py +100644 blob 8fc913576d58cec1fd713022f97e1f8da0c383d7 openhcs/processing/backends/cellprofiler/infrastructure.py +100644 blob cbb6dbcde05b6258cdd94e50482df505511e521b openhcs/processing/backends/cellprofiler/intensity.py +100644 blob 4e2a4460d05a9ed5d0099984424566718949536f openhcs/processing/backends/cellprofiler/intensity_distribution.py +100644 blob 2cef276048a33337346b91012ef1443c666b7d61 openhcs/processing/backends/cellprofiler/intensity_object_quantiles_numba.py +100644 blob 0cc202fd17b9560bc7ced872e1f694b4396a2efa openhcs/processing/backends/cellprofiler/label_geometry.py +100644 blob 2dff878b3aa6e8057822cc999c0e72308a80be01 openhcs/processing/backends/cellprofiler/manual_objects.py +100644 blob 2aa947615101841cf74f2bd90c68872d864f49bf openhcs/processing/backends/cellprofiler/maxima.py +100644 blob 16d8192ad53b8c7b043fdd851ed410c5167e4f15 openhcs/processing/backends/cellprofiler/measurement_math.py +100644 blob 5562ceb4399b2a3f77b165b503e9938994b7e049 openhcs/processing/backends/cellprofiler/medial_axis.py +100644 blob ca24bd2c001f18b5ceb4666c330262a5158bf651 openhcs/processing/backends/cellprofiler/median_filter.py +100644 blob 9aca5367c2107ec46ed37274e744223684cf24f5 openhcs/processing/backends/cellprofiler/morphology.py +100644 blob 11b18b4a1ef0f2f00662ff1757020788df462f99 openhcs/processing/backends/cellprofiler/neighbors.py +100644 blob 4da1708f23b64d1133673b5199960cb704f8b10f openhcs/processing/backends/cellprofiler/object_filtering.py +100644 blob 2ec98235ff889570cbd1260d2b59c24b05330849 openhcs/processing/backends/cellprofiler/object_images.py +100644 blob f7204c73abc3ba593e8f060f99150183f6a6ad39 openhcs/processing/backends/cellprofiler/object_overlap.py +100644 blob cdaeb5cefd0a5242ec72337520f3e4dc3322c6b2 openhcs/processing/backends/cellprofiler/outlines.py +100644 blob 4b0e9396043b2a77032d7a8e0867471f02572bb7 openhcs/processing/backends/cellprofiler/perf_fixtures.py +100644 blob 253aac98d389b9993e5d0c4fd59e029bb5aa0c5b openhcs/processing/backends/cellprofiler/primary_object_diagnostics.py +100644 blob 63da41096189dee98c23cd99a7bd1d5a9e11596c openhcs/processing/backends/cellprofiler/primary_objects.py +100644 blob d5f9781295390fa9f8694361edc1225378033818 openhcs/processing/backends/cellprofiler/projection.py +100644 blob a775ecd7c2ae4e7af8bdec291f9eadd3a2d76628 openhcs/processing/backends/cellprofiler/relationships.py +100644 blob 796419fcbf71ee254e90df86a85d5cba9836d5c8 openhcs/processing/backends/cellprofiler/save_images.py +100644 blob bec44bb350ad03dddbdb4c0a58fbf972721f979a openhcs/processing/backends/cellprofiler/secondary.py +100644 blob cedece0a06f42bc03cc1d585898c02e7bc2c9a38 openhcs/processing/backends/cellprofiler/shape.py +100644 blob 947ca74c014e6f92d2f034f5275d00cce9d11b14 openhcs/processing/backends/cellprofiler/skeleton.py +100644 blob 0b803b2294a7be62347d68d04a77ed9124333cdb openhcs/processing/backends/cellprofiler/smoothing.py +100644 blob f30171726b5781724e2b7c2e1b60edca6e328e80 openhcs/processing/backends/cellprofiler/spreadsheet_export.py +100644 blob 54870cfcf302757c935bed17facd3cc1e34b342d openhcs/processing/backends/cellprofiler/structuring_elements.py +100644 blob 28050c06e689350792d197908e3a3581d2435640 openhcs/processing/backends/cellprofiler/texture.py +100644 blob 534560c8edefe95024c4206d09944c2b1648dcf7 openhcs/processing/backends/cellprofiler/thresholding.py +100644 blob 8b3634eecee01ba9769dc6c3519cc537dd7f42f1 openhcs/processing/backends/cellprofiler/thresholding_threshold_numba_diagnostics.py +100644 blob 0112751f4d96d2d2bee486bf719f6c06784375b8 openhcs/processing/backends/cellprofiler/thresholding_threshold_numba_diagnostics_quantized.py +100644 blob 73093e0ccd08304e8d1b5467fb2f5b161287bab5 openhcs/processing/backends/cellprofiler/thresholding_threshold_numba_otsu.py +100644 blob ec386f6b50f82becff383363f6bb26c62bf99db5 openhcs/processing/backends/cellprofiler/thresholding_threshold_numba_otsu_histogram_multiotsu.py +100644 blob c04117b1000bddd5f3166da242d44562849e1f87 openhcs/processing/backends/cellprofiler/thresholding_threshold_numba_otsu_weighted.py +100644 blob 3a36e51e4edf87841e6f6c71d0bb93cc4278ee35 openhcs/processing/backends/cellprofiler/tracking.py +100644 blob 09e8bfafe437b366a8ff3455f88a952c36cfb333 openhcs/processing/backends/cellprofiler/watershed.py +100644 blob c9af20347de195c223bb52ca03cf1e4d0e7ca80d openhcs/processing/backends/cellprofiler/worm_geometry.py +100644 blob c35e5eb206c7df4e1d68dc3ba94a7f289116b60f openhcs/processing/backends/cellprofiler/worms.py +100644 blob 325053fa3834a6f1e9d682236bd8a3e383f6706c openhcs/processing/backends/cellprofiler/zernike.py +100644 blob 03663ad92d28c3bf59f6eb713a10586a483d7313 openhcs/processing/backends/enhance/__init__.py +100644 blob f117e97d6a8b17cfdf246c1cc18af0964c612bc0 openhcs/processing/backends/enhance/basic_processor_cupy.py +100644 blob 02620abe29ff107409219d8a8425236bed54995f openhcs/processing/backends/enhance/basic_processor_jax.py +100644 blob 28bc2de3c6af4b197b4ef9b2a7c8a176a58820fd openhcs/processing/backends/enhance/basic_processor_numpy.py +100644 blob 913273eca542c376eba9dc3fa1d7f1aedae63e2f openhcs/processing/backends/enhance/cupy_clahe.py +100644 blob b92eea4ed660d0c33931a485cd7ebe8aac36282e openhcs/processing/backends/enhance/deconvolution.py +100644 blob ab7049e8048893edc7a0e56dcbe77096bb99a368 openhcs/processing/backends/enhance/dl_edof_unsupervised.py +100644 blob ea53c8a072a5efb8c98dd26f1d95bbc39feff0ea openhcs/processing/backends/enhance/flatfield.py +100644 blob a26d1c4091b6818d9d82316020be9ccb89d835ad openhcs/processing/backends/enhance/focus_torch.py +100644 blob 110c46a5cf800b555ce95f45c2843e49dcaabd72 openhcs/processing/backends/enhance/jax_nlm_processor.py +100644 blob 02a2f04e43a95d8fe8e146117d2e52e4c19e4ef0 openhcs/processing/backends/enhance/n2v2_processor_torch.py +100644 blob ff15c8aaf0176cec74a0fa5d382028deda87098f openhcs/processing/backends/enhance/self_supervised_2d_deconvolution.py +100644 blob 688228377f1de34375b0624e39332cfc59b4a0f7 openhcs/processing/backends/enhance/self_supervised_3d_deconvolution.py +100644 blob c81b93b842f83c4ed6ba39f62a5a804344fccb92 openhcs/processing/backends/enhance/torch_nlm_processor.py +100644 blob 3b45e246f511eb2a6cd36aa30f25b7f481d7d536 openhcs/processing/backends/experimental_analysis/__init__.py +100644 blob 5c539cf45240053dc0406064b061fe5317d44441 openhcs/processing/backends/experimental_analysis/unified_analysis_engine.py +100644 blob c2434ed79057229d2de33253e9f0c4e67242397f openhcs/processing/backends/lib_registry/cupy_registry.py +100644 blob d9599bf810f66f83e4f7cf08b2e583cbbeaf4fcc openhcs/processing/backends/lib_registry/openhcs_registry.py +100644 blob 40267442a91ab533b4bb1df6fbab3b0c3373a943 openhcs/processing/backends/lib_registry/pyclesperanto_registry.py +100644 blob 536d827d7072b429b3e48db7a9c4b6991d55a7af openhcs/processing/backends/lib_registry/registry_service.py +100644 blob 9021f71dd2aa7eba3542ea31820957a83a08f029 openhcs/processing/backends/lib_registry/scikit_image_registry.py +100644 blob 9cca8159f8a65ee281fc9f752de20eb2cc771308 openhcs/processing/backends/lib_registry/unified_registry.py +100644 blob 2cafbb0733c6404d51d139ea3713775a890f9d21 openhcs/processing/backends/numpy_runtime.py +100644 blob 58a4adbeaaedc48da41a1e262c66b3e16f3f08d1 openhcs/processing/backends/pos_gen/__init__.py +100644 blob 4ce92bb77e9644bf8c667f0eef3a23a9e9604db9 openhcs/processing/backends/pos_gen/acquisition_positions.py +100644 blob 7d91f49eac4bcbef08027e8216b5e4d7336b2b98 openhcs/processing/backends/pos_gen/ashlar_config.py +100644 blob 3a273ac1d578c77316304234baca6319e0352dc3 openhcs/processing/backends/pos_gen/ashlar_main_cpu.py +100644 blob add8fef0cec4d60300048c5fbb081d692e43cdb5 openhcs/processing/backends/pos_gen/ashlar_main_gpu.py +100644 blob 998d5b8f65685d0024bad214aa0320625dd9e8f2 openhcs/processing/backends/pos_gen/mist/__init__.py +100644 blob 7c274781c1fad039ee7482dc228afb4b6caa8e34 openhcs/processing/backends/pos_gen/mist/boruvka_mst.py +100644 blob 84ac0bd498d894cb9b4ba05e7e90a679b38312ad openhcs/processing/backends/pos_gen/mist/gpu_kernels.py +100644 blob 8dd1bda7f9805436dc67525c3662c6f3c5699c1e openhcs/processing/backends/pos_gen/mist/mist_main.py +100644 blob dbb9ca786ff1c477bf095924e1eefe7b066962de openhcs/processing/backends/pos_gen/mist/phase_correlation.py +100644 blob d1b8b621a66be068904425c391b892686c1dcbe6 openhcs/processing/backends/pos_gen/mist/position_reconstruction.py +100644 blob 5a1fd794ab8fc69416426dc3f1735dc432e54034 openhcs/processing/backends/pos_gen/mist/quality_metrics.py +100644 blob 894bb42b695e42c0c96e4fa0ada245d09f08b0a5 openhcs/processing/backends/pos_gen/mist_processor_cupy.py +100644 blob 370f74a56d1917c79b4fbadc51fe7c847c4a7a01 openhcs/processing/backends/pos_gen/tile_position_artifacts.py +100644 blob 7fe1bd42a787495e77d5ed92c9b4d23118db61ad openhcs/processing/backends/processors/__init__.py +100644 blob 2ea268c5248d863b11d5f743c1155cd3aed1d8d3 openhcs/processing/backends/processors/cupy_processor.py +100644 blob bcf496e7b6111791a847cb3f746a26bf99ae31f3 openhcs/processing/backends/processors/jax_processor.py +100644 blob 58d7847411becdc3b9a46ee41e61b48960078563 openhcs/processing/backends/processors/method_axes.py +100644 blob 5a467e0c0c32a7ccd2519839eb6056bb6936b33f openhcs/processing/backends/processors/numpy_processor.py +100644 blob fb28b5992ac20930ed6620812be6e53e56c84c64 openhcs/processing/backends/processors/percentile_utils.py +100644 blob baccd7347482420807b3afe4437ed964807982eb openhcs/processing/backends/processors/pyclesperanto_processor.py +100644 blob f9a7394275ca947697ab5685c5acf4f7d369a130 openhcs/processing/backends/processors/tensorflow_processor.py +100644 blob cdfa43e13b3abdd0127fabd57e1be1cd0d4a758f openhcs/processing/backends/processors/torch_processor.py +100644 blob 073063d41d22eb5cfc3dbe43318e0fd06e24e7bc openhcs/processing/custom_functions/__init__.py +100644 blob 151259b07ef055549c9fa80e561628a58013eac7 openhcs/processing/custom_functions/events.py +100644 blob 817cbe7737d95492a771498c9304a13dd353e04e openhcs/processing/custom_functions/manager.py +100644 blob 6ee7dcd4344efc942b7548fed2d6a68e945e863d openhcs/processing/custom_functions/runtime_registry.py +100644 blob d28ffb3ebb556b93506d0096b614c73255bbd523 openhcs/processing/custom_functions/signals.py +100644 blob 43c271b9d93465a6a34bcfa6889ae01730308078 openhcs/processing/custom_functions/source_namespace.py +100644 blob efee064eb1772a4359fea6f0ebb996471f03db26 openhcs/processing/custom_functions/templates.py +100644 blob 2bfe204cda9de2a30421517c5bf7bd9d365932d4 openhcs/processing/custom_functions/validation.py +100644 blob 394e9bc2043492d16d34e4815cbb6e0fb886c42b openhcs/processing/func_registry.py +100644 blob a8e58d6dded8ca3f27efc73898d20c227d98dc9f openhcs/processing/materialization/__init__.py +100644 blob ccc305285d4ffe7b9f6265055129569b18c09ee5 openhcs/processing/materialization/constants.py +100644 blob cfa1841f984664580068297b56dab9e550cc5944 openhcs/processing/materialization/core.py +100644 blob d29b4e8f5fddebf3a36e36a74ef2e440a75eb7e1 openhcs/processing/materialization/options.py +100644 blob 85e9b481e8c12714f8faefbd2cc48d6a8570ce76 openhcs/processing/materialization/path_scopes.py +100644 blob 8408c47ceb46ad9387f44a7668b324be113da52f openhcs/processing/materialization/presets.py +100644 blob d2dce06c48c1df97f43880be792ab3f04a26822c openhcs/processing/presets/__init__.py +100644 blob 6ff8cc2699b39feb13f3b473c55ee3b1e1700acd openhcs/processing/presets/demo_contribution.py +100644 blob e996c15de1999613d59b42cbf35b59a01b3a0605 openhcs/processing/presets/mfd_specs.py +100644 blob f8bea827c82378c995987732a89646b72869fc27 openhcs/processing/presets/pipelines/10x_mfd_crop_analyze.py +100644 blob 78ad1b0aa05654d36806a42e2eebebce52fe46f4 openhcs/processing/presets/pipelines/10x_mfd_crop_analyze_dapi-fitc-cy5.py +100644 blob b605b9b0e7e1856fef259cf0df6b304a5f3d78b5 openhcs/processing/presets/pipelines/10x_mfd_stitch_ashlar_cpu.py +100644 blob ab86eb0cf5e598b4c6579c7d6eaec24939fafc39 openhcs/processing/presets/pipelines/10x_mfd_stitch_gpu.py +100755 blob 170e2510f17b6fb0c6fd8a6eeba23543535e6fbf openhcs/processing/presets/pipelines/cy5_axon_cell_body_crop_analysis.py +100755 blob 2effc552b80cf08c0434d467d74a4ec18b3e33e5 openhcs/processing/presets/pipelines/cy5_ctb_cell_count.py +100644 blob a9896b3930b33036638af8536b16e6e6c7d592ca openhcs/processing/presets/pipelines/czi_brain_axon_cellbody.py +100644 blob 6c3696f63cba85f512835295a221b91828ee4b81 openhcs/processing/presets/pipelines/imx_96_well_neurite_outgrowth_pipeline_cpu.py +100755 blob 7a03e90dd33ecea5b5003d3606bfa5f50d1cb80b openhcs/processing/presets/pipelines/imx_96_well_neurite_outgrowth_pipeline_gpu.py +100644 blob 3434bf4d5148396cdf8fe3b125cd266ed21b9ed8 openhcs/processing/presets/pipelines/loose_operaphenix_neurite_outgrowth.py +100644 blob f73f534ad63d588fe9918d6068297dbc38d325f1 openhcs/processing/presets/pipelines/loose_operaphenix_neurite_outgrowth_metaxpress.py +100644 blob f97743b06879a3af020f895880d1b36755b04033 openhcs/processing/presets/pipelines/neuroncyto_ii_crossover_neurite_outgrowth.py +100755 blob e171c96bb2a913b0241b9e90203aa3e706f28515 openhcs/processing/presets/pipelines/test.py +100644 blob 82ea9a85f2aed1647d1f2851dd1b8852d217865d openhcs/pyqt_gui/__init__.py +100644 blob da81b2ef682fd670bafcd89538157a4d327fe8cf openhcs/pyqt_gui/__main__.py +100644 blob da386d227110d01a2265bad20bc8b1334c0ae444 openhcs/pyqt_gui/app.py +100644 blob 079af1312e6e318611f807ef94837710f0d9abbc openhcs/pyqt_gui/branding.py +100644 blob eca20f9cc567a63c5c1bbf054c357e1cf1d31463 openhcs/pyqt_gui/config.py +100644 blob f6e4bd81fafec561cfc006f7b7fbc11349fc4a8b openhcs/pyqt_gui/dialogs/custom_function_manager_dialog.py +100644 blob 8fcb6c9836feafc855aa6a97cee04d7e76b36932 openhcs/pyqt_gui/dialogs/function_selector_dialog.py +100644 blob 43e91c21b85c54ad97363a8f8f246de0702bb857 openhcs/pyqt_gui/dialogs/metadata_viewer_dialog.py +100644 blob 9af8701a49a3b35988e00befe4e72cef44c32da1 openhcs/pyqt_gui/launch.py +100644 blob 79a7d7219a1845255e1045ee859675e639a95a4a openhcs/pyqt_gui/main.py +100644 blob bc2f7b0c361dba634feba8f9cbb5eb26b9eb67d4 openhcs/pyqt_gui/services/__init__.py +100644 blob b77aee859b3c00a853a6c903bc68a65b0afa6878 openhcs/pyqt_gui/services/code_document_normalization.py +100644 blob b7fed8685bc14d0a11ff07307c88c62e9a130ae7 openhcs/pyqt_gui/services/config_window_code_document.py +100644 blob dd90f63debe36dfd7667b1b7ca02086cb435e9e6 openhcs/pyqt_gui/services/desktop_restart.py +100644 blob 3b2c3a837c3cc8c62c94eab7e8c635a521718e43 openhcs/pyqt_gui/services/desktop_restart_worker.py +100644 blob 1e03a55acdb2b15bf74719d339bcc3f5a046c6d4 openhcs/pyqt_gui/services/desktop_update.py +100644 blob b30ccfb23634bf2d853a9cdf24bbc98003c9da18 openhcs/pyqt_gui/services/desktop_update_worker.py +100644 blob 6126b9447c336fd4e3e6c0d65af1b149cb8678d0 openhcs/pyqt_gui/services/embedded_code_documents.py +100644 blob 810a14079cc3d125fed1887d3b858d3b86a7efba openhcs/pyqt_gui/services/function_step_code_document.py +100644 blob b888ce021de97eba3b9aa68ae12d8ec1ddc72b74 openhcs/pyqt_gui/services/history_migration.py +100644 blob 5291dceda777df23c0adffff2dd40870119882e8 openhcs/pyqt_gui/services/logging_config.py +100644 blob 752c2b59edebadea70738a2efafae94ad4f08715 openhcs/pyqt_gui/services/main_window_workflows.py +100644 blob 8a573ddf5c2efa8dcc5c288c31258775db3b0cff openhcs/pyqt_gui/services/pipeline_object_state_binding.py +100644 blob a801c7d30f3ceb9fe7d767e4a8b097aa4e8b66cc openhcs/pyqt_gui/services/plate_manager_batch_workflow.py +100644 blob e2a3c31428974b4b7f50069b03985c81363b179e openhcs/pyqt_gui/services/plate_manager_root_state.py +100644 blob 0bf5ea79225dbf19f365c67c33d6f9be2ce953bb openhcs/pyqt_gui/services/plate_manager_row.py +100644 blob 9974fddefdaac74661be2827a06cf88fce70dc35 openhcs/pyqt_gui/services/plate_manager_state_projection.py +100644 blob 1cbc75ff3b34e425feb42671038794b5062a10d5 openhcs/pyqt_gui/services/reactor_providers.py +100644 blob 45d65792b706c6ac19c0eef974c4555b06d1e5d5 openhcs/pyqt_gui/services/service_adapter.py +100644 blob d6a5cfa87f7dcfc2b338dfea4d551956f7ad9584 openhcs/pyqt_gui/services/step_scope_identity.py +100644 blob 067bf0f85f8eb6648b08b4fb23e3d6036cbf3aaf openhcs/pyqt_gui/services/time_travel_navigation.py +100644 blob 5157332071bb5f1208595bd2f5223dec52da2bd4 openhcs/pyqt_gui/services/ui_agent_bridge.py +100644 blob cc6ee9240cf5ef3286f137b99647ee9f5d8d6b3d openhcs/pyqt_gui/services/ui_bridge_composition.py +100644 blob ca033a007d097206e4cfe8cffd3ecc090c246a0e openhcs/pyqt_gui/services/ui_bridge_contracts.py +100644 blob 171969e65ec4912a59ad2754bdbcaa571b4b0054 openhcs/pyqt_gui/services/ui_bridge_live_overview.py +100644 blob da3958dcc2366b233ee189d940083a33ea43e163 openhcs/pyqt_gui/services/ui_bridge_object_state.py +100644 blob 760a0a1e17964c196d9ab4553d4c1876e0e395e8 openhcs/pyqt_gui/services/ui_bridge_object_state_scope_policy.py +100644 blob 0b36957d9bd6440863c3a7f28987d55b05d38873 openhcs/pyqt_gui/services/ui_bridge_pipeline_editor.py +100644 blob bd0f0e3dfe674e72c4e8e9b9293ebd95e2755e19 openhcs/pyqt_gui/services/ui_bridge_plate_manager.py +100644 blob 8f4feca7bb477bb26a17541061555c780f961979 openhcs/pyqt_gui/services/ui_bridge_registry.py +100644 blob a84711d751c00d067c18a9ab2a9e7de49b382798 openhcs/pyqt_gui/services/ui_bridge_server.py +100644 blob 05d00b6b6feba3611cc7596d25d04ecce2cd2d39 openhcs/pyqt_gui/services/ui_bridge_windows.py +100644 blob 59a60a848ee331a8d3eff3a01739dfa91e80d49d openhcs/pyqt_gui/services/ui_window_ids.py +100644 blob b607b7ee9af9ed123dd6082658aa7fafb60bbd03 openhcs/pyqt_gui/services/window_config.py +100644 blob f392b15d6bebaf94d7df3bc5b527a4135d401d3a openhcs/pyqt_gui/services/window_handlers.py +100644 blob 164fa7ef54c4ce585981838dd6fe9122565c2e8c openhcs/pyqt_gui/services/zmq_version_restart.py +100644 blob 6d6a772a10cc7cbc28956ef3c267c125220d6789 openhcs/pyqt_gui/ui_tab_identities.py +100644 blob b22dc70c0f73a7182843b94e4d5543d9a9b3560b openhcs/pyqt_gui/utils/__init__.py +100644 blob b878bd7587cb6d09d8b851be1c5c69b1a39d5f37 openhcs/pyqt_gui/widgets/__init__.py +100644 blob 783c1da07398be427c946e8ff1b45d263aaac6d3 openhcs/pyqt_gui/widgets/artifact_plan_view.py +100644 blob 69934c10e1dc210eb356dffc4db057a84a281500 openhcs/pyqt_gui/widgets/config_preview_formatters.py +100644 blob 433fe92d944a5cf846a25fe6c38ac3896a53ec0d openhcs/pyqt_gui/widgets/debug_toolbar.py +100644 blob 6c92831bcba67c2bc19ab5ef7904bc2dd6987bd1 openhcs/pyqt_gui/widgets/image_browser.py +100644 blob 2662a7fe8a40a289c22f15cb4d959ef5734bf87d openhcs/pyqt_gui/widgets/pipeline_editor.py +100644 blob cb8be747da24a2182aa1a4f14c6a688d1f85bc7e openhcs/pyqt_gui/widgets/plate_manager.py +100644 blob e8cc6f17feb549222aadb41cbe8637693a4a12f3 openhcs/pyqt_gui/widgets/shared/__init__.py +100644 blob be8274dc5418db5a837f36ce898cd87cbe585709 openhcs/pyqt_gui/widgets/shared/openhcs_manager_mixins.py +100644 blob 088af711ee7a6a5efa008674c9cd3ef7d9c9aaec openhcs/pyqt_gui/widgets/shared/plate_view_widget.py +100644 blob a6b7da3abb2696d372f16064703d5d2fd69ef1bb openhcs/pyqt_gui/widgets/shared/server_browser/__init__.py +100644 blob e7046d8bb53bc68c12391bcf41fc7af6bf0d4ab9 openhcs/pyqt_gui/widgets/shared/server_browser/live_tree_sync.py +100644 blob aab2b38c6e99f1fc40086979ac302a48c85152f3 openhcs/pyqt_gui/widgets/shared/server_browser/presentation_models.py +100644 blob b1a1e522d3f6eed54c71dc9ecdaeab0c8816f22c openhcs/pyqt_gui/widgets/shared/server_browser/progress_projection.py +100644 blob 0ed9259f71cfda809877bd1daad5970e4c3c9b65 openhcs/pyqt_gui/widgets/shared/server_browser/progress_tree_builder.py +100644 blob ab909cedde74d4001e5ad48e5cb68a32eac7962a openhcs/pyqt_gui/widgets/shared/services/batch_context.py +100644 blob e5f2169cc66a5eb4936ab93f9491a4fa2cc6a576 openhcs/pyqt_gui/widgets/shared/services/batch_workflow_components.py +100644 blob fc1595df6c4c6308bdfa7fabb138d6a27fbc412f openhcs/pyqt_gui/widgets/shared/services/compile_batch_workflow_service.py +100644 blob 7e9e8f1fb666e0bc38c920506ec5fd3c831882d8 openhcs/pyqt_gui/widgets/shared/services/compile_workflow_service.py +100644 blob a97022bb9fc4cceca40def4b022ec28350bee506 openhcs/pyqt_gui/widgets/shared/services/debug_progress_service.py +100644 blob 8f38e47e53787e35db2dbe4e3d1517be7a8a0520 openhcs/pyqt_gui/widgets/shared/services/debug_session_projection.py +100644 blob 86349b6a98ab6d38784df949c955f23c0c4f618d openhcs/pyqt_gui/widgets/shared/services/debug_workflow_service.py +100644 blob f6a3c601d61d5498bb2ec45a80e60fc881cc1756 openhcs/pyqt_gui/widgets/shared/services/execution_control_service.py +100644 blob 48b4f6f9f60ca566e261caf61c576158ce976769 openhcs/pyqt_gui/widgets/shared/services/execution_server_status_presenter.py +100644 blob 193f7970dba77a59148e79e66b21f2c73ea16820 openhcs/pyqt_gui/widgets/shared/services/execution_state.py +100644 blob 6e96d00055411bd5e3cdb2c28a3ffe6137febd5d openhcs/pyqt_gui/widgets/shared/services/execution_submission_service.py +100644 blob dbe1657c0c98623678443c2a628aa92b6108fe20 openhcs/pyqt_gui/widgets/shared/services/gui_event_bus_broadcast.py +100644 blob afac4f61ae8a4134e37ad7ef0048ef531a3dfa3f openhcs/pyqt_gui/widgets/shared/services/live_measurement_progress_service.py +100644 blob 674b313fe4c95c6d4c8c0df3de87c10900df1b54 openhcs/pyqt_gui/widgets/shared/services/pipeline_debug_actions.py +100644 blob 930ba13ab7dc00ac46c136d9b781e740d98c4cd8 openhcs/pyqt_gui/widgets/shared/services/pipeline_editor_workflows.py +100644 blob cc9d7800090fa862c70d907a7b1cb1b790384f6d openhcs/pyqt_gui/widgets/shared/services/plate_config_resolver.py +100644 blob 7af63ba8f10b3d9cab01c97bc0aea5dfd31f9173 openhcs/pyqt_gui/widgets/shared/services/plate_manager_workflows.py +100644 blob 69154212da89e1f008a6cc4bd5f9be7229630f03 openhcs/pyqt_gui/widgets/shared/services/plate_pipeline_request_builder.py +100644 blob d08759971ed044b4a5d100102f957df350988a96 openhcs/pyqt_gui/widgets/shared/services/plate_status_presenter.py +100644 blob c59e3bfd49dc80ed139dc050edb490ad6d6525ee openhcs/pyqt_gui/widgets/shared/services/progress_batch_reset.py +100644 blob 8529f045a3a9c012d5cc02361fbe270a69ae3540 openhcs/pyqt_gui/widgets/shared/services/progress_workflow_service.py +100644 blob e4838b52ea82edd68852c663e27eb7897934b2ea openhcs/pyqt_gui/widgets/shared/services/qt_widget_edit_commit.py +100644 blob 36c49a19d3a61e2fbddda264bdf6bb81b9e52f83 openhcs/pyqt_gui/widgets/shared/services/runtime_artifact_progress_service.py +100644 blob f3877f264af12e4e44fb8bc2e953eff09cfdc041 openhcs/pyqt_gui/widgets/shared/services/widget_action_dispatch.py +100644 blob d0ebfb996ad83c87b22591d030a8e7f52b226037 openhcs/pyqt_gui/widgets/shared/services/zmq_client_service.py +100644 blob a2505a5aa778dd42e385fb6d9f635739758ccc9c openhcs/pyqt_gui/widgets/shared/time_travel_widget.py +100644 blob 3f0f181d3f4a5f478b61a600c5f192cf502a2570 openhcs/pyqt_gui/widgets/shared/zmq_server_manager.py +100644 blob 5fe669561237afc864fc960dad262f35e5bb5d7f openhcs/pyqt_gui/widgets/source_bindings_editor.py +100644 blob 29e5f5fa27e29cc38471ed8d9774d8289379e736 openhcs/pyqt_gui/widgets/step_parameter_editor.py +100644 blob c7a7e38fdf321a8a69c9344c1c9f5719f3005a15 openhcs/pyqt_gui/windows/__init__.py +100644 blob 5e8c252dd782b6942bb71ec7b57acbccaed5b25b openhcs/pyqt_gui/windows/about_window.py +100644 blob 21c79189d40a4016a32dab2b968951bc4178f992 openhcs/pyqt_gui/windows/config_edit_session.py +100644 blob 8887b717dc66d325db4c60b4aaf60048b400c5f6 openhcs/pyqt_gui/windows/config_window.py +100644 blob 1501b23c584614af8ac03f444a6212e982d9aafa openhcs/pyqt_gui/windows/debug_inspector_window.py +100644 blob 46eccfe9be1766af6ab40bbcdbb83fef84b6772d openhcs/pyqt_gui/windows/dual_editor_session.py +100644 blob 02dd99e126ff188bb77e32f75e2c286c5a1b446b openhcs/pyqt_gui/windows/dual_editor_tab_builder.py +100644 blob 2e19b0ddd6b9cf0768250f87952891fc0f47ed1c openhcs/pyqt_gui/windows/dual_editor_window.py +100644 blob 3e9de46cba8e6c6c2e81ff1ac046a233e2108946 openhcs/pyqt_gui/windows/help_window.py +100644 blob a7d34283c39cd20ddd7f73212f714d31a841a667 openhcs/pyqt_gui/windows/live_measurements_window.py +100644 blob 0b913d394c472a6703da31facb63ee843fef6e6e openhcs/pyqt_gui/windows/managed_windows.py +100644 blob 9973a47db2306d72d99927aec91a17cb0eeafe56 openhcs/pyqt_gui/windows/plate_viewer_window.py +100644 blob 24b231a243cbc8762ac882092c8d3ee8579b755c openhcs/pyqt_gui/windows/snapshot_browser_window.py +100644 blob 70a7ca0f5d5db5cf335725fbb76fb6847f5a1bc7 openhcs/pyqt_gui/windows/synthetic_plate_generator_window.py +100644 blob b718f1ecb0e2e3920452431976e11772cfc83bd2 openhcs/resources/__init__.py +100644 blob 2e4f77b86926d26a5a2c801abd79f588867cc577 openhcs/resources/brand.py +100644 blob a80475dfbae28cd8fe0e2a09b5b17ff747faf6d4 openhcs/resources/windows/__init__.py +100644 blob 373c9821be1bd923bb41bed5ce1a6b6c4c1d5838 openhcs/runtime/environment_provenance.py +100644 blob 7810f2edcd447c460c1a5bbddd0a89255ce648fa openhcs/runtime/fiji_macro_runtime.py +100644 blob bf1fc21183f37fb5ada7f06b4915f9669f4ce674 openhcs/runtime/fiji_stream_visualizer.py +100644 blob 82f602b53f209126649de3076d629faa7ae6dfca openhcs/runtime/fiji_viewer_server.py +100644 blob cd5e090f6389d5c6de17b8c89f69dc5735d19701 openhcs/runtime/function_catalog_preparation.py +100644 blob 17916eeac25867e46752900fccb21807c57c1243 openhcs/runtime/import_authority.py +100644 blob c1309477beb3cc17ae84197b1f55c841584640ff openhcs/runtime/napari_orthogonal_widget.py +100644 blob c7cd97eb1543d5a17fd054aa8add7665eba5f1d1 openhcs/runtime/napari_stream_visualizer.py +100644 blob 61c304ecf2db2a59543201dd6dd2da96a81dac9c openhcs/runtime/napari_streaming_handlers.py +100644 blob 6057d7c5c2767c25473c0855f8c73a4fda43a28a openhcs/runtime/napari_swc_reader.py +100644 blob 7301a4d65c8e5998db088a4cc9feb0de061ebfd0 openhcs/runtime/napari_viewer_server.py +100644 blob 07198c23c437d775b807843e0e99026a6e135f18 openhcs/runtime/omero_instance_manager.py +100644 blob b2714800aac06a621550b1209b414c7737cdc34a openhcs/runtime/viewer_component_system.py +100644 blob 023ebbcac7c9d550688fdef1cfdd7289f93f8932 openhcs/runtime/viewer_controls.py +100644 blob 4df0827453a1032136af19d04cd9860b841e4520 openhcs/runtime/viewer_measurements.py +100644 blob 39e6e7abbbe696156cf67ecda912f99fa0e39eeb openhcs/runtime/viewer_protocol.py +100644 blob 843a9296c74dd5c4d859f7707dd68cdc3923bc08 openhcs/runtime/zmq_application.py +100644 blob f20ef7f6d5c65b47b7ee37ac3a48a2e3a1a07962 openhcs/runtime/zmq_compilation.py +100644 blob 3285aeefb0a22e196da500a22446f1de67d361f0 openhcs/runtime/zmq_config.py +100644 blob c2c09965467ebe8fcc9a6d62db95a572b808c312 openhcs/runtime/zmq_control.py +100644 blob b01d9599125557937758274bf9598f72fc19f8a9 openhcs/runtime/zmq_execution_client.py +100644 blob fecffce4120f276f9a748a98f027bdfc30e59860 openhcs/runtime/zmq_execution_observation.py +100644 blob ce858a0a2f027833056d779aae3658a4433610aa openhcs/runtime/zmq_execution_server.py +100644 blob 477fd88c7ede02d33d151e802b7e1165f58da363 openhcs/runtime/zmq_execution_server_launcher.py +100644 blob db76c61f2f66167c08839605324ffe9d7003c00d openhcs/runtime/zmq_execution_signature.py +100644 blob 1f555953f45dfa1e2973cc04aaacf8d231d6ec74 openhcs/runtime/zmq_orchestrator_environment.py +100644 blob c7b22ceb7d06b154ae72a9c0879d6a31ddd4f0e7 openhcs/runtime/zmq_progress.py +100644 blob 1475f718dacdbd663da7f77855702ca6fc59c158 openhcs/runtime/zmq_server_hooks.py +100644 blob 7da7cc1ca98180a2818dedad179b222681556699 openhcs/runtime/zmq_worker_execution.py +100644 blob a955ce8f6ec5956a2fb5968f13fd042c7f4c9413 openhcs/serialization/__init__.py +100644 blob 392de3473765297d90b2897b482b1238c3bb0486 openhcs/serialization/json.py +100644 blob 7ce679c45ba144998ef63f7b63a84079ca151b52 openhcs/serialization/pycodify_formatters.py +100644 blob 0c8a5c31288c822cddb00f35166622c6a7da1f61 openhcs/serialization/source_path_factoring.py +100644 blob 2c77a132726df0b26d25ad154413b6a225025e2b openhcs/ui/shared/__init__.py +100644 blob 9c72d1a5d68d726b965fb9227c4a3d6e28819fea openhcs/ui/shared/code_editor_form_updater.py +100644 blob f9ee4b4f1da14308aaa5eaca23077f4af50ee048 openhcs/ui/shared/pattern_data_manager.py +100644 blob 8df81e5e139c47f94153f25dd1d17c67ae9089b2 openhcs/ui/shared/pattern_file_service.py +100644 blob cb9e47acba6940822163ed43fee924436cef7614 openhcs/ui/shared/plate_manager_code_document.py +100644 blob 4fd2b2680d9d6b47bf75ae4aea6f1328f5a25102 openhcs/ui/shared/plate_scope_identity.py +100644 blob 38ca51f16c7c2288ab21b548503be69dd8926290 openhcs/utils/environment.py +100644 blob 377896e6105e8bce8b880512a2130b30ee76a7dc openhcs/utils/import_utils.py +100644 blob 3156362eeec15fdfd708331d7e26a0c134d3833f openhcs/utils/performance_monitor.py +100644 blob 27456f1e1fdf7ad875bc167fa44c285a8b0e6273 openhcs/utils/pipeline_migration.py +100644 blob 41caf87c07b85e9fbd78233df2764372d0fff06e openhcs/utils/recache_function_registry.py +100644 blob 0a859c0712560de3cfe0e6d8aab49137875f392d openhcs/validation/__init__.py +100644 blob 5e461e920b4e3d4ee89fe50a4fa69db2baf2181b openhcs/validation/ast_validator.py +100644 blob a59e294c2b49f82969f8085cb8c1f6aa39affe2b openhcs/validation/validate.py +100644 blob 5254fc4556d58103f070ad28dccdbe1529f369cd packaging/mcpb/openhcs/server/main.py +100644 blob 1fd7b4c998d8faa72a7f054cbe66a91f0b084b2c paper/build_docx_from_markdown.py +100644 blob fe8465d890f6326a319f4aae748f1d7758aa0b2b paper/build_paper.py +100644 blob 71cb29d179b6e23fa1d1b35625bea05caf75c675 paper/figures/build_slas_agent.py +100644 blob a993da114cfd2a7611d480420d1399c9ae4b680e paper/figures/build_slas_benchmark.py +100644 blob 738840623263b13eaeaaa0bfc887ddc954a6402d paper/figures/build_slas_cellprofiler.py +100644 blob d8eece5b32662fbe1c36eef1944fced6f129bf57 paper/figures/build_slas_compiler.py +100644 blob e3209f3d49cc2de0a06af489d01c58533cee831d paper/figures/build_slas_complex_workflows.py +100644 blob f3219f9ea78d1f7aa7ed03c1b0b2d4ffa883db84 paper/figures/build_slas_extension.py +100644 blob f04802386018e2963fe7a9bac24777eb0c861432 paper/figures/build_slas_independent_validation.py +100644 blob 537145378b299d7a7500ffaad08c97bb07d6a3eb paper/figures/build_slas_outputs.py +100644 blob 25377725a4d5c0dba9c3190933e3d7fc6a62ff69 paper/figures/build_slas_processes.py +100644 blob 102f818f5391aa33da090ddb1aade0e75cc24b61 paper/figures/build_slas_runtime.py +100644 blob 495c97800c805c46a6ea385719b65b97d78ce819 paper/figures/build_slas_visual_story.py +100644 blob 6d4c0e8d1ebf1dda3a1a6ee8fd1e249e170a027e paper/figures/capture_slas_authoring.py +100644 blob a44c45f21659b1a440a2d4bc208b63de0a45a42e paper/figures/render_diagrams.py +100644 blob 4c8bb350d08e9f65693dfcaeb1ae1350db7c5e8c paper/figures/slas/cellprofiler_translation_imported.py +100644 blob c4b550b0956eb956a94284e9ee9fff1f2257d09a paper/figures/slas/custom_signal_example.py +100644 blob 68f6e5662d77a04b3d29999a6be1c672ff2d158b paper/figures/validate_slas_roundtrip.py +100644 blob ff043c8bda043c26f0ff4c44e733400e5ba111b9 paper/supplementary/cp_tutorial_3d_monolayer_imported.py +100644 blob 53c3ff5ae3ab4cb4d72d30708772a7c1fe292162 paper/supplementary/cp_tutorial_advanced_segmentation_final_imported.py +100644 blob eb1c53b737017d6a2cd4abdd80c3214c8b1a7307 paper/supplementary/independent_validation/bbbc007_frozen_pipeline.py +100644 blob acbb9f32130694332366c7b82ddec6d3852e89a4 paper/supplementary/independent_validation/bbbc013_frozen_pipeline.py +100644 blob e90c669499719da95251c21d02f05ee3b3a608ff paper/supplementary/independent_validation/bbbc039_frozen_pipeline.py +100644 blob 29298369aae0e49c328244b72efad0256716ae69 paper/test_build_paper.py +100644 blob 33fc6500a5854ddc46c362b4030ae991206aea77 paper/test_build_regressions.py +100644 blob 22b12a5265b1543309726c48ee4b6931df6bda12 scripts/annotate_wells_with_experimental_metadata.py +100644 blob 65081edc41f5fe3f1f097e2f930cdeed216880c5 scripts/benchmark_cellprofiler_fixtures.py +100644 blob ec2da5a6067db6034128691be2475f90a0a27d2a scripts/benchmark_cellprofiler_vs_openhcs.py +100644 blob 8ac95419807513575437c6bc68336ed680088732 scripts/benchmark_cppipe_throughput_scaling.py +100644 blob accdb6e5ea635b50a0f6dc2ff88c78fd730a70f7 scripts/benchmark_cppipe_well_throughput.py +100644 blob 21fe7fdb623b9825d450d64ca73289aa1f9f3566 scripts/build_hosted_mcp_plugin.py +100644 blob 62cc57527182d038259f32dc00f075b475438ee7 scripts/build_mcp_knowledge_assets.py +100644 blob f882b23b699f881fb7e424422a4626c740cc71b0 scripts/build_website.py +100755 blob 3ec6921dd7b4df94a672ea7209d7f32e19569e6e scripts/capture_media_gallery.py +100644 blob 3bba3192c92c6f007ec7d65f3c350edac3a1a39d scripts/check_mcp_memory_ownership.py +100644 blob abc301fe8d4203a9015e618cf660d424436b6e01 scripts/check_refactor_r1.py +100644 blob ee9d2838cce3e6ffba238e0cc82632e053aa2a45 scripts/codemods/audit_cellprofiler_declaration_semantics.py +100644 blob 1b1da77529a1c73d9f8ffb45d84ac700dc8b30d8 scripts/codemods/collapse_cellprofiler_artifact_binding_declarations.py +100644 blob 3244962307818d9773f9074efa3546ac7f08885b scripts/codemods/collapse_cellprofiler_artifact_output_hooks.py +100644 blob 76ac27caabb2ae5ba0dd50e48edc6c9f92844b7c scripts/codemods/delete_cellprofiler_special_input_policy.py +100644 blob b5ebd4d4e92d754e51abddf7724d0f61fdd60f9e scripts/codemods/delete_cellprofiler_typed_artifact_mixins.py +100644 blob f659abaee3b906f5fd4d78f5cedad492c55be1c5 scripts/codemods/migrate_runtime_input_binding_request_api.py +100644 blob a1a29a51ec970b3ecb4977b958c7cc35ff7f0246 scripts/codemods/order_cellprofiler_setting_binding_declarations.py +100644 blob 44ca43b9d1a6713c8a212d1219266584a8aabd5d scripts/codemods/replace_cellprofiler_typed_binding_queries.py +100644 blob 978b332f925bb5807aef01596d393873515064b4 scripts/codemods/split_cellprofiler_module_measurement_owner.py +100644 blob 406084a6ea9eefaecaad3d815815ad32db6983f4 scripts/codemods/split_cellprofiler_module_settings_owner.py +100644 blob 2bc59f6a9a205bcbe547a2c30946b8523224292f scripts/dev_install.py +100644 blob 156d789970381d026830db06633708b616ae5266 scripts/figures/generate_automated_plots.py +100644 blob 7da64d82fe69263d4874d5b794db54f44b5d394b scripts/figures/generate_figure_mosaics.py +100644 blob 1cdb8b4832d7050982b396e9657a6bc55a6b3af8 scripts/figures/generate_figure_overlays.py +100644 blob 757c540d2ab03a1de33a0221b5d5bd11606b1206 scripts/figures/generate_xy_xz_composite_figures.py +100644 blob af4f8e32e0677b559b4eccb6631cd1ecddcf06cc scripts/figures/orthogonal_projections/__init__.py +100644 blob d999315c3f3fe62c7f2c58b8b4a47c5a9d85e898 scripts/figures/orthogonal_projections/cli.py +100644 blob 33a5c996c6a0edcd3946457dd73fdb42897c4832 scripts/figures/orthogonal_projections/composer.py +100644 blob e721856f78fe475e0cb4083af4f268b5a33199b9 scripts/figures/orthogonal_projections/constants.py +100644 blob a57d0f2bbe40046425c0da953d0514d400aae35a scripts/figures/orthogonal_projections/discovery.py +100644 blob 2de132e1f20b3ba5c090b72ca258e8bebb1b7a2c scripts/figures/orthogonal_projections/exporters/__init__.py +100644 blob 6bfc1fe7381e1381719ec96410bad9d5824ff643 scripts/figures/orthogonal_projections/exporters/assets.py +100644 blob d213b2ae094a9252e026b68e45378f8beb051631 scripts/figures/orthogonal_projections/exporters/grouping.py +100644 blob abfe358c86fabe0aaaab868fed354988b2b71ca6 scripts/figures/orthogonal_projections/exporters/layouts.py +100644 blob 75f0fe1047a8c526b4a1128e2156a2fd314b4c5e scripts/figures/orthogonal_projections/exporters/models.py +100644 blob 1a2dfd2b5ca3102d41720d912e3e844d1a48702e scripts/figures/orthogonal_projections/exporters/powerpoint.py +100644 blob 01770119e862f1e86a50fcb7b4c5ca9bfd0eccc8 scripts/figures/orthogonal_projections/exporters/service.py +100644 blob f642579f615776f99f0e4f4e8efaa4233f1318dd scripts/figures/orthogonal_projections/io_handler.py +100644 blob 816d8b916cf1465ed635c7750b177345bb9ae56c scripts/figures/orthogonal_projections/labeling.py +100644 blob 5b7b068bb080a493de33b65d2bd4efc2bbbb57ad scripts/figures/orthogonal_projections/mosaic.py +100644 blob 498ecbaadfb3c4729abb058fd15faee4c2e58a41 scripts/gallery_catalog.py +100755 blob 45b88aafe5e7a6858eadaffb27303f339e968195 scripts/generate_brand_svgs.py +100644 blob 9268f024f4a08147aa1942ad5a47e45527919c28 scripts/generate_cppipe_benchmark_figures.py +100644 blob 804b0e038d9aea511bc088ee3cef7b1b38c78a92 scripts/generate_cppipe_throughput_figures.py +100644 blob 930ef59050725cf25098578a4c11fc6481176981 scripts/generate_lab_meeting_deck.py +100644 blob 21d65255de594ec60ad11660fc6eb495fcbe50ff scripts/generate_lab_meeting_summary_figures.py +100644 blob bd0c89fdc5f441a6522f34acab6e81c553ed4238 scripts/install_ci_candidate.py +100644 blob 51fbd94b2eedb0fcb5e55492fa2d7821a0184b56 scripts/install_omero_deps.py +100644 blob 695d60b3259b6969f67c052e00d05deb5eec4c11 scripts/master_multi_plate_demo.py +100644 blob a4d07e607d70b46bcee77843b0907013c5bc82ec scripts/mcp_assay_showcase.py +100755 blob 6493345dd03851101568dcca42340dcf8a3938e0 scripts/mcp_thesis_demo_live.py +100644 blob 98ec6045e686c06bb49d238120ba92cc51db1d14 scripts/migrate_cellprofiler_function_facade.py +100644 blob eda2c72c431325ffb6fe7dd5d7b6de66b7b400ab scripts/napari-plugins/napari_orthogonal_projections.py +100644 blob 8cf6e5a2f588d2015067486ad639fa11611c572e scripts/prepare_cellprofiler_benchmark_datasets.py +100644 blob e79b61c24effd93160281bc454be3da28f20991c scripts/prepare_cellprofiler_reference_exports.py +100644 blob dd3a559ac81208c55fe0cad4d8b14d27b640d380 scripts/prototype_flatten_object_state.py +100644 blob ece79e8175583d34778e7090cccf3084f756e7cb scripts/prototype_unified_none_forcing.py +100755 blob b8b6bf111732747adbaf4f6c810ea8aad37a49f7 scripts/release.py +100755 blob c9e71bf9ac685ae08e173da0014dea07395b10d1 scripts/release_readiness.py +100644 blob 78f8a399a69f40e0cfa7e23eff62867e87f28701 scripts/render_installer_contract.py +100644 blob 9e71eb3b52dab9485cb29542bdad2cb28fd84b35 scripts/resolve_successful_job_baseline.py +100644 blob e74c55daca2dd7516a5e23c99be864fc48a44d97 scripts/run_cellprofiler_cppipe_parity.py +100755 blob 9319a31ce945bda2f9160611862266c17f64df92 scripts/run_experimental_analysis.py +100644 blob f12044896f3cbd47a9b43ff8df86c8780efada57 scripts/run_installed_tests.py +100644 blob 23552e5fd8ca677f4c93c773b4f267f4419c75c2 scripts/smoke_installed_desktop.py +100644 blob 63bcf564bc9835d098678d47762605a6fd35e625 scripts/smoke_installed_gui.py +100644 blob a27b06a935c42f5e657dad339d415e83cf6f074e scripts/smoke_installed_mcp.py +100644 blob 84a9f5ec5c2788d66556a08f334e30eec125b5f4 scripts/smoke_native_granularity_wheel.py +100644 blob 5552925c90b6de14aaaa31e72f830f5f1d9dcc26 scripts/smoke_owner_quickstarts.py +100644 blob 2c87e1d5aafaab395121e865f41966ed479009c9 scripts/smoke_staged_desktop_update.py +100644 blob 9ec63f7fd306ae7ad12798011334e2a6e17dff45 scripts/stage_ci_candidate_version.py +100644 blob 81d5db9b5893073bde213d6cad3551563fc18c94 scripts/summarize_cellprofiler_reference_export_run.py +100644 blob 37d5e5e88d9aa05ca13e3d41108e2056051fbe18 scripts/summarize_cellprofiler_reference_inventory.py +100644 blob 231b412840a61d88311c0d74106b4df26ac28003 scripts/summarize_runtime_image_pair_receipts.py +100644 blob 0ea620402ab5be68f9ff4f01de5d15f72ed721ab scripts/summarize_runtime_profile.py +100644 blob 6f12c20692af8e8c1a91cf6e75ca715502adf461 scripts/sync_mcp_release_metadata.py +100644 blob ad8152a2dca0c232f1b273b2fca0258217ce9d3d scripts/test_real_global_config.py +100644 blob 8205bb185dd485646ac9c5efc3983c6c4a62d8e9 scripts/validate_docs.py +100644 blob d03a490c59072da95bbd50b1ae2bc2a6fb9a1862 scripts/validate_local_release_floors.py +100644 blob 3efe95c7f0411ab9e11c44b27344dfdc48893ec5 scripts/validate_wheel_deployment.py +100644 blob 4037ee1fd8f1977df1bed39794d92a384098aabf scripts/verify_existing_imagej_bundle.py +100755 blob 102f0a8867bca49453a62c464dbe0c40d497392b scripts/verify_release_ready.py +100755 blob 6dda218e92ab9a03b84b1412b9b54c8e0dd04f64 scripts/wait_for_pypi_release.py +100644 blob 41990ef6340dc41e559b4407a614dea461b90b0b scripts/website_gallery_projection.py +100644 blob 9273f90ab9ced966c979663a3b7c14a4bec8ad34 setup.py +100644 blob 65140f2e3919fe56b74572d1518910df4a331030 tests/__init__.py +100644 blob 1333c85ee07af95ce4f4865876084bff2ec62390 tests/conftest.py +100644 blob 07d76b903a700ba1c682206ef4b25490fdf388e0 tests/core/test_alias_property.py +100644 blob cea1be974fa35fbea50ce354e21f59e7cec20257 tests/diagnostics/centrosome_watershed_reference_worker.py +100644 blob c7e40e5aa93468efdf654ae5953132f2db872555 tests/diagnostics/check_centrosome_watershed_reference.py +100644 blob a09cb6e5873843b9c076e65f5a8b3072328bc3df tests/diagnostics/check_custom_registration_live.py +100644 blob 0ad003a6936ee712d63eca215f74a3f3c3e23ac5 tests/diagnostics/check_owned_bootstrap_live.py +100644 blob 9fa35d7fe3771216a2e5b8d7db131d612782da87 tests/diagnostics/check_viewer_feature_measurement_live.py +100644 blob 93a92114f1ecc9fdd6a8a1d9d448e9723f15a7af tests/diagnostics/create_native_point_viewer_fixture.py +100644 blob 1909929737d1337cb97bd092609d52af11114b3c tests/diagnostics/create_native_result_reopening_fixture.py +100644 blob f8c833dff2b1f850e1f79bb69607874ce203e15b tests/diagnostics/create_orthogonal_viewer_fixture.py +100644 blob c9d495650982ba257e138bf9c3ac8110f16307e1 tests/diagnostics/owned_bootstrap_readback.py +100644 blob 98b95ddadd4499c705baccb45ab80a9bd365b069 tests/diagnostics/registration_probe_source.py +100644 blob 05e2ebf82b17f23737efdc69046c1757c1293d17 tests/diagnostics/volume_projection_fixture.py +100644 blob c2e6d77665fc759617d9136bfd581215a3cf52b4 tests/installer/test_installed_desktop_smoke.py +100644 blob 0fcf2de68bcec5b912f255ea4c7c65daa5068c2e tests/installer/test_installer_branding.py +100644 blob f66fa6f28e42036175a51fe0fa19b556967cf478 tests/installer/test_installer_contract.py +100644 blob ec5d994ffe964d97a07b8db511b35834800b9808 tests/installer/test_installer_signing.py +100644 blob 75567786d958f058f0e20903ef2049d53d98713e tests/installer/test_macos_dmg_lifecycle.py +100644 blob fe5f4f01fae2f69ec39b994c4165b0053612a363 tests/installer/test_macos_simple_installer.py +100644 blob b5c971f768ac5b771e02da330f523324afe40f5f tests/installer/test_windows_simple_installer.py +100644 blob a853fdb53056ea381e191450ece90fd7f6d0458b tests/integration/conftest.py +100644 blob 5e46effb97d6490e2304fa85881ae8f63e454c95 tests/integration/helpers/__init__.py +100644 blob 21a31b444abdade0eb91271cf82ae75bef617450 tests/integration/helpers/fixture_utils.py +100755 blob bd1f3ac2339a4e1562f0c0e298deba08ef3800f3 tests/integration/helpers/omero_utils.py +100644 blob 66421391821aed9c4f83a116a4d83a74c89037ac tests/integration/test_agent_observation_export_zmq.py +100644 blob 2d2f3da32e0ecb42afc5b351766a0fbafff4bb40 tests/integration/test_benchmark_openhcs_adapter_cppipe.py +100644 blob 2dbe39259c871ff25ae153f00aeec406e733120f tests/integration/test_bioformats_handler_runtime.py +100644 blob 0968698a1280bdd5fae4506cb20af865a25c4166 tests/integration/test_bioformats_imagexpress_synthetic.py +100644 blob f1b9b351311aa41231ec8d0b7e70cbe5e09dd402 tests/integration/test_cellprofiler_generated_pipeline.py +100644 blob bc9cd1df986394ff65e593e8a6d6d7579a5ce921 tests/integration/test_cellprofiler_official30_zmq.py +100644 blob 59c840578c1f013430e24e1082887533a4e99154 tests/integration/test_chained_callable_lineage_journey.py +100644 blob 317bf0469a5d5324e292b886667b156876f681f6 tests/integration/test_compiled_artifact_inspection.py +100644 blob bb25df9c4a8985ae6236c67968855b172c1fe9d8 tests/integration/test_count_cells_simple_dual_channel.py +100644 blob f0f67b247dbd74e18c5713e0c4f62311f7d3a97a tests/integration/test_custom_source_transport.py +100644 blob a01fe828b9434c8c5fd707b82387cb1035c9895c tests/integration/test_generated_source_relative_paths.py +100644 blob a82354e8581a8df7e13c13df003f4a6068b7ae66 tests/integration/test_main.py +100644 blob bbcf1dd880d8752a2fc55c011181d79cd0613505 tests/integration/test_measurement_declaration_journey.py +100644 blob 143033fdd8ceb25d953bb0079c1c283a4b93994e tests/integration/test_neurite_outgrowth_synthetic_plate.py +100644 blob c73c3577a2b2008822376c755ab01e8e7d2fc1f2 tests/integration/test_primary_segmentation_diagnostics_journey.py +100644 blob f8858301d9131549e1af8939b7865bea28b13b63 tests/integration/test_source_store_code_mode_zmq.py +100644 blob 5bcf304f78c89d1526412210a2b8ea08866ff01a tests/ome_zarr_fixture.py +100644 blob bf440eb7bb2de2f7034f7e58cb2880a4f530da2a tests/pyqt_gui/conftest.py +100644 blob 301bd43ac999c1179ff05c58abd7e97551eab590 tests/pyqt_gui/integration/test_end_to_end_workflow_foundation.py +100644 blob 3cba66aee673dcea1cdb0b7a23a1eda49d0a8421 tests/pyqt_gui/test_code_document_normalization.py +100644 blob c9fc5311426cebf1942122dfa64b36eaabe82d4e tests/pyqt_gui/test_dual_editor_window_context.py +100644 blob 0d67ca993eb9faa727d2d257023f3175a4a421c9 tests/pyqt_gui/test_image_browser_filter_controller.py +100644 blob b82f64d0a93fd5b0bafc54bc1a9e27aa5ba7333d tests/pyqt_gui/test_managed_windows.py +100644 blob 65ede639fc19b996528c955ba4bac1cf02e25ff0 tests/pytest_integration_options.py +100644 blob 476b34bf9934ba21f6b795eac0eb4e6068f18e60 tests/runtime_diagnostics/orthogonal_class_census.py +100644 blob 385200404366f63d30fc6d0b1a1260a16ed6f601 tests/runtime_diagnostics/orthogonal_native_7d.py +100644 blob 4ace90a25b317611504c2e1ec2616b3fcc79aaf8 tests/unit/agent/test_agent_serialization.py +100644 blob 3c4a2c7704db551420e4e282e97600e3df7a922d tests/unit/agent/test_agent_services.py +100644 blob 08439f8d4839b92565019793a2504e1451eb2059 tests/unit/agent/test_agent_services_package.py +100644 blob eb34f4e65c9116b9af92e28a5415dc11f97ae54e tests/unit/agent/test_analysis_knowledge_transfer.py +100644 blob 7d87ddc9ce158b282bcd085ee354e94f8a4d8289 tests/unit/agent/test_architecture_projection_service.py +100644 blob f8e275499a35cbf3c3ef36005c7423389c140077 tests/unit/agent/test_artifact_plan_renderer.py +100644 blob 0ea7fc8146b6289976a55613655b354642ba6550 tests/unit/agent/test_blind_recipe_audit.py +100644 blob 258a7d60ab802e3ca9af03079b0b845f15ab60ca tests/unit/agent/test_callable_artifact_reference.py +100644 blob 08163b733f93829df0602107142fe19476b13e9b tests/unit/agent/test_capabilities.py +100644 blob c163ea6cdc00bd5334be2e7f79fcb14bc5d20c69 tests/unit/agent/test_compile_inspection_declared_callable.py +100644 blob b25b02e5279a7d87d0b0e5e93146ffd6827b7376 tests/unit/agent/test_config_reference_service.py +100644 blob d249a61144a4edfcfeb344d585bf37ba6f3810f0 tests/unit/agent/test_config_schema_authority.py +100644 blob bb865ab7252225ac184e485070144564df1370eb tests/unit/agent/test_custom_registration_admission.py +100644 blob 2004f395f06a10bc67999567db647c89f4cb3cb6 tests/unit/agent/test_hosted_mcp_semantic_ownership.py +100644 blob ff73c8ec308f4978b9f0c9f2692ecf85df1a378a tests/unit/agent/test_image_analysis_qa.py +100644 blob f95b91fc848723c12f229612ad85797e98ab3283 tests/unit/agent/test_knowledge_base_service.py +100644 blob 973cdcac9891340375668244819d8a3ec348a2f9 tests/unit/agent/test_mcp_bounded_discovery.py +100644 blob 395cfbcfd6f6449aaf981eb64a0cb0bda14ff5ff tests/unit/agent/test_mcp_capability_discovery_and_widget_projection.py +100644 blob b8994c015affb38afa3faeecde1497d807744fa9 tests/unit/agent/test_mcp_cellprofiler_function_contract_friction.py +100644 blob 3bc53e0dc3fbf33ccc3667d9d76e6e343f271bbb tests/unit/agent/test_mcp_client_registration.py +100644 blob 6177e5a5f6566a6eb75777ae0a5cc8b9d77bbfd8 tests/unit/agent/test_mcp_dev_client_config_renderer.py +100644 blob 7d88fb30c1e71415931e12fe75d5dd57d577e715 tests/unit/agent/test_mcp_dev_client_runtime_debug_renderer.py +100644 blob e735bff31895f1c87c15a75568697614cf6b106b tests/unit/agent/test_mcp_dev_client_transport_failures.py +100644 blob 5bc22215c56f3f32454a30a627f3921d20bea54c tests/unit/agent/test_mcp_diagnostics.py +100644 blob b89d4bb5e1c26c6917c8a3b784d9138b28ed230e tests/unit/agent/test_mcp_distribution_runtime.py +100644 blob 5d8e4e4ba0a0d8dabecba911f9175fa98288f4ae tests/unit/agent/test_mcp_http.py +100644 blob c9db6eab4afc9ce8d7a5d847d63114bf6ca24ba7 tests/unit/agent/test_mcp_http_auth.py +100644 blob 437a6142acd9449427557b264f8ef977cea56f7c tests/unit/agent/test_mcp_lifecycle.py +100644 blob 35ab70061f65d9ac1596ae5830adf9b98e7a0b5e tests/unit/agent/test_mcp_self_description_contracts.py +100644 blob 516adb033933a95e87beec58a051b8d5c7626966 tests/unit/agent/test_mcp_server.py +100644 blob 72cbcde7d9f5059b60f1eb201c0d0c606072eaf3 tests/unit/agent/test_mcp_skill_registration.py +100644 blob b12207e20ada825b4155c10af1003c176a8794c9 tests/unit/agent/test_mcp_stdio_transport.py +100644 blob a014698f51f72336ecefe787b8319585452033ac tests/unit/agent/test_object_state_field_help_service.py +100644 blob b21a7f02709eaaf9b5ea6ccc0bc3c2dc7e78c720 tests/unit/agent/test_official30_knowledge_examples.py +100644 blob 440fee653fc47dacf033254af7b9ddb87059e691 tests/unit/agent/test_owned_bootstrap_readback.py +100644 blob 5847958513d52168a317b26f68152d7b8a105984 tests/unit/agent/test_owned_runtime_bootstrap.py +100644 blob 65550bfaca15cb49ab736729e783a1c475c8da74 tests/unit/agent/test_path_policy.py +100644 blob 96e7f58c85f4720111ace1f6e524ef4afdc5d818 tests/unit/agent/test_plate_inspection_cold_runtime.py +100644 blob ba09552d2508024a83812d34c90752e15d903117 tests/unit/agent/test_plate_inspection_service.py +100644 blob 98adf66c606ec454afe54df110118ec521295bad tests/unit/agent/test_plate_streaming_service.py +100644 blob ae363487b1a0f6f92c9b213b76c2e1fac3b26d29 tests/unit/agent/test_progressive_authoring_context.py +100644 blob f774d323ec3e3530860c1759a02549314af49500 tests/unit/agent/test_runtime_debug_inspection.py +100644 blob 4c1beccdbf892b0974bc4fb47e9b082231d6b641 tests/unit/agent/test_skill_sync.py +100644 blob 55268e267d79d69c2ffd617903cee98852ae6aaf tests/unit/agent/test_synthetic_plate_mcp_progress.py +100644 blob ebf0436e0ad8767f9a1d797b518d4f7a741d4b4c tests/unit/agent/test_ui_bridge_service.py +100644 blob 86e48c9d0d1beeb9c3ab2f26c18fdfd8ef354f01 tests/unit/agent/test_user_facing_help_projection.py +100644 blob 64fd76585adec94bd281c1007baf2f26dd4ad043 tests/unit/benchmark/test_agent_validation_attempt_recorder.py +100644 blob 562b6ae75c33376bdc9f2136f9dafccaeed07a72 tests/unit/benchmark/test_agent_validation_corpus.py +100644 blob ada603d79e78509e4c3eb8ff20d35dcfd0c3e410 tests/unit/bioformats_fixture.py +100644 blob bddc25eedc105d69aecb2772a179fac9864e9a5b tests/unit/bioformats_imagexpress_fixture.py +100644 blob c387ce86f446accbf7b751a1799fd99e2f30bf84 tests/unit/cellprofiler_runtime_test_support.py +100644 blob 96975c3f7109df493ff9f5c16869b6b0ff13261c tests/unit/core/test_config_cache.py +100644 blob 529fbc6acc4963030eef6962085349262058628e tests/unit/progress/test_debug_projection.py +100644 blob 614a6af92a23b67be673632ee0cd8d88cf960a7b tests/unit/progress/test_live_measurements.py +100644 blob 2e88550c001d71cce5592d887a37c1abd59aac62 tests/unit/progress/test_projection.py +100644 blob 1dc4ecdafedb2f0f550e1d1ea081707db9f2ea3d tests/unit/progress/test_registry_channel_keying.py +100644 blob cee57099f70e681ccdc7c333e72b380e9ce4f2e0 tests/unit/pyqt_gui/test_about_window.py +100644 blob 79575ae12d76601c4d63fa20e3bfd034e51cd4c5 tests/unit/pyqt_gui/test_application_cleanup.py +100644 blob d2118a1674466a5fa17cf48f2b9aef983e4eca2c tests/unit/pyqt_gui/test_batch_workflow_compile_engine.py +100644 blob 8f0bcd3e765053a75eab44a39fef0bb20faf4b43 tests/unit/pyqt_gui/test_branding.py +100644 blob 415bc3f21bae19bacb17bc4aebd7f740d14495ed tests/unit/pyqt_gui/test_cellprofiler_parameter_help.py +100644 blob bf4f91826f70ee26d6fe3cbadcae54275017e819 tests/unit/pyqt_gui/test_code_document_catalog_imports.py +100644 blob 5a03009629d1b6cca41f20d3767d6bcc241e2cd0 tests/unit/pyqt_gui/test_code_editor_form_updater.py +100644 blob 9d49871d7944e670d5f1b2c7ae082d991e0fb341 tests/unit/pyqt_gui/test_compile_terminal_supersession.py +100644 blob b9808c72a51c422b1eda8f760a01fcdf866f3918 tests/unit/pyqt_gui/test_concurrent_initialization_progress.py +100644 blob 38e314f3403bd38bafa0e86c20143eed9c3d9542 tests/unit/pyqt_gui/test_config_preview_formatters.py +100644 blob 37ef1e64cb1883d719af390ad7fe47f41c6f1443 tests/unit/pyqt_gui/test_config_window_state_resolution.py +100644 blob cb8cdcff9fa40aac1a7e83a5abf7d382e7876a83 tests/unit/pyqt_gui/test_config_window_transaction.py +100644 blob f645cb2548e4944d11d3de966c7a0b970bfc161f tests/unit/pyqt_gui/test_debug_inspector_window.py +100644 blob 89bdea1baff47abfc6a0cd1b91a725b7cc8c9198 tests/unit/pyqt_gui/test_debug_toolbar.py +100644 blob e303cc6973833b26019ca0346a8d86124c09b9a5 tests/unit/pyqt_gui/test_desktop_history_upgrade.py +100644 blob e9ddbbb4e852a3534265e5cb2d9e71889bc305a2 tests/unit/pyqt_gui/test_desktop_restart.py +100644 blob aab92ede88742b72359d1ec7767f332f04eff62e tests/unit/pyqt_gui/test_desktop_restart_worker.py +100644 blob cb7f113413e5a15e0872cc9d6df266493d46edac tests/unit/pyqt_gui/test_desktop_update.py +100644 blob 97bdf241f9435a0133260be536dc937cde4bf500 tests/unit/pyqt_gui/test_desktop_update_worker.py +100644 blob 2919cb0ef2ea8ced0eeaac3476d4bf1d96f3776c tests/unit/pyqt_gui/test_dual_editor_window_artifact_refresh.py +100644 blob 3fe6de1fc352800f832c68b87f23625459f309ca tests/unit/pyqt_gui/test_durable_decorated_history.py +100644 blob 89b2014c1a14e13b46ca7e0811a5cf666f008021 tests/unit/pyqt_gui/test_enableable_function_ui.py +100644 blob 3af50abe54756fbbf1a9a139acf3d7f9d9f295dc tests/unit/pyqt_gui/test_execution_server_status_presenter.py +100644 blob ca09e9848a9a060fb7f1f0d2762139313419ce24 tests/unit/pyqt_gui/test_execution_server_summary.py +100644 blob 3cb54910b5076d96c7608e1c6b495f96e0e9b8b5 tests/unit/pyqt_gui/test_function_catalog_form_materialization.py +100644 blob 5a1bfbf2240218487a2e83de351dd43f6da96d10 tests/unit/pyqt_gui/test_function_catalog_projection.py +100644 blob 8568d7efb6abef3464985e8641babe66c357108b tests/unit/pyqt_gui/test_function_selector_column_presentation.py +100644 blob b2f866d428a13814be180d2378fec3cfbc1adc19 tests/unit/pyqt_gui/test_function_step_code_document.py +100644 blob 79df6d1365c95b8ce1e4d4ef6d60fd461006df10 tests/unit/pyqt_gui/test_gui_startup_progress.py +100644 blob e9844d3e09d6fc4a0594508681e717c8a62766d2 tests/unit/pyqt_gui/test_image_browser_column_presentation.py +100644 blob 075257fa0b96e0eaddfdbc53c770cfc9c3134e54 tests/unit/pyqt_gui/test_image_browser_streaming_config.py +100644 blob d3f2790bb3321aa2ab5e1e782a92a7fa08218cca tests/unit/pyqt_gui/test_interval_snapshot_poller.py +100644 blob 0e3f802b4079910101b904b25020197e64aff05d tests/unit/pyqt_gui/test_live_measurements_window.py +100644 blob ffa0f52523e55c756ced45cf2d340805a7daf00f tests/unit/pyqt_gui/test_live_server_tree_sync.py +100644 blob 6b9c4e137ba22e17868dd391b7f72953940a0039 tests/unit/pyqt_gui/test_logging_config.py +100644 blob 4f8dc6ef7965a8d16bf4b0040613dd1da3e9f79a tests/unit/pyqt_gui/test_main_config_propagation.py +100644 blob 4fcc4f88788174bacee8260b83a04ea24ab43f13 tests/unit/pyqt_gui/test_main_status_bar.py +100644 blob aa56e5977401878b59caba5970e98b454c97a833 tests/unit/pyqt_gui/test_main_window_embedded_layout.py +100644 blob 6e0fc3c541576b4828b14311b00a37a5fa4f3e98 tests/unit/pyqt_gui/test_main_window_file_actions.py +100644 blob dfbac882a4af12b7b95636923b0f32f1eb13f829 tests/unit/pyqt_gui/test_main_window_time_travel_workflow.py +100644 blob 59887d6f04453406253eaf3a4f32590114fc9aa5 tests/unit/pyqt_gui/test_main_zmq_window_routing.py +100644 blob b9a9fa47ba6c743c65b11c5792513003af845d24 tests/unit/pyqt_gui/test_object_state_callable_preview.py +100644 blob d89f466bea4636ba064a57672070bbadf4c5a5d6 tests/unit/pyqt_gui/test_parameter_form_manager_cross_window.py +100644 blob e54ca5807689bc3c236a6f76ee1cf62b172e196c tests/unit/pyqt_gui/test_pipeline_code_document_transactionality.py +100644 blob 49ece3938ce1e5440161720d1a08c6dd033cc32d tests/unit/pyqt_gui/test_pipeline_editor_auto_load.py +100644 blob 348b4557776a325f19098ac18bfb4e9d470c9fe2 tests/unit/pyqt_gui/test_pipeline_editor_widget.py +100644 blob 2676716f073664cecf942cd5b94850b5820be6de tests/unit/pyqt_gui/test_pipeline_history_occurrence_restart_regression.py +100644 blob f063079cec3e5694863f916b5380f6f6a0bdbe61 tests/unit/pyqt_gui/test_plate_compile_connection_action.py +100644 blob 1abbc2c78b88fa97beac238fcea1ac45c1308f7f tests/unit/pyqt_gui/test_plate_manager_cppipe_import.py +100644 blob 44e909796675da147252f0e42e45adf64db53fe6 tests/unit/pyqt_gui/test_plate_manager_widget.py +100644 blob 390df8ead0b7dddede61e43009c722bbb9baca46 tests/unit/pyqt_gui/test_plate_scope_identity.py +100644 blob c0bb26b673c5eaacbadbce169803b858f5574ab5 tests/unit/pyqt_gui/test_plate_status_presenter.py +100644 blob dd7effd9c5f3cc7cfff185e01690539321af6bed tests/unit/pyqt_gui/test_plate_view_grid_model.py +100644 blob 5ff4c08d0b1e54e90085b6f5f399b27152957a6b tests/unit/pyqt_gui/test_plate_viewer_lifecycle.py +100644 blob ca3d8e181803991d75dda4e92041d5a45f0055ec tests/unit/pyqt_gui/test_progress_topology_state.py +100644 blob 286556e2f3e469853ee99646744f419582dce198 tests/unit/pyqt_gui/test_progress_tree_aggregation.py +100644 blob 04fb88f82c46a96bbcb0a3742fae71cd5ad2ae26 tests/unit/pyqt_gui/test_reactor_providers.py +100644 blob b6905a600a3cd4eb1da5945fad397804286290fb tests/unit/pyqt_gui/test_server_row_presenter.py +100644 blob 1bafae854d0b1a697108873c27c58b3daf90adaf tests/unit/pyqt_gui/test_snapshot_browser_window.py +100644 blob 75ab576226d52ff3996f34d65b3e5f1e5d8854d6 tests/unit/pyqt_gui/test_source_binding_preview_policy.py +100644 blob a6c1e7fe9e768eb02eba8c60ff5d2cb1bdea493c tests/unit/pyqt_gui/test_source_bindings_editor.py +100644 blob 87a72099fe4818bc5ec72b9e59b4fbd3ad3c02c3 tests/unit/pyqt_gui/test_source_bindings_preview_surface.py +100644 blob 4c77346bdf03401776cef84f9484b723772014b4 tests/unit/pyqt_gui/test_step_code_widget_roundtrip.py +100644 blob 1eacc2271a0a5aebb45a60efce8873334f7d67c3 tests/unit/pyqt_gui/test_synthetic_plate_pipeline_document.py +100644 blob aceee3c79b021a4934e5fb33be4740cc51c443db tests/unit/pyqt_gui/test_system_monitor_widget.py +100644 blob 38171c0936c9cbc5c08284c3b0fe7de709e992be tests/unit/pyqt_gui/test_time_travel_viewport_context.py +100644 blob 3d628eaf1c594d8290085f981230bf21dabab17d tests/unit/pyqt_gui/test_tree_rebuild_coordinator.py +100644 blob 6ce25b1d3251b735d9d1400eb270f3acd7b2416c tests/unit/pyqt_gui/test_tree_state_adapter.py +100644 blob 39e51897ac3937cae1acf2db5a2c0b3e43c96342 tests/unit/pyqt_gui/test_ui_agent_bridge.py +100644 blob d68860d015a8f0790c504e9929ac42dd96fb7757 tests/unit/pyqt_gui/test_ui_bridge_lifecycle_config.py +100644 blob f3503d1cc15152b2298daa89418d0956c91dcd5e tests/unit/pyqt_gui/test_ui_bridge_live_measurements.py +100644 blob 083515e28ec9604609c60608e46833c791abe120 tests/unit/pyqt_gui/test_ui_bridge_live_overview.py +100644 blob 3f2544eb0ea4d12716e818b29056af644df374ea tests/unit/pyqt_gui/test_ui_bridge_object_state_mutation.py +100644 blob 5c578edc5846825a03911ff55a01785ecd50bf5d tests/unit/pyqt_gui/test_ui_bridge_preview_disclosure.py +100644 blob c50df0d0272d51f20531912011a1e3cf94e473c2 tests/unit/pyqt_gui/test_ui_bridge_registry_cache.py +100644 blob 7ba3d8ba578cde8f2e8345ecf5e75ecb38dc3fb3 tests/unit/pyqt_gui/test_ui_config_lifecycle.py +100644 blob 2a01ffd5ea3fb00e48ef02b4efead3e465e4780b tests/unit/pyqt_gui/test_ui_config_widget_projection.py +100644 blob b63ade45a7869c4c3465db5d785d322f9d314442 tests/unit/pyqt_gui/test_ui_window_flash_snapshot.py +100644 blob a39381a48e9215ba41a9b0f234ab12ad534847b9 tests/unit/pyqt_gui/test_user_facing_help_surfaces.py +100644 blob 577951e0a7e6465c86853e3ebd250cce751dfd92 tests/unit/pyqt_gui/test_widget_action_dispatch.py +100644 blob 49c6fce50ae1b78fc6cae84690883987e4b63f88 tests/unit/pyqt_gui/test_zmq_client_service.py +100644 blob 6c3a3221c08824372c90e5986cb7bf47234332f2 tests/unit/pyqt_gui/test_zmq_server_info.py +100644 blob f8a534e24886c3bc98de5e6c248458971585e1d7 tests/unit/pyqt_gui/test_zmq_version_restart.py +100644 blob c7453561f03c35fbbb31c28865eb5747fed6c488 tests/unit/test_ack_return_route_journey.py +100644 blob f47d6070ff1b50b01600c43531ef4149d726d5db tests/unit/test_acquisition_calibration_pipeline_journey.py +100644 blob 4e0d4c2bb9e4e451edb68bd5d6e3581f3f765e02 tests/unit/test_aligned_image_payload_device.py +100644 blob d86066c90b21bb1da5026989bf6d4e30858a0eab tests/unit/test_aligned_image_payload_registry.py +100644 blob b4e4e05b039d051bdc1368b3ecd2f05a322e08d3 tests/unit/test_aligned_main_flow_projection.py +100644 blob 191f1c0a98d689ad8b002e86abd0213f1e4bc76f tests/unit/test_aligned_output_projection.py +100644 blob 549da7213f41c2b0e499a7623c46e4ad69044ed0 tests/unit/test_annotated_validation.py +100644 blob b83c5943c619deeccea5a685528624df9b22e277 tests/unit/test_artifact_declaration_step_context.py +100644 blob 2fafc18b1819d22b0ba9e5118563d1a49f8472cc tests/unit/test_artifact_input_edge_cardinality.py +100644 blob 7f66f530ce4bbb9a9bdbbc53529544a381c31a9d tests/unit/test_artifact_input_parameter_normalization.py +100644 blob 80a6e8e6e4b57f6b70dc209081f5696e51508015 tests/unit/test_artifact_input_projection_plan.py +100644 blob b317d95fd67918c1a7ab4cc5535ab5b9e25d1260 tests/unit/test_artifact_output_materialization_planner.py +100644 blob 48b69abc57b7bc87b152fcc99e8213d050168a7c tests/unit/test_artifact_output_ownership.py +100644 blob 464d91dd1f8eeef624829d84d4ecf9c88516fe8c tests/unit/test_artifact_plan_view.py +100644 blob c89ca1cd1dc7c8568574869d677bccf9f30004e0 tests/unit/test_artifact_publication_journey.py +100644 blob db6e37dd1c754d8c8c733944ebaef8f2ba67bfee tests/unit/test_artifact_spec_collection.py +100644 blob 93b418bfa96b331d348483e4a8103bb048b2fc7a tests/unit/test_ashlar_request_records.py +100644 blob efcc9ccd8086311066486a448e1ccaf64ac5cd23 tests/unit/test_assembly_acquisition_placement.py +100644 blob 69cf03db787f76ad4222066fb305dc7939a88fb9 tests/unit/test_ast_validator_registry.py +100644 blob d5298c7dc86c654e1de7e01371625d1573095019 tests/unit/test_batch_submit_wait_engine.py +100644 blob 833e0e14348e538e132d0c2c84df051b20857dd9 tests/unit/test_benchmark_control.py +100644 blob 55102fec42e645bbeba65cea62ad03333845cc86 tests/unit/test_benchmark_manifests.py +100644 blob 4fa75dcbc35f808d7970f6d3332c1472653f5d13 tests/unit/test_benchmark_pipeline_registry.py +100644 blob 2081d32d8436d94b50507f5c5ac37388778ad626 tests/unit/test_benchmark_progress.py +100644 blob 2456962945737a3bb50e0266e4816647f8c6f4b2 tests/unit/test_benchmark_timing.py +100644 blob 713e6475e7b1e7c27ee141f374cc2e4aac52ed65 tests/unit/test_benchmark_visible_source.py +100644 blob f1356eda51773b68815b85655a77f24a9b7b6edc tests/unit/test_bioformats_hcs_validation.py +100644 blob 8413fa584d9315f4cd3ae5860547e9d7340ec28e tests/unit/test_bioformats_java_adapter.py +100644 blob 4b304185c4d4a3c3176906fd8fb237ebae6fb88e tests/unit/test_bioformats_microscope_handler.py +100644 blob de4daac745e634f6f28bd2d2b156a0ca7e18c757 tests/unit/test_bioformats_spw_projector.py +100644 blob 22fdc7c46d112a8a404ffa834a923e1df9224e6c tests/unit/test_bioformats_storage_backend.py +100644 blob 3c0a6c573645c83e56f8039e52ec524fb9c0753a tests/unit/test_brand_assets.py +100644 blob f8fafaa71ced353c37d177895f0517d1c4254da4 tests/unit/test_build_hosted_mcp_plugin.py +100644 blob 258f8e6bbd529d2a68bec150c70732ad083a7ddd tests/unit/test_build_mcp_knowledge_assets.py +100644 blob 526f7f91f5d09429bf355a347d8a45dcf5e5a136 tests/unit/test_build_website.py +100644 blob a51e8f18edd3648cbdd0ded831975699a0a27013 tests/unit/test_callable_contract.py +100644 blob d5853ed757ae1191a918ac5ba6b4bb82ca90b27b tests/unit/test_callable_request_binding.py +100644 blob c4afbb1cda5b1b802d6e16210237cdb057e240d3 tests/unit/test_capture_media_gallery.py +100644 blob 80f9e05874895f2a206fc8e4e549c31702a87765 tests/unit/test_cell_counting_cpu.py +100644 blob ff055b0cf50f5fa2f370cb6650b4b8146c21b6bc tests/unit/test_cell_counting_cpu_artifact_contract.py +100644 blob c72b5d4b4114662fb02783af0c100e4df1d29946 tests/unit/test_cell_counting_cupy.py +100644 blob afe8d73571e5a49301e63e1bf1fb05ae2469ce41 tests/unit/test_cellprofiler_adapter.py +100644 blob f502cbbfb1f2be39d77bf374aab742919755b6a4 tests/unit/test_cellprofiler_adaptive_guide_threshold.py +100644 blob 89390f33703ac1c97a348419fdcd378125430f25 tests/unit/test_cellprofiler_analyst_export.py +100644 blob 2ba3901aa30f8d2fbf75725588344a79e55208d7 tests/unit/test_cellprofiler_area_occupied.py +100644 blob c144bafde03c8e1026dd41a26f983a48714f5063 tests/unit/test_cellprofiler_artifact_activation_identity.py +100644 blob 6b6f2fb3187c69d329e9138e3b44dd07ba228007 tests/unit/test_cellprofiler_artifact_declarations.py +100644 blob 42b49b8e97bbf2b99569375ea23a97047079461f tests/unit/test_cellprofiler_artifact_identity_reconstruction.py +100644 blob 2ddf7c714824fdd6fb1d225910147e9db4683482 tests/unit/test_cellprofiler_backend_leaf_wrapper_deletion.py +100644 blob 9e7819635801a4de9ea99a06c881d188e32029c2 tests/unit/test_cellprofiler_backend_public_api.py +100644 blob 1c47b5bcb74139afbe31b160e7cf865d7ff4751c tests/unit/test_cellprofiler_backend_selection.py +100644 blob 7bb3435d1a6c8eb9437ce21c80221781504fd40b tests/unit/test_cellprofiler_callable_kernel_preparation.py +100644 blob e104ebf1a806698768007f2edd2101cd6f767807 tests/unit/test_cellprofiler_centrosome_independence.py +100644 blob ee8ff224914e15c365208e720b19f4a2d41d3d3d tests/unit/test_cellprofiler_closing_hotpath.py +100644 blob 08323bf0a50254e3722967c0c699c9c02ae00dbc tests/unit/test_cellprofiler_combineobjects_source_scope.py +100644 blob 7b320f769eaa2a97e7d49c2554ff215bfb4493fe tests/unit/test_cellprofiler_comparison.py +100644 blob 512fccfbd07bed229c9f9e2609be4c578714955c tests/unit/test_cellprofiler_compatibility_matrix.py +100644 blob 06f9ddb436bf72072c5376b46d157ec8180c2919 tests/unit/test_cellprofiler_conditional_analysis_images.py +100644 blob a441aa438881b61067186788b29951a3c86c092e tests/unit/test_cellprofiler_conditional_measurement_outputs.py +100644 blob 84e9c3f73d5103dc7dd9f7261fbc4ef7b8e61551 tests/unit/test_cellprofiler_conditional_named_images.py +100644 blob c07c1b331b94ea68773270b1c1fb92bb46b120aa tests/unit/test_cellprofiler_conditional_topology_declarations.py +100644 blob cb937cbda3b5598bf0cb39b1daa00ab738c20e1e tests/unit/test_cellprofiler_converter_cli.py +100644 blob 32f5048dd3e6c2a4a68e0a7d7d38d7a4ac4e8935 tests/unit/test_cellprofiler_display_manual_projection_declarations.py +100644 blob 606576c8e609c0fd177909ef658f2f25ed88c038 tests/unit/test_cellprofiler_display_plate_map.py +100644 blob 9125e789026051db47e8d5a8ee5266ed55a5cbf3 tests/unit/test_cellprofiler_display_runtime_payload.py +100644 blob 6d29760c6676bd81fcfa094a7b76041ce7250cc4 tests/unit/test_cellprofiler_export_equivalence.py +100644 blob 1617ca8a64729a17f63efd8f12f3d27b39ca31c6 tests/unit/test_cellprofiler_export_measurement_outputs.py +100644 blob 18a8a28398b56c237c054153fc16ef5f056248be tests/unit/test_cellprofiler_export_to_database.py +100644 blob 7383f3e6f19094b1c2965539fe6dbb239f7ff90b tests/unit/test_cellprofiler_extended_relationship_topology.py +100644 blob 2a61995cecab3e92e8bebe224e83f3d026184325 tests/unit/test_cellprofiler_function_contract_execution.py +100644 blob 51553ffdf81efdba32185ce1c1001ba6bcb3f225 tests/unit/test_cellprofiler_generated_pipeline_execution.py +100644 blob 76177753ec368c273c3cf78859e54acc65ae9e3b tests/unit/test_cellprofiler_generic_special_input_binding.py +100644 blob dbf8842f1f19ed9f3f72b4d48ed976806dc9cc9a tests/unit/test_cellprofiler_identify_secondary_replacement_primary.py +100644 blob 67a42b012e29e941cec319b1aadc1818ce9531e4 tests/unit/test_cellprofiler_identify_tertiary_output_abi.py +100644 blob 83094de3347a258e02578827c59611a69d7acb84 tests/unit/test_cellprofiler_image_geometry_cardinality.py +100644 blob f6d472972d7f5f5dbeb27bc0bbee8b5e95f352cd tests/unit/test_cellprofiler_image_math_hotpath.py +100644 blob 3b2902f444a7ccd3d13c4f3962d7d17229e24ce3 tests/unit/test_cellprofiler_image_math_mask_metadata.py +100644 blob 82ca7f16e4d2e64d302cbf7d0c3f71f900d6c231 tests/unit/test_cellprofiler_image_math_operand_axes.py +100644 blob 483e2eaabb1f4f3ebc9214af6aef2fb5e85c962c tests/unit/test_cellprofiler_image_math_public_roundtrip.py +100644 blob 1c9a01eacdd95cd67520df7b057ba60c2dd6b512 tests/unit/test_cellprofiler_image_output_metadata.py +100644 blob 64165a06391e31113dc0de079c86dd9a5525e3a1 tests/unit/test_cellprofiler_image_quality.py +100644 blob 57d97f3dcbb5d237e6fbf1df738556fceeeeb331 tests/unit/test_cellprofiler_interop_import_records.py +100644 blob 3c82f60d089ddb6d33971ff12ff0a9e17ccc480f tests/unit/test_cellprofiler_interop_namespace.py +100644 blob 82dcd52d5dc1639fd8bbf7ae8e4712cf1fc2897b tests/unit/test_cellprofiler_kernel_preparation.py +100644 blob bc6e58ac70ae1698a05ae0d154143182ba2b1e64 tests/unit/test_cellprofiler_label_hull.py +100644 blob c7986e94d945340de783346406fea4d094d372f8 tests/unit/test_cellprofiler_library_loading.py +100644 blob 6799ca54da560a256167110a686bb080a5129eb0 tests/unit/test_cellprofiler_library_untangleworms.py +100644 blob eabbde32185537552b42526da1dce424dc478817 tests/unit/test_cellprofiler_measure_image_skeleton_contract.py +100644 blob 94b3edb8de529fd1ff5e16a5374ddc08d40852a5 tests/unit/test_cellprofiler_measurement_math.py +100644 blob 40f0b199c1d27cab6feaca6ebef56f48909f6163 tests/unit/test_cellprofiler_measurement_projector_cleanup.py +100644 blob 6aee8a97caa6f95e8badec6a8e1c92a78dd8d1bb tests/unit/test_cellprofiler_measurement_rows.py +100644 blob b03af8ce1e5e90c378f55cd5b1ad114480ab4bc0 tests/unit/test_cellprofiler_measurement_slice_consumers.py +100644 blob 142e37def2f4bdf81b69bed8b2fa2ba88b83406e tests/unit/test_cellprofiler_measurement_source_group_scope.py +100644 blob be4807a7c5e8dfb4e04ab9db1c1c82f2bc3bc7c9 tests/unit/test_cellprofiler_measurement_source_names.py +100644 blob 9fec67a7f35f65ac10784d4011eeddcca472c7c0 tests/unit/test_cellprofiler_medial_axis_contract.py +100644 blob 0ae63472948a8ff1963ab9aedb84670dd350d6b9 tests/unit/test_cellprofiler_module_execution.py +100644 blob 6a5209eaafdad8ef61426fd1d0faef7c50c0ecbd tests/unit/test_cellprofiler_module_execution_semantics.py +100644 blob 2d6db1eb706d72312b26efb1abe67dd8b5d8d043 tests/unit/test_cellprofiler_module_function_resolution.py +100644 blob a6198aae1f7744759bb410a3d8a66b0374596a07 tests/unit/test_cellprofiler_module_measurement_features.py +100644 blob ee0b533bc942aa03d47c296baaed3947b6f57845 tests/unit/test_cellprofiler_module_measurement_scopes.py +100644 blob f444e5ca87bcfe29c8fad2c38559998a1aa783b0 tests/unit/test_cellprofiler_module_processing_config.py +100644 blob 2a400718e61e479bf2dd8863ec08d87c330e42e4 tests/unit/test_cellprofiler_morphology.py +100644 blob 904e5852b5286ad73f0bc1679d6f59c4c38204aa tests/unit/test_cellprofiler_morphology_public_contracts.py +100644 blob 2a2d824df92df0b4946ea97cac1d96bbd6db0c01 tests/unit/test_cellprofiler_neighbors_contract.py +100644 blob 2e7681ec8afd900419a6da9c94b47569fb945f3e tests/unit/test_cellprofiler_nominal_policy_migration.py +100644 blob df58559417e517a9a2dc85351b622421a6e5cc65 tests/unit/test_cellprofiler_object_intensity_hotpath.py +100644 blob 8e55da8f9df623c6ba29cdeadad9256d34549a0f tests/unit/test_cellprofiler_object_label_payload_inputs.py +100644 blob 104e5dd4a5b88a575bb14a45d45beb43a05f422d tests/unit/test_cellprofiler_object_measurement_schema.py +100644 blob 1c2406778a794e719b4134843f27e045901815d8 tests/unit/test_cellprofiler_object_morphology_hotpath.py +100644 blob d9b804b851db23bab13137ab9865db8c4ad64f63 tests/unit/test_cellprofiler_output_cardinality_declarations.py +100644 blob 3f33d40f8f348a45b7414ddaa10639e5317f2c95 tests/unit/test_cellprofiler_output_record_occurrence.py +100644 blob 698d2131c395367a4446e4c2ac9f7fac55e9225d tests/unit/test_cellprofiler_output_recording.py +100644 blob d687c1079b8c50c8acf4599cacd208f851a50259 tests/unit/test_cellprofiler_pipeline_import.py +100644 blob 561070ca4bb101a845d436098f85bcf157d8b013 tests/unit/test_cellprofiler_pixel_classification_entropy_parity.py +100644 blob a76af4f08743da116a604d672433da58b1123086 tests/unit/test_cellprofiler_plate_workspace.py +100644 blob 18404e339922ac9115804490cadb4f9ebafa6e03 tests/unit/test_cellprofiler_primary_object_performance_kernels.py +100644 blob 6e1647f1b574da35e97a6e0d8fb806ab1da8238f tests/unit/test_cellprofiler_prior_measurement_output_relations.py +100644 blob 4f0a86265c163ccd70ce08ba2218a7d14d92235b tests/unit/test_cellprofiler_processing_backend.py +100644 blob 81219be64ca04123b139021a06b86c127c62d45a tests/unit/test_cellprofiler_producer_row_schema_authority.py +100644 blob 98118557b5e1ba8b07e36cb959cff33fff45948e tests/unit/test_cellprofiler_projection_backend.py +100644 blob 73c03c7160e18972f37a60402a78b93c8b170101 tests/unit/test_cellprofiler_public_boundary_contracts.py +100644 blob f55e1cb67b8fc8ba1be836f3775b8216d646e8b0 tests/unit/test_cellprofiler_reference_exports.py +100644 blob 74ee1d575a25b3e71f305af13d66bb8524eb5069 tests/unit/test_cellprofiler_relationship_contracts.py +100644 blob 50b5a8ccf326ee7429942e38dfe9ee18f40a9936 tests/unit/test_cellprofiler_relationship_hook_caller.py +100644 blob 3d3293300578a3716bbbb9674b38e813611e71a9 tests/unit/test_cellprofiler_repeated_row_declarations.py +100644 blob 14d411f019f03bc0f075112f2b8cd48fff923e10 tests/unit/test_cellprofiler_rescale_intensity_hotpath.py +100644 blob d8a11cce5ebd2851c1f241089d9a4d27d144a85e tests/unit/test_cellprofiler_resize_hotpath.py +100644 blob c5a86f3d1b0c7fb286ae7d1953958c76c9cd2130 tests/unit/test_cellprofiler_runtime_adapter.py +100644 blob 53243627dfd1f8379714ff85e698efdc4004d4b7 tests/unit/test_cellprofiler_runtime_binding_identity.py +100644 blob 108d2cb0e1fc02047edcd763e440ae39bf5e12b9 tests/unit/test_cellprofiler_runtime_cache_authorities.py +100644 blob e435baed1fce8c66f35efe65f71c17f552c2fcc7 tests/unit/test_cellprofiler_runtime_callable_introspection.py +100644 blob 4902047a6f2224724e4fad81829c3fe52b1b843c tests/unit/test_cellprofiler_runtime_input_binding_contract.py +100644 blob a6162bab2b81c17424aba5c652092fd6097c8033 tests/unit/test_cellprofiler_save_images.py +100644 blob a5e98f9eefebf43d0cef43ee627a21dfdbd77ea5 tests/unit/test_cellprofiler_save_images_hotpath.py +100644 blob 1331d81e37d12e404d7c4cc9462f822a0c86157e tests/unit/test_cellprofiler_secondary_distance_backend.py +100644 blob 266dee616788ec0dd532ae89ca13877e1f9d0a35 tests/unit/test_cellprofiler_shape_hotpath.py +100644 blob c5b44a9f57062a79a8be95031ca3123f7981ae09 tests/unit/test_cellprofiler_source_bindings.py +100644 blob 31e3832db2085b91decdcb404e3eec76c38c735b tests/unit/test_cellprofiler_source_bindings_ingestion.py +100644 blob a7dc1764a257505f10d47ff3175fd843d2fb50d8 tests/unit/test_cellprofiler_special_io_declarations.py +100644 blob 47782563378ee6abb86503cbbd55ea6e8248f4fa tests/unit/test_cellprofiler_spreadsheet_export.py +100644 blob 1c48cb79723e0fb6745b3efc40cece05b9c6b37f tests/unit/test_cellprofiler_static_deletion_gates.py +100644 blob 1d91e594c0edbea4436cf49777a0859b2e9dbae4 tests/unit/test_cellprofiler_strategy_registries.py +100644 blob 3ce92c887627085c34f7d8d61b5300bb4cbd8174 tests/unit/test_cellprofiler_threshold_hotpath.py +100644 blob 32fadaec7aa74d6ff7ee2ed748fa86a520e6c0f0 tests/unit/test_cellprofiler_threshold_measurement_feature_parity.py +100644 blob 16dda647fc6bf3b0be781d57982e6a4dc66b0f83 tests/unit/test_cellprofiler_thresholding.py +100644 blob 9b962deba3bb29e855ad8186fb04198d057f9f54 tests/unit/test_cellprofiler_trackobjects.py +100644 blob 63ed0ec6cb1eed1d1aacea60cac17b369de0040d tests/unit/test_cellprofiler_uncovered_image_measurement_contracts.py +100644 blob cde5e96836d3f3d6a6d9721bab1afd1d6e7c0efa tests/unit/test_cellprofiler_uncovered_object_output_contracts.py +100644 blob 1b3375b793f9f4ce13ea34c98234563faebf4487 tests/unit/test_cellprofiler_watershed_3d.py +100644 blob 2490a4b503a00b21f238f7e2f49ec92cf46446b7 tests/unit/test_cellprofiler_watershed_hotpath.py +100644 blob cdd19f4020c1eb9e9fa402c993e2ae308b668737 tests/unit/test_cellprofiler_watershed_provider.py +100644 blob 5353f96483dfd55df549ab3d8c24050794edb2f2 tests/unit/test_cellprofiler_watershed_residual_hotpath.py +100644 blob 840c7e90c52fa94269a3c309aa36dd6cd9623752 tests/unit/test_cellprofiler_worm_external_resources.py +100644 blob fae7fb70298fa1299bc167600f3f1012557ddc9c tests/unit/test_cellprofiler_worm_geometry.py +100644 blob 24bddef26101d281f681d6358e807eb85f3e9f12 tests/unit/test_cellprofiler_worm_measurements.py +100644 blob f659aca9be5cec14074f993e58fe456ea046394a tests/unit/test_ci_action_pinning.py +100644 blob dd2a2af8d15ae640e78f8aff5bfe66a8124c68cf tests/unit/test_ci_package_boundaries.py +100644 blob 3e2e401a8725a8051207ef22751fe08e8a64f79e tests/unit/test_cli.py +100644 blob a742425a78bf29c82c12f69da6ed3f40ceb3d39c tests/unit/test_code_mode_path_artifact_architecture.py +100644 blob 58408bda252689f0adc849bdbc536b33aab83e18 tests/unit/test_columnar_row_schema_authority.py +100644 blob 06bf63cb633d47522c221ae861df5504a7cae8e2 tests/unit/test_comparison_manifest_acquisition.py +100644 blob 88369a524d9597141a59385573102023113a683b tests/unit/test_compilation_paths.py +100644 blob d2656e432fd0a49414c22c905d46fb6bbf849902 tests/unit/test_compilation_session.py +100644 blob 29f7bbd1c49b4b07be0b54e9f043d655cde6b49b tests/unit/test_compiled_execution.py +100644 blob 2d57a9f307392b6d1ccb382ff3e10d227d0d6f23 tests/unit/test_compiler_auto_materialization_policy.py +100644 blob 157caefc6228d18af6ff0a77db0974efad7087ba tests/unit/test_config_document.py +100644 blob 356a249b33754896e4fbb0fd53755502b2d8982e tests/unit/test_configuration_consumer_coverage.py +100644 blob a3e3fdf1961be94645f60eeb59718e2c797dd404 tests/unit/test_configuration_mirror_deletion.py +100644 blob 143dce5fbe74843709b03369bd9269e76652162a tests/unit/test_core_config_annotation_validation.py +100644 blob b2d5ef007b67d9b85ad64513dbc3d1f5aca03b4b tests/unit/test_costes_parent_mean_qualification.py +100644 blob e705888be0787394ed352b78474c826ec0f29801 tests/unit/test_count_cells_simple.py +100644 blob 1b195cc2e8892c1ff51fb6447e4f5fee9ea27366 tests/unit/test_cppipe_corpus.py +100644 blob a734d03e2270a917a499e7ace148445511620ab1 tests/unit/test_cppipe_execution_validation.py +100644 blob 387cc88df71706d6943aab3cd1f049b281f27ffa tests/unit/test_cppipe_parser.py +100644 blob 8302c15205ec7b09a585d34055901e36043a6b1c tests/unit/test_custom_function_events.py +100644 blob 70163268dbed68422c6fc48f9e1b223bfc220f5a tests/unit/test_custom_function_lifecycle.py +100644 blob f8fbd7c542d3af25639ede11f81bcdb56dcc3573 tests/unit/test_czi_brain_axon_cellbody_demo.py +100644 blob 8b32b7c6a69d62d0f3e3c548278776621dfe6443 tests/unit/test_czi_zarr_source_audit.py +100644 blob 754c3b85d30d8a3c490ded8665e1f43ac50a0b32 tests/unit/test_dataset_acquisition_infra.py +100644 blob 5d62ac03dd2d8006ea56b4bb67d5ab310319677a tests/unit/test_dataset_registry.py +100644 blob 4c6ece9111916c16bd0c9d696a9e1f976d9f7b7e tests/unit/test_debug_runtime.py +100644 blob 880f195b760ca03603a6b5015b59b60b1b9189e6 tests/unit/test_debug_views.py +100644 blob c5c4ed52267994df335430d7b7ec45f4f179a2bc tests/unit/test_derived_runtime_image_provenance.py +100644 blob 69271b630c4b36afc994fa61deec8486fadfedde tests/unit/test_desktop_deployment.py +100644 blob 6b28f79c9b6affd9ff94e100cba759a6d39c8887 tests/unit/test_documented_dimensionality.py +100644 blob bd19c886d800eabfa1e29cea1bee0ddd430b5505 tests/unit/test_enableable_function_identity.py +100644 blob 198e073877ee535d45046b4935cd5ee44f030511 tests/unit/test_exception_traceback_compatibility.py +100644 blob a31017d1b8e95bd88947cc7c29d512a6fcf0dafa tests/unit/test_execution_server_startup_preparation.py +100644 blob fa133b0b50b462152b577d8713df3da96d0259d1 tests/unit/test_execution_status_poller.py +100644 blob 993b300b3e476e7ed95685087392f7d970c43851 tests/unit/test_expandorshrinkobjects.py +100644 blob 53053c760816d038f31af95e3edd9dbee6139d5b tests/unit/test_experimental_analysis_engine.py +100644 blob 5dc5cf43377d325130749734c734969816dca442 tests/unit/test_experimental_layout_rows.py +100644 blob 38036267b22166f8776ce51e11ead35e6cfff65d tests/unit/test_fiji_test_environment.py +100644 blob 22ce0a127c87fccb4bfb82b0dc7cef86bc98e5f5 tests/unit/test_fiji_viewer_server.py +100644 blob 0f8556052a0e273648ab3912ec49fa2cf38a8555 tests/unit/test_fiji_viewer_server_launch_config.py +100644 blob d4ee275f12bc831ee12ed0d245bf4bddaf605f5d tests/unit/test_file_materialization_options.py +100644 blob c4f146de2833cfb4774769ac1b1a724d7deee677 tests/unit/test_fork_compiler_preparation.py +100644 blob 31aca0a2cbf555c1b071ce8e751da38786169162 tests/unit/test_framework_device_resolver.py +100644 blob c5e341073be17a3d1407e4cc7636f2ad7a0d4c13 tests/unit/test_framework_execution_scope.py +100644 blob 140aea754e3be87beefa27d3e6fb258ec0a097d2 tests/unit/test_func_registry_projection.py +100644 blob 73b9e88ef157e83ff7bf7e03b9b1a92ead90e717 tests/unit/test_funcstep_contract_validator.py +100644 blob 1559f16542621c730a0fddce59ed557a36d72767 tests/unit/test_function_artifact_materialization.py +100644 blob b6627f4cfab5b4345e713ec810414c6ae89e1dd8 tests/unit/test_function_artifact_materialization_io_hotpath.py +100644 blob e10ad5c99521100a94fda4d74325d67ae05dee0a tests/unit/test_function_artifact_outputs.py +100644 blob 25927712bc3e2b379521d587de00a4433b4fb626 tests/unit/test_function_catalog_zmq.py +100644 blob 7396d972c6b59355751483c8b597d6ad33bb8c13 tests/unit/test_function_execution_lifecycle_anchors.py +100644 blob 0198cf7446cd3e6366028e7747098f2851f5bd86 tests/unit/test_function_invocation_callable_resolver.py +100644 blob b53923824821fa0db6784ee7909c50a898e3e578 tests/unit/test_function_io.py +100644 blob d2b55b26fd719e3ee956a44f4491ef7bf3356961 tests/unit/test_function_output_manifest_input_scope.py +100644 blob ebd66c519f2a1eabede3527dff9466c3232f1320 tests/unit/test_function_outputs.py +100644 blob e9da0944c6c6c100e07be11c26b30ed59d42931f tests/unit/test_function_patterns.py +100644 blob 16c3548d10e10e35dd7b9319b1a05ad6497027f4 tests/unit/test_function_reference_identity.py +100644 blob 1d4c2ead7d6602e42e2c95f7746e47599180d19b tests/unit/test_function_runtime_source_projection.py +100644 blob 1d73aadc15492515a28a7d31148815ad40b08509 tests/unit/test_function_step_document.py +100644 blob 1af5495d0424203b10c52501c7b726e06b9575f5 tests/unit/test_function_step_execution_plan.py +100644 blob 9836d217d2e52c464a65db62e76a9a2c4c351619 tests/unit/test_function_step_execution_scope.py +100644 blob b50344fffb260ae9f3129004c63f3c4bff11194d tests/unit/test_function_step_transport.py +100644 blob 33453a5fefd540c2a62bbb31936103231ea2ed4e tests/unit/test_git_hook_submodule_safety.py +100644 blob 292f239a38861ea137cbc9e59ccace13b36eda72 tests/unit/test_haralick_feature_arithmetic.py +100644 blob af9132d1305614697dd4564f837d35991e4b75e4 tests/unit/test_hosted_mcp_container.py +100644 blob b9dcee0ffe6a340ba1556e6862334caebbc9ac95 tests/unit/test_image_file_serialization.py +100644 blob 7c42a5fa1dacdc9531db2a45672d0e89018956ae tests/unit/test_image_output_context_projection_proof.py +100644 blob 7e1b10c630c99773b25da28965ccab050d8b3a12 tests/unit/test_image_plane_contracts.py +100644 blob 4027933d56ff0124a1d9f30cdf3534dab05f4638 tests/unit/test_implicit_main_flow_compilation.py +100644 blob a68860364dc8281e48a49b3ed9f540faa1edd722 tests/unit/test_import_utils.py +100644 blob 5ac6ad7253f0c7dd0e49fa37467668f6ee855ceb tests/unit/test_independent_validation.py +100644 blob 3e947c774b3299d070dbbc7e22786e46cca168ab tests/unit/test_install_ci_candidate.py +100644 blob 40e4453edffdedf601517b21a944c66b300f9aef tests/unit/test_installed_mcp_demo.py +100644 blob b987982643b02d273bfd8070a79bbc1cf48fb85a tests/unit/test_invocation_contract_provider.py +100644 blob 43cea99fbd812b795121a25fafc9a15d430a778a tests/unit/test_invocation_input_source_context_identity.py +100644 blob 9c0c028a0b1af0c41d38320efa937f0dff9c2a61 tests/unit/test_label_area_perimeter_performance.py +100644 blob 617f012344b2a3163cca5af8f4459f98ba8c5b0e tests/unit/test_library_registry_discovery.py +100644 blob 9fee42897dc6707d774da032550a3269f2ed3d11 tests/unit/test_loose_operaphenix_neurite_example.py +100644 blob 0f41e4a76f045c80f2c3f69c77f660d6c2a4d0b3 tests/unit/test_loose_operaphenix_neurite_metaxpress_example.py +100644 blob 67826d576a1a7ce334e7932f111d0b2e39f079d7 tests/unit/test_master_multi_plate_demo.py +100644 blob e6f77c8bb9ccd768ab0c1a422236f7222cd2656b tests/unit/test_matched_cellprofiler_batch.py +100644 blob cf0bfe960ba11fc49fd43435b04a823500a4e392 tests/unit/test_materialization_api.py +100644 blob f1669802a08aa0c8d55a6ef541e8ebfcf3685313 tests/unit/test_materialization_core.py +100644 blob fb5272643357733ca4b3a693c7fcd82f03546bf4 tests/unit/test_materialization_filter_inheritance.py +100644 blob af35fdca9a28f795fc676dbb43630a62c83ed739 tests/unit/test_materialization_flag_planner.py +100644 blob 5fd4e2d79f1551654f50d81717d55e32c449fd2e tests/unit/test_materialization_source_extension.py +100644 blob 438cb2c8450788d051c27e6a48ffdf7d9c64344b tests/unit/test_mcp_assay_showcase.py +100644 blob b240b6f91f88cfe27220bc25efed1655efdff96c tests/unit/test_mcp_dev_client_persistent_session.py +100644 blob 851a746845054009df17e4eeb998b1581ce98b74 tests/unit/test_mcp_memory_diagnostic.py +100644 blob 878b576c5b149edb300530a9c8c287b905f3f661 tests/unit/test_mcp_release_workflow.py +100644 blob 0ec5bf2123782ca886793011973c1d5438607b03 tests/unit/test_mcp_thesis_demo_live.py +100644 blob b29d858106e01d3bfca59dfef012cbaa97eda915 tests/unit/test_measuregranularity.py +100644 blob 8d1735fa73f629d02cce4c1d0d21c4aba8755670 tests/unit/test_measurement_axis_field_projection_performance.py +100644 blob c45f956e8f65260d3ff2866d1e4d8b43020be590 tests/unit/test_measurement_image_alignment.py +100644 blob 6ce34fab28d33fc8150b34199e1b51f79e7aeee5 tests/unit/test_measurement_image_plane_projection.py +100644 blob 1de36425ee74272f6fbc3a74b446d234f7b5adf5 tests/unit/test_measurement_lookup_dialect_performance.py +100644 blob 78deaa89e506bc52d071e7cd2f935b499d8408bd tests/unit/test_measurement_output_coalescing.py +100644 blob 3a3a2b054bc7969a87d02f238b35dca58a9ea662 tests/unit/test_measurement_row_materialization.py +100644 blob 926c93d25c4aa473028ac21e924a6073ae66ca75 tests/unit/test_measureobjectintensitydistribution.py +100644 blob aff98833ee3bf3eb7fe856f39eb94ade63f6995a tests/unit/test_memory_type_authority.py +100644 blob cde163ef2f6f28986f1822143547580fa49f0560 tests/unit/test_metrics_memory.py +100644 blob dc4f7abe6e2090c32ed51c9baec76d190f81b7e0 tests/unit/test_mfd_preset_specs.py +100644 blob 5aa119b3d894ad4a8e9d1ecc2e5bf98e6af55f8d tests/unit/test_microscope_handler_identity.py +100644 blob 217e66961f6ae9b8f09bb8ae6717087e6cda281c tests/unit/test_microscope_virtual_workspace_metadata.py +100644 blob 08a1b221502eb463ac59034b910247fdb7aebda0 tests/unit/test_multi_template_matching.py +100644 blob 29d84378e26e6e985295ad15e751d6b7bba67a9d tests/unit/test_named_checkpoint_publication.py +100644 blob 091b8594541d42e0d5434853abda6f7fdefdaaa5 tests/unit/test_napari_accepted_work_settlement.py +100644 blob a055d3e3302acefc1b82d563076528056f1c7e6b tests/unit/test_napari_orthogonal_navigation.py +100644 blob d4e86d5a8af519ed41917184004533d7d051d7ca tests/unit/test_napari_reset_transitions.py +100644 blob cf281d0c6b28a902c91f4d35fb2f572aa50cb80d tests/unit/test_napari_roi_manager_integration.py +100644 blob e0e4d9663c5fcda235c9cbfa2f9f8e310ac0771d tests/unit/test_napari_shared_axis_navigation.py +100644 blob 02f482287632cfc2c46f0d4affcabf42f7c29ecb tests/unit/test_napari_streaming_handlers.py +100644 blob 3e75aba0aff48d0aac4947f977cfb73416dcaf0e tests/unit/test_napari_swc_reader.py +100644 blob 7a4cbfdcabb4c383913f30a9e7ec63fd5e09c4c5 tests/unit/test_napari_transport_ownership.py +100644 blob cc6877220d6b14881c3dc4b23a53259e57a0cf3e tests/unit/test_native_batch_barrier.py +100644 blob a7e9fc13548af8b4aeb665a340484a4dbc9a0a58 tests/unit/test_native_synthetic_well_scaling.py +100644 blob 7b49e14fee54d4ac9376f9df11f3376e798d9896 tests/unit/test_native_tabular.py +100644 blob b0d7104fd9e2c16736a903e7818465c114025ddb tests/unit/test_native_threading.py +100644 blob ef0afa21f4c613124def925e40981c07958d622b tests/unit/test_native_viewer_presentation.py +100644 blob 0a36a378a51c461d1cc9e3210cb88e598cdafba6 tests/unit/test_native_worker_durable_evidence.py +100644 blob 76c9879662cec927bdd5b670e780c4e0906c6b59 tests/unit/test_neurite_outgrowth.py +100644 blob 182820ed2c5416f1bacdc5bb013c890a64b07202 tests/unit/test_neuroncyto_ii_neurite_demo.py +100644 blob 76fa88c8792c9a00bc17b7b9af5431bacba49fe2 tests/unit/test_nlm_slice_contract.py +100644 blob d140652fa78b21c77f72edf86ee9677ed2c9d017 tests/unit/test_nominal_contract_architecture.py +100644 blob fdc45c95e6c671e954612f16ee27edb0c13f50bc tests/unit/test_nonpersistent_viewer_state_evidence.py +100644 blob 2cacc711c7fd69f6747e6eeb84e78ab0732d1d1e tests/unit/test_numpy_runtime_capabilities.py +100644 blob b12327215df55fc53929d2179ebd3a7f4727de13 tests/unit/test_official30_lab_meeting_demo.py +100644 blob 11f74e7cab86cea2fb09e6fd577f94602a1fe052 tests/unit/test_omero_instance_manager.py +100644 blob e383d2b8f761c91fe6ebac583c6cf86ed0610faf tests/unit/test_omero_microscope_metadata.py +100644 blob 383c8d8fbe1d900632b18eadbeeaf43faf72c117 tests/unit/test_openhcs_adapter.py +100644 blob d01a215d926ddce8249ff8fe8da96219352c94e8 tests/unit/test_openhcs_measured_run.py +100644 blob 465670c00e01b888203d904d41d9ee31e86183c0 tests/unit/test_orchestrator_execution_result.py +100644 blob b26ec32794a812d8f61d6a188838bd595c019018 tests/unit/test_orchestrator_lane_planning.py +100644 blob 03c2211141a3c43bf466232a88535e081c9d7c6b tests/unit/test_path_planner_axis_source_scope.py +100644 blob ba182ad70a91821daf85b71a7d8fe9095de86f62 tests/unit/test_path_planner_materialization.py +100644 blob fc677b518fa60ab44acf669517d6aec8c97242eb tests/unit/test_pattern_data_manager.py +100644 blob 7df244dfc0a7b8c4521e460c42d3fa1622eb6d15 tests/unit/test_persisted_image_metadata.py +100644 blob 9dd251927c6ddd1a9b714753c0ef1a7fd76066b1 tests/unit/test_persisted_semantic_metadata.py +100644 blob 33e78ad5f0b73b2631eb241585011bd820de3782 tests/unit/test_pipeline_definition.py +100644 blob 6ac305f5e61dd7f94f8beee0483915bca9e8249f tests/unit/test_pipeline_demo_contribution.py +100644 blob 4b58a23201b9997c2253598fcd049ad93f9d78aa tests/unit/test_pipeline_document.py +100644 blob e0dc6c586a8e22c62e746c8fd1e2a3cc32786e4d tests/unit/test_plane_store_sources.py +100644 blob fabf48fe17092243d7c4ac2f70b50c5f587dd739 tests/unit/test_plate_image_inventory.py +100644 blob 8232ddca811a1395e361a028aeaa370da8a8157e tests/unit/test_plate_manager_code_document.py +100644 blob 258892ccea1f78809c31fa53ca0459cf6fc8c857 tests/unit/test_polystore_disk_symlink.py +100644 blob 75fcbb1b4dbe3826392d02474ba8145a7de3e433 tests/unit/test_prepare_blind_neurite.py +100644 blob 517ae75b4b6ef6646ac312ba84de7d299fdaca9e tests/unit/test_primary_image_carrier_compile_gate.py +100644 blob 55534f1546f5d4a673212c75531fef9e548e42b2 tests/unit/test_primary_object_diagnostics.py +100644 blob 77f0c8b27aebabd6e75869446f499e9dc5218dc6 tests/unit/test_process_environment.py +100644 blob b92d38177758a07671e6876c3b05f16ec01561ce tests/unit/test_process_local_cache.py +100644 blob b221965354d7a77193f0eaf27618ec30d566f41b tests/unit/test_processing_preparation.py +100644 blob 4c76f45c320abc03433995d65b19b18ea3541a2a tests/unit/test_processor_method_strategies.py +100644 blob 25583a614424e30907c58435463fbb8ed902761d tests/unit/test_produced_plate_source_selection.py +100644 blob 91192c4fa8e1c056eb35909856b3aae4ee0d3977 tests/unit/test_projected_image_output.py +100644 blob 8a264d457ef0c62cd94ba79c37a775354762cef3 tests/unit/test_pycodify_formatters.py +100644 blob 16dba0261f6a13b893bcfc6c515b55893598e611 tests/unit/test_registry_owner_iteration.py +100644 blob ff38e90f8a1aa876e705d61d476e46283d36e8d1 tests/unit/test_release_readiness.py +100644 blob 404494825e3ac274d53d5ef23b4aef9b276e6358 tests/unit/test_repository_layout.py +100644 blob a62970c7468417c885d3883a9841413ec6a5fc23 tests/unit/test_returned_output_abi.py +100644 blob 10dbabf88ba4464e65791af9c4d66ad384cf51df tests/unit/test_roi_source_metadata.py +100644 blob 20c9490db7d0ec36d1619bebc315a4c4b60876a2 tests/unit/test_routed_channel_selection.py +100644 blob 0cb1384007e9a277dc69ef8c4905fab7b510fad9 tests/unit/test_routed_composite_execution.py +100644 blob ba7c2e308c17f509fe1f1fbfa87f1a1508f17cbb tests/unit/test_runner_cellprofiler_compatibility.py +100644 blob 28595b345a3b2417c7459ec6095135de3fe6b372 tests/unit/test_runtime_adapter_source_artifacts.py +100644 blob 105607d76d636223260e42c64d7b9c30d5a911ff tests/unit/test_runtime_artifact_queries.py +100644 blob 496d59aa51602501ec527445d5820c543e0abe3c tests/unit/test_runtime_callable_resolution.py +100644 blob 9d6c4040f06899b2ed6d1758ec5ba61cf8b7c47c tests/unit/test_runtime_equivalence.py +100644 blob 8c310d43e3f7c7d65057d47bac814e88ba3b0f6a tests/unit/test_runtime_equivalence_package.py +100644 blob 077d4a5e4171033de517aaec53cbc4c7a288a89c tests/unit/test_runtime_execution_validation.py +100644 blob 3e14b1eb6499b317d39ef9819a786cfb267c5032 tests/unit/test_runtime_exports.py +100644 blob d0b80fbb6a4789992e9f7c2945433fa6fe5fd62b tests/unit/test_runtime_image_singleton_alignment.py +100644 blob 168ff7b0b4afe7ef32258de29a66090d7b877b18 tests/unit/test_runtime_import_authority.py +100644 blob 5abd648bda9485be69d233f004c208c5e2b60fba tests/unit/test_runtime_object_label_domain_transitions.py +100644 blob 74eb8a2e32e43eeea35b16a69e54f6f87b996bbc tests/unit/test_runtime_output_matching.py +100644 blob 4211090b099c2be92c27368afb24b7255a9f8cd6 tests/unit/test_runtime_semantics.py +100644 blob 78aec1511f54d8d51cced51c8d4b4d777f06dc07 tests/unit/test_runtime_slice_projection.py +100644 blob 32a560f00f9b9fa6396be4ce4b232ab0acb2439d tests/unit/test_runtime_sparse_labels.py +100644 blob 78470ea371a000c4d8295082d87bbf926866b31c tests/unit/test_runtime_stack_cache_lifetime.py +100644 blob 7d04e130d965dd016b1251c69558f9ea1229938a tests/unit/test_runtime_tabular_values.py +100644 blob cd053fb9017708ed20f0b1a13532d9b0c9d5b241 tests/unit/test_runtime_value_store.py +100644 blob abe53ac83c3fc77e077d6dd8f19c770a680d46b7 tests/unit/test_runtime_values.py +100644 blob 67e045c4bc43c20d143644ac2b11aa1dd358aaf2 tests/unit/test_self_supervised_stitcher.py +100644 blob 67a666c24e346295b3e7e182034e5bf83cb58646 tests/unit/test_settings_binder.py +100644 blob 175c970aa12c981948249c97a907f9ee18cfabde tests/unit/test_skan_axon_artifact_contract.py +100644 blob cd3d85274191bd282e33910e7abf31c3105923cd tests/unit/test_skeletonize_and_save.py +100644 blob 5a378c4850be95c8316aa9ddd40c6ba1d65ca1a5 tests/unit/test_smoke_installed_gui.py +100644 blob ec5753cadf2f0a4572871f00096f375374343e73 tests/unit/test_smoke_installed_mcp.py +100644 blob 32436c252706ce09b51f306c8e28b0ccdc80939c tests/unit/test_source_binding_workspace.py +100644 blob 26df00c4c487c52d51aa58e0cf524f034e45a61a tests/unit/test_source_bindings.py +100644 blob 323f0322e5a63e20385113c323ca227bd0ea00a7 tests/unit/test_source_bindings_view.py +100644 blob f79d80899b8d512e90a889299e976756b7724791 tests/unit/test_source_bound_matched_image_set_anchors.py +100644 blob eae9118787ab6677a17ff76309e23cfd249ac76e tests/unit/test_source_image_provenance.py +100644 blob bf3e167d5007a42da20f83e8595237a66135575e tests/unit/test_source_image_provenance_hotpath.py +100644 blob b163730e829527b88c749206ffc66baa52df15f3 tests/unit/test_source_image_set_identity_policy.py +100644 blob 5243b09e56ec8cafcdec4c9ccbfdf14f1e563cb9 tests/unit/test_source_matching.py +100644 blob f4d338b4a21b35a9e713cacf72e49ef0e2dac881 tests/unit/test_source_path_factoring.py +100644 blob a2a590d50a85494ea83b043e27f84fbd68a985be tests/unit/test_source_projection.py +100644 blob 269f5e6a09ff22722b995d80a80b49e035985627 tests/unit/test_source_spatial_domain.py +100644 blob 4368d969679fd45b34e64ea3fc343a3e0424234d tests/unit/test_source_tile_geometry.py +100644 blob 6dc0145d26e7b259e64ffd94241948d3ef04d8a2 tests/unit/test_spatial_graph_materialization.py +100644 blob 632605501e4e305be3210d30967151a32c478092 tests/unit/test_stage_ci_candidate_version.py +100644 blob ddbf5ca4cbe97bfb9d76f9af7e9b640ac72cb605 tests/unit/test_step_snapshot.py +100644 blob d65078b4ab745da782b33651283df4eaf70b085b tests/unit/test_stream_component_semantics.py +100644 blob 2e7b98e48d971e3fdc940e830d3a748e8edde12a tests/unit/test_streaming_config_factory_registry.py +100644 blob 588da9dde323ef93f9251a72930b9bad09f5aa38 tests/unit/test_streaming_service.py +100644 blob e3de9ac3853e2de7d7584fe15c6d7fde4ec54640 tests/unit/test_successful_job_baseline.py +100644 blob 730f62799be88e40f9cf7f42eae94f31c3776df1 tests/unit/test_sync_mcp_release_metadata.py +100644 blob 3437193519dc8280953fbede9e953196c269f78f tests/unit/test_synthetic_generator_randomness.py +100644 blob 980fc4554e778520a181fadb34865fca82079be4 tests/unit/test_synthetic_imagexpress_bioformats_compatibility.py +100644 blob 472a81eec66d69336fe38fa84b4d4cc30ea5323e tests/unit/test_template_crop_pipeline_execution.py +100644 blob 5c4f670f95485a748a84b77125c461fb98ea98a5 tests/unit/test_tiff_metadata_mixin.py +100644 blob 7ada403ad4b5c23b9ad08b26153273ed30d8e047 tests/unit/test_tiff_output_compression.py +100644 blob 540772d58db9abc544e4b4d299a52dd128591272 tests/unit/test_time_travel_navigation.py +100644 blob 66f6f1d70cf15a0b9a0781038efa443294a3e021 tests/unit/test_ui_zmq_config_authority.py +100644 blob acafac1954adcc3549015e0636d505fd40e4ba85 tests/unit/test_unified_registry_runtime_payloads.py +100644 blob 8b3dc9f47402f0ada8c0de23cd3544029e62802d tests/unit/test_validate_documentation_audit.py +100644 blob 4d80ff06feb7070a8768b73a54db6d0fa25ef3ba tests/unit/test_validate_local_release_floors.py +100644 blob 40b1de24a8bbc8d10214526fd067137a1548f448 tests/unit/test_validate_wheel_deployment.py +100644 blob 10167c9c0a6368986ef9353ea5ad9f206aa98aae tests/unit/test_viewer_channel_display_metadata.py +100644 blob 0af191c811b20bf3a868210f5cd8665e31f07e0a tests/unit/test_viewer_feature_measurement.py +100644 blob 4428c562ac60dd3058fe0ccbb5293b579c1013f5 tests/unit/test_viewer_listener_binding.py +100644 blob 7c9cd31268bd36e2b1de2e22672f5d038e549692 tests/unit/test_viewer_protocol.py +100644 blob bad15efcafd185687b2089c4483b4a509659d501 tests/unit/test_viewer_receipt_replay.py +100644 blob d0d004d2a2611399008c235544e75f1552c15891 tests/unit/test_viewer_result_element_selection.py +100644 blob 8813b6eee1bee658920f0145ab083c8e9c7acc82 tests/unit/test_viewer_source_projection_chain.py +100644 blob 418674246c01c18262f232019a15e16efa95136c tests/unit/test_volume_projection_fixture.py +100644 blob afd8f2e7efba1f07a3efb7b61d66f1cc207e6592 tests/unit/test_wait_for_pypi_release.py +100644 blob 7628addf81f152cf5f14714ad70d65b155709ff5 tests/unit/test_well_filter_processor.py +100644 blob 2ab8ddd50e0886238225935753ffa2c035cb4c25 tests/unit/test_well_throughput_scaling.py +100644 blob 0ba78f569b28ec65be6ab05c5bf98771466e746a tests/unit/test_worker_profiling.py +100644 blob 53450c19f06b797df0f1d16855df4c1ebb038c53 tests/unit/test_worker_start_policy.py +100644 blob a467dfae1c1f24a35d5db9eb68e34679c430c310 tests/unit/test_yeast_output_identity.py +100644 blob a2804c29bd6d30bd995f094f5134ec30551c3137 tests/unit/test_zarr_config_owner.py +100644 blob f71ffd793ce15f285e7e9ceab929eadead59cf6f tests/unit/test_zmq_application.py +100644 blob 252c76b642ea3adacc298c976c1f2126ddd8a4c0 tests/unit/test_zmq_compilation.py +100644 blob 445a09764faa151dbd5c112043b249e878c71d3d tests/unit/test_zmq_compilation_identity.py +100644 blob 476ccabb38441468b917037f29e36e57b7722a24 tests/unit/test_zmq_compiled_pipeline_run.py +100644 blob 45e8070fa379c57a9be17370aad4184dd8e67c8f tests/unit/test_zmq_execution_server.py +100644 blob d5c58ede8d8bbd5f88a41d40bab95658696b095d tests/unit/test_zmq_execution_server_process.py +100644 blob c93eab23f10968a9e7e747a53354bd35dc3012a7 tests/unit/test_zmq_orchestrator_environment.py +100644 blob 3edbb443cb40b7da7e905f2a2fa4cc0b4c60b9fc tests/unit/test_zmq_port_pair_authority.py +100644 blob 16ee0d55bff4f7ae665c84718d384a4ac0e7a839 tests/unit/test_zmq_progress.py +100644 blob f358c89ca1373cac5e5c2e59e1047f61b9e487ec tests/unit/test_zmq_runtime_outcome_export.py +100644 blob 0b4c857c7878248de60675902ae96a00f75c8dcc tests/unit/test_zmq_submission_timeout.py +100644 blob 4569f25ddaf400b62a9737884a1419cf1143c6aa tools/reproduce_issue257_filename_identity.py +100644 blob e6e4b5a7e3e12e86a559404e1d6b260ce17e35e7 website/assets/agent/cold-start-workflow-pipeline.py diff --git a/docs/validation/runtime_owner_sync_323_20261001.rst b/docs/validation/runtime_owner_sync_323_20261001.rst new file mode 100644 index 0000000000..9179812109 --- /dev/null +++ b/docs/validation/runtime_owner_sync_323_20261001.rst @@ -0,0 +1,119 @@ +Runtime ownership after main synchronization (#323, #336) +======================================================= + +Production source ``f7b39a2a49ce07134d58ef8ae61c85e2395fd93f`` includes main +``f24a828da16691b83284622a01e1765b1d147e66`` and its exact dependency pins, +including PolyStore ``84f322e``. PR331's completed Official30 qualification +repairs are integrated. This note supersedes older source cohorts for current +qualification; their receipts remain historical counterevidence. + +The warmed-parent review fix +--------------------------- + +``ProcessLocalBoundedCache`` declares one process-local singleton per concrete +subclass. Previously a child could inherit a warmed parent's singleton and its +values. The shared owner's cooperative subclass hook now initializes its own +singleton field and construction lock at each declaration. ``BoundedCache`` +still owns LRU storage, ``SynchronizedBoundedCache`` owns instance mutation +locking, and the existing metaclass owns registration and cleanup views. +There is no consumer workaround, mirror registry or runtime type fallback. + +The slotted dataclass replaces its class object, so the cooperative super call +names the final public owner. Executed controls cover plain, registered and +identity-bound warmed parents; eight-way concurrent child construction; slotted +dataclass children; warmed synchronized diamonds; actual hook/MRO cooperation; +bounded LRU behavior; and registered cleanup. Four new inheritance controls +fail on the unmodified owner. All corrected controls pass. This semantic +initialization change is authored; a syntax guard is not an equivalence proof. + +Test-context isolation +---------------------- + +Two existing source-projection integration tests install an ImageXpress global +configuration without restoring the incoming saved/live projections. On +unchanged main, the checkpoint module passes 2/2 alone but the ordered source +projection/checkpoint modules fail 2/101 for missing HTD metadata. The actual +fixture declares an OpenHCS workspace, so fabricating HTD files or changing +microscope admission would hide the leak. + +The two tests now scope their edits through the existing nominal +``objectstate.global_config.GlobalContextValues.capture(...).apply()`` owner, +including absent incoming contexts. No blanket reset is added to unrelated +tests. The corrected ordered and broad controls retain strict original pixel, +address, source shape and 0.65 calibration assertions. This resolves #336. + +Current validation +------------------ + +* 1,538 local tests and 42 subtests pass; one optional Napari skip and two + unchanged watershed warnings. Main's latest acquisition filename ownership + change is integrated and its source-contract tests are included. +* Original CI-pinned R0 passes for all three roots without increases. +* Original NRA R1 passes both configured detectors with complete dependency + context and no increases. This does not claim all-detector cleanliness. +* Original ClassDef census before/after: 5,129 declarations, 5,117 projected, + all 12 OPEN retained. No new production class/registry authority is introduced + by this review fix. +* Full native-reference qualification passes 30/30, every difference count zero. + Existing 1e-6 absolute/relative numerical tolerances and exact discrete/identity + and declared-image checks remain. Retained native outputs are scientific + references; their clocks/speedup columns are not fresh performance evidence. + +Matched ordinary timing +----------------------- + +The public throughput route runs a source-asserting main/candidate/candidate/main +sequence for each case, CPU5, one well and one numerical thread, current pins and +the shared persistent Numba cache. All eight observations succeed. Means of two +samples per side, in seconds: + +These ordinary timing receipts identify the prior synchronized production +``68aed451f`` and main ``8c512d404``. They are not relabeled as measurements of +the newer acquisition parser integration. The full native and local/structural +gates above were repeated on the latest production source. + +.. list-table:: Main / candidate pipeline clocks + :header-rows: 1 + + * - Case + - Compile + - Execute + - Total + * - ImagingFlow + - 1.522 / 1.876 + - 14.482 / 14.573 + - 16.682 / 17.126 + * - Advanced segmentation + - 1.874 / 1.992 + - 9.442 / 8.999 + - 12.386 / 12.101 + +ImagingFlow total is 0.444s higher on this branch, including 0.354s compilation; +the execution difference is 0.092s. Advanced segmentation execution is 0.443s +lower. These small samples do not establish neutrality or a general speedup. +The remaining performance target is open under #162. This PR repairs ownership +and review correctness; it does not claim that the latency target is achieved. + +Pipeline clocks exclude ready-server startup and shutdown. Mandatory registry +and kernel preparation precedes clocks. No tests, audits, builds or other replays +overlap timed pipelines. The ordinary throughput route retains its standard +memory observer; the native qualification uses no memory observer. Their +observation scopes are distinct and their clocks are not pooled. + +Receipts +-------- + +``runtime_owner_sync_323_evidence_20261001.tgz`` includes exact source/pin and +controller recipes, the explicit ownership decision, main and warmed-parent +negative controls, test logs/XML, original guards/census, final 30 native +observations/generated sources/measured receipts, and all eight ordinary timing +observations. ``SHA256SUMS`` authenticates included files. Large scientific +inputs and outputs remain in the benchmark workspace. + +Reproduce using the included source-asserting recipes and the configured shared +benchmark Python. The native recipe requires the retained reference manifest +``official30-native-complete-fresh-20260928/observations.csv``; when absent, +produce new references through the public native comparison route with the +configured CellProfiler environment. Native startup/ROI/scaling figure work +remains in the continuing performance goal. Removed private import paths remain +an explicit dynamic external boundary; no compatibility forwarding is restored. diff --git a/docs/validation/runtime_owner_sync_323_evidence_20261001.tgz b/docs/validation/runtime_owner_sync_323_evidence_20261001.tgz new file mode 100644 index 0000000000..65704fb6b7 Binary files /dev/null and b/docs/validation/runtime_owner_sync_323_evidence_20261001.tgz differ diff --git a/openhcs/core/measurement_feature_queries.py b/openhcs/core/measurement_feature_queries.py index c53ff16c64..15acdfb0d7 100644 --- a/openhcs/core/measurement_feature_queries.py +++ b/openhcs/core/measurement_feature_queries.py @@ -31,6 +31,7 @@ ) from openhcs.core.process_local_cache import ( IdentityBoundProcessCache, + BoundedCache, RegisteredProcessLocalBoundedCache, identity_owner_tuples_match, ) @@ -151,6 +152,15 @@ def __post_init__(self) -> None: ) +class RuntimeObjectLabelMeasurementQueryCache( + BoundedCache[ + RuntimeObjectLabelMeasurementQuery, + tuple[np.ndarray, ...], + ] +): + """Store-owned label-aligned values keyed by their full nominal query.""" + + def _diagnostic_value(value: object | None) -> str: if value is None or value == "": return _DIAGNOSTIC_NONE diff --git a/openhcs/core/measurement_row_materialization.py b/openhcs/core/measurement_row_materialization.py index cfc52af924..ac6c9bf6fa 100644 --- a/openhcs/core/measurement_row_materialization.py +++ b/openhcs/core/measurement_row_materialization.py @@ -150,6 +150,21 @@ def measurement_table_axis_values( ] +class ObjectMeasurementColumnarRows(ColumnarRows, ABC): + """Object measurement columns spanning their declared label domain.""" + + @property + def covers_declared_object_measurement_domain(self) -> bool: + """Object-measurement carriers span their declared label domain.""" + return True + + def __len__(self) -> int: + return self.row_count() + + def __iter__(self): + yield from self.iter_row_mappings() + + class MeasurementRowDeclaredValue(ABC, metaclass=AutoRegisterMeta): """Nominal declaration for values projected from a measurement row.""" diff --git a/openhcs/core/process_local_cache.py b/openhcs/core/process_local_cache.py index c0685f96fd..cf774a7562 100644 --- a/openhcs/core/process_local_cache.py +++ b/openhcs/core/process_local_cache.py @@ -1,4 +1,4 @@ -"""Small process-local cache substrates for immutable runtime projections.""" +"""Shared bounded values and process-local cache lifetime policies.""" from __future__ import annotations @@ -6,6 +6,8 @@ from dataclasses import dataclass, field from collections.abc import Sequence from typing import Any, ClassVar, Generic, TypeVar +from threading import Lock +from _thread import LockType from metaclass_registry import AutoRegisterMeta @@ -40,8 +42,8 @@ def named_identity_owner_tuples_match( @dataclass(slots=True) -class ProcessLocalBoundedCache(Generic[CacheKey, CachedValue]): - """Bounded LRU cache with one singleton instance per concrete subclass.""" +class BoundedCache(Generic[CacheKey, CachedValue]): + """Bounded LRU values with lifetime supplied by their owning consumer.""" max_entries: int = 4096 entries: OrderedDict[CacheKey, CachedValue] = field(default_factory=OrderedDict) @@ -61,15 +63,48 @@ def store_value(self, key: CacheKey, value: CachedValue) -> CachedValue: return value def clear(self) -> None: - """Discard all values retained by this process-local cache instance.""" + """Discard all values retained by this cache instance.""" self.entries.clear() + +@dataclass +class SynchronizedBoundedCache(BoundedCache[CacheKey, CachedValue]): + """Bounded storage whose individual mutations share one instance lock.""" + + _lock: LockType = field(default_factory=Lock, init=False, repr=False, compare=False) + + def cached_value(self, key: CacheKey) -> CachedValue | None: + with self._lock: + return super().cached_value(key) + + def store_value(self, key: CacheKey, value: CachedValue) -> CachedValue: + with self._lock: + return super().store_value(key, value) + + def clear(self) -> None: + with self._lock: + super().clear() + + +@dataclass(slots=True) +class ProcessLocalBoundedCache(BoundedCache[CacheKey, CachedValue]): + """Bounded values with one process-local singleton per concrete subclass.""" + + def __init_subclass__(cls, **kwargs) -> None: + # slots=True replaces the dataclass; name its final class for cooperative super. + super(ProcessLocalBoundedCache, cls).__init_subclass__(**kwargs) + cls._process_cache = None + cls._process_cache_lock = Lock() + @classmethod def process_cache(cls) -> "ProcessLocalBoundedCache[CacheKey, CachedValue]": cache = cls._process_cache if cache is None: - cache = cls() - cls._process_cache = cache + with cls._process_cache_lock: + cache = cls._process_cache + if cache is None: + cache = cls() + cls._process_cache = cache return cache @classmethod @@ -80,6 +115,7 @@ def clear_process_cache(cls) -> None: cache.clear() _process_cache: ClassVar["ProcessLocalBoundedCache[object, object] | None"] = None + _process_cache_lock: ClassVar[LockType] = Lock() @dataclass(slots=True) diff --git a/openhcs/core/processing_preparation.py b/openhcs/core/processing_preparation.py index 01ab268b71..e51440b48d 100644 --- a/openhcs/core/processing_preparation.py +++ b/openhcs/core/processing_preparation.py @@ -13,6 +13,7 @@ from itertools import islice from multiprocessing.connection import Connection, wait from multiprocessing.process import BaseProcess +from pathlib import Path from threading import Lock from typing import ClassVar @@ -23,6 +24,30 @@ CompilerPreparedAutoRegisterFamily, ) from openhcs.core.function_contract_metadata import FunctionContractAttribute +from openhcs.utils.environment import OpenHCSProcessEnvironment + + +class PersistentNumbaKernelPreparation(CompilerPreparedAutoRegisterFamily): + """Admit persistent Numba work only for an empty explicit CPU cache.""" + + @classmethod + def requires_persistent_kernel_cache(cls) -> bool: + """Declared pure kernel operations require a persistent Numba cache.""" + return True + + @classmethod + def can_prepare_in_child(cls) -> bool: + if not OpenHCSProcessEnvironment.cpu_only_mode(): + return False + if not cls.requires_persistent_kernel_cache(): + return False + from numba import config as numba_config + + cache_directory = numba_config.CACHE_DIR + return ( + bool(cache_directory) + and next(Path(cache_directory).rglob("*.nbi"), None) is None + ) class PreparationOperation(ABC): @@ -66,6 +91,33 @@ def reset(cls) -> None: AutoRegisterRegistryPreparation.cached_module_registry_families.cache_clear() +class RegisteredNumbaKernelPreparation( + PersistentNumbaKernelPreparation, PreparationOperation +): + """Derive independent pure-kernel obligations from each declared registry. + + This abstract parent has no registry. Concrete AutoRegisterMeta declarations + own their registries; the common parent owns identity, operation derivation + and successful parent preparation. + """ + + __registry_key__ = "__name__" + __registry__: ClassVar[dict[str, type[RegisteredNumbaKernelPreparation]]] + + @property + def identity(self) -> Hashable: + return type(self) + + @classmethod + def cache_preparation_operations(cls) -> tuple[PreparationOperation, ...]: + return tuple(declaration() for declaration in cls.__registry__.values()) + + @classmethod + def prepare_registered_family(cls) -> None: + for operation in cls.cache_preparation_operations(): + operation.prepare() + + @dataclass(frozen=True, slots=True) class RegistryFamilyPreparation(PreparationOperation): """Execute a family's declared warmup and project its admitted child work.""" diff --git a/openhcs/core/runtime_artifact_queries.py b/openhcs/core/runtime_artifact_queries.py index 9af87851cb..260fd32914 100644 --- a/openhcs/core/runtime_artifact_queries.py +++ b/openhcs/core/runtime_artifact_queries.py @@ -6,7 +6,6 @@ from dataclasses import dataclass from types import MappingProxyType from typing import TYPE_CHECKING, Any, cast -from weakref import WeakKeyDictionary import numpy as np @@ -39,6 +38,7 @@ resolve_runtime_measurement_lookup_dialect, ) from openhcs.core.process_local_cache import ( + BoundedCache, RegisteredProcessLocalBoundedCache, identity_owner_tuples_match, named_identity_owner_tuples_match, @@ -81,10 +81,14 @@ if TYPE_CHECKING: from openhcs.core.runtime_stores import RuntimeValueStore, StoredRuntimeValue -_MEASUREMENT_TABLE_CACHE: WeakKeyDictionary[ - RuntimeValueStore, - dict[tuple[int, str, str | None], tuple[MeasurementTable, ...]], -] = WeakKeyDictionary() + +class RuntimeMeasurementTablesQueryCache( + BoundedCache[ + tuple[str, str | None], + tuple[MeasurementTable, ...], + ] +): + """Store-owned measurement tables for one axis and component group.""" MeasurementLabelSliceFeatureBatchCacheValue = tuple[ @@ -433,20 +437,16 @@ def runtime_measurement_tables( context: RuntimeArtifactQueryContext, ) -> tuple[MeasurementTable, ...]: """Return all measurement tables in a runtime query context.""" - cache_key = (context.store.revision, context.axis_id, context.group_key) - store_cache = _MEASUREMENT_TABLE_CACHE.setdefault(context.store, {}) - cached = store_cache.get(cache_key) + cache_key = (context.axis_id, context.group_key) + store_cache = context.store.query_cache(RuntimeMeasurementTablesQueryCache) + cached = store_cache.cached_value(cache_key) if cached is not None: return cached tables = tuple( cast(MeasurementTable, record.value.data) for record in context.find(artifact_type=MeasurementsArtifactType) ) - for key in tuple(store_cache): - if key[0] != context.store.revision: - del store_cache[key] - store_cache[cache_key] = tables - return tables + return store_cache.store_value(cache_key, tables) def runtime_measurement_tables_for_object( diff --git a/openhcs/core/runtime_profile.py b/openhcs/core/runtime_profile.py index 7b9ae1ced4..cca04bf934 100644 --- a/openhcs/core/runtime_profile.py +++ b/openhcs/core/runtime_profile.py @@ -55,3 +55,16 @@ def log( if profile_path := os.environ.get(PROFILE_RUNTIME_PATH_ENV): with open(profile_path, "a", encoding="utf-8") as handle: handle.write(f"RUNTIME_PROFILE {label} {seconds:.6f}s {field_text}\n") + + +@dataclass(frozen=True, slots=True) +class RuntimeProfiler: + """Runtime-profile emitter bound to a module logger.""" + + logger: logging.Logger + + def enabled(self) -> bool: + return RuntimeProfileLogger.enabled() + + def log(self, label: str, seconds: float, **fields: object) -> None: + RuntimeProfileLogger.log(self.logger, label, seconds, **fields) diff --git a/openhcs/core/runtime_stores.py b/openhcs/core/runtime_stores.py index fb4362411a..d2840af84d 100644 --- a/openhcs/core/runtime_stores.py +++ b/openhcs/core/runtime_stores.py @@ -8,7 +8,7 @@ import inspect from pathlib import Path from types import MappingProxyType -from typing import Any +from typing import Any, TypeVar, cast from python_introspect import RuntimeParameterDeclarationABC @@ -26,6 +26,7 @@ ComponentGroupScope, ) from openhcs.core.component_set import ComponentSet +from openhcs.core.process_local_cache import BoundedCache from openhcs.core.function_patterns import InvocationArtifactInputEdgePlan from openhcs.core.runtime_artifact_values import ( ArtifactKey, @@ -811,6 +812,9 @@ def to_dict(self) -> dict[str, Any]: return dict(payload) +StoreQueryCacheT = TypeVar("StoreQueryCacheT", bound=BoundedCache[Any, Any]) + + class RuntimeValueStore: """Source of truth for validated runtime artifact values in one context.""" @@ -822,6 +826,10 @@ def __init__(self) -> None: self._observation_records: list[StoredRuntimeValue] = [] self._current_location_by_key: dict[ArtifactKey, RuntimeArtifactLocation] = {} self._revision = 0 + self._query_caches: dict[ + type[BoundedCache[Any, Any]], + BoundedCache[Any, Any], + ] = {} self._find_cache: dict[ tuple[ int, @@ -840,6 +848,27 @@ def __init__(self) -> None: tuple[StoredRuntimeValue, ...], ] = {} + def query_cache(self, cache_type: type[StoreQueryCacheT]) -> StoreQueryCacheT: + """Return a bounded derived-value cache owned by this store's lifetime. + + Concrete cache types separate query domains. Every store mutation clears + their values; transport reconstructs the store without derived caches. + """ + cache = self._query_caches.get(cache_type) + if cache is None: + cache = cache_type() + self._query_caches[cache_type] = cache + return cast(StoreQueryCacheT, cache) + + def __getstate__(self) -> dict[str, object]: + state = dict(self.__dict__) + del state["_query_caches"] + return state + + def __setstate__(self, state: dict[str, object]) -> None: + self.__dict__.update(state) + self._query_caches = {} + @staticmethod def address_matches_plan( address: RuntimeArtifactAddress, @@ -1098,6 +1127,8 @@ def _current_record(self, key: ArtifactKey) -> StoredRuntimeValue | None: def _mark_mutated(self) -> None: self._revision += 1 + for cache in self._query_caches.values(): + cache.clear() self._find_cache.clear() self._find_matching_cache.clear() diff --git a/openhcs/interop/cellprofiler/runtime/object_label_measurements.py b/openhcs/interop/cellprofiler/runtime/object_label_measurements.py index 5a442aa771..19c2890811 100644 --- a/openhcs/interop/cellprofiler/runtime/object_label_measurements.py +++ b/openhcs/interop/cellprofiler/runtime/object_label_measurements.py @@ -4,7 +4,6 @@ from dataclasses import dataclass from typing import TYPE_CHECKING, cast -from weakref import WeakKeyDictionary import numpy as np @@ -14,6 +13,7 @@ ObjectLabelsArtifactType, ) from openhcs.core.measurement_feature_queries import ( + RuntimeObjectLabelMeasurementQueryCache, MeasurementFeatureQuery, RuntimeObjectLabelMeasurementQuery, RuntimeObjectSliceMeasurementQuery, @@ -34,7 +34,6 @@ ObjectLabelMeasurementValues, ) from openhcs.core.runtime_slice_alignment import RuntimeSliceAlignedValues -from openhcs.core.runtime_stores import RuntimeValueStore from openhcs.interop.cellprofiler.measurement_dialect import ( CELLPROFILER_MEASUREMENT_LOOKUP_DIALECT, ) @@ -48,29 +47,6 @@ if TYPE_CHECKING: from openhcs.interop.cellprofiler.runtime.adapter import CellProfilerRuntimeAdapter -ObjectLabelMeasurementValuesProcessCache = dict[ - RuntimeObjectLabelMeasurementQuery, - tuple[np.ndarray, ...], -] - -_OBJECT_LABEL_MEASUREMENT_VALUES_PROCESS_CACHE: WeakKeyDictionary[ - RuntimeValueStore, - tuple[int, ObjectLabelMeasurementValuesProcessCache], -] = WeakKeyDictionary() - - -def object_label_measurement_values_cache( - store: RuntimeValueStore, -) -> ObjectLabelMeasurementValuesProcessCache: - """Return label-aligned vectors bound to the store's current revision.""" - cached_revision = _OBJECT_LABEL_MEASUREMENT_VALUES_PROCESS_CACHE.get(store) - if cached_revision is not None and cached_revision[0] == store.revision: - return cached_revision[1] - cache: ObjectLabelMeasurementValuesProcessCache = {} - _OBJECT_LABEL_MEASUREMENT_VALUES_PROCESS_CACHE[store] = (store.revision, cache) - return cache - - @dataclass(frozen=True, slots=True, kw_only=True) class ObjectFeatureMeasurementContext(RuntimeObjectSliceMeasurementQuery): """Nominal context for one object-feature measurement lookup.""" @@ -242,10 +218,12 @@ def values( """Return object measurements aligned to this request's label planes.""" label_domain = self.label_domain() query = self.measurement_query(adapter, label_domain=label_domain) - object_label_values_cache = object_label_measurement_values_cache( - adapter.request.context.runtime_value_store + object_label_values_cache = ( + adapter.request.context.runtime_value_store.query_cache( + RuntimeObjectLabelMeasurementQueryCache + ) ) - cached = object_label_values_cache.get(query) + cached = object_label_values_cache.cached_value(query) if cached is not None: return cached child_name = child_count_feature_child_name(self.feature_name) @@ -299,8 +277,7 @@ def values( plane_projector=adapter, dialect=CELLPROFILER_MEASUREMENT_LOOKUP_DIALECT, ).values_for_labels(self.labels) - object_label_values_cache[query] = values - return values + return object_label_values_cache.store_value(query, values) @dataclass(frozen=True, slots=True, kw_only=True) diff --git a/openhcs/interop/cellprofiler/runtime/object_measurement_vectors.py b/openhcs/interop/cellprofiler/runtime/object_measurement_vectors.py index f0c66292d4..858e1e7ce8 100644 --- a/openhcs/interop/cellprofiler/runtime/object_measurement_vectors.py +++ b/openhcs/interop/cellprofiler/runtime/object_measurement_vectors.py @@ -21,7 +21,10 @@ MeasurementLabelSliceFeatureQuery, MeasurementLabelSliceFeatureBatchQuery, ) -from openhcs.core.measurement_feature_queries import MeasurementFeatureQuery +from openhcs.core.measurement_feature_queries import ( + MeasurementFeatureQuery, + RuntimeObjectLabelMeasurementQueryCache, +) from openhcs.core.measurement_row_materialization import measurement_rows from openhcs.core.runtime_measurements import ( MeasurementRowAxisField, @@ -49,7 +52,6 @@ ) from openhcs.interop.cellprofiler.runtime.object_label_measurements import ( ObjectLabelMeasurementSliceRequest, - object_label_measurement_values_cache, ) from openhcs.interop.cellprofiler.runtime.object_measurement_tables import ( ObjectMeasurementTableIndex, @@ -597,25 +599,25 @@ def cache_runtime_batch_vectors( vectors: Mapping[str, tuple[np.ndarray, ...]], bindings: tuple[CellProfilerObjectMeasurementVectorBinding, ...], ) -> None: - process_cache = object_label_measurement_values_cache( - adapter.request.context.runtime_value_store + store_cache = adapter.request.context.runtime_value_store.query_cache( + RuntimeObjectLabelMeasurementQueryCache ) for binding in bindings: values = vectors[binding.object_name] query = binding.measurement_query(adapter) - process_cache[query] = values + store_cache.store_value(query, values) def cached_runtime_batch_vectors( self, adapter: "CellProfilerRuntimeAdapter", ) -> dict[str, tuple[np.ndarray, ...]]: - process_cache = object_label_measurement_values_cache( - adapter.request.context.runtime_value_store + store_cache = adapter.request.context.runtime_value_store.query_cache( + RuntimeObjectLabelMeasurementQueryCache ) cached_vectors: dict[str, tuple[np.ndarray, ...]] = {} for binding in self.bindings: query = binding.measurement_query(adapter) - cached = process_cache.get(query) + cached = store_cache.cached_value(query) if cached is not None: cached_vectors[binding.object_name] = cached return cached_vectors diff --git a/openhcs/processing/backends/cellprofiler/_backend.py b/openhcs/processing/backends/cellprofiler/_backend.py index ed20dbf29b..e37742d5b1 100644 --- a/openhcs/processing/backends/cellprofiler/_backend.py +++ b/openhcs/processing/backends/cellprofiler/_backend.py @@ -12,14 +12,9 @@ from metaclass_registry import AutoRegisterMeta from openhcs.constants.constants import MemoryType -from openhcs.core.callable_contract import ( - CallableContract, - CompilerPreparedAutoRegisterFamily, -) +from openhcs.core.callable_contract import CallableContract +from openhcs.core.processing_preparation import PersistentNumbaKernelPreparation from openhcs.core.runtime_plane_projection import RuntimeSliceInvariantValue -from openhcs.processing.backends.cellprofiler._preparation import ( - CellProfilerKernelCachePreparationMixin, -) class CellProfilerBackendProvider(str, Enum): @@ -280,9 +275,7 @@ def backend_key( ) -class CellProfilerBackendStrategyMixin( - CellProfilerKernelCachePreparationMixin, CompilerPreparedAutoRegisterFamily -): +class CellProfilerBackendStrategyMixin(PersistentNumbaKernelPreparation): """Mixin for backend strategies keyed by OpenHCS memory type and provider. Concrete strategy families keep their own AutoRegisterMeta registry; this diff --git a/openhcs/processing/backends/cellprofiler/_preparation.py b/openhcs/processing/backends/cellprofiler/_preparation.py index f28f94686f..933a8a3795 100644 --- a/openhcs/processing/backends/cellprofiler/_preparation.py +++ b/openhcs/processing/backends/cellprofiler/_preparation.py @@ -2,55 +2,12 @@ from __future__ import annotations -from collections.abc import Hashable -from pathlib import Path -from typing import ClassVar - -from openhcs.core.callable_contract import CompilerPreparedAutoRegisterFamily -from openhcs.core.processing_preparation import PreparationOperation -from openhcs.utils.environment import OpenHCSProcessEnvironment +from openhcs.core.processing_preparation import RegisteredNumbaKernelPreparation from openhcs.processing.backends.cellprofiler.perf_fixtures import capture_enabled -class CellProfilerKernelCachePreparationMixin: - """Admit persistent Numba work only for an empty explicit CPU cache.""" - - @classmethod - def requires_persistent_kernel_cache(cls) -> bool: - """Declared pure kernel operations require a persistent Numba cache.""" - return True - - @classmethod - def can_prepare_in_child(cls) -> bool: - if not OpenHCSProcessEnvironment.cpu_only_mode(): - return False - if not cls.requires_persistent_kernel_cache(): - return False - from numba import config as numba_config - - cache_directory = numba_config.CACHE_DIR - return ( - bool(cache_directory) - and next(Path(cache_directory).rglob("*.nbi"), None) is None - ) - - -class CellProfilerCallableKernelPreparation( - CellProfilerKernelCachePreparationMixin, - PreparationOperation, - CompilerPreparedAutoRegisterFamily, -): - """Own pure kernel work; concrete declarations own independent registries. - - This abstract protocol has no registry. AutoRegisterMeta creates one on - each direct concrete declaration, deriving child work from the existing - module registry discovery without inspecting callable or module hooks. - Parent registry preparation owns kernel readiness. Generic callable hooks - retain their independent completion and effect phase. - """ - - __registry_key__ = "__name__" - __registry__: ClassVar[dict[str, type[CellProfilerCallableKernelPreparation]]] +class CellProfilerCallableKernelPreparation(RegisteredNumbaKernelPreparation): + """Keep CellProfiler fixture capture in the parent processing hook.""" @classmethod def can_prepare_in_child(cls) -> bool: @@ -59,17 +16,8 @@ def can_prepare_in_child(cls) -> bool: return False return super().can_prepare_in_child() - @property - def identity(self) -> Hashable: - return type(self) - - @classmethod - def cache_preparation_operations(cls) -> tuple[PreparationOperation, ...]: - return tuple(declaration() for declaration in cls.__registry__.values()) - @classmethod def prepare_registered_family(cls) -> None: if capture_enabled(): return - for operation in cls.cache_preparation_operations(): - operation.prepare() + super().prepare_registered_family() diff --git a/openhcs/processing/backends/cellprofiler/colocalization.py b/openhcs/processing/backends/cellprofiler/colocalization.py index 6f55926076..12e4d220ff 100644 --- a/openhcs/processing/backends/cellprofiler/colocalization.py +++ b/openhcs/processing/backends/cellprofiler/colocalization.py @@ -37,6 +37,7 @@ ConcatenatedColumnarRows, DataclassMeasurementColumnarRows, MeasurementProjectedColumnarRows, + ObjectMeasurementColumnarRows, ) from openhcs.core.pipeline.function_contracts import ( ObjectLabelInputExecutionMode, @@ -157,12 +158,7 @@ object_colocalization_threshold_reductions, thresholded_colocalization_metrics, ) -from openhcs.processing.backends.cellprofiler.granularity import ( - CellProfilerRuntimeProfiler, -) -from openhcs.processing.backends.cellprofiler.object_measurement_columnar_rows import ( - LongObjectMeasurementColumnarRows, -) +from openhcs.core.runtime_profile import RuntimeProfiler from openhcs.processing.backends.lib_registry.unified_registry import ProcessingContract from openhcs.interop.cellprofiler.runtime.artifact_binding import ( RuntimeInputBindingRequest, @@ -1228,7 +1224,7 @@ def run_all_metrics_enabled(value: str, binder: "SettingsBinder") -> bool: logger = logging.getLogger(__name__) -runtime_profiler = CellProfilerRuntimeProfiler(logger) +runtime_profiler = RuntimeProfiler(logger) _COLOCALIZATION_MEASUREMENT_FUNCTION = "_colocalization_measurement" ColocalizationDenseLabelProjectionIdentity = tuple[tuple[str, Hashable], ...] @@ -2013,7 +2009,7 @@ def columns_for( @dataclass(frozen=True, slots=True) -class ObjectColocalizationColumnarMeasurements(LongObjectMeasurementColumnarRows): +class ObjectColocalizationColumnarMeasurements(ObjectMeasurementColumnarRows): """Columnar object-colocalization rows preserving direct row iteration.""" fields: ClassVar[tuple[FieldSpec, ...]] = FieldSpec.from_dataclass_type( diff --git a/openhcs/processing/backends/cellprofiler/granularity.py b/openhcs/processing/backends/cellprofiler/granularity.py index ce6ff80943..01dc63bb86 100644 --- a/openhcs/processing/backends/cellprofiler/granularity.py +++ b/openhcs/processing/backends/cellprofiler/granularity.py @@ -2,15 +2,14 @@ from __future__ import annotations +from openhcs.core.runtime_profile import RuntimeProfiler + from abc import ABC, abstractmethod -from collections import OrderedDict from collections.abc import Callable, Mapping from dataclasses import dataclass, field, fields as dataclass_fields import hashlib import logging -import os import re -from threading import Lock import time from types import MappingProxyType from typing import ClassVar @@ -43,8 +42,12 @@ ) from openhcs.core.measurement_row_materialization import ( DataclassMeasurementColumnarRows, + ObjectMeasurementColumnarRows, +) +from openhcs.core.process_local_cache import ( + RegisteredProcessLocalBoundedCache, + SynchronizedBoundedCache, ) -from openhcs.core.runtime_profile import RuntimeProfileLogger from openhcs.core.runtime_tabular_values import ( FieldSpec, ) @@ -87,9 +90,6 @@ CellProfilerBackendProvider, CellProfilerBackendStrategyMixin, ) -from openhcs.processing.backends.cellprofiler.object_measurement_columnar_rows import ( - LongObjectMeasurementColumnarRows, -) from openhcs.processing.backends.lib_registry.unified_registry import ProcessingContract from openhcs.processing.backends.cellprofiler._granularity_native import ( reconstruct_f32 as _reconstruct_f32, @@ -325,29 +325,10 @@ def bind_settings( ) -_PROFILE_RUNTIME_ENV = "OPENHCS_PROFILE_FUNCTION_RUNTIME" logger = logging.getLogger(__name__) -def profile_enabled() -> bool: - """Return whether per-function granularity runtime profiling is enabled.""" - return os.environ.get(_PROFILE_RUNTIME_ENV, "").lower() in {"1", "true", "yes"} - - -@dataclass(frozen=True, slots=True) -class CellProfilerRuntimeProfiler: - """Shared CellProfiler runtime-profile emitter bound to a module logger.""" - - logger: logging.Logger - - def enabled(self) -> bool: - return profile_enabled() - - def log(self, label: str, seconds: float, **fields: object) -> None: - RuntimeProfileLogger.log(self.logger, label, seconds, **fields) - - -runtime_profiler = CellProfilerRuntimeProfiler(logger) +runtime_profiler = RuntimeProfiler(logger) def log_profile(label: str, seconds: float, **fields: object) -> None: @@ -461,7 +442,7 @@ def object_granularity_measurement_value_fields() -> tuple[str, ...]: @dataclass(frozen=True, slots=True) -class ObjectGranularityMeasurementRows(LongObjectMeasurementColumnarRows): +class ObjectGranularityMeasurementRows(ObjectMeasurementColumnarRows): """Columnar object granularity rows over the emitted label-id domain.""" fields: ClassVar[tuple[FieldSpec, ...]] = FieldSpec.from_dataclass_type( @@ -728,12 +709,11 @@ def series(self) -> GranularityImageSeries: int(self.element_radius), int(self.spectrum_length), ) - with GRANULARITY_IMAGE_SERIES_CACHE_LOCK: - entry = GRANULARITY_IMAGE_SERIES_CACHE.get(key) - if entry is not None: - GRANULARITY_IMAGE_SERIES_CACHE.move_to_end(key) - self.log_profile("granularity_series_cache_hit", 0.0) - return entry + cache = GranularityImageSeriesCache.process_cache() + entry = cache.cached_value(key) + if entry is not None: + self.log_profile("granularity_series_cache_hit", 0.0) + return entry phase_started_at = time.perf_counter() pixels, grid = background_corrected_pixels( image_array, @@ -758,23 +738,23 @@ def series(self) -> GranularityImageSeries: series = GranularityImageSeries( pixels=pixels, grid=grid, reconstructions=reconstructions ) - with GRANULARITY_IMAGE_SERIES_CACHE_LOCK: - GRANULARITY_IMAGE_SERIES_CACHE[key] = series - GRANULARITY_IMAGE_SERIES_CACHE.move_to_end(key) - while ( - len(GRANULARITY_IMAGE_SERIES_CACHE) - > GRANULARITY_IMAGE_SERIES_CACHE_MAX_ENTRIES - ): - GRANULARITY_IMAGE_SERIES_CACHE.popitem(last=False) - return series + return cache.store_value(key, series) + +@dataclass +class GranularityImageSeriesCache( + SynchronizedBoundedCache[ + tuple[str, tuple[int, ...], bytes, float, float, int, int], + GranularityImageSeries, + ], + RegisteredProcessLocalBoundedCache[ + tuple[str, tuple[int, ...], bytes, float, float, int, int], + GranularityImageSeries, + ], +): + """Process-local reconstructed spectra; calculation and keys stay numerical.""" -GRANULARITY_IMAGE_SERIES_CACHE: dict[ - tuple[str, tuple[int, ...], bytes, float, float, int, int], - GranularityImageSeries, -] = OrderedDict() -GRANULARITY_IMAGE_SERIES_CACHE_MAX_ENTRIES = 16 -GRANULARITY_IMAGE_SERIES_CACHE_LOCK = Lock() + max_entries: int = 16 def granularity_array_content_key( @@ -1818,8 +1798,7 @@ def _prepare_granularity_backend() -> None: __all__ = [ - "GRANULARITY_IMAGE_SERIES_CACHE", - "GRANULARITY_IMAGE_SERIES_CACHE_MAX_ENTRIES", + "GranularityImageSeriesCache", "GRANULARITY_SPECTRUM_LENGTH", "GranularitySamplingGrid", "GranularityImageSeries", diff --git a/openhcs/processing/backends/cellprofiler/illumination.py b/openhcs/processing/backends/cellprofiler/illumination.py index fe9baadda6..db2ba6b1f3 100644 --- a/openhcs/processing/backends/cellprofiler/illumination.py +++ b/openhcs/processing/backends/cellprofiler/illumination.py @@ -68,9 +68,7 @@ CellProfilerBackendProvider, CellProfilerBackendStrategyMixin, ) -from openhcs.processing.backends.cellprofiler.granularity import ( - CellProfilerRuntimeProfiler, -) +from openhcs.core.runtime_profile import RuntimeProfiler from openhcs.processing.backends.cellprofiler.label_geometry import ( CellProfilerLabelHull, ) @@ -601,7 +599,7 @@ def artifact_output_relations( ROBUST_FACTOR = 0.02 CORRECT_ILLUMINATION_CALCULATE_NAME = "correct_illumination_calculate" logger = logging.getLogger(__name__) -runtime_profiler = CellProfilerRuntimeProfiler(logger) +runtime_profiler = RuntimeProfiler(logger) def illumination_gaussian_filter( diff --git a/openhcs/processing/backends/cellprofiler/image_quality.py b/openhcs/processing/backends/cellprofiler/image_quality.py index 7f6f0af6ab..e4338ba2f8 100644 --- a/openhcs/processing/backends/cellprofiler/image_quality.py +++ b/openhcs/processing/backends/cellprofiler/image_quality.py @@ -2,8 +2,9 @@ from __future__ import annotations +from openhcs.core.process_local_cache import RegisteredProcessLocalBoundedCache + from abc import ABC, abstractmethod -from collections import OrderedDict from collections.abc import Callable, Sequence from dataclasses import dataclass, replace from enum import Enum @@ -80,9 +81,7 @@ CellProfilerBackendProvider, CellProfilerBackendStrategyMixin, ) -from openhcs.processing.backends.cellprofiler.granularity import ( - CellProfilerRuntimeProfiler, -) +from openhcs.core.runtime_profile import RuntimeProfiler from openhcs.processing.backends.cellprofiler.thresholding import ( CellProfilerOtsuMethod, CellProfilerThresholdAssignment, @@ -678,7 +677,7 @@ def _selected_image_names(cls, module: "ModuleBlock") -> tuple[str, ...]: logger = logging.getLogger(__name__) -runtime_profiler = CellProfilerRuntimeProfiler(logger) +runtime_profiler = RuntimeProfiler(logger) @dataclass(frozen=True) @@ -752,10 +751,13 @@ class ImageQualityThresholdMetrics(ImageQualityMeasurementRecord): result_value: float = 0.0 -_RADIAL_SPECTRUM_GEOMETRY_CACHE: OrderedDict[ - tuple[int, int], _RadialSpectrumGeometry -] = OrderedDict() -_RADIAL_SPECTRUM_GEOMETRY_CACHE_MAX_ENTRIES = 16 +@dataclass +class RadialSpectrumGeometryCache( + RegisteredProcessLocalBoundedCache[tuple[int, int], _RadialSpectrumGeometry] +): + """Process-local numerical geometry with shared bounded storage.""" + + max_entries: int = 16 class ImageQualityBackendStrategy( @@ -1302,9 +1304,8 @@ def _radial_power_spectrum_numpy( def _radial_spectrum_geometry(shape: tuple[int, int]) -> _RadialSpectrumGeometry: key = (int(shape[0]), int(shape[1])) - geometry = _RADIAL_SPECTRUM_GEOMETRY_CACHE.get(key) + geometry = RadialSpectrumGeometryCache.process_cache().cached_value(key) if geometry is not None: - _RADIAL_SPECTRUM_GEOMETRY_CACHE.move_to_end(key) return geometry height, width = key row2 = np.arange(height).reshape((height, 1)) ** 2 @@ -1317,13 +1318,7 @@ def _radial_spectrum_geometry(shape: tuple[int, int]) -> _RadialSpectrumGeometry radii=np.floor(np.sqrt(radii2)).astype(int) + 1, labels=np.arange(2, int(np.floor(max_width)), dtype=int), ) - _RADIAL_SPECTRUM_GEOMETRY_CACHE[key] = geometry - _RADIAL_SPECTRUM_GEOMETRY_CACHE.move_to_end(key) - while ( - len(_RADIAL_SPECTRUM_GEOMETRY_CACHE) - > _RADIAL_SPECTRUM_GEOMETRY_CACHE_MAX_ENTRIES - ): - _RADIAL_SPECTRUM_GEOMETRY_CACHE.popitem(last=False) + RadialSpectrumGeometryCache.process_cache().store_value(key, geometry) return geometry diff --git a/openhcs/processing/backends/cellprofiler/intensity.py b/openhcs/processing/backends/cellprofiler/intensity.py index 1f7d1e12e2..cbb6dbcde0 100644 --- a/openhcs/processing/backends/cellprofiler/intensity.py +++ b/openhcs/processing/backends/cellprofiler/intensity.py @@ -17,6 +17,7 @@ from openhcs.core.measurement_row_materialization import ( DataclassMeasurementColumnarRows, MeasurementProjectedColumnarRows, + ObjectMeasurementColumnarRows, ) from openhcs.interop.cellprofiler.setting_names import SettingNameFamily from openhcs.interop.cellprofiler.settings_binder import ( @@ -314,9 +315,6 @@ def active_artifact_bindings( ObjectLabelValue, object_label_dense_array, ) -from openhcs.processing.backends.cellprofiler.object_measurement_columnar_rows import ( - ObjectMeasurementColumnarRows, -) from openhcs.core.runtime_profile import RuntimeProfileLogger from openhcs.core.runtime_batch_contracts import RuntimeBatchInvocationRequest from openhcs.interop.cellprofiler.runtime.measurement_execution_support import ( diff --git a/openhcs/processing/backends/cellprofiler/intensity_distribution.py b/openhcs/processing/backends/cellprofiler/intensity_distribution.py index 3d3fc13900..c9c89ba06d 100644 --- a/openhcs/processing/backends/cellprofiler/intensity_distribution.py +++ b/openhcs/processing/backends/cellprofiler/intensity_distribution.py @@ -2,8 +2,9 @@ from __future__ import annotations +from openhcs.core.process_local_cache import RegisteredProcessLocalBoundedCache + from abc import ABC, abstractmethod -from collections import OrderedDict from collections.abc import Mapping, Sequence from dataclasses import dataclass, field, replace from enum import Enum @@ -33,6 +34,7 @@ from openhcs.core.callable_contract import KeywordRuntimeParameter from openhcs.core.measurement_row_materialization import ( MeasurementProjectedColumnarRows, + ObjectMeasurementColumnarRows, ) from openhcs.core.memory.decorators import numpy from openhcs.core.pipeline.function_contracts import ( @@ -110,12 +112,7 @@ CellProfilerBackendStrategyMixin, DEFAULT_CELLPROFILER_BACKEND_SELECTION, ) -from openhcs.processing.backends.cellprofiler.granularity import ( - CellProfilerRuntimeProfiler, -) -from openhcs.processing.backends.cellprofiler.object_measurement_columnar_rows import ( - WideObjectMeasurementColumnarRows, -) +from openhcs.core.runtime_profile import RuntimeProfiler from openhcs.processing.backends.cellprofiler.secondary import ( SecondaryPropagationBackendStrategy, secondary_propagation_backend, @@ -959,12 +956,20 @@ def _runtime_heatmap_outputs( CenterChoice = IntensityDistributionCenterChoice ZernikeMode = IntensityDistributionZernikeMode + logger = logging.getLogger(__name__) -runtime_profiler = CellProfilerRuntimeProfiler(logger) -_RADIAL_LABEL_GEOMETRY_CACHE_LIMIT = 16 -_RADIAL_LABEL_GEOMETRY_CACHE: OrderedDict[ - "RadialLabelGeometryCacheKey", "RadialLabelGeometry" -] = OrderedDict() +runtime_profiler = RuntimeProfiler(logger) + + +@dataclass +class RadialLabelGeometryCache( + RegisteredProcessLocalBoundedCache[ + "RadialLabelGeometryCacheKey", "RadialLabelGeometry" + ] +): + """Process-local numerical geometry with shared bounded storage.""" + + max_entries: int = 16 @dataclass(frozen=True) @@ -1464,9 +1469,7 @@ def rows(self) -> ColumnarRows: @dataclass(slots=True) -class ObjectIntensityDistributionMeasurementColumnarRows( - WideObjectMeasurementColumnarRows -): +class ObjectIntensityDistributionMeasurementColumnarRows(ObjectMeasurementColumnarRows): """Columnar radial intensity-distribution rows.""" object_row_identity = MeasurementObjectRowIdentity.LABEL_ID @@ -1854,9 +1857,8 @@ def label_geometry(self, labels: np.ndarray) -> RadialLabelGeometry: """Return CP-compatible radial geometry derived only from object labels.""" labels_array = np.ascontiguousarray(labels, dtype=np.int32) cache_key = RadialLabelGeometryCacheKey.from_labels(labels_array) - cached = _RADIAL_LABEL_GEOMETRY_CACHE.get(cache_key) + cached = RadialLabelGeometryCache.process_cache().cached_value(cache_key) if cached is not None: - _RADIAL_LABEL_GEOMETRY_CACHE.move_to_end(cache_key) runtime_profiler.log( "idist_label_geometry_cache_hit", 0.0, @@ -1887,10 +1889,7 @@ def label_geometry(self, labels: np.ndarray) -> RadialLabelGeometry: labels_array, centers_i, centers_j ), ) - _RADIAL_LABEL_GEOMETRY_CACHE[cache_key] = geometry - _RADIAL_LABEL_GEOMETRY_CACHE.move_to_end(cache_key) - while len(_RADIAL_LABEL_GEOMETRY_CACHE) > _RADIAL_LABEL_GEOMETRY_CACHE_LIMIT: - _RADIAL_LABEL_GEOMETRY_CACHE.popitem(last=False) + RadialLabelGeometryCache.process_cache().store_value(cache_key, geometry) return geometry diff --git a/openhcs/processing/backends/cellprofiler/object_measurement_columnar_rows.py b/openhcs/processing/backends/cellprofiler/object_measurement_columnar_rows.py deleted file mode 100644 index 29742dee57..0000000000 --- a/openhcs/processing/backends/cellprofiler/object_measurement_columnar_rows.py +++ /dev/null @@ -1,60 +0,0 @@ -"""Columnar row base classes for CellProfiler object measurements.""" - -from __future__ import annotations - -from abc import ABC -from collections.abc import Sequence - -from openhcs.core.runtime_measurements import ( - ObjectMeasurementSliceValueRow, - ObjectMeasurementValueRow, -) -from openhcs.core.runtime_tabular_values import ( - ColumnarRows, -) - - -class ObjectMeasurementColumnarRows(ColumnarRows, ABC): - """Object measurement columns spanning their declared label domain.""" - - slice_index: int | None - - @property - def covers_declared_object_measurement_domain(self) -> bool: - """OpenHCS object-measurement carriers are built on their label domain.""" - return True - - def __len__(self) -> int: - return self.row_count() - - -class WideObjectMeasurementColumnarRows(ObjectMeasurementColumnarRows, ABC): - """One object row with a named column for each measured feature.""" - - def __iter__(self): - yield from self.iter_row_mappings() - - -class LongObjectMeasurementColumnarRows(ObjectMeasurementColumnarRows, ABC): - """One object/feature/value row per measured feature.""" - - def __iter__(self): - row_type = ( - ObjectMeasurementValueRow - if self.slice_index is None - else ObjectMeasurementSliceValueRow - ) - columns = self.columns - slice_values: Sequence[object] | None = columns.get("slice_index") - for row_index in range(len(self)): - kwargs = ( - {} - if slice_values is None - else {"slice_index": int(slice_values[row_index])} - ) - yield row_type( - object_label=int(columns["object_label"][row_index]), - feature_name=str(columns["feature_name"][row_index]), - result_value=float(columns["result_value"][row_index]), - **kwargs, - ) diff --git a/openhcs/processing/backends/cellprofiler/primary_objects.py b/openhcs/processing/backends/cellprofiler/primary_objects.py index 63da410961..70c083129a 100644 --- a/openhcs/processing/backends/cellprofiler/primary_objects.py +++ b/openhcs/processing/backends/cellprofiler/primary_objects.py @@ -80,9 +80,7 @@ filter_physical_border_objects_numba, manual_declumping_size, ) -from openhcs.processing.backends.cellprofiler.granularity import ( - CellProfilerRuntimeProfiler, -) +from openhcs.core.runtime_profile import RuntimeProfiler from openhcs.processing.backends.cellprofiler.shape import shape_measurement_backend from openhcs.processing.backends.cellprofiler._backend import ( BackendProviderInput, @@ -101,7 +99,7 @@ from openhcs.interop.cellprofiler.parser import ModuleBlock logger = logging.getLogger(__name__) -runtime_profiler = CellProfilerRuntimeProfiler(logger) +runtime_profiler = RuntimeProfiler(logger) class UnclumpMethod(Enum): diff --git a/openhcs/processing/backends/cellprofiler/secondary.py b/openhcs/processing/backends/cellprofiler/secondary.py index bec44bb350..63c481fbde 100644 --- a/openhcs/processing/backends/cellprofiler/secondary.py +++ b/openhcs/processing/backends/cellprofiler/secondary.py @@ -275,9 +275,7 @@ def artifact_contract_outputs( from openhcs.processing.backends.cellprofiler.enum_attributes import ( CellProfilerEnumAttributeMixin, ) -from openhcs.processing.backends.cellprofiler.granularity import ( - CellProfilerRuntimeProfiler, -) +from openhcs.core.runtime_profile import RuntimeProfiler from openhcs.processing.backends.cellprofiler.image_geometry import ( CellProfilerPlaneGeometry, ) @@ -310,7 +308,7 @@ def artifact_contract_outputs( ) logger = logging.getLogger(__name__) -runtime_profiler = CellProfilerRuntimeProfiler(logger) +runtime_profiler = RuntimeProfiler(logger) ClassNamespaceValue: TypeAlias = ( str | bool diff --git a/openhcs/processing/backends/cellprofiler/shape.py b/openhcs/processing/backends/cellprofiler/shape.py index 6177cd3568..7a5ced09ad 100644 --- a/openhcs/processing/backends/cellprofiler/shape.py +++ b/openhcs/processing/backends/cellprofiler/shape.py @@ -448,6 +448,7 @@ def measurement_all_field_names( ) from openhcs.core.measurement_row_materialization import ( MeasurementProjectedColumnarRows, + ObjectMeasurementColumnarRows, ) from openhcs.core.runtime_tabular_values import ColumnarRows from openhcs.core.runtime_object_labels import ( @@ -457,9 +458,6 @@ def measurement_all_field_names( object_label_sparse_ijv_rows, ) from openhcs.core.runtime_sparse_labels import SparseIJVLabelRows -from openhcs.processing.backends.cellprofiler.object_measurement_columnar_rows import ( - LongObjectMeasurementColumnarRows, -) from openhcs.processing.backends.analysis.region_properties import ( LabelRegionPropertiesBackendStrategy, ) @@ -476,16 +474,14 @@ def measurement_all_field_names( from openhcs.processing.backends.cellprofiler.morphology import ( MorphologyBackendStrategy, ) -from openhcs.processing.backends.cellprofiler.granularity import ( - CellProfilerRuntimeProfiler, -) +from openhcs.core.runtime_profile import RuntimeProfiler from openhcs.processing.backends.cellprofiler.distance_propagation_numba import ( _edt_1d_numba, ) from openhcs.processing.backends.cellprofiler.zernike import shape_zernike_moments logger = logging.getLogger(__name__) -runtime_profiler = CellProfilerRuntimeProfiler(logger) +runtime_profiler = RuntimeProfiler(logger) ShapeFeatureArrays = tuple[dict[str, np.ndarray], np.ndarray] ShapeFeatureRows = tuple[dict[str, np.ndarray], np.ndarray, tuple[int, ...]] RegionpropsBackendProviderInput: TypeAlias = Annotated[ @@ -559,7 +555,7 @@ def feature_missing_value(self, feature_name: str) -> ObjectFeatureMissingValue: ) -class ShapeObjectMeasurementRows(LongObjectMeasurementColumnarRows): +class ShapeObjectMeasurementRows(ObjectMeasurementColumnarRows): """Dense AreaShape rows that already span their declared object domain.""" object_row_identity = MeasurementObjectRowIdentity.ROW_SEQUENCE diff --git a/openhcs/processing/backends/cellprofiler/zernike.py b/openhcs/processing/backends/cellprofiler/zernike.py index 17ee6df968..7a45afc829 100644 --- a/openhcs/processing/backends/cellprofiler/zernike.py +++ b/openhcs/processing/backends/cellprofiler/zernike.py @@ -2,8 +2,9 @@ from __future__ import annotations +from openhcs.core.process_local_cache import RegisteredProcessLocalBoundedCache + from abc import ABC, abstractmethod -from collections import OrderedDict from collections.abc import Mapping, Sequence from dataclasses import dataclass, field from enum import Enum @@ -59,19 +60,17 @@ CellProfilerBackendStrategyMixin, CellProfilerBackendAuthority, ) -from openhcs.processing.backends.cellprofiler.granularity import ( - CellProfilerRuntimeProfiler, -) +from openhcs.core.runtime_profile import RuntimeProfiler from openhcs.processing.backends.cellprofiler.label_geometry import ( minimum_enclosing_circle_from_labels, ) -from openhcs.processing.backends.cellprofiler.object_measurement_columnar_rows import ( - WideObjectMeasurementColumnarRows, +from openhcs.core.measurement_row_materialization import ( + ObjectMeasurementColumnarRows, ) _INTENSITY_DEBUG_TRACE_DIR_ENV = "OPENHCS_ZERNIKE_INTENSITY_DEBUG_TRACE_DIR" logger = logging.getLogger(__name__) -runtime_profiler = CellProfilerRuntimeProfiler(logger) +runtime_profiler = RuntimeProfiler(logger) ZernikeMomentIndexes: TypeAlias = tuple[tuple[int, int], ...] @@ -652,7 +651,7 @@ def rows(self) -> ColumnarRows: @dataclass(slots=True) -class ObjectIntensityZernikeMeasurementColumnarRows(WideObjectMeasurementColumnarRows): +class ObjectIntensityZernikeMeasurementColumnarRows(ObjectMeasurementColumnarRows): """Columnar intensity-Zernike measurement rows.""" object_ids: Sequence[int] @@ -762,11 +761,16 @@ def fields(self) -> tuple[FieldSpec, ...]: return self._fields -_ZERNIKE_LABEL_GEOMETRY_CACHE: OrderedDict[ - tuple[str, tuple[int, ...], bytes, str, tuple[int, ...], bytes], - _ZernikeLabelGeometry, -] = OrderedDict() -_ZERNIKE_LABEL_GEOMETRY_CACHE_MAX_ENTRIES = 16 +@dataclass +class ZernikeLabelGeometryCache( + RegisteredProcessLocalBoundedCache[ + tuple[str, tuple[int, ...], bytes, str, tuple[int, ...], bytes], + _ZernikeLabelGeometry, + ] +): + """Process-local numerical geometry with shared bounded storage.""" + + max_entries: int = 16 class ShapeZernikeBackendStrategy( @@ -857,9 +861,8 @@ def zernike_label_geometry( time.perf_counter() - key_started_at, objects=object_ids_array.size, ) - entry = _ZERNIKE_LABEL_GEOMETRY_CACHE.get(key) + entry = ZernikeLabelGeometryCache.process_cache().cached_value(key) if entry is not None: - _ZERNIKE_LABEL_GEOMETRY_CACHE.move_to_end(key) runtime_profiler.log( "zernike_geometry_cache_hit", time.perf_counter() - total_started_at, @@ -906,13 +909,7 @@ def zernike_label_geometry( label_values=np.ascontiguousarray(label_values, dtype=np.int32), raw_label_values=raw_label_values, ) - _ZERNIKE_LABEL_GEOMETRY_CACHE[key] = geometry - _ZERNIKE_LABEL_GEOMETRY_CACHE.move_to_end(key) - while ( - len(_ZERNIKE_LABEL_GEOMETRY_CACHE) - > _ZERNIKE_LABEL_GEOMETRY_CACHE_MAX_ENTRIES - ): - _ZERNIKE_LABEL_GEOMETRY_CACHE.popitem(last=False) + ZernikeLabelGeometryCache.process_cache().store_value(key, geometry) runtime_profiler.log( "zernike_geometry_total", time.perf_counter() - total_started_at, diff --git a/tests/unit/test_cellprofiler_callable_kernel_preparation.py b/tests/unit/test_cellprofiler_callable_kernel_preparation.py index 1b9e591493..7bb3435d1a 100644 --- a/tests/unit/test_cellprofiler_callable_kernel_preparation.py +++ b/tests/unit/test_cellprofiler_callable_kernel_preparation.py @@ -41,6 +41,47 @@ def process(image): return process +def test_generic_kernel_registry_prepares_non_cellprofiler_families_once( + monkeypatch, kernel_module, tmp_path +): + from openhcs.core.processing_preparation import ( + PersistentNumbaKernelPreparation, + RegisteredNumbaKernelPreparation, + ) + + events = [] + + class FirstKernel(RegisteredNumbaKernelPreparation, metaclass=AutoRegisterMeta): + __registry__ = {} + + def execute(self): + events.append("first") + + class SecondKernel(RegisteredNumbaKernelPreparation, metaclass=AutoRegisterMeta): + __registry__ = {} + + def execute(self): + events.append("second") + + kernel_module.FirstKernel = FirstKernel + kernel_module.SecondKernel = SecondKernel + kernel_module.__openhcs_prepare__ = lambda: events.append("module") + process = declare_callable(kernel_module, lambda: events.append("callable")) + monkeypatch.setenv("OPENHCS_CPU_ONLY", "true") + monkeypatch.setattr(numba_config, "CACHE_DIR", str(tmp_path / "cache")) + # A provider-specific capture flag must not suppress independent kernels. + monkeypatch.setenv("OPENHCS_CAPTURE_CELLPROFILER_FIXTURES_DIR", str(tmp_path)) + assert FirstKernel.can_prepare_in_child() + assert SecondKernel.can_prepare_in_child() + assert FirstKernel.__registry__ is not SecondKernel.__registry__ + assert "__registry__" not in vars(PersistentNumbaKernelPreparation) + assert "__registry__" not in vars(RegisteredNumbaKernelPreparation) + + prepare_processing_callable(process) + prepare_processing_callable(process) + assert events == ["first", "second", "module", "callable"] + + def test_real_declarations_own_independent_registry_obligations(): from openhcs.processing.backends.cellprofiler.grid import ( IdentifyObjectsInGridKernelPreparation, diff --git a/tests/unit/test_cellprofiler_nominal_policy_migration.py b/tests/unit/test_cellprofiler_nominal_policy_migration.py index 8e3be53b78..2e7681ec8a 100644 --- a/tests/unit/test_cellprofiler_nominal_policy_migration.py +++ b/tests/unit/test_cellprofiler_nominal_policy_migration.py @@ -116,7 +116,7 @@ def test_object_measurement_columnar_rows_own_complete_domain_semantics() -> Non from openhcs.processing.backends.cellprofiler.intensity import ( ObjectIntensityMeasurementRows, ) - from openhcs.processing.backends.cellprofiler.object_measurement_columnar_rows import ( + from openhcs.core.measurement_row_materialization import ( ObjectMeasurementColumnarRows, ) from openhcs.processing.backends.cellprofiler.shape import ( diff --git a/tests/unit/test_cellprofiler_processing_backend.py b/tests/unit/test_cellprofiler_processing_backend.py index 4f0a86265c..3aa43fc9aa 100644 --- a/tests/unit/test_cellprofiler_processing_backend.py +++ b/tests/unit/test_cellprofiler_processing_backend.py @@ -3322,15 +3322,15 @@ def test_zernike_label_geometry_cache_reuses_equal_label_values() -> None: labels[2:6, 2:6] = 1 labels[7:10, 7:11] = 2 object_ids = np.array([1, 2], dtype=np.int32) - zernike._ZERNIKE_LABEL_GEOMETRY_CACHE.clear() + zernike.ZernikeLabelGeometryCache.process_cache().clear() strategy = zernike.LegacyFastNumpyShapeZernikeBackendStrategy() first = strategy.zernike_label_geometry(labels, object_ids) second = strategy.zernike_label_geometry(labels.copy(), object_ids.copy()) assert second is first - assert len(zernike._ZERNIKE_LABEL_GEOMETRY_CACHE) == 1 - zernike._ZERNIKE_LABEL_GEOMETRY_CACHE.clear() + assert len(zernike.ZernikeLabelGeometryCache.process_cache().entries) == 1 + zernike.ZernikeLabelGeometryCache.process_cache().clear() def test_zernike_numba_provider_is_not_registered_until_pure() -> None: diff --git a/tests/unit/test_cellprofiler_runtime_cache_authorities.py b/tests/unit/test_cellprofiler_runtime_cache_authorities.py index 70030eb17f..108d2cb0e1 100644 --- a/tests/unit/test_cellprofiler_runtime_cache_authorities.py +++ b/tests/unit/test_cellprofiler_runtime_cache_authorities.py @@ -48,9 +48,11 @@ from openhcs.core.runtime_relationships import DirectedObjectRelationshipPayload from openhcs.core.runtime_tabular_values import FieldSpec from openhcs.core.runtime_stores import RuntimeValueStore +from openhcs.core.measurement_feature_queries import ( + RuntimeObjectLabelMeasurementQueryCache, +) from openhcs.interop.cellprofiler.runtime.object_label_measurements import ( ObjectLabelMeasurementSliceRequest, - object_label_measurement_values_cache, ) AXIS_ID = "A01" @@ -238,7 +240,9 @@ def test_object_label_measurements_use_store_bound_values_cache() -> None: ) query = request.measurement_query(adapter) expected = (np.asarray([11.0], dtype=np.float64),) - object_label_measurement_values_cache(store)[query] = expected + store.query_cache(RuntimeObjectLabelMeasurementQueryCache).store_value( + query, expected + ) resolved = request.values(adapter) diff --git a/tests/unit/test_function_runtime_source_projection.py b/tests/unit/test_function_runtime_source_projection.py index 1d4c2ead7d..d031997b88 100644 --- a/tests/unit/test_function_runtime_source_projection.py +++ b/tests/unit/test_function_runtime_source_projection.py @@ -5,6 +5,7 @@ import numpy as np import pytest +from objectstate.global_config import GlobalContextValues from polystore.virtual_workspace import SourcePixelRef from openhcs.constants.constants import AllComponents, GroupBy, VariableComponents @@ -26,6 +27,7 @@ ObjectLabelsArtifactType, ) from openhcs.core.compiled_step_plan import CompiledStepPlan +from openhcs.core.config import GlobalPipelineConfig from openhcs.core.component_group_scope import ( ComponentGroupScope, ) @@ -1975,8 +1977,16 @@ def test_pipeline_start_anchors_project_raw_selectors_to_semantic_groups() -> No } +@pytest.fixture +def preserve_global_pipeline_context(): + context = GlobalContextValues.capture(GlobalPipelineConfig) + yield + context.apply() + + def test_first_step_prepares_raw_source_anchors_under_semantic_binding_groups( tmp_path: Path, + preserve_global_pipeline_context, ) -> None: from multiprocessing import SimpleQueue @@ -1985,7 +1995,7 @@ def test_first_step_prepares_raw_source_anchors_under_semantic_binding_groups( from objectstate.lazy_factory import ensure_global_config_context from openhcs.constants import Microscope - from openhcs.core.config import GlobalPipelineConfig, PipelineConfig + from openhcs.core.config import PipelineConfig from openhcs.core.orchestrator.orchestrator import PipelineOrchestrator from openhcs.core.progress import set_progress_queue from openhcs.core.source_bindings import LazyStepSourceBindingsConfig @@ -2968,6 +2978,7 @@ def measure_neurites(image, pixel_size=1.0): def test_pipeline_start_main_flow_survives_prior_producer_image_input( tmp_path: Path, + preserve_global_pipeline_context, ) -> None: from multiprocessing import SimpleQueue @@ -2978,7 +2989,6 @@ def test_pipeline_start_main_flow_survives_prior_producer_image_input( from openhcs.constants import Microscope from openhcs.constants.input_source import InputSource from openhcs.core.config import ( - GlobalPipelineConfig, LazyProcessingConfig, PipelineConfig, ) diff --git a/tests/unit/test_measuregranularity.py b/tests/unit/test_measuregranularity.py index b29d858106..82c417de8e 100644 --- a/tests/unit/test_measuregranularity.py +++ b/tests/unit/test_measuregranularity.py @@ -10,7 +10,7 @@ ) from openhcs.core.runtime_tabular_values import FieldSpec from openhcs.processing.backends.cellprofiler.granularity import ( - GRANULARITY_IMAGE_SERIES_CACHE, + GranularityImageSeriesCache, GRANULARITY_SPECTRUM_LENGTH, GranularityImageSeriesRequest, GranularitySamplingGrid, @@ -306,7 +306,8 @@ def test_measure_granularity_objects_preserves_sparse_label_ids(): def test_granularity_series_cache_reuses_equal_image_values(): image = np.arange(36, dtype=np.float64).reshape(6, 6) image_copy = image.copy() - GRANULARITY_IMAGE_SERIES_CACHE.clear() + cache = GranularityImageSeriesCache.process_cache() + cache.clear() first = GranularityImageSeriesRequest( image=image, @@ -326,7 +327,7 @@ def test_granularity_series_cache_reuses_equal_image_values(): ).series() assert second is first - assert len(GRANULARITY_IMAGE_SERIES_CACHE) == 1 + assert len(cache.entries) == 1 def test_measure_granularity_objects_uses_order_one_coordinate_sampling_after_subsampling(): diff --git a/tests/unit/test_process_local_cache.py b/tests/unit/test_process_local_cache.py index 52cf02905c..7f622288d7 100644 --- a/tests/unit/test_process_local_cache.py +++ b/tests/unit/test_process_local_cache.py @@ -1,8 +1,157 @@ +from dataclasses import dataclass +from concurrent.futures import ThreadPoolExecutor +from threading import Barrier + +import pytest + from openhcs.core.process_local_cache import ( + BoundedCache, IdentityBoundProcessCache, + ProcessLocalBoundedCache, RegisteredProcessLocalBoundedCache, + SynchronizedBoundedCache, clear_registered_process_local_caches, ) +from openhcs.core.measurement_feature_queries import ( + RuntimeObjectLabelMeasurementQueryCache, +) +from openhcs.core.runtime_artifact_queries import RuntimeMeasurementTablesQueryCache + + +@pytest.mark.parametrize( + "base", + ( + ProcessLocalBoundedCache, + RegisteredProcessLocalBoundedCache, + IdentityBoundProcessCache, + ), +) +def test_warmed_parent_cache_does_not_become_child_singleton(base): + @dataclass + class ParentCache(base): + max_entries: int = 2 + registry_key = "test_warmed_parent_cache" + + parent = ParentCache.process_cache() + parent.store_value("parent", "parent-only") + + @dataclass(slots=True) + class ChildCache(ParentCache): + max_entries: int = 3 + registry_key = "test_warmed_child_cache" + + barrier = Barrier(8) + + def obtain_child(_index): + barrier.wait(timeout=5) + return ChildCache.process_cache() + + with ThreadPoolExecutor(max_workers=8) as pool: + children = tuple(pool.map(obtain_child, range(8))) + child = children[0] + assert all(cache is child for cache in children) + assert type(parent) is ParentCache + assert type(child) is ChildCache + assert child is not parent + assert parent.max_entries == 2 + assert child.max_entries == 3 + assert child.cached_value("parent") is None + child.store_value("child", "child-only") + ChildCache.clear_process_cache() + assert ChildCache.process_cache() is child + assert child.cached_value("child") is None + assert parent.cached_value("parent") == "parent-only" + if base is not ProcessLocalBoundedCache: + clear_registered_process_local_caches() + assert parent.cached_value("parent") is None + + +def test_warmed_diamond_cache_preserves_synchronization_lru_and_cleanup(): + @dataclass + class ParentDiamondCache( + SynchronizedBoundedCache[str, str], + RegisteredProcessLocalBoundedCache[str, str], + ): + max_entries: int = 2 + + parent = ParentDiamondCache.process_cache() + parent.store_value("parent", "parent-only") + + class LeftDiamondCache(ParentDiamondCache): + pass + + left = LeftDiamondCache.process_cache() + left.store_value("left", "left-only") + + class RightDiamondCache(ParentDiamondCache): + pass + + right = RightDiamondCache.process_cache() + right.store_value("right", "right-only") + + class DiamondCache(LeftDiamondCache, RightDiamondCache): + pass + + diamond = DiamondCache.process_cache() + assert tuple(type(cache) for cache in (parent, left, right, diamond)) == ( + ParentDiamondCache, + LeftDiamondCache, + RightDiamondCache, + DiamondCache, + ) + assert len({id(cache) for cache in (parent, left, right, diamond)}) == 4 + assert len({id(cache._lock) for cache in (parent, left, right, diamond)}) == 4 + assert ( + len( + { + id(cls._process_cache_lock) + for cls in ( + ParentDiamondCache, + LeftDiamondCache, + RightDiamondCache, + DiamondCache, + ) + } + ) + == 4 + ) + assert all(diamond.cached_value(key) is None for key in ("parent", "left", "right")) + diamond.store_value("oldest", "first") + diamond.store_value("middle", "second") + assert diamond.cached_value("oldest") == "first" + diamond.store_value("newest", "third") + assert diamond.cached_value("middle") is None + assert all( + RegisteredProcessLocalBoundedCache.__registry__[type(cache).__name__] + is type(cache) + for cache in (parent, left, right, diamond) + ) + clear_registered_process_local_caches() + assert all(not cache.entries for cache in (parent, left, right, diamond)) + + +def test_process_cache_class_hook_cooperates_with_other_base(): + observed = [] + + class HookObserver: + def __init_subclass__(cls, *, marker, **kwargs): + super().__init_subclass__(**kwargs) + observed.append((cls, marker)) + + class CooperativeCache(ProcessLocalBoundedCache, HookObserver, marker="owner"): + pass + + assert observed == [(CooperativeCache, "owner")] + assert type(CooperativeCache.process_cache()) is CooperativeCache + + +def test_store_query_domains_use_bounded_values_without_process_singletons(): + for cache_type in ( + RuntimeObjectLabelMeasurementQueryCache, + RuntimeMeasurementTablesQueryCache, + ): + assert issubclass(cache_type, BoundedCache) + assert not issubclass(cache_type, ProcessLocalBoundedCache) def test_registered_process_local_cache_cleanup_clears_cache_instance(): @@ -34,3 +183,63 @@ class TestIdentityBoundProcessLocalCleanupCache(IdentityBoundProcessCache): clear_registered_process_local_caches() assert cache.get_bound(owner) is None + + +def test_synchronized_process_cache_preserves_lru_and_concurrent_singleton(): + @dataclass + class TestSynchronizedProcessCache( + SynchronizedBoundedCache[str, str], + RegisteredProcessLocalBoundedCache[str, str], + ): + max_entries: int = 2 + + barrier = Barrier(8) + + def obtain_cache(_index): + barrier.wait(timeout=5) + return TestSynchronizedProcessCache.process_cache() + + with ThreadPoolExecutor(max_workers=8) as pool: + caches = tuple(pool.map(obtain_cache, range(8))) + cache = caches[0] + assert all(value is cache for value in caches) + assert cache.max_entries == 2 + cache.store_value("oldest", "first") + cache.store_value("middle", "second") + assert cache.cached_value("oldest") == "first" + cache.store_value("newest", "third") + assert cache.cached_value("middle") is None + assert cache.cached_value("oldest") == "first" + assert cache.cached_value("newest") == "third" + clear_registered_process_local_caches() + assert cache.cached_value("oldest") is None + assert cache.cached_value("newest") is None + + +def test_numerical_cache_domains_keep_capacity_and_join_registered_cleanup(): + from openhcs.processing.backends.cellprofiler.granularity import ( + GranularityImageSeriesCache, + ) + from openhcs.processing.backends.cellprofiler.image_quality import ( + RadialSpectrumGeometryCache, + ) + from openhcs.processing.backends.cellprofiler.intensity_distribution import ( + RadialLabelGeometryCache, + ) + from openhcs.processing.backends.cellprofiler.zernike import ( + ZernikeLabelGeometryCache, + ) + + cache_types = ( + GranularityImageSeriesCache, + RadialSpectrumGeometryCache, + RadialLabelGeometryCache, + ZernikeLabelGeometryCache, + ) + caches = tuple(cls.process_cache() for cls in cache_types) + assert len({id(cache) for cache in caches}) == 4 + for cls, cache in zip(cache_types, caches, strict=True): + assert cache.max_entries == 16 + assert RegisteredProcessLocalBoundedCache.__registry__[cls.__name__] is cls + clear_registered_process_local_caches() + assert all(not cache.entries for cache in caches) diff --git a/tests/unit/test_runtime_profile.py b/tests/unit/test_runtime_profile.py new file mode 100644 index 0000000000..99525c15de --- /dev/null +++ b/tests/unit/test_runtime_profile.py @@ -0,0 +1,40 @@ +"""Bound runtime emitters preserve the shared sink's gating and output effects.""" + +import logging + +from openhcs.core.runtime_profile import ( + PROFILE_RUNTIME_ENV, + PROFILE_RUNTIME_PATH_ENV, + RuntimeProfiler, +) + + +def test_bound_profiler_disabled_has_no_output_effects(monkeypatch, tmp_path, caplog): + path = tmp_path / "profile.log" + monkeypatch.setenv(PROFILE_RUNTIME_ENV, "false") + monkeypatch.setenv(PROFILE_RUNTIME_PATH_ENV, str(path)) + profiler = RuntimeProfiler(logging.getLogger("test.bound.runtime.disabled")) + + with caplog.at_level(logging.INFO): + profiler.log("phase", 0.125, objects=3) + + assert not profiler.enabled() + assert not path.exists() + assert not caplog.records + + +def test_bound_profiler_enabled_writes_same_event_to_both_sinks( + monkeypatch, tmp_path, caplog +): + path = tmp_path / "profile.log" + monkeypatch.setenv(PROFILE_RUNTIME_ENV, "TRUE") + monkeypatch.setenv(PROFILE_RUNTIME_PATH_ENV, str(path)) + profiler = RuntimeProfiler(logging.getLogger("test.bound.runtime.enabled")) + + with caplog.at_level(logging.INFO): + profiler.log("phase", 0.125, objects=3, source="nuclei") + + assert profiler.enabled() + expected = "RUNTIME_PROFILE phase 0.125000s objects=3 source=nuclei" + assert path.read_text() == expected + "\n" + assert [record.getMessage() for record in caplog.records] == [expected] diff --git a/tests/unit/test_runtime_value_store.py b/tests/unit/test_runtime_value_store.py index f10f3af1ee..cd053fb901 100644 --- a/tests/unit/test_runtime_value_store.py +++ b/tests/unit/test_runtime_value_store.py @@ -1,4 +1,5 @@ from dataclasses import replace +import pickle import numpy as np import pytest @@ -43,6 +44,7 @@ image_payload_metadata, ) from openhcs.core.measurement_row_materialization import ( + MeasurementProjectedColumnarRows, MeasurementSparseColumnarRows, ) from openhcs.core.runtime_measurements import ( @@ -55,6 +57,11 @@ MeasurementScope, MeasurementSubject, ) +from openhcs.core.measurement_feature_queries import ( + RuntimeObjectLabelMeasurementQuery, + RuntimeObjectLabelMeasurementQueryCache, +) +from openhcs.core.runtime_artifact_queries import RuntimeMeasurementTablesQueryCache from openhcs.core.runtime_plane_projection import ( RuntimePlaneAxis, ) @@ -129,6 +136,103 @@ def _runtime_value(name="measurements", path="/memory/measurements.pkl"): ) +def _label_query(feature_name="AreaShape_Area"): + return RuntimeObjectLabelMeasurementQuery( + axis_id="A01", + group_key="DAPI", + object_name="Cells", + feature_name=feature_name, + label_domain=(1,), + ) + + +@pytest.mark.parametrize("mutation", ("record", "replace", "clear", "merge")) +def test_store_mutations_invalidate_all_derived_query_domains(mutation): + store = RuntimeValueStore() + original = _runtime_value() + store.record(original, path="/memory/measurements.pkl", backend="memory") + label_cache = store.query_cache(RuntimeObjectLabelMeasurementQueryCache) + tables_cache = store.query_cache(RuntimeMeasurementTablesQueryCache) + query = _label_query() + label_cache.store_value(query, (np.asarray([11.0]),)) + tables_cache.store_value(("A01", "DAPI"), (original.data,)) + + if mutation == "record": + store.record(_runtime_value("new"), path="/memory/new.pkl", backend="memory") + elif mutation == "replace": + store.replace(original, path="/memory/replacement.pkl", backend="memory") + elif mutation == "clear": + store.clear() + else: + worker = RuntimeValueStore() + worker.record( + _runtime_value("worker"), path="/memory/worker.pkl", backend="memory" + ) + store.merge_observed_values(worker.observed_values) + + assert label_cache.cached_value(query) is None + assert tables_cache.cached_value(("A01", "DAPI")) is None + assert store.query_cache(RuntimeObjectLabelMeasurementQueryCache) is label_cache + assert store.query_cache(RuntimeMeasurementTablesQueryCache) is tables_cache + + +def test_store_query_values_are_bounded_and_isolated_between_stores(): + first, second = RuntimeValueStore(), RuntimeValueStore() + first_cache = first.query_cache(RuntimeObjectLabelMeasurementQueryCache) + second_cache = second.query_cache(RuntimeObjectLabelMeasurementQueryCache) + first_cache.max_entries = 2 + queries = tuple(_label_query(feature) for feature in ("a", "b", "c")) + values = (np.asarray([42.0]),) + first_cache.store_value(queries[0], values) + first_cache.store_value(queries[1], values) + assert first_cache.cached_value(queries[0]) is values + first_cache.store_value(queries[2], values) + + assert first_cache.cached_value(queries[0]) is values + assert first_cache.cached_value(queries[1]) is None + assert first_cache.cached_value(queries[2]) is values + assert second_cache.cached_value(queries[0]) is None + + +def test_store_transport_excludes_derived_caches_and_retains_records(): + store = RuntimeValueStore() + value = _runtime_value() + value.data.rows = MeasurementProjectedColumnarRows( + {"object_id": (1,)}, fields=(FieldSpec("object_id", int),) + ) + store.record(value, path="/memory/measurements.pkl", backend="memory") + serialized_without_cache = pickle.dumps(store, protocol=5) + query = _label_query() + cache = store.query_cache(RuntimeObjectLabelMeasurementQueryCache) + values = (np.ones(100_000),) + cache.store_value(query, values) + store.query_cache(RuntimeMeasurementTablesQueryCache).store_value( + ("A01", "DAPI"), (value.data,) + ) + + assert pickle.dumps(store, protocol=5) == serialized_without_cache + restored = pickle.loads(serialized_without_cache) + assert restored.revision == store.revision + assert len(restored) == len(store) == 1 + assert ( + restored.observed_values[0].value.data.row_mappings() + == value.data.row_mappings() + ) + assert ( + restored.query_cache(RuntimeObjectLabelMeasurementQueryCache).cached_value( + query + ) + is None + ) + assert ( + restored.query_cache(RuntimeMeasurementTablesQueryCache).cached_value( + ("A01", "DAPI") + ) + is None + ) + assert cache.cached_value(query) is values + + def test_output_plan_uses_its_single_scope_for_ungrouped_invocation(): output_plan = ArtifactOutputPlan( name="Nuclei",