arraybridge 0.2.0__py3-none-any.whl → 0.2.8__py3-none-any.whl

arraybridge/__init__.py

@@ -5,13 +5,29 @@ This package provides automatic memory type conversion, declarative decorators,
 and unified utilities for working with multiple array/tensor frameworks.
 """
 
-__version__ = "0.2.0"
+__version__ = "0.2.8"
 
 from .converters import convert_memory, detect_memory_type
-from .decorators import cupy, jax, memory_types, numpy, tensorflow, torch
+from .decorators import (
+    DtypeConversion,
+    cupy,
+    jax,
+    memory_types,
+    numpy,
+    pyclesperanto,
+    tensorflow,
+    torch,
+)
+from .dtype_scaling import SCALING_FUNCTIONS
 from .exceptions import MemoryConversionError
+from .framework_config import _FRAMEWORK_CONFIG
+from .framework_ops import _FRAMEWORK_OPS
+from .gpu_cleanup import cleanup_all_gpu_frameworks
+from .oom_recovery import _execute_with_oom_recovery
+from .slice_processing import process_slices
 from .stack_utils import stack_slices, unstack_slices
 from .types import CPU_MEMORY_TYPES, GPU_MEMORY_TYPES, SUPPORTED_MEMORY_TYPES, MemoryType
+from .utils import _ensure_module, _get_device_id, _supports_dlpack
 
 __all__ = [
     # Types
@@ -29,9 +45,26 @@ __all__ = [
     "torch",
     "tensorflow",
     "jax",
+    "pyclesperanto",
+    "DtypeConversion",
     # Stack utilities
     "stack_slices",
     "unstack_slices",
+    # Slice processing
+    "process_slices",
+    # GPU cleanup
+    "cleanup_all_gpu_frameworks",
     # Exceptions
     "MemoryConversionError",
+    # Scaling
+    "SCALING_FUNCTIONS",
+    # Framework config (internal but needed by some consumers)
+    "_FRAMEWORK_CONFIG",
+    "_FRAMEWORK_OPS",
+    # OOM recovery
+    "_execute_with_oom_recovery",
+    # Utils
+    "_ensure_module",
+    "_supports_dlpack",
+    "_get_device_id",
 ]

arraybridge/converters.py

@@ -4,9 +4,9 @@ from typing import Any
 
 import numpy as np
 
-from arraybridge.conversion_helpers import _CONVERTERS
+from arraybridge.converters_registry import get_converter
 from arraybridge.framework_config import _FRAMEWORK_CONFIG
-from arraybridge.types import MemoryType
+from arraybridge.types import MemoryType, VALID_MEMORY_TYPES
 
 
 def convert_memory(data: Any, source_type: str, target_type: str, gpu_id: int) -> Any:
@@ -26,8 +26,14 @@ def convert_memory(data: Any, source_type: str, target_type: str, gpu_id: int) -
         ValueError: If source_type or target_type is invalid
         MemoryConversionError: If conversion fails
     """
-    source_enum = MemoryType(source_type)
-    converter = _CONVERTERS[source_enum]
+    if isinstance(target_type, MemoryType):
+        target_type = target_type.value
+    if target_type not in VALID_MEMORY_TYPES:
+        raise ValueError(
+            f"Invalid target_type '{target_type}'. Available types: {sorted(VALID_MEMORY_TYPES)}"
+        )
+
+    converter = get_converter(source_type)  # Will raise ValueError if invalid
     method = getattr(converter, f"to_{target_type}")
     return method(data, gpu_id)
 
@@ -52,10 +58,14 @@ def detect_memory_type(data: Any) -> str:
     # Check all frameworks using their module names from config
     module_name = type(data).__module__
 
+    top_level = module_name.split(".")[0]
+
     for mem_type, config in _FRAMEWORK_CONFIG.items():
-        import_name = config['import_name']
-        # Check if module name starts with or contains the import name
-        if module_name.startswith(import_name) or import_name in module_name:
+        import_name = config["import_name"]
+        aliases = {import_name}
+        if import_name == "jax":
+            aliases.add("jaxlib")
+        if top_level in aliases:
             return mem_type.value
 
     raise ValueError(f"Unknown memory type for {type(data)} (module: {module_name})")

arraybridge/converters_registry.py

