aignostics 0.2.232__tar.gz → 0.2.234__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aignostics
-Version: 0.2.232
+Version: 0.2.234
 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.234}/examples/notebook.py

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "aignostics"
-version = "0.2.232"
+version = "0.2.234"
 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.234"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{aignostics-0.2.232 → aignostics-0.2.234}/src/aignostics/gui/_frame.py

@@ -20,6 +20,11 @@ FLAT_COLOR_WHITE = "flat color=white"
 
 HEALTH_UPDATE_INTERVAL = 30
 USERINFO_UPDATE_INTERVAL = 60 * 60
+PROPS_CLICKABLE = "clickable"
+PROPS_AVATAR = "avatar"
+CLASSES_FULL_WIDTH = "w-full"
+CLASSES_FULL_HEIGHT = "h-full"
+CLASSES_FULL_SIZE = f"{CLASSES_FULL_WIDTH} {CLASSES_FULL_HEIGHT}"
 
 
 @contextmanager
@@ -47,9 +52,38 @@ def frame(  # noqa: C901, PLR0915
     from aignostics.platform import Service as PlatformService  # noqa: PLC0415
     from aignostics.platform import UserInfo, settings  # noqa: PLC0415
     from aignostics.system import Service as SystemService  # noqa: PLC0415
+    from aignostics.utils import NavItem, gui_get_nav_groups  # noqa: PLC0415
 
     theme()
 
+    def _nav_item(icon: str, label: str, target: str, marker: str, new_tab: bool = True) -> None:
+        """Create a navigation item with icon and link."""
+        with ui.item().props(PROPS_CLICKABLE).classes(CLASSES_FULL_WIDTH):
+            with ui.item_section().props(PROPS_AVATAR):
+                ui.icon(icon, color="primary")
+            with ui.item_section():
+                ui.link(label, target, new_tab=new_tab).mark(marker)
+
+    def _render_nav_item(item: NavItem) -> None:
+        """Render a single NavItem."""
+        _nav_item(item.icon, item.label, item.target, item.marker or "", item.new_tab)
+
+    def _render_nav_groups() -> None:
+        """Render all navigation groups from discovered NavBuilders."""
+        nav_groups = gui_get_nav_groups()
+        for group in nav_groups:
+            if group.use_expansion:
+                with (
+                    ui.expansion(group.name, icon=group.icon, group="nav").classes(CLASSES_FULL_WIDTH),
+                    ui.list().props("dense").classes(CLASSES_FULL_WIDTH),
+                ):
+                    for item in group.items:
+                        _render_nav_item(item)
+            else:
+                # Render items flat without expansion
+                for item in group.items:
+                    _render_nav_item(item)
+
     user_info: UserInfo | None = None
     launchpad_healthy: bool | None = None
 
@@ -247,6 +281,7 @@ def frame(  # noqa: C901, PLR0915
                     ui.label("Manage Cloud Bucket").classes(
                         "font-bold" if context.client.page.path == "/bucket" else "font-normal"
                     )
+            _render_nav_groups()
             with ui.item(on_click=lambda _: ui.navigate.to("/system")).props("clickable"):
                 with ui.item_section().props("avatar"):
                     health_icon()

{aignostics-0.2.232 → aignostics-0.2.234}/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.234}/src/aignostics/utils/__init__.py

@@ -22,10 +22,11 @@ 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
+from ._nav import BaseNavBuilder, NavGroup, NavItem, gui_get_nav_groups
 from ._process import SUBPROCESS_CREATION_FLAGS, ProcessInfo, get_process_info
 from ._service import BaseService
 from ._settings import UNHIDE_SENSITIVE_INFO, OpaqueSettings, load_settings, strip_to_none_before_validator
@@ -35,9 +36,12 @@ from .boot import boot
 __all__ = [
     "SUBPROCESS_CREATION_FLAGS",
     "UNHIDE_SENSITIVE_INFO",
+    "BaseNavBuilder",
     "BaseService",
     "Health",
     "LogSettings",
+    "NavGroup",
+    "NavItem",
     "OpaqueSettings",
     "ProcessInfo",
     "__author_email__",
@@ -60,8 +64,10 @@ __all__ = [
     "__version_full__",
     "boot",
     "console",
+    "discover_plugin_packages",
     "get_process_info",
     "get_user_data_directory",
+    "gui_get_nav_groups",
     "load_modules",
     "load_settings",
     "locate_implementations",

aignostics-0.2.234/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.234/src/aignostics/utils/_nav.py

@@ -0,0 +1,162 @@
+"""Navigation infrastructure for NiceGUI sidebar.
+
+This module provides:
+- NavItem: Individual navigation item dataclass
+- NavGroup: Group of navigation items
+- BaseNavBuilder: Abstract base class for module navigation builders
+- gui_get_nav_groups: Collect and sort navigation groups from all NavBuilders
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+
+from ._di import locate_subclasses
+
+
+@dataclass
+class NavItem:
+    """Navigation item for sidebar.
+
+    Attributes:
+        icon: Material icon name (e.g., 'waving_hand', 'settings').
+        label: Display label for the navigation item.
+        target: URL path or external URL for the link.
+        marker: Test marker for the item. Auto-generated from label if None.
+        new_tab: Whether to open the link in a new tab. Defaults to False (same tab).
+    """
+
+    icon: str
+    label: str
+    target: str
+    marker: str | None = None
+    new_tab: bool = False
+
+    def __post_init__(self) -> None:
+        """Auto-generate marker from label if not provided."""
+        if self.marker is None:
+            # Convert label to SCREAMING_SNAKE_CASE marker
+            self.marker = "LINK_" + self.label.upper().replace(" ", "_").replace("(", "").replace(")", "")
+
+
+@dataclass
+class NavGroup:
+    """Group of navigation items from a NavBuilder.
+
+    Used internally for rendering navigation in the sidebar.
+    """
+
+    name: str
+    icon: str = "folder"
+    items: list[NavItem] = field(default_factory=list)
+    position: int = 1000
+    use_expansion: bool = True
+
+
+class BaseNavBuilder(ABC):
+    """Base class for navigation builders.
+
+    Each module should have ONE NavBuilder that defines its navigation items.
+    NavBuilders are auto-discovered and used to populate the sidebar.
+
+    Example:
+        class NavBuilder(BaseNavBuilder):
+            @staticmethod
+            def get_nav_name() -> str:
+                return "My Module"
+
+            @staticmethod
+            def get_nav_items() -> list[NavItem]:
+                return [
+                    NavItem(icon="home", label="Home", target="/my-module"),
+                    NavItem(icon="settings", label="Settings", target="/my-module/settings"),
+                ]
+
+            @staticmethod
+            def get_nav_position() -> int:
+                return 200  # Lower = higher in sidebar
+    """
+
+    @staticmethod
+    @abstractmethod
+    def get_nav_name() -> str:
+        """Return the display name for this module's navigation group.
+
+        Returns:
+            str: Display name shown in sidebar (e.g., 'Hello World', 'System').
+        """
+
+    @staticmethod
+    @abstractmethod
+    def get_nav_items() -> list[NavItem]:
+        """Return navigation items for the sidebar.
+
+        Items are rendered in list order within the module's group.
+
+        Returns:
+            list[NavItem]: Navigation items for this module.
+        """
+
+    @staticmethod
+    def get_nav_position() -> int:
+        """Return position in sidebar (lower = higher).
+
+        Convention:
+            - 100-199: Core demo/example pages
+            - 200-499: Feature modules
+            - 500-799: Default (unspecified)
+            - 800-899: System/admin pages
+            - 900-999: External links (API docs, status, repo)
+
+        Returns:
+            int: Position value. Defaults to 1000.
+        """
+        return 1000
+
+    @staticmethod
+    def get_nav_icon() -> str:
+        """Return the icon for the navigation group expansion panel.
+
+        Uses Material Icons names. See: https://fonts.google.com/icons
+
+        Returns:
+            str: Material icon name. Defaults to 'folder'.
+        """
+        return "folder"
+
+    @staticmethod
+    def get_nav_use_expansion() -> bool:
+        """Return whether to render items in an expansion panel.
+
+        If True, items are grouped in a collapsible expansion with get_nav_name().
+        If False, items are rendered flat without grouping.
+
+        Returns:
+            bool: Use expansion panel. Defaults to True.
+        """
+        return True
+
+
+def gui_get_nav_groups() -> list[NavGroup]:
+    """Collect navigation groups from all NavBuilders.
+
+    Returns:
+        list[NavGroup]: Navigation groups sorted by position.
+    """
+    nav_builders = locate_subclasses(BaseNavBuilder)
+    groups: list[NavGroup] = []
+
+    for nav_builder in nav_builders:
+        items = nav_builder.get_nav_items()
+        if items:  # Only include builders with nav items
+            groups.append(
+                NavGroup(
+                    name=nav_builder.get_nav_name(),
+                    icon=nav_builder.get_nav_icon(),
+                    items=items,
+                    position=nav_builder.get_nav_position(),
+                    use_expansion=nav_builder.get_nav_use_expansion(),
+                )
+            )
+
+    # Sort by position (lower = higher in sidebar)
+    return sorted(groups, key=lambda g: g.position)

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