Lazy napari checks for BatchRunner to improve import times (#5)

This pull request refactors how the code detects and handles the
presence of the `napari` library for threaded batch operations. Instead
of checking for `napari` at module import time, the code now tries to
import `napari` only when needed, improving flexibility and testability.
The test suite is also updated to simulate the absence of `napari` by
monkeypatching the import mechanism.

**Refactoring napari detection and threading logic:**

* Removed the module-level `HAS_NAPARI` flag and deferred importing
`napari` to runtime, allowing the code to try using napari threading if
available and fall back to standard threading otherwise
(`src/nbatch/_runner.py`)
[[1]](diffhunk://#diff-0dd9aa30afa1d11d42cc399298b79ac401045ee0c5261caafff03f7a7ee41597L26-L34)
[[2]](diffhunk://#diff-0dd9aa30afa1d11d42cc399298b79ac401045ee0c5261caafff03f7a7ee41597L238-R238).
* Updated the `cancel` method to check for a `quit` method on the worker
instead of relying on the `HAS_NAPARI` flag, making cancellation logic
more robust and decoupled from napari-specific checks
(`src/nbatch/_runner.py`).
* Moved the import of `create_worker` into the `_run_napari_threaded`
method so it only occurs when napari threading is actually used
(`src/nbatch/_runner.py`).

**Testing improvements:**

* Updated the threaded fallback test to simulate napari's absence by
monkeypatching Python's import mechanism, ensuring the fallback path is
tested regardless of napari's actual installation
(`tests/test_runner.py`)
[[1]](diffhunk://#diff-55824c57bc66ac238570c2acc0d4904ab52df3131aae66c0ecefc2f08a4e8806L492-R502)
[[2]](diffhunk://#diff-55824c57bc66ac238570c2acc0d4904ab52df3131aae66c0ecefc2f08a4e8806L509-R516).

Author: TimMonko

src/nbatch/_runner.py

@@ -23,15 +23,6 @@
 # Module-level logger
 _logger = logging.getLogger('nbatch.runner')
 
-# Check for napari availability
-try:
-    from napari.qt.threading import create_worker
-
-    HAS_NAPARI = True
-except ImportError:
-    HAS_NAPARI = False
-    create_worker = None
-
 
 class BatchRunner:
     """Orchestrates batch operations with threading, progress, and cancellation.
@@ -163,10 +154,11 @@ def cancel(self) -> None:
             self._cancel_requested = True
             self._was_cancelled = True  # Set immediately for threaded cases
             # Store local reference to avoid race condition with _handle_finished
-            worker = self._worker if HAS_NAPARI else None
+            # Check for quit method to determine if it's a napari worker
+            worker = self._worker
 
-        # If using napari worker, request quit
-        if worker is not None:
+        # If using napari worker (has quit method), request quit
+        if worker is not None and hasattr(worker, 'quit'):
             with contextlib.suppress(RuntimeError):
                 worker.quit()
 
@@ -235,14 +227,18 @@ def run(
         if self._on_start is not None:
             self._on_start(len(items_list))
 
-        if threaded and HAS_NAPARI:
-            self._run_napari_threaded(
-                func, items_list, args, kwargs, log_file, log_header
-            )
-        elif threaded:
-            self._run_thread_fallback(
-                func, items_list, args, kwargs, log_file, log_header
-            )
+        # Try napari threading first, fall back to standard threading
+        if threaded:
+            try:
+                import napari.qt.threading  # noqa: F401
+
+                self._run_napari_threaded(
+                    func, items_list, args, kwargs, log_file, log_header
+                )
+            except ImportError:
+                self._run_thread_fallback(
+                    func, items_list, args, kwargs, log_file, log_header
+                )
         else:
             self._run_sync(
                 func, items_list, args, kwargs, log_file, log_header
@@ -285,6 +281,7 @@ def _run_napari_threaded(
         log_header: Mapping[str, object] | None,
     ) -> None:
         """Run batch using napari's create_worker for Qt-safe threading."""
+        from napari.qt.threading import create_worker
 
         def _worker_func():
             """Generator function for napari worker."""

tests/test_runner.py

@@ -489,10 +489,17 @@ class TestBatchRunnerThreaded:
 
     def test_run_threaded_fallback_no_napari(self, monkeypatch):
         """Test threaded execution using fallback (concurrent.futures)."""
-        # Force the fallback path by pretending napari isn't available
-        import nbatch._runner as runner_module
+        # Force the fallback path by making napari import fail
+        import builtins
 
-        monkeypatch.setattr(runner_module, 'HAS_NAPARI', False)
+        real_import = builtins.__import__
+
+        def mock_import(name, *args, **kwargs):
+            if name == 'napari.qt.threading' or name.startswith('napari'):
+                raise ImportError('napari not available')
+            return real_import(name, *args, **kwargs)
+
+        monkeypatch.setattr(builtins, '__import__', mock_import)
 
         results = []
         completed = []
@@ -506,7 +513,7 @@ def process(item):
             on_complete=lambda: completed.append(True),
         )
 
-        # Run threaded (will use fallback since we monkeypatched HAS_NAPARI)
+        # Run threaded (will use fallback since napari import fails)
         runner.run(process, [1, 2, 3], threaded=True)
 
         # Wait for completion