@@ -0,0 +1,196 @@
+"""
+Registry-based converter infrastructure using metaclass-registry.
+
+This module provides the ConverterBase class using AutoRegisterMeta,
+concrete converter implementations for each framework, and a helper
+function for registry lookups.
+"""
+
+import logging
+from abc import abstractmethod
+
+from metaclass_registry import AutoRegisterMeta
+
+from arraybridge.framework_config import _FRAMEWORK_CONFIG
+from arraybridge.types import MemoryType
+
+logger = logging.getLogger(__name__)
+
+
+class ConverterBase(metaclass=AutoRegisterMeta):
+    """Base class for memory type converters using auto-registration.
+
+    Each concrete converter sets memory_type to register itself in the registry.
+    The registry key is the memory_type attribute (e.g., "numpy", "torch").
+    """
+
+    __registry_key__ = "memory_type"
+    __registry__ = {}  # Simple dict - no lazy discovery needed (converters created dynamically below)
+    memory_type: str = None
+
+    @abstractmethod
+    def to_numpy(self, data, gpu_id):
+        """Extract to NumPy (type-specific implementation)."""
+        pass
+
+    @abstractmethod
+    def from_numpy(self, data, gpu_id):
+        """Create from NumPy (type-specific implementation)."""
+        pass
+
+    @abstractmethod
+    def from_dlpack(self, data, gpu_id):
+        """Create from DLPack capsule (type-specific implementation)."""
+        pass
+
+    @abstractmethod
+    def move_to_device(self, data, gpu_id):
+        """Move data to specified GPU device if needed (type-specific implementation)."""
+        pass
+
+
+def _ensure_module(memory_type: str):
+    """Import and return the module for the given memory type."""
+    from arraybridge.utils import _ensure_module as _ensure_module_impl
+
+    return _ensure_module_impl(memory_type)
+
+
+def _make_lambda_with_name(expr_str, mem_type, method_name):
+    """Create a lambda from expression string and add proper __name__ for debugging.
+
+    Note: Uses eval() for dynamic code generation from trusted framework_config.py strings.
+    This is safe because:
+    1. Input strings come from _FRAMEWORK_CONFIG, not user input
+    2. Strings are defined at module load time by package maintainers
+    3. This pattern enables declarative framework configuration
+    """
+    module_str = f'_ensure_module("{mem_type.value}")'
+    lambda_expr = f"lambda self, data, gpu_id: {expr_str.format(mod=module_str)}"
+    lambda_func = eval(lambda_expr)
+    lambda_func.__name__ = method_name
+    lambda_func.__qualname__ = f"{mem_type.value.capitalize()}Converter.{method_name}"
+    return lambda_func
+
+
+def _make_not_implemented(mem_type_value, method_name):
+    """Create a lambda that raises NotImplementedError with the correct signature."""
+
+    def not_impl(self, data, gpu_id):
+        raise NotImplementedError(f"DLPack not supported for {mem_type_value}")
+
+    not_impl.__name__ = method_name
+    not_impl.__qualname__ = f"{mem_type_value.capitalize()}Converter.{method_name}"
+    return not_impl
+
+
+# Auto-generate converter classes for each memory type
+def _create_converter_classes():
+    """Create concrete converter classes for each memory type."""
+    converters = {}
+
+    for mem_type in MemoryType:
+        config = _FRAMEWORK_CONFIG[mem_type]
+        conversion_ops = config["conversion_ops"]
+
+        # Build class attributes
+        class_attrs = {
+            "memory_type": mem_type.value,
+        }
+
+        # Add conversion methods
+        for method_name, expr in conversion_ops.items():
+            if expr is None:
+                class_attrs[method_name] = _make_not_implemented(mem_type.value, method_name)
+            else:
+                class_attrs[method_name] = _make_lambda_with_name(expr, mem_type, method_name)
+
+        # Create the class
+        class_name = f"{mem_type.value.capitalize()}Converter"
+        converter_class = type(class_name, (ConverterBase,), class_attrs)
+
+        converters[mem_type] = converter_class
+
+    return converters
+
+
+# Create all converter classes at module load time
+_CONVERTER_CLASSES = _create_converter_classes()
+
+
+def get_converter(memory_type: str):
+    """Get a converter instance for the given memory type.
+
+    Args:
+        memory_type: The memory type string (e.g., "numpy", "torch")
+
+    Returns:
+        A converter instance for the memory type
+
+    Raises:
+        ValueError: If memory type is not registered
+    """
+    converter_class = ConverterBase.__registry__.get(memory_type)
+    if converter_class is None:
+        raise ValueError(
+            f"No converter registered for memory type '{memory_type}'. "
+            f"Available types: {sorted(ConverterBase.__registry__.keys())}"
+        )
+    return converter_class()
+
+
+def _add_converter_methods():
+    """Add to_X() methods to ConverterBase.
+
+    For each target memory type, generates a method like to_cupy(), to_torch(), etc.
+    that tries GPU-to-GPU conversion via DLPack first, then falls back to CPU roundtrip.
+    """
+    from arraybridge.utils import _supports_dlpack
+
+    for target_type in MemoryType:
+        method_name = f"to_{target_type.value}"
+
+        def make_method(tgt):
+            def method(self, data, gpu_id):
+                # Try GPU-to-GPU first (DLPack)
+                if _supports_dlpack(data):
+                    try:
+                        target_converter = get_converter(tgt.value)
+                        result = target_converter.from_dlpack(data, gpu_id)
+                        return target_converter.move_to_device(result, gpu_id)
+                    except Exception as e:
+                        logger.warning(f"DLPack conversion failed: {e}. Using CPU roundtrip.")
+
+                # CPU roundtrip using polymorphism
+                numpy_data = self.to_numpy(data, gpu_id)
+                target_converter = get_converter(tgt.value)
+                return target_converter.from_numpy(numpy_data, gpu_id)
+
+            return method
+
+        setattr(ConverterBase, method_name, make_method(target_type))
+
+
+def _validate_registry():
+    """Validate that all memory types are registered."""
+    required_types = {mt.value for mt in MemoryType}
+    registered_types = set(ConverterBase.__registry__.keys())
+
+    if required_types != registered_types:
+        missing = required_types - registered_types
+        extra = registered_types - required_types
+        msg_parts = []
+        if missing:
+            msg_parts.append(f"Missing: {missing}")
+        if extra:
+            msg_parts.append(f"Extra: {extra}")
+        raise RuntimeError(f"Registry validation failed. {', '.join(msg_parts)}")
+
+    logger.debug(f"✅ Validated {len(registered_types)} memory type converters in registry")
+
+
+# Add to_X() conversion methods after converter classes are created
+_add_converter_methods()
+
+# Run validation at module load time
+_validate_registry()

