dataeval-plots 0.0.11__tar.gz → 0.0.13__tar.gz

{dataeval_plots-0.0.11 → dataeval_plots-0.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dataeval-plots
-Version: 0.0.11
+Version: 0.0.13
 Summary: DataEval companion package for plotting utilities
 Project-URL: Homepage, https://dataeval.ai/
 Project-URL: Repository, https://github.com/aria-ml/dataeval/
@@ -13,12 +13,12 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: matplotlib>=3.7.1
 Requires-Dist: numpy>=1.24.2; python_version < '3.12'
 Requires-Dist: numpy>=1.26.2; python_version >= '3.12'

{dataeval_plots-0.0.11 → dataeval_plots-0.0.13}/pyproject.toml

@@ -6,7 +6,7 @@ authors = [
   { name = "Andrew Weng", email = "andrew.weng@ariacoustics.com" },
   { name = "Ryan Wood", email = "ryan.wood@ariacoustics.com" },
 ]
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 readme = "README.md"
 license = "MIT"
 maintainers = [
@@ -18,10 +18,10 @@ classifiers = [
   "Intended Audience :: Science/Research",
   "License :: OSI Approved :: MIT License",
   "Programming Language :: Python :: 3 :: Only",
-  "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
   "Topic :: Scientific/Engineering",
 ]
 dependencies = [
@@ -86,6 +86,14 @@ dev = [
   "ipywidgets",
 ]
 
+[tool.uv]
+constraint-dependencies = [
+  "pillow>=13.0.0", # Pillow 13.0.0 security release (decoder/encoder OOB reads and writes, DoS):
+                    # CVE-2026-112395, CVE-2026-112397, CVE-2026-112400,
+                    # CVE-2026-112403, CVE-2026-112404, CVE-2026-112895,
+                    # CVE-2026-112896, CVE-2026-112897, CVE-2026-112899
+]
+
 [[tool.uv.index]]
 name = "pytorch-cpu"
 url = "https://download.pytorch.org/whl/cpu"
@@ -155,7 +163,7 @@ exclude = [
 ]
 line-length = 120
 indent-width = 4
-target-version = "py310"
+target-version = "py311"
 
 [tool.ruff.lint]
 select = ["A", "ANN", "C4", "C90", "E", "F", "I", "NPY", "S", "SIM", "RET", "RUF100", "UP"]

{dataeval_plots-0.0.11 → dataeval_plots-0.0.13}/src/dataeval_plots/__init__.py

@@ -198,7 +198,26 @@ def plot(
     >>> plot(result, images=dataset)  # Uses seaborn
     """
     plotting_backend = get_backend(backend)
-    return plotting_backend.plot(output, figsize=figsize, **kwargs)
+    return _display_once(plotting_backend.plot(output, figsize=figsize, **kwargs))
+
+
+def _display_once(result: Any) -> Any:
+    """
+    Close a returned matplotlib figure under the notebook inline backend, so the notebook draws it once.
+
+    The inline backend draws every open pyplot figure when a cell ends, and the notebook draws a returned figure as
+    the cell's value, so an open returned figure appears twice. Closing it leaves the returned value as the only
+    drawing. Under any other backend the figure stays open for ``plt.show()``, and a list of figures is left open
+    because a notebook shows a list as text.
+    """
+    import matplotlib
+    from matplotlib.figure import Figure
+
+    if isinstance(result, Figure) and "inline" in matplotlib.get_backend().lower():
+        import matplotlib.pyplot as plt
+
+        plt.close(result)
+    return result
 
 
 def project(
@@ -319,14 +338,16 @@ def project(
                 )
                 for m in methods
             ]
-            return plotting_backend.project_grid(
-                reduced_list,
-                methods=methods,
-                labels=labels_array,
-                label_names=label_names,
-                dimensions=dimensions,
-                figsize=figsize,
-                title=title,
+            return _display_once(
+                plotting_backend.project_grid(
+                    reduced_list,
+                    methods=methods,
+                    labels=labels_array,
+                    label_names=label_names,
+                    dimensions=dimensions,
+                    figsize=figsize,
+                    title=title,
+                )
             )
 
     # Single method
@@ -347,12 +368,14 @@ def project(
             )
         dimensions = embeddings_array.shape[1]  # type: ignore[assignment]
 
-    return plotting_backend.project(
-        embeddings_array,
-        labels=labels_array,
-        label_names=label_names,
-        method=method or "custom",
-        dimensions=dimensions,
-        figsize=figsize,
-        title=title,
+    return _display_once(
+        plotting_backend.project(
+            embeddings_array,
+            labels=labels_array,
+            label_names=label_names,
+            method=method or "custom",
+            dimensions=dimensions,
+            figsize=figsize,
+            title=title,
+        )
     )

{dataeval_plots-0.0.11 → dataeval_plots-0.0.13}/src/dataeval_plots/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.0.11'
-__version_tuple__ = version_tuple = (0, 0, 11)
+__version__ = version = '0.0.13'
+__version_tuple__ = version_tuple = (0, 0, 13)
 
 __commit_id__ = commit_id = None

{dataeval_plots-0.0.11 → dataeval_plots-0.0.13}/src/dataeval_plots/backends/_shared.py

@@ -167,8 +167,8 @@ def reduce_embeddings(
 
         # scikit-learn 1.8 renamed the non-metric switch from `metric` to `metric_mds`
         # -- `metric` now names the distance metric -- and moved `init` from fit() onto
-        # the constructor. 1.8 requires Python >=3.11, so on the 3.10 leg the lockfile
-        # necessarily resolves 1.7.x, where neither new spelling exists.
+        # the constructor. The projection extra still allows older releases, where neither
+        # new spelling exists.
         #
         # Ask the signature rather than compare version strings: it needs no extra
         # dependency and tests exactly the thing being depended on. Omitting `init` on
@@ -932,6 +932,61 @@ def _feasibility_band(
     )
 
 
+# These mirror DataEval's performance/_feasibility.py: _SOURCES, _source_name, _unit_noun and FeasibilityOutput._bounds
+_SOURCE_NAMES = {
+    "replica_ceiling/v1": "repeated labels",
+    "builtin_witness/v1:knn": "built-in k-NN",
+    "builtin_witness/v1:probe": "built-in linear probe",
+    "user_witness/v1": "your model",
+}
+_EVIDENCE_SCHEMA = {
+    "target_spec": pl.String,
+    "metric": pl.String,
+    "threshold": pl.Float64,
+    "source": pl.String,
+    "evidence_id": pl.String,
+    "information_scope": pl.String,
+    "unit": pl.String,
+    "bound_type": pl.String,
+    "observed": pl.Float64,
+    "bound": pl.Float64,
+    "n": pl.Int64,
+    "state": pl.String,
+}
+
+
+def _evidence_rows(output: PlottableFeasibility) -> pl.DataFrame:
+    """One row per endpoint on a target in ``determinations``, in their order, then the order of ``evidence``."""
+    targets = {r["target_spec"]: r for r in output.determinations.iter_rows(named=True)}
+    rows = []
+    for spec, target in targets.items():
+        for eid, ev in output.evidence.items():
+            for e in ev.endpoints:
+                if e.target_spec != spec:
+                    continue
+                stats = ev.details["endpoints"][spec] or {}
+                rows.append(
+                    {
+                        "target_spec": spec,
+                        "metric": target["metric"],
+                        "threshold": target["threshold"],
+                        "source": _GROUP_CEILING
+                        if ev.kind.startswith("local_panel_ceiling/v1")
+                        else _SOURCE_NAMES.get(eid, eid),
+                        "evidence_id": eid,
+                        "information_scope": ev.information_scope,
+                        "unit": "sequence" if ev.unit == "group" else "image",
+                        "bound_type": e.direction,
+                        # A ceiling's mean is panel agreement, not an observed score
+                        "observed": stats.get("mean") if e.direction == "lower" else None,
+                        "bound": e.value,
+                        "n": stats.get("n"),
+                        "state": e.state,
+                    }
+                )
+    return pl.DataFrame(rows, schema=_EVIDENCE_SCHEMA)
+
+
 def prepare_feasibility_data(output: PlottableFeasibility) -> list[FeasibilityBand]:
     """
     Prepare feasibility data for plotting across all backends.
@@ -955,7 +1010,7 @@ def prepare_feasibility_data(output: PlottableFeasibility) -> list[FeasibilityBa
         spec = json.loads(row["target_spec"])
         spec.pop("threshold", None)
         groups.setdefault(json.dumps(spec, sort_keys=True), []).append(row)
-    evidence = output.aggregate_by_evidence().to_dicts()
+    evidence = _evidence_rows(output).to_dicts()
     alpha = output.meta().state["alpha"]
     noun = _unit(rows, evidence) or "image"  # the printout's footer noun, for the whole call
     bands = []

{dataeval_plots-0.0.11 → dataeval_plots-0.0.13}/src/dataeval_plots/protocols.py

@@ -22,14 +22,16 @@ from datetime import datetime
 from typing import (
     Any,
     Literal,
+    NotRequired,
     Protocol,
+    Required,
     TypedDict,
     runtime_checkable,
 )
 
 import polars as pl
 from numpy.typing import NDArray
-from typing_extensions import NotRequired, ReadOnly, Required
+from typing_extensions import ReadOnly
 
 
 class ExecutionMetadata(Protocol):
@@ -287,36 +289,55 @@ class PlottableDriftMVDC(Plottable, Protocol):
     def plot_type(self) -> Literal["drift_mvdc"]: ...
 
 
+class FeasibilityEndpoint(Protocol):
+    """One bound on one target, as DataEval's ``Endpoint`` records it; only the fields the plot reads."""
+
+    @property
+    def target_spec(self) -> str: ...
+    @property
+    def value(self) -> float | None: ...
+    @property
+    def direction(self) -> Literal["lower", "upper"]: ...
+    @property
+    def state(self) -> str: ...
+
+
+class FeasibilityEvidence(Protocol):
+    """One evidence item, as DataEval's ``Evidence`` records it; only the fields the plot reads."""
+
+    @property
+    def kind(self) -> str: ...
+    @property
+    def information_scope(self) -> str: ...
+    @property
+    def unit(self) -> str: ...
+    @property
+    def endpoints(self) -> Sequence[FeasibilityEndpoint]: ...
+    @property
+    def details(self) -> Mapping[str, Any]: ...
+
+
 @runtime_checkable
 class PlottableFeasibility(Plottable, Protocol):
     """Protocol for feasibility plot outputs.
 
     Required attributes:
     - determinations: One row per target (DataFrame)
-    - aggregate_by_evidence(): One row per evidence item and target (DataFrame)
+    - evidence: Every evidence item of the call, by evidence id
     - meta().state["alpha"]: The call's error budget
     - plot_type -> 'feasibility'
 
-    DataFrame structures:
+    Structures:
     - determinations columns: target_spec, metric, threshold, judged_scope, determination, ceiling,
       ceiling_scope, witness, witness_source
-    - aggregate_by_evidence() columns: target_spec, metric, threshold, source, evidence_id,
-      information_scope, unit, bound_type, observed, bound, n, state, alpha, basis
+    - each evidence item: kind, information_scope, unit (``item`` or ``group``), endpoints (target_spec, value,
+      direction, state) and details["endpoints"][target_spec], which is None or holds the bound's mean and n
     """
 
     @property
     def determinations(self) -> pl.DataFrame: ...
-    def aggregate_by_evidence(self) -> pl.DataFrame:
-        """Evidence as a polars DataFrame.
-
-        Returns
-        -------
-        pl.DataFrame
-            One row per evidence item and target: each source's bound on the target, and its observed score
-            where one exists
-        """
-        ...
-
+    @property
+    def evidence(self) -> Mapping[str, FeasibilityEvidence]: ...
     @property
     def plot_type(self) -> Literal["feasibility"]: ...