simind-python-connector 1.1.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

simind_python_connector/__init__.py

@@ -3,18 +3,9 @@ simind-python-connector connector/adaptor API.
 """
 
 import importlib
-from importlib import metadata as _meta
 from typing import Any
 
-
-for _dist_name in ("simind-python-connector", __name__):
-    try:  # installed (pip/poetry)
-        __version__ = _meta.version(_dist_name)
-        break
-    except _meta.PackageNotFoundError:
-        continue
-else:  # editable / source checkout
-    __version__ = "1.1.1"
+from ._version import __version__ as __version__
 
 
 def __getattr__(name: str) -> Any:
@@ -58,9 +49,9 @@ __all__ = [
     "ProjectionResult",
     "PyTomographySimindAdaptor",
     "RuntimeOperator",
-    "SirfSimindAdaptor",
     "SimindPythonConnector",
     "SimulationConfig",
+    "SirfSimindAdaptor",
     "StirSimindAdaptor",
     "builders",
     "configs",

simind_python_connector/_version.py

@@ -0,0 +1,3 @@
+"""Canonical package version, also read by packaging and release tooling."""
+
+__version__ = "1.2.0"

simind_python_connector/backends/__init__.py

@@ -20,8 +20,9 @@ Usage:
 import importlib
 import logging
 import os
-from typing import TYPE_CHECKING, Any, Literal, Optional, Union
+from typing import TYPE_CHECKING, Any, Literal, Union
 
+from ..utils.import_helpers import _import_stir_extra
 from .base import AcquisitionDataInterface, ImageDataInterface
 
 
@@ -43,11 +44,11 @@ if TYPE_CHECKING:
         FloatVoxelsOnCartesianGrid = Any  # type: ignore[assignment]
 
 # Global backend state
-_backend: Optional[str] = None
+_backend: str | None = None
 _backend_initialized = False
 
 
-def _import_sirf_types() -> tuple[Optional[type], Optional[type]]:
+def _import_sirf_types() -> tuple[type | None, type | None]:
     """Import SIRF image/acquisition types lazily."""
     try:
         from sirf.STIR import AcquisitionData as SirfAcquisitionData  # type: ignore
@@ -57,7 +58,7 @@ def _import_sirf_types() -> tuple[Optional[type], Optional[type]]:
     return SirfImageData, SirfAcquisitionData
 
 
-def _import_stir_types() -> tuple[Optional[type], Optional[type]]:
+def _import_stir_types() -> tuple[type | None, type | None]:
     """Import STIR image/acquisition types lazily."""
     try:
         from stir import FloatVoxelsOnCartesianGrid as StirImageData  # type: ignore
@@ -68,7 +69,7 @@ def _import_stir_types() -> tuple[Optional[type], Optional[type]]:
     return StirImageData, StirProjData
 
 
-def detect_image_backend(obj: Any) -> Optional[str]:
+def detect_image_backend(obj: Any) -> str | None:
     """Return 'sirf' or 'stir' if obj is a native image type."""
     if obj is None:
         return None
@@ -84,7 +85,7 @@ def detect_image_backend(obj: Any) -> Optional[str]:
     return None
 
 
-def detect_acquisition_backend(obj: Any) -> Optional[str]:
+def detect_acquisition_backend(obj: Any) -> str | None:
     """Return 'sirf' or 'stir' if obj is a native acquisition type."""
     if obj is None:
         return None
@@ -101,8 +102,8 @@ def detect_acquisition_backend(obj: Any) -> Optional[str]:
 
 
 def detect_backend_from_interface(
-    obj: Union[ImageDataInterface, AcquisitionDataInterface, Any],
-) -> Optional[str]:
+    obj: ImageDataInterface | AcquisitionDataInterface | Any,
+) -> str | None:
     """Detect backend by unwrapping known interface objects."""
     native = getattr(obj, "native_object", None)
     if native is None:
@@ -115,7 +116,7 @@ def detect_backend_from_interface(
     return detect_acquisition_backend(native)
 
 
-def _activate_backend(preferred: Optional[str]) -> Optional[str]:
+def _activate_backend(preferred: str | None) -> str | None:
     """Force-activate a specific backend if requested."""
     if preferred is None:
         return None
@@ -150,7 +151,7 @@ def get_backend() -> str:
     except ImportError:
         try:
             importlib.import_module("stir")
-            importlib.import_module("stirextra")
+            _import_stir_extra()
 
             _backend = "stir"
             logger.info("Auto-detected STIR Python backend")
@@ -159,7 +160,7 @@ def get_backend() -> str:
                 "Neither SIRF nor STIR Python found. "
                 "Please install one of: "
                 "\n  - SIRF (sirf.STIR)"
-                "\n  - STIR Python (stir + stirextra)"
+                "\n  - STIR Python (stir + stir.extra)"
             )
 
     _backend_initialized = True
@@ -190,7 +191,7 @@ def set_backend(backend: Literal["sirf", "stir"]) -> None:
     elif backend == "stir":
         try:
             importlib.import_module("stir")
-            importlib.import_module("stirextra")
+            _import_stir_extra()
         except ImportError:
             raise ImportError("STIR Python is not available")
 
@@ -210,9 +211,10 @@ def reset_backend() -> None:
 
 
 def create_image_data(
-    filepath_or_object: Optional[
-        Union[str, ImageDataInterface, "ImageData", "FloatVoxelsOnCartesianGrid"]
-    ] = None,
+    filepath_or_object: Union[
+        str, ImageDataInterface, "ImageData", "FloatVoxelsOnCartesianGrid"
+    ]
+    | None = None,
 ) -> ImageDataInterface:
     """Create an image data object using the current backend.
 
