plexora 0.0.32__tar.gz → 0.0.35__tar.gz

{plexora-0.0.32/plexora.egg-info → plexora-0.0.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexora
-Version: 0.0.32
+Version: 0.0.35
 Summary: OpenSeadragon-based cellular image viewing and analysis tool.
 Author-email: BioCognia <support@biocognia.com>
 License-Expression: LicenseRef-Plexora-EULA-1.0
@@ -15,6 +15,7 @@ License-File: LICENSE
 Requires-Dist: aiohttp>=3.14.4
 Requires-Dist: anndata>=0.10
 Requires-Dist: biocognia<0.2,>=0.1.2
+Requires-Dist: biocognia-intelligence<0.4,>=0.2.1
 Requires-Dist: Flask>=3.1
 Requires-Dist: fsspec>=2024.12
 Requires-Dist: h5py>=3.16.0

{plexora-0.0.32 → plexora-0.0.35}/plexora/agent/bridge_wire.py

@@ -182,3 +182,22 @@ def job_state(record: dict) -> dict:
                                         "message": f"the job was {record.get('status')}"}
         out["error"] = problem(error)
     return out
+
+
+def encode_images(result):
+    """`result` with its `_images` -- PNG bytes, or `{data: bytes, format}` -- as
+    `{"data": "<base64>", "encoding": "base64", "format"}` each, so JSON can
+    carry them (the protocol's wire form, `spatialbridge.images`). Anything
+    else unchanged."""
+    import base64
+
+    if not isinstance(result, dict) or not result.get("_images"):
+        return result
+    encoded = []
+    for image in result["_images"]:
+        data, fmt = (image, "png") if isinstance(image, (bytes, bytearray)) else (
+            (image.get("data"), image.get("format") or "png") if isinstance(image, dict) else (None, None))
+        if isinstance(data, (bytes, bytearray)):
+            encoded.append({"data": base64.b64encode(bytes(data)).decode("ascii"), "encoding": "base64",
+                            "format": str(fmt)})
+    return {**result, "_images": encoded}

{plexora-0.0.32 → plexora-0.0.35}/plexora/agent/core/project.py

@@ -679,6 +679,67 @@ def _record_depth_roles(name, roles):
     record.patch(dataset=spec).with_confirmed(tuple(f"role:{key}" for key in named)).save()
 
 
