PyLV200 0.1.2__tar.gz → 0.1.3__tar.gz

pylv200-0.1.3/MANIFEST.in

@@ -0,0 +1,8 @@
+include README_AI.md
+include pylv200_context.json
+recursive-include src/pylv200 README_AI.md pylv200_context.json
+
+recursive-include demo *.py *.json *.md
+include docs/software-performance/independent-images.json
+include docs/software-performance/independent-image-arrays.npz
+recursive-include scripts *.py *.txt

{pylv200-0.1.2/src/PyLV200.egg-info → pylv200-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyLV200
-Version: 0.1.2
+Version: 0.1.3
 Summary: Pull images from a running Olympus/Evident cellSens experiment before the .vsi is written
 Author: Jamie Malcolm
 License-Expression: MIT
@@ -94,7 +94,7 @@ probe left`, `list`, `--help`.
 It is built locally rather than committed, so it is not in a fresh clone. See
 [docs/BUILDING.md](docs/BUILDING.md).
 
-The desktop application is distributed from the GitHub release page as a
+The desktop application is distributed from the [public Windows downloads page](https://github.com/Jay2owe/PyLV200-downloads/releases/latest) as a
 portable Windows ZIP and a per-user `PyLV200-<version>-Setup.exe` installer.
 Both are built and checked against the matching Python package in one release
 run.
@@ -841,3 +841,9 @@ pytest
 ## Licence
 
 MIT.
+
+## Development review
+
+[Performance changes](docs/PERFORMANCE.md) cover dataset discovery, previews and reduced export memory. Timing comparisons use synthetic workloads; live instrument throughput has not been certified.
+
+Open the example desktop with `python demo/open_app.py --reload`; run focused checks with `python -m pytest -q tests/test_performance_contracts.py`. The [offline example](demo/README.md) documents isolation and expected-answer controls.

{pylv200-0.1.2 → pylv200-0.1.3}/README.md

@@ -47,7 +47,7 @@ probe left`, `list`, `--help`.
 It is built locally rather than committed, so it is not in a fresh clone. See
 [docs/BUILDING.md](docs/BUILDING.md).
 
-The desktop application is distributed from the GitHub release page as a
+The desktop application is distributed from the [public Windows downloads page](https://github.com/Jay2owe/PyLV200-downloads/releases/latest) as a
 portable Windows ZIP and a per-user `PyLV200-<version>-Setup.exe` installer.
 Both are built and checked against the matching Python package in one release
 run.
@@ -794,3 +794,9 @@ pytest
 ## Licence
 
 MIT.
+
+## Development review
+
+[Performance changes](docs/PERFORMANCE.md) cover dataset discovery, previews and reduced export memory. Timing comparisons use synthetic workloads; live instrument throughput has not been certified.
+
+Open the example desktop with `python demo/open_app.py --reload`; run focused checks with `python -m pytest -q tests/test_performance_contracts.py`. The [offline example](demo/README.md) documents isolation and expected-answer controls.

pylv200-0.1.3/demo/README.md

@@ -0,0 +1,13 @@
+# Offline acquisition example
+
+Status: verified headless; every exported pixel matches the fixed analytic fixture. The image viewer is available with `--show`.
+
+From this checkout, run `python demo/run_demo.py`. It generates tiny deterministic input, uses the real public client, exports a TIFF and checks every pixel with zero tolerance. `python demo/run_demo.py --show` opens the actual image viewer. Real sources and settings are isolated; temporary output is removed on exit.
+
+[Expected answers](expected_result.json) describe analytic pixel values, not biological measurements. Explicitly approving changed answers requires `python demo/run_demo.py --update-expected --reason "explanation"`; this records the reason and must be reviewed alongside the fixture changes. Ordinary runs never update expected answers.
+
+[Verification and performance review](../docs/software-performance/README.md) records the broader app checks. Fixture generators live in tests/; no external acquisition or network connection is needed.
+
+## Desktop development
+
+Run `python demo/open_app.py --reload` to open the actual application on isolated synthetic data and restart it after source edits. Closing the window stops the launcher. `python demo/open_app.py --check` opens the populated desktop and closes it automatically for verification. Both populated-desktop check commands passed in the current review.

pylv200-0.1.3/demo/expected_result.json

@@ -0,0 +1,8 @@
+{
+  "shape": [3, 2, 8, 8],
+  "dtype": "uint16",
+  "first_pixel_by_frame_channel": [[1000, 2000], [1010, 2010], [1020, 2020]],
+  "pixel_sum": 579840,
+  "tolerance": 0,
+  "source": "Analytic tile values from tests/synthetic.py: 1000*(channel+1)+10*time. No fitted or implementation-generated expected statistics."
+}

pylv200-0.1.3/demo/open_app.py

@@ -0,0 +1,46 @@
+"""Open the actual desktop on isolated example data; optionally reload on save."""
+import argparse
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+
+ROOT=Path(__file__).resolve().parents[1]
+
+def desktop(work,reload=False,check=False):
+    sys.path[:0]=[str(ROOT/'src'),str(ROOT)]
+    os.environ['PYLV200_HOME']=str(work/'settings')
+    from tests.synthetic import make_ets,make_vsi
+    from pylv200 import Source
+    from pylv200.config import save_source
+    from pylv200.gui.app import App
+    import tkinter as tk
+    source=work/'source'
+    make_ets(source/'sample.ets',tile=64,nc=2,nt=4,grid_x=1,grid_y=1)
+    make_vsi(source/'sample.vsi',['BF','GFP'],experiment='Example')
+    save_source(Source(name='Example',roots=(str(source),)))
+    window=tk.Tk();app=App(window,target='Example:Example')
+    def signature():return {str(p):p.stat().st_mtime_ns for p in (ROOT/'src/pylv200').rglob('*.py')}
+    original=signature();changed=[]
+    def tick():
+        if reload and signature()!=original:
+            changed.append(True);app.on_close();return
+        if check and app.tree.get_children() and not app.busy:
+            app.on_close();return
+        window.after(500,tick)
+    window.after(500,tick);window.mainloop()
+    return 75 if changed else 0
+
+if __name__=='__main__':
+    p=argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--reload',action='store_true');p.add_argument('--check',action='store_true')
+    p.add_argument('--work',type=Path,help=argparse.SUPPRESS);a=p.parse_args()
+    if a.work:raise SystemExit(desktop(a.work,a.reload,a.check))
+    with tempfile.TemporaryDirectory(prefix='pylv200-desktop-demo-') as folder:
+        command=[sys.executable,__file__,'--work',folder]
+        if a.reload:command.append('--reload')
+        if a.check:command.append('--check')
+        while True:
+            done=subprocess.run(command)
+            if done.returncode!=75:raise SystemExit(done.returncode)

pylv200-0.1.3/demo/run_demo.py

@@ -0,0 +1,61 @@
+"""Pull a tiny synthetic acquisition and verify every exported pixel offline."""
+from __future__ import annotations
+import argparse
+import json
+import os
+from pathlib import Path
+import sys
+import tempfile
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path[:0] = [str(ROOT / "src"), str(ROOT)]
+
+
+def run(directory, show=False, update_reason=None):
+    os.environ["PYLV200_HOME"] = str(directory / "settings")
+    import numpy as np
+    import tifffile
+    from pylv200 import LV200Client
+    from tests.synthetic import make_ets, make_vsi
+    source = directory / "source"
+    make_ets(source / "sample.ets", tile=8, nc=2, nt=3, grid_x=1, grid_y=1)
+    make_vsi(source / "sample.vsi", ["BF", "GFP"], experiment="Synthetic demo")
+    with LV200Client(source) as client:
+        result = client.fetch("Synthetic demo", output=str(directory / "output"), include_last=True)
+        assert result.files, result.summary()
+        pixels = tifffile.imread(result.files[0].path).reshape(3, 2, 8, 8)
+        expected_path = Path(__file__).with_name("expected_result.json")
+        expected = json.loads(expected_path.read_text())
+        if update_reason:
+            from datetime import datetime, timezone
+            expected.update(shape=list(pixels.shape), dtype=str(pixels.dtype),
+                            first_pixel_by_frame_channel=pixels[:, :, 0, 0].tolist(),
+                            pixel_sum=int(pixels.sum()), tolerance=0)
+            expected.setdefault("updates", []).append(dict(reason=update_reason,
+                at=datetime.now(timezone.utc).isoformat()))
+            from pylv200._atomic import write_json
+            write_json(expected_path, expected)
+        expected_pixels = np.broadcast_to(np.asarray(expected["first_pixel_by_frame_channel"],
+                                          dtype=np.uint16)[:, :, None, None], pixels.shape)
+        np.testing.assert_array_equal(pixels, expected_pixels)
+        assert list(pixels.shape) == expected["shape"]
+        assert str(pixels.dtype) == expected["dtype"]
+        assert int(pixels.sum()) == expected["pixel_sum"]
+        if show:
+            client.preview("Synthetic demo").show(title="PyLV200 — synthetic demo")
+    return dict(verified=True, frames=3, channels=2, pixels=int(pixels.size), tolerance=0)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--show", action="store_true", help="Open the real preview viewer after verification")
+    parser.add_argument("--update-expected", action="store_true",
+                        help="Explicitly approve new expected pixels; requires --reason")
+    parser.add_argument("--reason", help="Recorded reason for approving changed fixture answers")
+    args = parser.parse_args()
+    if args.update_expected and not (args.reason or "").strip():
+        parser.error("--update-expected requires a nonempty --reason")
+    if args.reason and not args.update_expected:
+        parser.error("--reason is only valid with --update-expected")
+    with tempfile.TemporaryDirectory(prefix="pylv200-demo-") as folder:
+        print(json.dumps(run(Path(folder), args.show, args.reason if args.update_expected else None)))

pylv200-0.1.3/docs/software-performance/independent-images.json

@@ -0,0 +1,41 @@
+{
+  "rows": [
+    {
+      "capability": "PNG pixel encoding",
+      "case": "(1, 1)",
+      "reference": "Pillow 12.3.0",
+      "scope": "Independent decoder",
+      "status": "exact",
+      "max_error": 0,
+      "tolerance": 0
+    },
+    {
+      "capability": "PNG pixel encoding",
+      "case": "(7, 13)",
+      "reference": "Pillow 12.3.0",
+      "scope": "Independent decoder",
+      "status": "exact",
+      "max_error": 0,
+      "tolerance": 0
+    },
+    {
+      "capability": "PNG pixel encoding",
+      "case": "(64, 64)",
+      "reference": "Pillow 12.3.0",
+      "scope": "Independent decoder",
+      "status": "exact",
+      "max_error": 0,
+      "tolerance": 0
+    },
+    {
+      "capability": "Complete exported TIFF pixels",
+      "case": "Synthetic_demo.tif",
+      "reference": "Pillow 12.3.0",
+      "scope": "Independent pixel decoder; proprietary input metadata not certified",
+      "status": "exact",
+      "max_error": 0,
+      "tolerance": 0
+    }
+  ],
+  "arrays_sha256": "32d73544bc8387f6a6e492e7d918fcc15985cc7b2d369121b1e4bb411bbb2033"
+}

{pylv200-0.1.2 → pylv200-0.1.3}/pylv200_context.json

@@ -1,6 +1,6 @@
 {
   "package": "pylv200",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "reader_contract": {
     "python": "from pylv200 import context; context.read(topic=None, format='text')",
     "search": "context.search(query, limit=5)",
@@ -11,7 +11,7 @@
     {
       "ok": true,
       "package": "pylv200",
-      "version": "0.1.2",
+      "version": "0.1.3",
       "topic": "inspect",
       "title": "Identify an acquisition safely",
       "description": "Check roots and resolve the exact experiment before planning or pulling.",
@@ -27,7 +27,7 @@
     {
       "ok": true,
       "package": "pylv200",
-      "version": "0.1.2",
+      "version": "0.1.3",
       "topic": "overview",
       "title": "PyLV200 overview",
       "description": "Read live cellSens LV200 acquisitions from filesystem roots and pull compatible image stacks.",
@@ -42,7 +42,7 @@
     {
       "ok": true,
       "package": "pylv200",
-      "version": "0.1.2",
+      "version": "0.1.3",
       "topic": "plan-and-pull",
       "title": "Plan and pull image stacks",
       "description": "Preview the files and time window before writing a resumable pull.",
@@ -58,7 +58,7 @@
     {
       "ok": true,
       "package": "pylv200",
-      "version": "0.1.2",
+      "version": "0.1.3",
       "topic": "preview",
       "title": "Preview a live acquisition",
       "description": "Read a bounded set of tiles to identify positions and channels before pulling.",
@@ -74,7 +74,7 @@
     {
       "ok": true,
       "package": "pylv200",
-      "version": "0.1.2",
+      "version": "0.1.3",
       "topic": "protocol",
       "title": "Read the acquisition protocol",
       "description": "Inspect channels, exposures, positions, requested cadence, achieved cadence, and progress.",
@@ -90,7 +90,7 @@
     {
       "ok": true,
       "package": "pylv200",
-      "version": "0.1.2",
+      "version": "0.1.3",
       "topic": "troubleshooting",
       "title": "PyLV200 troubleshooting",
       "description": "Recognise common source, identity, live-file, and output problems.",
@@ -107,7 +107,7 @@
     {
       "ok": true,
       "package": "pylv200",
-      "version": "0.1.2",
+      "version": "0.1.3",
       "topic": "watch-once",
       "title": "Collect new data once",
       "description": "Run one resumable poll for a scheduler or repeated agent call without leaving a worker running.",

{pylv200-0.1.2 → pylv200-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "PyLV200"
-version = "0.1.2"
+version = "0.1.3"
 description = "Pull images from a running Olympus/Evident cellSens experiment before the .vsi is written"
 readme = "README.md"
 requires-python = ">=3.9"

pylv200-0.1.3/scripts/benchmark_accepted_residuals.py

@@ -0,0 +1,84 @@
+"""Reproduce accepted residual changes against immutable original functions."""
+import argparse
+import ast
+import hashlib
+import importlib
+import json
+from pathlib import Path
+import statistics
+import sys
+import time
+import zipfile
+
+
+def run(root,work):
+    sys.path[:0]=[str(root/'src'),str(root)]
+    import numpy as np
+    import psutil
+    from benchmark_workflows import fingerprint
+    while psutil.virtual_memory().available<4.25*1024**3:time.sleep(15)
+    lv=(root/'src/pylv200').exists();name='pylv200' if lv else 'pyincucyte';prefix='src/pylv200' if lv else name
+    archive=root/'docs/software-performance/baseline-source.zip';rows=[]
+    def original(module,function):
+        current=importlib.import_module(name+'.'+module)
+        with zipfile.ZipFile(archive) as z:tree=ast.parse(z.read(prefix+'/'+module+'.py').decode('utf-8-sig'))
+        node=next(n for n in tree.body if isinstance(n,ast.FunctionDef) and n.name==function)
+        namespace=dict(current.__dict__)
+        exec(compile(ast.Module(body=[node],type_ignores=[]),'<immutable original>','exec'),namespace)
+        return namespace[function],getattr(current,function)
+    def paired(ident,before,after,pairs=9):
+        wall={'before':[],'after':[]};cpu={'before':[],'after':[]};host=[]
+        for pair in range(pairs):
+            results={};psutil.cpu_percent()
+            for label in ('before','after') if pair%2==0 else ('after','before'):
+                start=time.perf_counter();start_cpu=time.process_time()
+                results[label]=(before if label=='before' else after)()
+                cpu[label].append(time.process_time()-start_cpu);wall[label].append(time.perf_counter()-start)
+            host.append(psutil.cpu_percent())
+            if isinstance(results['before'],np.ndarray):np.testing.assert_array_equal(results['before'],results['after'])
+            else:assert results['before']==results['after'],ident
+        rows.append(dict(id=ident,before_seconds=wall['before'],after_seconds=wall['after'],cpu=cpu,host_cpu_percent=host,
+                         parity=True,ratio=statistics.median(wall['before'])/statistics.median(wall['after'])))
+    before,after=original('models','json_clean')
+    for count in (8,64,512):
+        data={'files':[{'path':Path('output')/f'field-{i}.tif','frames':96,'channels':[0,1],
+                       'shape':[96,2,512,512],'size':100663296,'scale':2.5,'missing':None,
+                       'complete':True,'record':{'index':i,'value':float(i)}} for i in range(count)]}
+        paired(f'complete_json/{count}',lambda:json.dumps(before(data),allow_nan=False),lambda:json.dumps(after(data),allow_nan=False))
+    if lv:
+        before,after=original('timeline','_block_mean_proxy')
+        data=np.random.default_rng(14).integers(0,65536,(512,512),dtype=np.uint16)
+        paired('block_mean_uint16/512',lambda:before(data),lambda:after(data))
+        from unittest.mock import patch
+        from pylv200 import channels
+        before,after=original('channels','channel_stats')
+        work.mkdir(parents=True,exist_ok=True)
+        for edge in (64,256,1024):
+            data=np.random.default_rng(14).integers(0,65536,(10,edge,edge),dtype=np.uint16)
+            path=work/'statistics.raw';path.write_bytes(data.tobytes())
+            length=edge*edge*2
+            meta=dict(chunks=[((i//5,i%5),i*length,length,path) for i in range(10)])
+            decoder=lambda blob,_:np.frombuffer(blob,dtype=np.uint16).reshape(edge,edge)
+            before.__globals__['decode_tile']=decoder
+            try:
+                with patch.object(channels,'decode_tile',decoder):
+                    paired('channel_statistics/'+str(edge),lambda:before(meta,{'names':['c','t']}),lambda:after(meta,{'names':['c','t']}))
+            finally:path.unlink()
+        before,after=original('setup','candidate_networks')
+        paired('setup:network_choices',before,after,pairs=5)
+    else:
+        before,after=original('timeline','downsample_native')
+        for shape,edge in (((512,512),256),((1152,1536),512),((2304,3072),512)):
+            data=np.random.default_rng(14).integers(0,65536,shape,dtype=np.uint16)
+            paired('downsample/'+str(shape),lambda:before(data,max_edge=edge),lambda:after(data,max_edge=edge))
+    return dict(source=fingerprint(root,root/prefix),baseline_sha256=hashlib.sha256(archive.read_bytes()).hexdigest(),
+                collector_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),rows=rows,
+                limitation='Paired local operations on shared host; full timeline/action collections remain required. Process CPU excludes child PowerShell CPU. Returned network metadata is compared but never persisted.')
+
+
+if __name__=='__main__':
+    parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--root',type=Path,required=True)
+    parser.add_argument('--work',type=Path,required=True)
+    a=parser.parse_args();root=a.root.resolve();result=run(root,a.work.resolve())
+    (root/'docs/software-performance/accepted-residuals.json').write_text(json.dumps(result,indent=2)+'\n')
+    print([(r['id'],r['ratio']) for r in result['rows']])

pylv200-0.1.3/scripts/benchmark_catalogues.py

@@ -0,0 +1,73 @@
+"""Paired real-client catalogue growth probes, separate from image-size trials."""
+import argparse
+import contextlib
+import importlib
+import io
+import json
+import os
+from pathlib import Path
+import sys
+import struct
+import time
+from benchmark_workflows import canonical, environment, fingerprint, memory
+
+
+def run(root,work,size,thumbnail_bytes=0):
+    lv=(root/'src/pylv200').exists();name='pylv200' if lv else 'pyincucyte'
+    sys.path[:0]=[str(root/'src'),str(root),str(root/'tests')]
+    work.mkdir(parents=True,exist_ok=True)
+    os.environ['PYLV200_HOME']=str(work/'settings');os.environ['PYINCUCYTE_HOME']=str(work/'settings')
+    package=root/('src/pylv200' if lv else 'pyincucyte');source=fingerprint(root,package)
+    pkg=importlib.import_module(name);count={'small':8,'typical':64,'growth':512}[size];rows=[]
+    with contextlib.ExitStack() as stack:
+        if lv:
+            from tests.synthetic import make_ets,make_vsi
+            for i in range(count):
+                folder=work/'input'/f'Run{i:04}'
+                make_ets(folder/'sample.ets',tile=16,nc=2,nt=2,grid_x=1,grid_y=1)
+                make_vsi(folder/'sample.vsi',['BF','GFP'],experiment=f'Run{i:04}')
+                if thumbnail_bytes:
+                    import random
+                    file=folder/'sample.vsi';blob=bytearray(file.read_bytes())
+                    ifd=struct.unpack_from('<I',blob,4)[0]
+                    count_tags=struct.unpack_from('<H',blob,ifd)[0]
+                    for index in range(count_tags):
+                        entry=ifd+2+12*index
+                        if struct.unpack_from('<H',blob,entry)[0]==33560:
+                            offset=struct.unpack_from('<I',blob,entry+8)[0]
+                            assert blob[offset:offset+4]==b'SIS0'
+                            struct.pack_into('<I',blob,entry+8,offset+thumbnail_bytes)
+                            prefix=random.Random(20261014).randbytes(thumbnail_bytes)
+                            file.write_bytes(blob[:offset]+prefix+blob[offset:])
+                            break
+                    else:raise AssertionError('Missing declared metadata offset')
+                for p in folder.iterdir():os.utime(p,(1770000000,1770000000))
+            client=stack.enter_context(pkg.LV200Client(work/'input'))
+            fresh=lambda:client.experiments(refresh=True,live=True)
+            cached=lambda:client.experiments()
+        else:
+            from fakes import FakeDevice,patched,logged_in_store,vessel_record
+            device=FakeDevice(vessels=[vessel_record(vessel_id=i+1,name=f'Run{i:04}') for i in range(count)])
+            stack.enter_context(patched(device))
+            client=stack.enter_context(pkg.IncucyteClient('10.0.0.1',store=logged_in_store(work)))
+            fresh=lambda:client.vessels(refresh=True)
+            cached=lambda:client.vessels()
+        outputs={}
+        for label,fn in [('catalogue:fresh',fresh),('catalogue:warm',cached),('catalogue:refresh',fresh)]:
+            if thumbnail_bytes:label=label.replace('catalogue:','catalogue:thumbnail_')
+            start=time.perf_counter();value=fn();elapsed=time.perf_counter()-start
+            assert len(value)==count
+            result=canonical([v.to_dict() for v in value],work)
+            rows.append(dict(id=label,seconds=elapsed,result=result,memory=memory()))
+            outputs[label]=result
+    assert source==fingerprint(root,package)
+    return dict(package=name,size=size,source=source,rows=rows,outputs=outputs,environment=environment(),fixture={'catalogue_items':count,'opaque_thumbnail_sized_prefix_bytes':thumbnail_bytes},limitations='Actual client methods; synthetic files or simulated device transport. Optional opaque prefix represents thumbnail byte-scan cost, not JPEG decoding.')
+
+
+if __name__=='__main__':
+    p=argparse.ArgumentParser(description=__doc__)
+    for name in ('root','work','out'):p.add_argument('--'+name,type=Path,required=True)
+    p.add_argument('--size',choices=('small','typical','growth'),default='small');a=p.parse_args()
+    with contextlib.redirect_stdout(io.StringIO()):result=run(a.root.resolve(),a.work.resolve(),a.size)
+    a.out.write_text(json.dumps(result,indent=2,default=str)+'\n')
+    print(json.dumps({'ok':True,'cases':len(result['rows'])}))

pylv200-0.1.3/scripts/benchmark_channel_statistics.py

@@ -0,0 +1,62 @@
+"""Test repeated variance elimination in complete channel statistics, without editing production."""
+import argparse
+import inspect
+import json
+from pathlib import Path
+import statistics
+import sys
+import time
+from collections import defaultdict
+
+
+def run(root, work):
+    sys.path.insert(0, str(root/'src'))
+    import numpy as np
+    from pylv200 import channels
+    from benchmark_workflows import fingerprint
+    work.mkdir(parents=True, exist_ok=True)
+    source = inspect.getsource(channels.channel_stats)
+    source = source.replace('dx = np.diff(f0, axis=1)', 'dx = np.diff(f0, axis=1)\n        dx_variance = dx.var()')
+    source = source.replace('f0.var() / dx.var()) if dx.var() > 0', 'f0.var() / dx_variance) if dx_variance > 0')
+    namespace = dict(channels.__dict__)
+    exec(compile(source, '<single variance prototype>', 'exec'), namespace)
+    candidate = namespace['channel_stats']
+    rows = []
+    for edge in (64, 256, 1024):
+        frames = np.random.default_rng(14).integers(0, 65536, (10, edge, edge), dtype=np.uint16)
+        path = work/'channel-frames.raw'
+        path.write_bytes(frames.tobytes())
+        frame_bytes = edge*edge*2
+        meta = dict(chunks=[((i//5, i%5), i*frame_bytes, frame_bytes, path) for i in range(10)])
+        # Exercise complete file reads and statistics with a fixed raw decoder.
+        decoder = lambda blob, _: np.frombuffer(blob, dtype=np.uint16).reshape(edge, edge)
+        old_decoder = channels.decode_tile
+        channels.decode_tile = decoder
+        namespace['decode_tile'] = decoder
+        try:
+            samples = {'before': [], 'after': []}
+            results = {}
+            for pair in range(9):
+                for label in ('before', 'after') if pair%2 == 0 else ('after', 'before'):
+                    fn = channels.channel_stats if label == 'before' else candidate
+                    start = time.perf_counter()
+                    results[label] = fn(meta, {'names': ['c','t']})
+                    samples[label].append(time.perf_counter()-start)
+                assert results['before'] == results['after']
+            rows.append(dict(edge=edge, **samples, parity=True,
+                             ratio=statistics.median(samples['before'])/statistics.median(samples['after']),
+                             saved_seconds=statistics.median(samples['before'])-statistics.median(samples['after'])))
+        finally:
+            channels.decode_tile = old_decoder
+            path.unlink()
+    return dict(source=fingerprint(root, root/'src/pylv200'), rows=rows,
+                scope='Complete statistics on two channels, five raw frames each. Only duplicate horizontal-difference variance removed; production unchanged.')
+
+
+if __name__ == '__main__':
+    p=argparse.ArgumentParser(description=__doc__)
+    for name in ('root','work','out'):p.add_argument('--'+name,type=Path,required=True)
+    a=p.parse_args()
+    result=run(a.root.resolve(),a.work.resolve())
+    a.out.write_text(json.dumps(result,indent=2)+'\n')
+    print([(r['edge'],r['ratio'],r['saved_seconds']) for r in result['rows']])

pylv200-0.1.3/scripts/benchmark_concurrent.py

@@ -0,0 +1,52 @@
+"""Complete PyIncucyte export with its default four-worker download pool."""
+import argparse
+import contextlib
+from datetime import datetime,timedelta
+import io
+import json
+import os
+from pathlib import Path
+import sys
+import time
+from benchmark_workflows import canonical,environment,fingerprint,memory,output_files
+
+def run(root,work,size):
+    sys.path[:0]=[str(root),str(root/'tests')]
+    work.mkdir(parents=True,exist_ok=True);os.environ['PYINCUCYTE_HOME']=str(work/'settings')
+    import pyincucyte as pkg
+    from fakes import FakeDevice,patched,logged_in_store,tiff_bytes
+    before=fingerprint(root,root/'pyincucyte')
+    count,edge={'small':(4,64),'typical':(24,256),'growth':(96,512),'native':(24,1536)}[size]
+    shape=(1152,1536) if size=='native' else (edge,edge)
+    class Device(FakeDevice):
+        def fetch_image(self,host,token,item,max_retries=3):
+            return pixels[int(item.get('img_type',1))],None
+    scans=[(datetime(2026,3,1,9)+timedelta(minutes=5*i)).isoformat() for i in range(count)]
+    device=Device(scans=scans,wells=((0,0),(0,1)),channels=(1,2))
+    pixels={c:tiff_bytes(value=c*100,shape=shape) for c in (1,2)}
+    options=pkg.ExportOptions(output=str(work/'output'),vessels=[38],wells='A1-A2',channels='phase,green',start_from='2026-03-01',end_at='2026-03-01',layout='time_channel_stack')
+    assert options.workers==4
+    with patched(device),pkg.IncucyteClient('10.0.0.1',store=logged_in_store(work)) as client:
+        import psutil
+        process=psutil.Process();io_before=process.io_counters();cpu=time.process_time()
+        start=time.perf_counter();result=client.fetch(options);elapsed=time.perf_counter()-start
+        cpu=time.process_time()-cpu;io_after=process.io_counters()
+    assert result.files
+    outputs=output_files(work/'output');assert outputs
+    native=canonical(result.to_dict(),work)
+    comparison=dict(native)
+    # The public client appends from the completion callback. Baseline trials
+    # themselves return A1/A2 in either order. Keep that exact arrival list in
+    # the receipt, and compare independent output files by their declared path.
+    files={item['path']:item for item in native['files']}
+    assert len(files)==len(native['files'])
+    comparison['files']=files
+    assert before==fingerprint(root,root/'pyincucyte')
+    return dict(package='pyincucyte',size=size,source=before,rows=[dict(id='workflow:default_workers',seconds=elapsed,cpu_seconds=cpu,io_delta={k:getattr(io_after,k)-getattr(io_before,k) for k in io_before._fields},result=comparison,memory=memory())],native_result=native,outputs=outputs,environment=environment(),fixture=dict(frames=count,shape=shape,workers=4),limitations='Real public fetch and worker pool; simulated transport excludes network waits. Native completion order is retained; independent files compared by path. Within-file frame, channel and pixel order are exact. CPU covers all process threads; I/O counters surround the timed fetch.')
+
+if __name__=='__main__':
+    p=argparse.ArgumentParser(description=__doc__)
+    for name in ('root','work','out'):p.add_argument('--'+name,type=Path,required=True)
+    p.add_argument('--size',default='small');a=p.parse_args()
+    with contextlib.redirect_stdout(io.StringIO()):result=run(a.root.resolve(),a.work.resolve(),a.size)
+    a.out.write_text(json.dumps(result,indent=2)+'\n');print('Default-worker export complete')