polystore 0.2.2__tar.gz → 0.2.4__tar.gz

{polystore-0.2.2/src/polystore.egg-info → polystore-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polystore
-Version: 0.2.2
+Version: 0.2.4
 Summary: Framework-agnostic multi-backend storage abstraction for ML and scientific computing
 Author-email: Tristan Simas <tristan.simas@mail.mcgill.ca>
 License-Expression: MIT

{polystore-0.2.2 → polystore-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "polystore"
-version = "0.2.2"
+version = "0.2.4"
 description = "Framework-agnostic multi-backend storage abstraction for ML and scientific computing"
 readme = "README.md"
 requires-python = ">=3.11"

{polystore-0.2.2 → polystore-0.2.4}/src/polystore/__init__.py

@@ -40,7 +40,6 @@ from .filemanager import FileManager
 from .formats import DEFAULT_IMAGE_EXTENSIONS, FileFormat
 from .imagej_runtime import (
     FIJI_IMAGEJ_RUNTIME,
-    ImageJJvmTeardown,
     ImageJRuntimePolicy,
     ImageJRuntimeUnavailableError,
 )
@@ -97,7 +96,6 @@ __all__ = [
     "Backend",
     "MemoryType",
     "FileFormat",
-    "ImageJJvmTeardown",
     "ImageJRuntimePolicy",
     "ImageJRuntimeUnavailableError",
     "FIJI_IMAGEJ_RUNTIME",

{polystore-0.2.2 → polystore-0.2.4}/src/polystore/bioformats_java.py

@@ -93,17 +93,30 @@ class BioFormatsJavaContext:
             self.FormatTools = format_tools
 
     def dispose(self) -> None:
-        """Dispose the owned ImageJ gateway before interpreter shutdown."""
+        """Dispose the current ImageJ gateway while keeping the JVM reusable."""
 
         with self._lifecycle_lock:
-            gateway = self.ij
-            self.ij = None
-            self.ImageReader = None
-            self.MetadataTools = None
-            self.FormatTools = None
+            gateway = self._detach_gateway()
             if gateway is not None:
                 gateway.dispose()
 
+    def shutdown(self) -> None:
+        """Stop the process-owned ImageJ context and JVM exactly once."""
+
+        with self._lifecycle_lock:
+            gateway = self._detach_gateway()
+            FIJI_IMAGEJ_RUNTIME.shutdown(gateway, self.scyjava)
+
+    def _detach_gateway(self) -> Any | None:
+        """Clear and return the currently owned ImageJ gateway."""
+
+        gateway = self.ij
+        self.ij = None
+        self.ImageReader = None
+        self.MetadataTools = None
+        self.FormatTools = None
+        return gateway
+
     @classmethod
     def dispose_instance(cls) -> None:
         """Dispose the initialized process-wide context without creating it."""
@@ -113,6 +126,16 @@ class BioFormatsJavaContext:
         if context is not None:
             context.dispose()
 
+    @classmethod
+    def shutdown_instance(cls) -> None:
+        """Stop and release the initialized process-wide context without creating it."""
+
+        with cls._lock:
+            context = cls._instance
+            cls._instance = None
+        if context is not None:
+            context.shutdown()
+
     def open_reader(self, source_path: str | Path) -> BioFormatsOpenedReader:
         self.ensure_initialized()
         metadata = self.MetadataTools.createOMEXMLMetadata()
@@ -136,7 +159,7 @@ class BioFormatsJavaContext:
             reader.close()
 
 
-register_cleanup_callback(BioFormatsJavaContext.dispose_instance)
+register_cleanup_callback(BioFormatsJavaContext.shutdown_instance)
 
 
 def java_int(value: Any) -> int | None:

{polystore-0.2.2 → polystore-0.2.4}/src/polystore/imagej_runtime.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import logging
 import time
 from dataclasses import dataclass
-from enum import Enum
 from typing import Any
 
 logger = logging.getLogger(__name__)
@@ -15,29 +14,14 @@ class ImageJRuntimeUnavailableError(RuntimeError):
     """Raised when an ImageJ distribution cannot use its declared Java runtime."""
 
 
-class ImageJJvmTeardown(Enum):
-    """JPype teardown behavior owned by an ImageJ process runtime."""
-
-    PROCESS_EXIT = False
-    DESTROY_JVM = True
-
-    def configure(self) -> None:
-        """Apply this teardown behavior before the process starts its JVM."""
-
-        import jpype.config
-
-        jpype.config.destroy_jvm = self.value
-
-
 @dataclass(frozen=True, slots=True)
 class ImageJRuntimePolicy:
-    """Own the endpoint and managed Java requirement for an ImageJ runtime."""
+    """Own an ImageJ endpoint, managed Java requirement, and process lifecycle."""
 
     endpoint: str
     java_fetch: str
     java_vendor: str
     java_version: str
-    jvm_teardown: ImageJJvmTeardown
     initialization_retry_delays_seconds: tuple[float, ...] = ()
 
     @property
@@ -82,7 +66,7 @@ class ImageJRuntimePolicy:
     def configure_java(self, scyjava_module: Any) -> None:
         """Select managed Java before startup or validate the active JVM."""
 
-        self.jvm_teardown.configure()
+        self._configure_controlled_jvm_shutdown()
         if scyjava_module.jvm_started():
             self.require_compatible_active_java(scyjava_module)
             return
@@ -92,6 +76,24 @@ class ImageJRuntimePolicy:
             version=self.java_version,
         )
 
+    def shutdown(self, gateway: Any | None, scyjava_module: Any) -> None:
+        """Dispose the ImageJ gateway and stop its JVM before Python finalization."""
+
+        self._configure_controlled_jvm_shutdown()
+        try:
+            if gateway is not None:
+                gateway.dispose()
+        finally:
+            scyjava_module.shutdown_jvm()
+
+    @staticmethod
+    def _configure_controlled_jvm_shutdown() -> None:
+        """Require explicit JVM destruction while Python runtime state is valid."""
+
+        import jpype.config
+
+        jpype.config.destroy_jvm = True
+
     def require_compatible_active_java(self, scyjava_module: Any) -> None:
         """Reject a JVM whose feature version differs from this declaration."""
 
@@ -122,6 +124,5 @@ FIJI_IMAGEJ_RUNTIME = ImageJRuntimePolicy(
     java_fetch="always",
     java_vendor="zulu-jre",
     java_version="21",
-    jvm_teardown=ImageJJvmTeardown.PROCESS_EXIT,
     initialization_retry_delays_seconds=(1.0, 2.0),
 )

{polystore-0.2.2 → polystore-0.2.4}/src/polystore/omero_tables.py

@@ -122,8 +122,8 @@ class OMEROTableService:
 
         return bool(connection.c.sf.sharedResources().areTablesEnabled())
 
-    def create_table(self, connection: Any, path: str) -> Any:
-        """Create one table through a ready service and repository declaration."""
+    def wait_until_available(self, connection: Any) -> Any:
+        """Return shared resources after the declared table capability is ready."""
 
         resources = connection.c.sf.sharedResources()
         retry_delays = iter(self.readiness_retry_delays_seconds)
@@ -139,6 +139,13 @@ class OMEROTableService:
             )
             time.sleep(retry_delay)
 
+        return resources
+
+    def create_table(self, connection: Any, path: str) -> Any:
+        """Create one table through a ready service and repository declaration."""
+
+        resources = self.wait_until_available(connection)
+
         repository_map = resources.repositories()
         descriptions = repository_map.descriptions
         if not descriptions:

{polystore-0.2.2 → polystore-0.2.4/src/polystore.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polystore
-Version: 0.2.2
+Version: 0.2.4
 Summary: Framework-agnostic multi-backend storage abstraction for ML and scientific computing
 Author-email: Tristan Simas <tristan.simas@mail.mcgill.ca>
 License-Expression: MIT

{polystore-0.2.2 → polystore-0.2.4}/tests/test_bioformats_java.py

@@ -23,6 +23,7 @@ class _Gateway:
 class _Runtime:
     def __init__(self) -> None:
         self.gateways: list[_Gateway] = []
+        self.shutdown_gateways: list[_Gateway | None] = []
 
     def initialize(self, imagej_module, scyjava_module, *, mode: str) -> _Gateway:
         assert imagej_module == "imagej"
@@ -32,11 +33,18 @@ class _Runtime:
         self.gateways.append(gateway)
         return gateway
 
+    def shutdown(self, gateway: _Gateway | None, scyjava_module) -> None:
+        self.shutdown_gateways.append(gateway)
+        if gateway is not None:
+            gateway.dispose()
+        scyjava_module.shutdown_jvm()
+
 
 class _ScyJava:
     def __init__(self, *, failing_import: str | None = None) -> None:
         self.failing_import = failing_import
         self.imports: list[str] = []
+        self.shutdown_count = 0
 
     def jimport(self, name: str) -> object:
         self.imports.append(name)
@@ -44,6 +52,9 @@ class _ScyJava:
             raise RuntimeError(f"could not import {name}")
         return object()
 
+    def shutdown_jvm(self) -> None:
+        self.shutdown_count += 1
+
 
 def test_bioformats_context_disposes_and_can_reinitialize(monkeypatch) -> None:
     runtime = _Runtime()
@@ -98,8 +109,11 @@ def test_dispose_instance_does_not_create_process_context(monkeypatch) -> None:
     assert BioFormatsJavaContext._instance is None
 
 
-def test_test_runtime_cleanup_disposes_process_context(monkeypatch) -> None:
-    context = BioFormatsJavaContext("imagej", _ScyJava())
+def test_test_runtime_cleanup_stops_process_context(monkeypatch) -> None:
+    runtime = _Runtime()
+    scyjava = _ScyJava()
+    monkeypatch.setattr(bioformats_java, "FIJI_IMAGEJ_RUNTIME", runtime)
+    context = BioFormatsJavaContext("imagej", scyjava)
     gateway = _Gateway()
     context.ij = gateway
     monkeypatch.setattr(BioFormatsJavaContext, "_instance", context)
@@ -108,3 +122,6 @@ def test_test_runtime_cleanup_disposes_process_context(monkeypatch) -> None:
 
     assert gateway.dispose_count == 1
     assert context.ij is None
+    assert runtime.shutdown_gateways == [gateway]
+    assert scyjava.shutdown_count == 1
+    assert BioFormatsJavaContext._instance is None

{polystore-0.2.2 → polystore-0.2.4}/tests/test_imagej_runtime.py

@@ -6,7 +6,6 @@ import pytest
 
 from polystore.imagej_runtime import (
     FIJI_IMAGEJ_RUNTIME,
-    ImageJJvmTeardown,
     ImageJRuntimePolicy,
     ImageJRuntimeUnavailableError,
 )
@@ -25,6 +24,7 @@ class _ScyJava:
     def __init__(self, *, started: bool, java_version: str) -> None:
         self._started = started
         self.constraints: list[dict[str, str]] = []
+        self.shutdown_count = 0
         self.config = SimpleNamespace(
             set_java_constraints=lambda **constraints: self.constraints.append(constraints)
         )
@@ -37,12 +37,27 @@ class _ScyJava:
         assert name == "java.lang.System"
         return self._system
 
+    def shutdown_jvm(self) -> None:
+        self.shutdown_count += 1
+        self._started = False
+
+
+class _Gateway:
+    def __init__(self, events: list[str] | None = None) -> None:
+        self.dispose_count = 0
+        self.events = events
+
+    def dispose(self) -> None:
+        self.dispose_count += 1
+        if self.events is not None:
+            self.events.append("gateway_disposed")
+
 
 class _ImageJ:
     def __init__(self, scyjava: _ScyJava) -> None:
         self._scyjava = scyjava
         self.calls: list[tuple[str, str]] = []
-        self.gateway = object()
+        self.gateway = _Gateway()
 
     def init(self, endpoint: str, *, mode: str) -> object:
         self.calls.append((endpoint, mode))
@@ -53,7 +68,7 @@ class _ImageJ:
 def test_fiji_runtime_selects_managed_java_before_initialization(monkeypatch) -> None:
     import jpype.config
 
-    monkeypatch.setattr(jpype.config, "destroy_jvm", True)
+    monkeypatch.setattr(jpype.config, "destroy_jvm", False)
     scyjava = _ScyJava(started=False, java_version="21.0.8")
     imagej = _ImageJ(scyjava)
 
@@ -62,7 +77,43 @@ def test_fiji_runtime_selects_managed_java_before_initialization(monkeypatch) ->
     assert gateway is imagej.gateway
     assert scyjava.constraints == [{"fetch": "always", "vendor": "zulu-jre", "version": "21"}]
     assert imagej.calls == [("sc.fiji:fiji", "headless")]
-    assert jpype.config.destroy_jvm is False
+    assert jpype.config.destroy_jvm is True
+
+
+def test_fiji_runtime_shuts_down_gateway_before_jvm(monkeypatch) -> None:
+    import jpype.config
+
+    events: list[str] = []
+    gateway = _Gateway(events)
+    scyjava = _ScyJava(started=True, java_version="21")
+    original_shutdown = scyjava.shutdown_jvm
+
+    def record_shutdown() -> None:
+        events.append("jvm_shutdown")
+        original_shutdown()
+
+    scyjava.shutdown_jvm = record_shutdown
+    monkeypatch.setattr(jpype.config, "destroy_jvm", False)
+
+    FIJI_IMAGEJ_RUNTIME.shutdown(gateway, scyjava)
+
+    assert events == ["gateway_disposed", "jvm_shutdown"]
+    assert gateway.dispose_count == 1
+    assert scyjava.shutdown_count == 1
+    assert jpype.config.destroy_jvm is True
+
+
+def test_fiji_runtime_stops_jvm_after_gateway_disposal_failure() -> None:
+    class _FailingGateway:
+        def dispose(self) -> None:
+            raise RuntimeError("gateway disposal failed")
+
+    scyjava = _ScyJava(started=True, java_version="21")
+
+    with pytest.raises(RuntimeError, match="gateway disposal failed"):
+        FIJI_IMAGEJ_RUNTIME.shutdown(_FailingGateway(), scyjava)
+
+    assert scyjava.shutdown_count == 1
 
 
 def test_runtime_accepts_compatible_active_java_without_reconfiguration() -> None:
@@ -95,7 +146,6 @@ def test_runtime_reports_an_unparseable_active_java_version() -> None:
         java_fetch="always",
         java_vendor="example-jre",
         java_version="21",
-        jvm_teardown=ImageJJvmTeardown.PROCESS_EXIT,
     )
     scyjava = _ScyJava(started=True, java_version="unknown")
 
@@ -138,7 +188,6 @@ def test_runtime_retries_initialization_only_before_jvm_start(monkeypatch) -> No
         java_fetch="always",
         java_vendor="example-jre",
         java_version="21",
-        jvm_teardown=ImageJJvmTeardown.PROCESS_EXIT,
         initialization_retry_delays_seconds=(0.1, 0.2),
     )
     scyjava = _ScyJava(started=False, java_version="21")
