aignostics 0.2.232__tar.gz → 0.2.233__tar.gz

{aignostics-0.2.232 → aignostics-0.2.233}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aignostics
-Version: 0.2.232
+Version: 0.2.233
 Summary: 🔬 Python SDK providing access to the Aignostics Platform. Includes Aignostics Launchpad (Desktop Application), Aignostics CLI (Command-Line Interface), example notebooks, and Aignostics Client Library.
 Project-URL: Homepage, https://aignostics.readthedocs.io/en/latest/
 Project-URL: Documentation, https://aignostics.readthedocs.io/en/latest/

{aignostics-0.2.232 → aignostics-0.2.233}/examples/notebook.py

@@ -2,7 +2,7 @@
 # requires-python = ">=3.13"
 # dependencies = [
 #     "marimo",
-#     "aignostics==0.2.232",
+#     "aignostics==0.2.233",
 # ]
 # ///
 

{aignostics-0.2.232 → aignostics-0.2.233}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aignostics"
-version = "0.2.232"
+version = "0.2.233"
 description = "🔬 Python SDK providing access to the Aignostics Platform. Includes Aignostics Launchpad (Desktop Application), Aignostics CLI (Command-Line Interface), example notebooks, and Aignostics Client Library."
 readme = "README.md"
 authors = [
@@ -395,7 +395,7 @@ source = ["src/"]
 
 
 [tool.bumpversion]
-current_version = "0.2.232"
+current_version = "0.2.233"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{aignostics-0.2.232 → aignostics-0.2.233}/src/aignostics/qupath/_service.py

@@ -42,6 +42,7 @@ QUPATH_SCRIPT_MAX_EXECUTION_TIME = 60 * 60 * 2  # seconds, maximum wait time for
 
 PROJECT_FILENAME = "project.qpproj"
 ANNOTATIONS_BATCH_SIZE = 500000
+JSON_SUFFIX = ".json"
 
 
 class QuPathVersion(BaseModel):
@@ -1124,40 +1125,46 @@ class Service(BaseService):
             progress_callable(progress)
 
         # We communicate via file I/O with the Groovy script running within QuPath
-        with (
-            tempfile.NamedTemporaryFile(mode="w", suffix=".json", encoding="utf-8") as paths_file,
-            tempfile.NamedTemporaryFile(mode="w", suffix=".json", encoding="utf-8") as output_file,
-        ):
-            try:
-                json.dump([str(path.resolve()) for path in paths], paths_file.file)
-                paths_file.flush()
+        # Use delete=False to avoid Windows file locking issues - the file must be closed
+        # before QuPath can read it, but NamedTemporaryFile keeps files locked while open on Windows
+        paths_file = tempfile.NamedTemporaryFile(mode="w", suffix=JSON_SUFFIX, encoding="utf-8", delete=False)  # noqa: SIM115
+        output_file = tempfile.NamedTemporaryFile(mode="w", suffix=JSON_SUFFIX, encoding="utf-8", delete=False)  # noqa: SIM115
+        try:
+            # Write paths and close file so QuPath can read it
+            json.dump([str(path.resolve()) for path in paths], paths_file)
+            paths_file.close()
+            output_file.close()
 
-                pid = Service.execute_qupath(
-                    script=Service._find_groovy_script("add"),
-                    script_args=[str(project), str(paths_file.name), str(output_file.name)],
-                )
+            pid = Service.execute_qupath(
+                script=Service._find_groovy_script("add"),
+                script_args=[str(project), paths_file.name, output_file.name],
+            )
 
-                if not pid:
-                    message = "Failed to execute QuPath script for adding images."
-                    logger.error(message)
-                    raise RuntimeError(message)  # noqa: TRY301
-
-                with Path(output_file.name).open("r", encoding="utf-8") as f:
-                    result_data = json.load(f)
-                added_count = int(result_data.get("added_count", 0))
-                errors = result_data.get("errors", [])
-                for error in errors:
-                    logger.warning(f"QuPath add script error: {error}")
-
-                if progress_callable:
-                    progress.status = AddProgressState.COMPLETED
-                    progress_callable(progress)
-
-                return added_count
-            except Exception as e:
-                message = f"Failed to add images to QuPath project: {e!s}"
-                logger.exception(message)
-                raise RuntimeError(message) from e
+            if not pid:
+                message = "Failed to execute QuPath script for adding images."
+                logger.error(message)
+                raise RuntimeError(message)  # noqa: TRY301
+
+            with Path(output_file.name).open("r", encoding="utf-8") as f:
+                result_data = json.load(f)
+            added_count = int(result_data.get("added_count", 0))
+            errors = result_data.get("errors", [])
+            for error in errors:
+                logger.warning(f"QuPath add script error: {error}")
+
+            if progress_callable:
+                progress.status = AddProgressState.COMPLETED
+                progress_callable(progress)
+
+            return added_count
+        except Exception as e:
+            message = f"Failed to add images to QuPath project: {e!s}"
+            logger.exception(message)
+            raise RuntimeError(message) from e
+        finally:
+            # Clean up temp files
+            Path(paths_file.name).unlink(missing_ok=True)
+            Path(output_file.name).unlink(missing_ok=True)
 
     @staticmethod
     def annotate(
@@ -1246,9 +1253,12 @@ class Service(BaseService):
             RuntimeError: If there is an error inspecting the project.
         """
         # We communicate via file I/O with the Groovy script running within QuPath
-        with tempfile.NamedTemporaryFile(mode="w+", suffix=".json", encoding="utf-8") as temp_file:
-            output_file = Path(temp_file.name).resolve()
-
+        # Use delete=False to avoid Windows file locking issues - the file must be closed
+        # before QuPath can write to it, but NamedTemporaryFile keeps files locked while open on Windows
+        temp_file = tempfile.NamedTemporaryFile(mode="w+", suffix=JSON_SUFFIX, encoding="utf-8", delete=False)  # noqa: SIM115
+        output_file = Path(temp_file.name).resolve()
+        temp_file.close()
+        try:
             pid = Service.execute_qupath(
                 quiet=True,
                 project=project,
@@ -1267,3 +1277,5 @@ class Service(BaseService):
                 raise RuntimeError(message)
 
             return QuPathProject.model_validate_json(output_file.read_text(encoding="utf-8"))
+        finally:
+            output_file.unlink(missing_ok=True)

{aignostics-0.2.232 → aignostics-0.2.233}/src/aignostics/utils/__init__.py

@@ -22,7 +22,7 @@ from ._constants import (
     __version__,
     __version_full__,
 )
-from ._di import load_modules, locate_implementations, locate_subclasses
+from ._di import discover_plugin_packages, load_modules, locate_implementations, locate_subclasses
 from ._fs import get_user_data_directory, open_user_data_directory, sanitize_path, sanitize_path_component
 from ._health import Health
 from ._log import LogSettings
@@ -60,6 +60,7 @@ __all__ = [
     "__version_full__",
     "boot",
     "console",
+    "discover_plugin_packages",
     "get_process_info",
     "get_user_data_directory",
     "load_modules",

aignostics-0.2.233/src/aignostics/utils/_di.py

@@ -0,0 +1,113 @@
+"""Module for dynamic import and discovery of implementations and subclasses."""
+
+import importlib
+import pkgutil
+from functools import lru_cache
+from importlib.metadata import entry_points
+from inspect import isclass
+from typing import Any
+
+from ._constants import __project_name__
+
+_implementation_cache: dict[Any, list[Any]] = {}
+_subclass_cache: dict[Any, list[Any]] = {}
+
+# Entry point group name for aignostics plugins
+PLUGIN_ENTRY_POINT_GROUP = "aignostics.plugins"
+
+
+@lru_cache(maxsize=1)
+def discover_plugin_packages() -> tuple[str, ...]:
+    """
+    Discover plugin packages using entry points.
+
+    Plugins register themselves in their pyproject.toml:
+
+        [project.entry-points."aignostics.plugins"]
+        my_plugin = "my_plugin"
+
+    Results are cached after the first call.
+
+    Returns:
+        tuple[str, ...]: Tuple of discovered plugin package names.
+    """
+    eps = entry_points(group=PLUGIN_ENTRY_POINT_GROUP)
+    return tuple(ep.value for ep in eps)
+
+
+def load_modules() -> None:
+    package = importlib.import_module(__project_name__)
+    for _, name, _ in pkgutil.iter_modules(package.__path__):
+        importlib.import_module(f"{__project_name__}.{name}")
+
+
+def locate_implementations(_class: type[Any]) -> list[Any]:
+    """
+    Dynamically discover all instances of some class.
+
+    Searches in the main project and all plugins registered via entry points.
+
+    Args:
+        _class (type[Any]): Class to search for.
+
+    Returns:
+        list[Any]: List of discovered implementations of the given class.
+    """
+    if _class in _implementation_cache:
+        return _implementation_cache[_class]
+
+    plugin_packages = discover_plugin_packages()
+
+    implementations = []
+    for package_name in [*plugin_packages, __project_name__]:
+        package = importlib.import_module(package_name)
+
+        for _, name, _ in pkgutil.iter_modules(package.__path__):
+            module = importlib.import_module(f"{package_name}.{name}")
+            # Check all members of the module
+            for member_name in dir(module):
+                member = getattr(module, member_name)
+                if isinstance(member, _class):
+                    implementations.append(member)
+
+    _implementation_cache[_class] = implementations
+    return implementations
+
+
+def locate_subclasses(_class: type[Any]) -> list[Any]:
+    """
+    Dynamically discover all classes that are subclasses of some type.
+
+    Searches in the main project and all plugins registered via entry points.
+
+    Args:
+        _class (type[Any]): Parent class of subclasses to search for.
+
+    Returns:
+        list[type[Any]]: List of discovered subclasses of the given class.
+    """
+    if _class in _subclass_cache:
+        return _subclass_cache[_class]
+
+    plugin_packages = discover_plugin_packages()
+
+    subclasses = []
+    for package_name in [*plugin_packages, __project_name__]:
+        try:
+            package = importlib.import_module(package_name)
+        except ImportError:
+            continue
+
+        for _, name, _ in pkgutil.iter_modules(package.__path__):
+            try:
+                module = importlib.import_module(f"{package_name}.{name}")
+                # Check all members of the module
+                for member_name in dir(module):
+                    member = getattr(module, member_name)
+                    if isclass(member) and issubclass(member, _class) and member != _class:
+                        subclasses.append(member)
+            except ImportError:
+                continue
+
+    _subclass_cache[_class] = subclasses
+    return subclasses

aignostics-0.2.232/src/aignostics/utils/_di.py

@@ -1,76 +0,0 @@
-"""Module for dynamic import and discovery of implementations and subclasses."""
-
-import importlib
-import pkgutil
-from inspect import isclass
-from typing import Any
-
-from ._constants import __project_name__
-
-_implementation_cache: dict[Any, list[Any]] = {}
-_subclass_cache: dict[Any, list[Any]] = {}
-
-
-def load_modules() -> None:
-    package = importlib.import_module(__project_name__)
-    for _, name, _ in pkgutil.iter_modules(package.__path__):
-        importlib.import_module(f"{__project_name__}.{name}")
-
-
-def locate_implementations(_class: type[Any]) -> list[Any]:
-    """
-    Dynamically discover all instances of some class.
-
-    Args:
-        _class (type[Any]): Class to search for.
-
-    Returns:
-        list[Any]: List of discovered implementations of the given class.
-    """
-    if _class in _implementation_cache:
-        return _implementation_cache[_class]
-
-    implementations = []
-    package = importlib.import_module(__project_name__)
-
-    for _, name, _ in pkgutil.iter_modules(package.__path__):
-        module = importlib.import_module(f"{__project_name__}.{name}")
-        # Check all members of the module
-        for member_name in dir(module):
-            member = getattr(module, member_name)
-            if isinstance(member, _class):
-                implementations.append(member)
-
-    _implementation_cache[_class] = implementations
-    return implementations
-
-
-def locate_subclasses(_class: type[Any]) -> list[Any]:
-    """
-    Dynamically discover all classes that are subclasses of some type.
-
-    Args:
-        _class (type[Any]): Parent class of subclasses to search for.
-
-    Returns:
-        list[type[Any]]: List of discovered subclasses of the given class.
-    """
-    if _class in _subclass_cache:
-        return _subclass_cache[_class]
-
-    subclasses = []
-    package = importlib.import_module(__project_name__)
-
-    for _, name, _ in pkgutil.iter_modules(package.__path__):
-        try:
-            module = importlib.import_module(f"{__project_name__}.{name}")
-            # Check all members of the module
-            for member_name in dir(module):
-                member = getattr(module, member_name)
-                if isclass(member) and issubclass(member, _class) and member != _class:
-                    subclasses.append(member)
-        except ImportError:
-            continue
-
-    _subclass_cache[_class] = subclasses
-    return subclasses