arraybridge/decorators.py

@@ -30,20 +30,20 @@ from arraybridge.utils import optional_import
 
 logger = logging.getLogger(__name__)
 
-F = TypeVar('F', bound=Callable[..., Any])
+F = TypeVar("F", bound=Callable[..., Any])
 
 
 class DtypeConversion(Enum):
     """Data type conversion modes for all memory type functions."""
 
-    PRESERVE_INPUT = "preserve"     # Keep input dtype (default)
-    NATIVE_OUTPUT = "native"        # Use framework's native output
-    UINT8 = "uint8"                # Force uint8 (0-255 range)
-    UINT16 = "uint16"              # Force uint16 (microscopy standard)
-    INT16 = "int16"                # Force int16 (signed microscopy data)
-    INT32 = "int32"                # Force int32 (large integer values)
-    FLOAT32 = "float32"            # Force float32 (GPU performance)
-    FLOAT64 = "float64"            # Force float64 (maximum precision)
+    PRESERVE_INPUT = "preserve"  # Keep input dtype (default)
+    NATIVE_OUTPUT = "native"  # Use framework's native output
+    UINT8 = "uint8"  # Force uint8 (0-255 range)
+    UINT16 = "uint16"  # Force uint16 (microscopy standard)
+    INT16 = "int16"  # Force int16 (signed microscopy data)
+    INT32 = "int32"  # Force int32 (large integer values)
+    FLOAT32 = "float32"  # Force float32 (GPU performance)
+    FLOAT64 = "float64"  # Force float64 (maximum precision)
 
     @property
     def numpy_dtype(self):
@@ -65,6 +65,7 @@ _gpu_frameworks_cache = {}
 
 def _create_lazy_getter(framework_name: str):
     """Factory function that creates a lazy import getter for a framework."""