+# -- which project shows this image (another application's import) ---------------
+
+
+class ImportInput(AgentModel):
+    image: str = Field(description="Path to the image on this machine (OME-TIFF, TIFF, "
+                                   "OME-Zarr, a whole-slide file).")
+    mask: str | None = Field(None, description="Its segmentation mask (a label image), for "
+                             "a new project.")
+    table: str | None = Field(None, description="Its cell table (CSV, Parquet, .h5ad, a "
+                              "SpatialData store), for a new project.")
+    name: str | None = Field(None, description="The new project's name; default from the "
+                             "image's filename.")
+    dataset: str | None = Field(None, description="Put the new project in this dataset.")
+
+
+def import_image(call, inp):
+    """The project that shows this image, made from it when there is none.
+
+    What another application calls when a person adds an image to its
+    workspace (Biocognia Intelligence, through `plexora_intelligence`). A
+    project already showing this file -- matched on the file, however its path
+    is spelled, as quick view matches it -- is answered as it is, its mask and
+    table left alone. Otherwise one is made from the image, with the mask and
+    table when they are given (`datasets.create_project`). The image is read
+    where it lies, never copied; what is written is Plexora's project
+    registry, and for a large TIFF with no reduced-resolution levels the
+    one-time pyramidized copy every import makes of it.
+    """
+    import os
+    from pathlib import Path
+
+    from plexora import datasets, get_config
+    from plexora.agent.receipts import make_receipt
+    from plexora.datasource import _find_existing_datasource_for_image
+
+    # Absolute, so the project never depends on this process's working folder.
+    image = Path(os.path.abspath(Path(inp.image).expanduser()))
+    if not image.exists():
+        raise AgentError("invalid_input", f"no image at {inp.image}",
+                         detail={"image": str(image)})
+    if not os.access(image, os.R_OK):
+        raise AgentError("invalid_input", f"{inp.image} cannot be read by Plexora",
+                         detail={"image": str(image)})
+    found = _find_existing_datasource_for_image(image, get_config())
+    if found:
+        call.project_name = found
+        return {"project": found, "created": False, "image": str(image)}
+    try:
+        name = datasets.create_project(str(image), name=inp.name, segmentation=inp.mask,
+                                       data=inp.table, exist_ok=False, dataset=inp.dataset)
+    except ValueError as exc:
+        raise AgentError("invalid_input", str(exc), detail={"image": str(image)}) from None
+    call.project_name = name
+    receipt = make_receipt(
+        call, changed=True, before=None,
+        after={"project": name, "image": str(image), "mask": inp.mask, "table": inp.table},
+        persistent_state="config", reversible=False)
+    return {"project": name, "created": True, "image": str(image),
+            "receipt": receipt.model_dump(mode="json")}
+
+
 def capabilities():
     return [
         Capability(
@@ -759,6 +820,14 @@ def capabilities():
             permission="reversible_write", input_model=BindInput, handler=bind_project,
             writes=("project",), persistent=True, reversible=False,
             tags=("project", "bind", "bridge", "handoff")),
+        Capability(
+            name="project.import", tool_name="import_image", owner="core",
+            purpose="The project that shows an image file on this machine, made from it (with "
+                    "its mask and cell table, when given) when there is none yet: the image is "
+                    "read where it lies, and a project already showing it is answered as it is.",
+            permission="reversible_write", input_model=ImportInput, handler=import_image,
+            writes=("project",), persistent=True, reversible=False,
+            tags=("project", "import", "image", "bridge", "handoff")),
         Capability(
             name="resource.status", tool_name="get_resource_status", owner="core",
             purpose="Where a project's image, mask and table are (this machine or a data "

{plexora-0.0.32 → plexora-0.0.35}/plexora/api/plugin.py

@@ -116,6 +116,27 @@ def _depth_keys(project, wanted) -> list[str]:
     return ["role:z"] if int(getattr(project.image, "depth", 1) or 1) > 1 else []
 
 
+def _asked_as(project, keys) -> list[str]:
+    """`keys` with any `role:x`/`role:y` in it put the way this project can
+    answer them -- `_coordinate_keys`, at the place the first one stood.
+
+    For keys a plugin names outside `roles`: its optional inputs, and the ones
+    its panel asks for mid-session. Left literal, those were two column selects
+    over `obs` on an AnnData project, which cannot point at an `obsm` array --
+    the X and Y a user could not give were the ones their file already had.
+    """
+    wanted = [role for role in _COORDINATE_ROLES if f"role:{role}" in keys]
+    asked = []
+    for key in keys:
+        if key in (f"role:{role}" for role in _COORDINATE_ROLES):
+            fresh = _coordinate_keys(project, wanted)
+            wanted = []
+        else:
+            fresh = [key]
+        asked.extend(one for one in fresh if one not in asked)
+    return asked
+
+
 def _layer_matches(layer, wanted: str) -> bool:
     """Whether one layer answers a `Requires.layers` entry.
 
@@ -401,12 +422,13 @@ class Requires:
                        if key not in keys]
 
     def _optional_keys(self, project) -> tuple[str, ...]:
-        """`optional`, with Z beside an optional X and Y on a z-stack -- the
-        same question `_coordinate_keys` adds beside a required pair."""
-        wanted = [role for role in _COORDINATE_ROLES if f"role:{role}" in self.optional]
-        extra = tuple(key for key in _depth_keys(project, wanted)
-                      if key not in self.optional and key.split(":", 1)[1] not in self.roles)
-        return tuple(self.optional) + extra
+        """`optional`, with an optional X and Y asked the way a required pair
+        is (`_asked_as`): one `coordinates` question on AnnData and
+        SpatialData, Z beside them on a z-stack's table. What that adds is
+        dropped where the plugin already requires it."""
+        required = self._column_keys(project)
+        return tuple(key for key in _asked_as(project, self.optional)
+                     if key in self.optional or key not in required)
 
     def declared_keys(self, project) -> list[str]:
         """Every input this plugin names, required and optional, in ask order.
@@ -499,7 +521,7 @@ class Requires:
         declared = set(self.declared_keys(project))
         optional = self._optional_keys(project)
         return [requirement(key, optional=key in optional)
-                for key in keys
+                for key in _asked_as(project, list(keys))
                 if key in declared and not _answered(project, key)]
 
     def satisfied_by(self, project) -> bool:

{plexora-0.0.32 → plexora-0.0.35}/plexora/plugins/cell_explorer/__init__.py

@@ -84,12 +84,13 @@ PLUGIN = Plugin(
     # y)", so all three are offered and the panel checks for itself that at
     # least one arrived (see `intro`, and the empty state in panel.html).
     #
-    # `role:x`/`role:y` rather than `coordinates`: the coordinate question is a
-    # CSV one. On AnnData and SpatialData x/y are answered at import, when the
-    # adapter is told where to read them from, and asking again would put an
-    # obsm picker in front of a user whose coordinates are already resolved.
-    # Core translates between the two forms per format -- see plugin.py's
-    # _coordinate_keys.
+    # `role:x`/`role:y` rather than `coordinates`: a plugin names the roles it
+    # reads, and core decides which question answers them. On a CSV that is
+    # two column selects; on AnnData and SpatialData it is the one coordinate
+    # question, which can name an obsm array as well as two obs columns, and
+    # which coordinates already resolved at import count as answering. See
+    # plugin.py's _asked_as -- the panel's own "add what's missing" button
+    # names the same two roles and goes through it too.
     requires=Requires(
         table=True,
         roles=("cell_id",),

{plexora-0.0.32 → plexora-0.0.35}/plexora/plugins/figure_builder/static/figureQuickEdit.js

@@ -204,7 +204,16 @@ class FigureQuickEdit {
             ?.addEventListener("click", () => this.close());
         document.getElementById("fb_quickedit_main")
             ?.addEventListener("click", () => this.openInViewer());
-        this.zRange?.addEventListener("input", () => this.onPlaneInput());
+        // The app's slider (slider.js), wrapped around the template's input;
+        // a page without it keeps the bare input.
+        if (this.zRange && typeof PlexoraSlider !== "undefined") {
+            this.zSlider = new PlexoraSlider(this.zRange, {
+                integer: true, fieldId: "fb_quickedit_z_value",
+                onInput: (value) => this.onPlaneInput(value),
+            });
+        } else {
+            this.zRange?.addEventListener("input", () => this.onPlaneInput());
+        }
         this.bindView();
 
         // The card is a flex child of the body and the body is the window's:
@@ -229,6 +238,9 @@ class FigureQuickEdit {
 
     destroy() {
         this.resizeObserver?.disconnect();
+        // Gives the template's input back, for the next setup() to wrap.
+        this.zSlider?.destroy();
+        this.zSlider = null;
         this.close();
     }
 
@@ -680,20 +692,29 @@ class FigureQuickEdit {
         if (volume.mode === "slab") {
             // The range slides; its thickness is the panel's.
             const thickness = Math.max(0, volume.slab.z1 - volume.slab.z0);
-            this.zRange.max = String(Math.max(0, depth - 1 - thickness));
-            this.zRange.value = String(volume.slab.z0);
+            this.placePlane(Math.max(0, depth - 1 - thickness), volume.slab.z0);
         } else {
-            this.zRange.max = String(depth - 1);
-            this.zRange.value = String(Number(volume.z) || 0);
+            this.placePlane(depth - 1, Number(volume.z) || 0);
         }
         this.zLabel.textContent = this.planeLabel();
     }
 
-    onPlaneInput() {
+    /** The plane control's extent and position, without an event. */
+    placePlane(max, value) {
+        if (this.zSlider) {
+            this.zSlider.setBounds({ min: 0, max });
+            this.zSlider.set(value, { silent: true });
+        } else {
+            this.zRange.max = String(max);
+            this.zRange.value = String(value);
+        }
+    }
+
+    onPlaneInput(value) {
         const session = this.session;
         const volume = session?.volume;
         if (!volume || session.three) return;
-        const at = Math.round(Number(this.zRange.value) || 0);
+        const at = Math.round(Number(value ?? this.zRange.value) || 0);
         if (volume.mode === "slab" && volume.slab) {
             const thickness = volume.slab.z1 - volume.slab.z0;
             volume.slab = { ...volume.slab, z0: at, z1: at + thickness };

{plexora-0.0.32 → plexora-0.0.35}/plexora/plugins/figure_builder/static/figure_builder.css

@@ -3585,8 +3585,8 @@
     min-width: 7.5em;
 }
 
-.fb-quickedit-z input[type="range"] {
-    accent-color: var(--accent-channel);
+/* The app's slider (PlexoraSlider), wrapped around the template's input. */
+.fb-quickedit-z > .plx-slider {
     flex: 1 1 auto;
     min-width: 0;
 }

{plexora-0.0.32 → plexora-0.0.35}/plexora/plugins/gating/capabilities_session.py

@@ -2233,9 +2233,11 @@ def status(call, inp):
 class FinishInput(AgentModel):
     session_id: str
     action: Literal["close", "commit", "cancel", "rollback"] = Field(
-        "close", description="close: end the session (writes stay; a session the user "
-                             "stopped in the viewer is cancelled); commit: write a "
-                             "propose-mode session's accepted gates and empty gates; "
+        "close", description="close: end the session (writes stay; a marker not yet "
+                             "settled is written at the best gate it reached, for review; "
+                             "a session the user stopped in the viewer is cancelled); "
+                             "commit: write a propose-mode session's accepted gates and "
+                             "empty gates; "
                              "cancel: stop the bulk pass (writes stay); rollback: undo every "
                              "write the session made, newest first.")
 
@@ -2252,6 +2254,22 @@ def _save_versions(call, images, *, session_id=None, by=None):
             continue
 
 
+def _close_unsettled(engine):
+    """No marker is left ungated by a close or a commit: one still waiting on
+    a look, a check or the user is written (or, in propose mode, proposed) at
+    the best gate it reached, for review (`Engine.close`). A Stop is a cancel
+    and writes nothing: it may be for values that moved (`_matrix_moved`).
+    An auto-contrast session never gates, so it is left as it is."""
+    if engine.options["purpose"] == "contrast":
+        return
+    for unit in list(engine.record["units"].values()):
+        if unit["state"] not in schemas.TERMINAL_STATES:
+            engine.close(unit, "manual_review_recommended",
+                         "the session was closed before this marker was settled; written "
+                         "at the best gate it reached, for manual review",
+                         unlooked="session_closed")
+
+
 def finish(call, inp):
     from plexora.agent import jobs, registry
     from plexora.plugins.gating.server.autogate import engine as engines
@@ -2275,6 +2293,7 @@ def finish(call, inp):
         elif action == "commit":
             if record["options"]["mode"] != "propose":
                 raise AgentError("invalid_input", "commit is for a propose-mode session")
+            _close_unsettled(engine)              # proposed, then written below
             record["options"]["mode"] = "apply"
             written = []
             for unit in record["units"].values():
@@ -2326,6 +2345,7 @@ def finish(call, inp):
             if record["state"] == "bulk_running":
                 raise AgentError("conflict", "the bulk pass is still running; cancel it or "
                                  "wait for it", retryable=True)
+            _close_unsettled(engine)
             record["state"] = "done"
         record["finished_at"] = _now()
         if action != "rollback" and any(u.get("receipts") for u in record["units"].values()):

{plexora-0.0.32 → plexora-0.0.35}/plexora/plugins/gating/server/autogate/report.py

@@ -643,3 +643,20 @@ def provenance_long_of(ds, project=None) -> list:
                          **{k: row.get(k, "") for k in CLASSIFIER_COLUMNS}})
     return rows
 
+
+def source_extras(ds) -> dict:
+    """What a save to the source file writes beside the latest gates:
+    `provenance` -- a row per gated marker, who set it, how and when
+    (`uns[<table>_provenance]`) -- and `versions` (`model.versions_payload`).
+    Here, beside the rows it is made of, so gating's model imports nothing
+    from autogate (`tests/test_licensing_hardening.py::KNOWN_COUPLINGS`)."""
+    from plexora.agent import cell_exclusions
+
+    try:
+        qc_fp = cell_exclusions.fingerprint(cell_exclusions.call_record(ds))
+    except Exception:  # no QC to read: the provenance goes without it
+        qc_fp = ""
+    rows = [{**row, "call_mode": cell_exclusions.current_call_mode(), "qc_fingerprint": qc_fp}
+            for row in provenance_long_of(ds)]
+    return {"provenance": rows, "versions": model.versions_payload(ds.name)}
+

{plexora-0.0.32 → plexora-0.0.35}/plexora/plugins/gating/server/autogate/transitions.py

@@ -748,9 +748,9 @@ def apply_regression(engine, packet, answer):
             and not engine.options["whole_image_moves"]:
         # The rows of a look at candidates judged the very cells a move would
         # flip; one glance at the whole image does not overrule them. The
-        # gate stays, the failed checks unconfirmed (low confidence), and
-        # the disagreement is on the record -- not a review: a review gate is
-        # no partner's evidence, and the rows had settled it.
+        # gate stays where the rows put it and the disagreement is on the
+        # record; its failed checks unconfirmed, `finalize` writes it there
+        # marked for review (a failed check never accepts).
         unit["whole_image_disagreed"] = answer.verdict
         unit["look_flags"] = sorted(set(unit.get("look_flags") or [])
                                     | {"whole_image_disagreed"})

{plexora-0.0.32 → plexora-0.0.35}/plexora/plugins/gating/server/model.py

@@ -810,22 +810,6 @@ def versions_payload(datasource_name) -> list:
     return out
 
 
-def source_extras(ds) -> dict:
-    """What a save to the source file writes beside the latest gates:
-    `provenance` -- a row per gated marker, who set it, how and when
-    (`uns[<table>_provenance]`) -- and `versions` (`versions_payload`)."""
-    from plexora.agent import cell_exclusions
-    from plexora.plugins.gating.server.autogate import report
-
-    try:
-        qc_fp = cell_exclusions.fingerprint(cell_exclusions.call_record(ds))
-    except Exception:  # no QC to read: the provenance goes without it
-        qc_fp = ""
-    rows = [{**row, "call_mode": cell_exclusions.current_call_mode(), "qc_fingerprint": qc_fp}
-            for row in report.provenance_long_of(ds)]
-    return {"provenance": rows, "versions": versions_payload(ds.name)}
-
-
 def set_gate(ds, marker, low, high, *, expected_revision=None, allow_protected=False,
              empty=False):
     """Store one marker's range; returns (before, after, new_revision).

{plexora-0.0.32 → plexora-0.0.35}/plexora/plugins/gating/server/routes.py

@@ -396,6 +396,8 @@ def save_gates_to_anndata():
     active_gates = {channel: low for channel, (low, _high)
                     in gating_model.active_gates(dataset).items()}
 
+    from plexora.plugins.gating.server.autogate import report
+
     payload = {
         "image_id": datasource,
         "gates": active_gates,
@@ -403,7 +405,7 @@ def save_gates_to_anndata():
         "imageid_column": imageid_column,
         # Beside the latest gates: where each came from, and every version
         # kept (`<table>_provenance`, `<table>_versions`).
-        **gating_model.source_extras(dataset),
+        **report.source_extras(dataset),
     }
     # Markers the Single Cell Classifier decides, and those with a gating
     # session's layer, travel with the gates: their calls and scores as

{plexora-0.0.32 → plexora-0.0.35}/plexora/server/models/remote_sessions.py

@@ -861,7 +861,17 @@ class RemoteSession:
             if self.remote.gcloud:
                 self._prepare_compute()
             env = self._ssh_environment()
-            self.session = self._build(env)
+            built = self._build(env)
+            # A Disconnect while the machine was being readied or the session
+            # built found nothing to stop (stop() reads `self.session`), so it
+            # is honoured here: nothing is spawned for a session already ended.
+            with self._lock:
+                stopped = self._stopping
+                if not stopped:
+                    self.session = built
+            if stopped:
+                self._cleanup_helper()
+                return
             self.session.establish()
         except BaseException as exc:  # noqa: BLE001 - reported, never raised
             self._fail(exc)
@@ -883,7 +893,9 @@ class RemoteSession:
 
         self._report_connect("connected", started)
         with self._lock:
-            if self.state != STATE_FAILED:
+            # Not after a Disconnect that came during establishment: stop()
+            # has already said EXITED, and a session it ended stays ended.
+            if self.state != STATE_FAILED and not self._stopping:
                 self.state = STATE_CONNECTED
                 # For a job that was allocated instantly and never announced a
                 # queue wait. No-op for one that did -- see the method.

{plexora-0.0.32 → plexora-0.0.35}/plexora/server/routes/agent_routes.py

@@ -338,7 +338,7 @@ def call_capability(tool):
     tools included."""
     from plexora import api
     from plexora.agent import registry
-    from plexora.agent.bridge_wire import http_status, problem
+    from plexora.agent.bridge_wire import encode_images, http_status, problem
 
     try:
         policy, origin = _caller()
@@ -364,7 +364,8 @@ def call_capability(tool):
     if not answer["ok"]:
         return jsonify(success=False, error=problem(answer["error"]),
                        operation_id=answer.get("operation_id")), http_status(answer["error"])
-    return jsonify(success=True, result=answer["result"],
+    # A rendered image crosses as base64 (JSON cannot carry bytes).
+    return jsonify(success=True, result=encode_images(answer["result"]),
                    operation_id=answer.get("operation_id"))
 
 

{plexora-0.0.32 → plexora-0.0.35/plexora.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexora
-Version: 0.0.32
+Version: 0.0.35
 Summary: OpenSeadragon-based cellular image viewing and analysis tool.
 Author-email: BioCognia <support@biocognia.com>
 License-Expression: LicenseRef-Plexora-EULA-1.0
@@ -15,6 +15,7 @@ License-File: LICENSE
 Requires-Dist: aiohttp>=3.14.4
 Requires-Dist: anndata>=0.10
 Requires-Dist: biocognia<0.2,>=0.1.2
+Requires-Dist: biocognia-intelligence<0.4,>=0.2.1
 Requires-Dist: Flask>=3.1
 Requires-Dist: fsspec>=2024.12
 Requires-Dist: h5py>=3.16.0

{plexora-0.0.32 → plexora-0.0.35}/plexora.egg-info/requires.txt

@@ -1,6 +1,7 @@
 aiohttp>=3.14.4
 anndata>=0.10
 biocognia<0.2,>=0.1.2
+biocognia-intelligence<0.4,>=0.2.1
 Flask>=3.1
 fsspec>=2024.12
 h5py>=3.16.0