@@ -294,9 +296,10 @@ def create_image_data(
 
 
 def create_acquisition_data(
-    filepath_or_object: Optional[
-        Union[str, AcquisitionDataInterface, "AcquisitionData", "ProjData"]
-    ] = None,
+    filepath_or_object: Union[
+        str, AcquisitionDataInterface, "AcquisitionData", "ProjData"
+    ]
+    | None = None,
 ) -> AcquisitionDataInterface:
     """Create an acquisition data object using the current backend.
 
@@ -379,7 +382,7 @@ def create_acquisition_data(
 
 
 def load_image_data(
-    filepath: str, backend: Optional[Literal["sirf", "stir"]] = None
+    filepath: str, backend: Literal["sirf", "stir"] | None = None
 ) -> ImageDataInterface:
     """Load image data from file for the requested backend.
 
@@ -408,7 +411,7 @@ def load_image_data(
 
 
 def load_acquisition_data(
-    filepath: str, backend: Optional[Literal["sirf", "stir"]] = None
+    filepath: str, backend: Literal["sirf", "stir"] | None = None
 ) -> AcquisitionDataInterface:
     """Load acquisition data from file for the requested backend.
 
@@ -454,7 +457,7 @@ def is_stir_backend() -> bool:
     return get_backend() == "stir"
 
 
-def unwrap(obj: Union[ImageDataInterface, AcquisitionDataInterface]):
+def unwrap(obj: ImageDataInterface | AcquisitionDataInterface):
     """Get the native object from a wrapped backend object.
 
     Args:
@@ -469,19 +472,19 @@ def unwrap(obj: Union[ImageDataInterface, AcquisitionDataInterface]):
 
 
 __all__ = [
-    "get_backend",
-    "set_backend",
-    "reset_backend",
-    "detect_image_backend",
+    "AcquisitionDataInterface",
+    "ImageDataInterface",
+    "create_acquisition_data",
+    "create_image_data",
     "detect_acquisition_backend",
     "detect_backend_from_interface",
-    "create_image_data",
-    "create_acquisition_data",
-    "load_image_data",
-    "load_acquisition_data",
+    "detect_image_backend",
+    "get_backend",
     "is_sirf_backend",
     "is_stir_backend",
+    "load_acquisition_data",
+    "load_image_data",
+    "reset_backend",
+    "set_backend",
     "unwrap",
-    "ImageDataInterface",
-    "AcquisitionDataInterface",
 ]

simind_python_connector/backends/base.py

@@ -6,7 +6,6 @@ for working with both SIRF and STIR Python libraries.
 """
 
 from abc import ABC, abstractmethod
-from typing import Tuple, Union
 
 import numpy as np
 
@@ -28,7 +27,6 @@ class ImageDataInterface(ABC):
         Returns:
             ImageDataInterface: Wrapped image object
         """
-        pass
 
     @abstractmethod
     def write(self, filepath: str) -> None:
@@ -37,16 +35,14 @@ class ImageDataInterface(ABC):
         Args:
             filepath: Output file path
         """
-        pass
 
     @abstractmethod
-    def fill(self, data: Union[np.ndarray, float]) -> None:
+    def fill(self, data: np.ndarray | float) -> None:
         """Fill image with data.
 
         Args:
             data: Numpy array or scalar value
         """
-        pass
 
     @abstractmethod
     def clone(self) -> "ImageDataInterface":
@@ -55,7 +51,6 @@ class ImageDataInterface(ABC):
         Returns:
             ImageDataInterface: Cloned image object
         """
-        pass
 
     @abstractmethod
     def get_uniform_copy(self, value: float) -> "ImageDataInterface":
@@ -67,25 +62,22 @@ class ImageDataInterface(ABC):
         Returns:
             ImageDataInterface: New uniform image
         """
-        pass
 
     @abstractmethod
-    def dimensions(self) -> Tuple[int, int, int]:
+    def dimensions(self) -> tuple[int, int, int]:
         """Get image dimensions.
 
         Returns:
             Tuple[int, int, int]: (z, y, x) dimensions
         """
-        pass
 
     @abstractmethod
-    def voxel_sizes(self) -> Tuple[float, float, float]:
+    def voxel_sizes(self) -> tuple[float, float, float]:
         """Get voxel sizes in mm.
 
         Returns:
             Tuple[float, float, float]: (z, y, x) voxel sizes
         """
-        pass
 
     @abstractmethod
     def as_array(self) -> np.ndarray:
@@ -94,7 +86,6 @@ class ImageDataInterface(ABC):
         Returns:
             np.ndarray: Image data as numpy array
         """
-        pass
 
     @abstractmethod
     def sum(self) -> float:
@@ -103,7 +94,6 @@ class ImageDataInterface(ABC):
         Returns:
             float: Sum of all voxel values
         """
-        pass
 
     @abstractmethod
     def max(self) -> float:
@@ -112,7 +102,6 @@ class ImageDataInterface(ABC):
         Returns:
             float: Maximum voxel value
         """
-        pass
 
     @abstractmethod
     def maximum(self, value: float) -> None:
@@ -121,7 +110,6 @@ class ImageDataInterface(ABC):
         Args:
             value: Minimum value to clip to
         """
-        pass
 
     @property
     @abstractmethod
@@ -131,53 +119,43 @@ class ImageDataInterface(ABC):
         Returns either SIRF ``ImageData`` or STIR
         ``FloatVoxelsOnCartesianGrid``.
         """
-        pass
 
     # Arithmetic operations
     @abstractmethod
     def __add__(self, other):
         """Add two images or image and scalar."""
-        pass
 
     @abstractmethod
     def __sub__(self, other):
         """Subtract two images or image and scalar."""
-        pass
 
     @abstractmethod
     def __mul__(self, other):
         """Multiply image by scalar or element-wise."""
-        pass
 
     @abstractmethod
     def __truediv__(self, other):
         """Divide image by scalar or element-wise."""
-        pass
 
     @abstractmethod
     def __radd__(self, other):
         """Right-hand addition."""
-        pass
 
     @abstractmethod
     def __rsub__(self, other):
         """Right-hand subtraction."""
-        pass
 
     @abstractmethod
     def __rmul__(self, other):
         """Right-hand multiplication."""
-        pass
 
     @abstractmethod
     def __rtruediv__(self, other):
         """Right-hand division."""
-        pass
 
     @abstractmethod
     def __neg__(self):
         """Negate image."""
-        pass
 
     @abstractmethod
     def sapyb(
@@ -195,7 +173,6 @@ class ImageDataInterface(ABC):
         Returns:
             ImageDataInterface: self after modification (for chaining)
         """
-        pass
 
 
 class AcquisitionDataInterface(ABC):
@@ -212,7 +189,6 @@ class AcquisitionDataInterface(ABC):
         Returns:
             AcquisitionDataInterface: Wrapped acquisition object
         """
-        pass
 
     @abstractmethod
     def write(self, filepath: str) -> None:
@@ -221,16 +197,14 @@ class AcquisitionDataInterface(ABC):
         Args:
             filepath: Output file path
         """
-        pass
 
     @abstractmethod
-    def fill(self, data: Union[np.ndarray, float]) -> None:
+    def fill(self, data: np.ndarray | float) -> None:
         """Fill acquisition data.
 
         Args:
             data: Numpy array or scalar value
         """
-        pass
 
     @abstractmethod
     def clone(self) -> "AcquisitionDataInterface":
@@ -239,7 +213,6 @@ class AcquisitionDataInterface(ABC):
         Returns:
             AcquisitionDataInterface: Cloned object
         """
-        pass
 
     @abstractmethod
     def get_uniform_copy(self, value: float) -> "AcquisitionDataInterface":
@@ -251,19 +224,17 @@ class AcquisitionDataInterface(ABC):
         Returns:
             AcquisitionDataInterface: New uniform acquisition data
         """
-        pass
 
     @abstractmethod
-    def dimensions(self) -> Tuple:
+    def dimensions(self) -> tuple:
         """Get acquisition data dimensions.
 
         Returns:
             Tuple: Dimensions (varies by format)
         """
-        pass
 
     @property
-    def shape(self) -> Tuple:
+    def shape(self) -> tuple:
         """Get acquisition data shape (alias for dimensions()).
 
         Returns:
@@ -278,7 +249,6 @@ class AcquisitionDataInterface(ABC):
         Returns:
             np.ndarray: Acquisition data as numpy array
         """
-        pass
 
     @abstractmethod
     def sum(self) -> float:
@@ -287,7 +257,6 @@ class AcquisitionDataInterface(ABC):
         Returns:
             float: Sum of all counts
         """
-        pass
 
     @abstractmethod
     def max(self) -> float:
@@ -296,7 +265,6 @@ class AcquisitionDataInterface(ABC):
         Returns:
             float: Maximum bin value
         """
-        pass
 
     @abstractmethod
     def get_info(self) -> str:
@@ -305,68 +273,56 @@ class AcquisitionDataInterface(ABC):
         Returns:
             str: Metadata string
         """
-        pass
 
     @abstractmethod
-    def get_energy_window_bounds(self) -> Tuple[float, float]:
+    def get_energy_window_bounds(self) -> tuple[float, float]:
         """Get the energy window bounds for the acquisition.
 
         Returns:
             Tuple[float, float]: (lower_threshold, upper_threshold) in keV
         """
-        pass
 
     @property
     @abstractmethod
     def native_object(self):
         """Get the underlying native object (AcquisitionData or ProjData)."""
-        pass
 
     # Arithmetic operations
     @abstractmethod
     def __add__(self, other):
         """Add two acquisition data or acquisition data and scalar."""
-        pass
 
     @abstractmethod
     def __sub__(self, other):
         """Subtract two acquisition data or acquisition data and scalar."""
-        pass
 
     @abstractmethod
     def __mul__(self, other):
         """Multiply acquisition data by scalar or element-wise."""
-        pass
 
     @abstractmethod
     def __truediv__(self, other):
         """Divide acquisition data by scalar or element-wise."""
-        pass
 
     @abstractmethod
     def __radd__(self, other):
         """Right-hand addition."""
-        pass
 
     @abstractmethod
     def __rsub__(self, other):
         """Right-hand subtraction."""
-        pass
 
     @abstractmethod
     def __rmul__(self, other):
         """Right-hand multiplication."""
-        pass
 
     @abstractmethod
     def __rtruediv__(self, other):
         """Right-hand division."""
-        pass
 
     @abstractmethod
     def __neg__(self):
         """Negate acquisition data."""
-        pass
 
     @abstractmethod
     def sapyb(
@@ -384,4 +340,3 @@ class AcquisitionDataInterface(ABC):
         Returns:
             AcquisitionDataInterface: self after modification (for chaining)
         """
-        pass

simind_python_connector/backends/sirf_backend.py

@@ -5,7 +5,7 @@ Provides wrappers around sirf.STIR.ImageData and sirf.STIR.AcquisitionData
 that conform to the backend interface.
 """
 
-from typing import Tuple, Union
+from typing import Union
 
 import numpy as np
 
@@ -60,21 +60,17 @@ class SirfImageData(ImageDataInterface):
         """Create uniform copy."""
         return SirfImageData(self._obj.get_uniform_copy(value))
 
-    def dimensions(self) -> Tuple[int, int, int]:
+    def dimensions(self) -> tuple[int, int, int]:
         """Get dimensions as (z, y, x)."""
         return self._obj.dimensions()
 
-    def voxel_sizes(self) -> Tuple[float, float, float]:
+    def voxel_sizes(self) -> tuple[float, float, float]:
         """Get voxel sizes as (z, y, x) in mm."""
         return self._obj.voxel_sizes()
 
     def as_array(self) -> np.ndarray:
         """Convert to numpy array."""
-        # Try asarray first (newer SIRF), fall back to as_array
-        if hasattr(self._obj, "asarray"):
-            return self._obj.asarray()
-        else:
-            return self._obj.as_array()
+        return self._obj.as_array()
 
     def sum(self) -> float:
         """Sum all values."""
@@ -124,16 +120,18 @@ class SirfImageData(ImageDataInterface):
             return SirfImageData(self._obj / other)
 
     def __radd__(self, other):
-        return SirfImageData(other + self._obj)
+        return self + other
 
     def __rsub__(self, other):
-        return SirfImageData(other - self._obj)
+        return -self + other
 
     def __rmul__(self, other):
-        return SirfImageData(other * self._obj)
+        return self * other
 
     def __rtruediv__(self, other):
-        return SirfImageData(other / self._obj)
+        if isinstance(other, ImageData):
+            return SirfImageData(other) / self
+        return self.get_uniform_copy(float(other)) / self
 
     def __neg__(self):
         return SirfImageData(-self._obj)
@@ -197,17 +195,13 @@ class SirfAcquisitionData(AcquisitionDataInterface):
         """Create uniform copy."""
         return SirfAcquisitionData(self._obj.get_uniform_copy(value))
 
-    def dimensions(self) -> Tuple:
+    def dimensions(self) -> tuple:
         """Get dimensions."""
         return self._obj.dimensions()
 
     def as_array(self) -> np.ndarray:
         """Convert to numpy array."""
-        # Try asarray first (newer SIRF), fall back to as_array
-        if hasattr(self._obj, "asarray"):
-            return self._obj.asarray()
-        else:
-            return self._obj.as_array()
+        return self._obj.as_array()
 
     def sum(self) -> float:
         """Sum all values."""
@@ -223,7 +217,7 @@ class SirfAcquisitionData(AcquisitionDataInterface):
         """Get metadata info."""
         return self._obj.get_info()
 
-    def get_energy_window_bounds(self) -> Tuple[float, float]:
+    def get_energy_window_bounds(self) -> tuple[float, float]:
         """Get the energy window bounds for the acquisition.
 
         Returns:
@@ -277,16 +271,18 @@ class SirfAcquisitionData(AcquisitionDataInterface):
             return SirfAcquisitionData(self._obj / other)
 
     def __radd__(self, other):
-        return SirfAcquisitionData(other + self._obj)
+        return self + other
 
     def __rsub__(self, other):
-        return SirfAcquisitionData(other - self._obj)
+        return -self + other
 
     def __rmul__(self, other):
-        return SirfAcquisitionData(other * self._obj)
+        return self * other
 
     def __rtruediv__(self, other):
-        return SirfAcquisitionData(other / self._obj)
+        if isinstance(other, AcquisitionData):
+            return SirfAcquisitionData(other) / self
+        return self.get_uniform_copy(float(other)) / self
 
     def __neg__(self):
         return SirfAcquisitionData(-self._obj)