@@ -169,7 +218,6 @@ def test_runtime_preserves_final_failure_after_retry_schedule() -> None:
         java_fetch="always",
         java_vendor="example-jre",
         java_version="21",
-        jvm_teardown=ImageJJvmTeardown.PROCESS_EXIT,
         initialization_retry_delays_seconds=(0.0, 0.0),
     )
     scyjava = _ScyJava(started=False, java_version="21")

{polystore-0.2.2 → polystore-0.2.4}/tests/test_omero_tables.py

@@ -142,6 +142,19 @@ def test_table_service_waits_on_capability_instead_of_exception_text(
     assert resources.created_tables == [(7, "measurements.h5")]
 
 
+def test_table_service_exposes_declared_readiness_wait(monkeypatch) -> None:
+    observed_delays: list[float] = []
+    monkeypatch.setattr("polystore.omero_tables.time.sleep", observed_delays.append)
+    resources = _Resources([False, True])
+
+    ready_resources = OMEROTableService(
+        readiness_retry_delays_seconds=(0.1,),
+    ).wait_until_available(_connection(resources))
+
+    assert ready_resources is resources
+    assert observed_delays == [0.1]
+
+
 def test_table_service_fails_before_create_when_capability_stays_unavailable() -> None:
     resources = _Resources([False])