+
     def getter():
         if framework_name not in _gpu_frameworks_cache:
             _gpu_frameworks_cache[framework_name] = optional_import(framework_name)
@@ -74,20 +75,22 @@ def _create_lazy_getter(framework_name: str):
                     f"{threading.current_thread().name}"
                 )
         return _gpu_frameworks_cache[framework_name]
+
     return getter
 
 
 # Auto-generate lazy getters for all GPU frameworks
 for mem_type in MemoryType:
     ops = _FRAMEWORK_OPS[mem_type]
-    if ops['lazy_getter'] is not None:
-        getter_func = _create_lazy_getter(ops['import_name'])
+    if ops["lazy_getter"] is not None:
+        getter_func = _create_lazy_getter(ops["import_name"])
         globals()[f"_get_{ops['import_name']}"] = getter_func
 
 
 # Thread-local storage for GPU streams and contexts
 _thread_gpu_contexts = threading.local()
 
+
 class ThreadGPUContext:
     """Thread-local GPU context manager for CUDA streams."""
 
@@ -100,8 +103,8 @@ class ThreadGPUContext:
     def get_cupy_stream(self):
         """Get or create thread-local CuPy stream."""
         if self.cupy_stream is None:
-            cupy = globals().get('_get_cupy', lambda: None)()  # noqa: F821
-            if cupy is not None and hasattr(cupy, 'cuda'):
+            cupy = globals().get("_get_cupy", lambda: None)()  # noqa: F821
+            if cupy is not None and hasattr(cupy, "cuda"):
                 self.cupy_stream = cupy.cuda.Stream()
                 logger.debug(f"🔧 Created CuPy stream for thread {threading.current_thread().name}")
         return self.cupy_stream
@@ -109,33 +112,31 @@ class ThreadGPUContext:
     def get_torch_stream(self):
         """Get or create thread-local PyTorch stream."""
         if self.torch_stream is None:
-            torch = globals().get('_get_torch', lambda: None)()  # noqa: F821
-            if torch is not None and hasattr(torch, 'cuda') and torch.cuda.is_available():
+            torch = globals().get("_get_torch", lambda: None)()  # noqa: F821
+            if torch is not None and hasattr(torch, "cuda") and torch.cuda.is_available():
                 self.torch_stream = torch.cuda.Stream()
                 logger.debug(
-                    f"🔧 Created PyTorch stream for thread "
-                    f"{threading.current_thread().name}"
+                    f"🔧 Created PyTorch stream for thread " f"{threading.current_thread().name}"
                 )
         return self.torch_stream
 
 
 def _get_thread_gpu_context():
     """Get or create thread-local GPU context."""
-    if not hasattr(_thread_gpu_contexts, 'context'):
+    if not hasattr(_thread_gpu_contexts, "context"):
         _thread_gpu_contexts.context = ThreadGPUContext()
     return _thread_gpu_contexts.context
 
 
 def memory_types(
-    input_type: str,
-    output_type: str,
-    contract: Optional[Callable[[Any], bool]] = None
+    input_type: str, output_type: str, contract: Optional[Callable[[Any], bool]] = None
 ) -> Callable[[F], F]:
     """
     Base decorator for declaring memory types of a function.
 
     This is the foundation decorator that all memory-type-specific decorators build upon.
     """
+
     def decorator(func: F) -> F:
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
@@ -171,40 +172,47 @@ def _create_dtype_wrapper(func, mem_type: MemoryType, func_name: str):
         if dtype_conversion is None:
             dtype_conversion = DtypeConversion.PRESERVE_INPUT
 
-        try:
-            # Store original dtype
-            original_dtype = image.dtype
-
-            # Handle slice_by_slice processing for 3D arrays
-            if slice_by_slice and hasattr(image, 'ndim') and image.ndim == 3:
-                result = process_slices(image, func, args, kwargs)
-            else:
-                # Call the original function normally
-                result = func(image, *args, **kwargs)
-
-            # Apply dtype conversion based on enum value
-            if hasattr(result, 'dtype') and dtype_conversion is not None:
-                if dtype_conversion == DtypeConversion.PRESERVE_INPUT:
-                    # Preserve input dtype
-                    if result.dtype != original_dtype:
-                        result = scale_func(result, original_dtype)
-                elif dtype_conversion == DtypeConversion.NATIVE_OUTPUT:
-                    # Return framework's native output dtype
-                    pass  # No conversion needed
-                else:
-                    # Force specific dtype
-                    target_dtype = dtype_conversion.numpy_dtype
-                    if target_dtype is not None:
-                        result = scale_func(result, target_dtype)
+        # Store original dtype
+        original_dtype = getattr(image, "dtype", None)
+
+        # Handle slice_by_slice processing for 3D arrays
+        if slice_by_slice and hasattr(image, "ndim") and image.ndim == 3:
+            result = process_slices(image, func, args, kwargs)
+        else:
+            # Call the original function normally
+            result = func(image, *args, **kwargs)
+
+        def _apply_dtype_conversion(array):
+            if dtype_conversion is None or not hasattr(array, "dtype"):
+                return array
+            if dtype_conversion == DtypeConversion.PRESERVE_INPUT:
+                # Preserve input dtype
+                if original_dtype is not None and array.dtype != original_dtype:
+                    return scale_func(array, original_dtype)
+                return array
+            if dtype_conversion == DtypeConversion.NATIVE_OUTPUT:
+                # Return framework's native output dtype
+                return array
+            # Force specific dtype
+            target_dtype = dtype_conversion.numpy_dtype
+            if target_dtype is not None:
+                return scale_func(array, target_dtype)
+            return array
 
-            return result
+        try:
+            # Apply dtype conversion to the main output
+            if isinstance(result, tuple):
+                if not result:
+                    return result
+                converted_main = _apply_dtype_conversion(result[0])
+                return (converted_main, *result[1:])
+            return _apply_dtype_conversion(result)
         except Exception as e:
             logger.error(
-                f"Error in {mem_type.value} dtype/slice preserving wrapper "
-                f"for {func_name}: {e}"
+                f"Error in {mem_type.value} dtype/slice preserving wrapper " f"for {func_name}: {e}"
             )
-            # Return original result on error
-            return func(image, *args, **kwargs)
+            # Return unmodified result on conversion errors
+            return result
 
     # Update function signature to include new parameters
     try:
@@ -215,22 +223,19 @@ def _create_dtype_wrapper(func, mem_type: MemoryType, func_name: str):
         param_names = [p.name for p in new_params]
 
         # Add dtype_conversion parameter first (before slice_by_slice)
-        if 'dtype_conversion' not in param_names:
+        if "dtype_conversion" not in param_names:
             dtype_param = inspect.Parameter(
-                'dtype_conversion',
+                "dtype_conversion",
                 inspect.Parameter.KEYWORD_ONLY,
                 default=DtypeConversion.PRESERVE_INPUT,
-                annotation=Optional[DtypeConversion]
+                annotation=Optional[DtypeConversion],
             )
             new_params.append(dtype_param)
 
         # Add slice_by_slice parameter
-        if 'slice_by_slice' not in param_names:
+        if "slice_by_slice" not in param_names:
             slice_param = inspect.Parameter(
-                'slice_by_slice',
-                inspect.Parameter.KEYWORD_ONLY,
-                default=False,
-                annotation=bool
+                "slice_by_slice", inspect.Parameter.KEYWORD_ONLY, default=False, annotation=bool
             )
             new_params.append(slice_param)
 
@@ -241,23 +246,18 @@ def _create_dtype_wrapper(func, mem_type: MemoryType, func_name: str):
         # Update docstring
         if dtype_wrapper.__doc__:
             dtype_wrapper.__doc__ += (
-                f"\n\n    Additional Parameters "
-                f"(added by {mem_type.value} decorator):\n"
+                f"\n\n    Additional Parameters " f"(added by {mem_type.value} decorator):\n"
             )
             dtype_wrapper.__doc__ += (
                 "        dtype_conversion (DtypeConversion, optional): "
                 "How to handle output dtype.\n"
             )
+            dtype_wrapper.__doc__ += "            Defaults to PRESERVE_INPUT (match input dtype).\n"
             dtype_wrapper.__doc__ += (
-                "            Defaults to PRESERVE_INPUT (match input dtype).\n"
+                "        slice_by_slice (bool, optional): " "Process 3D arrays slice-by-slice.\n"
             )
             dtype_wrapper.__doc__ += (
-                "        slice_by_slice (bool, optional): "
-                "Process 3D arrays slice-by-slice.\n"
-            )
-            dtype_wrapper.__doc__ += (
-                "            Defaults to False. "
-                "Prevents cross-slice contamination.\n"
+                "            Defaults to False. " "Prevents cross-slice contamination.\n"
             )
 
     except Exception as e:
@@ -273,8 +273,8 @@ def _create_gpu_wrapper(func, mem_type: MemoryType, oom_recovery: bool):
     This function creates the GPU-specific wrapper with stream management and OOM recovery.
     """
     ops = _FRAMEWORK_OPS[mem_type]
-    framework_name = ops['import_name']
-    lazy_getter = globals().get(ops['lazy_getter'])
+    framework_name = ops["import_name"]
+    lazy_getter = globals().get(ops["lazy_getter"])
 
     @functools.wraps(func)
     def gpu_wrapper(*args, **kwargs):
@@ -282,7 +282,7 @@ def _create_gpu_wrapper(func, mem_type: MemoryType, oom_recovery: bool):
 
         # Check if GPU is available for this framework
         if framework is not None:
-            gpu_check_expr = ops['gpu_check'].format(mod=framework_name)
+            gpu_check_expr = ops["gpu_check"].format(mod=framework_name)
             try:
                 gpu_available = eval(gpu_check_expr, {framework_name: framework})
             except Exception:
@@ -308,7 +308,7 @@ def _create_gpu_wrapper(func, mem_type: MemoryType, oom_recovery: bool):
                         return func(*args, **kwargs)
 
                 # Execute with OOM recovery if enabled
-                if oom_recovery and ops['has_oom_recovery']:
+                if oom_recovery and ops["has_oom_recovery"]:
                     return _execute_with_oom_recovery(execute_with_stream, mem_type.value)
                 else:
                     return execute_with_stream()
@@ -331,8 +331,14 @@ def _create_memory_decorator(mem_type: MemoryType):
     """
     ops = _FRAMEWORK_OPS[mem_type]
 
-    def decorator(func=None, *, input_type=mem_type.value, output_type=mem_type.value,
-                  oom_recovery=True, contract=None):
+    def decorator(
+        func=None,
+        *,
+        input_type=mem_type.value,
+        output_type=mem_type.value,
+        oom_recovery=True,
+        contract=None,
+    ):
         """
         Decorator for {mem_type} memory type functions.
 
@@ -346,12 +352,11 @@ def _create_memory_decorator(mem_type: MemoryType):
         Returns:
             Decorated function with memory type metadata and dtype preservation
         """
+
         def inner_decorator(func):
             # Apply base memory_types decorator
             memory_decorator = memory_types(
-                input_type=input_type,
-                output_type=output_type,
-                contract=contract
+                input_type=input_type, output_type=output_type, contract=contract
             )
             func = memory_decorator(func)
 
@@ -359,7 +364,7 @@ def _create_memory_decorator(mem_type: MemoryType):
             func = _create_dtype_wrapper(func, mem_type, func.__name__)
 
             # Apply GPU wrapper if this is a GPU memory type
-            if ops['gpu_check'] is not None:
+            if ops["gpu_check"] is not None:
                 func = _create_gpu_wrapper(func, mem_type, oom_recovery)
 
             return func
@@ -371,7 +376,7 @@ def _create_memory_decorator(mem_type: MemoryType):
 
     # Set proper function name and docstring
     decorator.__name__ = mem_type.value
-    decorator.__doc__ = decorator.__doc__.format(mem_type=ops['display_name'])
+    decorator.__doc__ = decorator.__doc__.format(mem_type=ops["display_name"])
 
     return decorator
 
@@ -384,13 +389,12 @@ for mem_type in MemoryType:
 
 # Export all decorators
 __all__ = [
-    'memory_types',
-    'DtypeConversion',
-    'numpy',  # noqa: F822
-    'cupy',  # noqa: F822
-    'torch',  # noqa: F822
-    'tensorflow',  # noqa: F822
-    'jax',  # noqa: F822
-    'pyclesperanto',  # noqa: F822
+    "memory_types",
+    "DtypeConversion",
+    "numpy",  # noqa: F822
+    "cupy",  # noqa: F822
+    "torch",  # noqa: F822
+    "tensorflow",  # noqa: F822
+    "jax",  # noqa: F822
+    "pyclesperanto",  # noqa: F822
 ]
-