scanlib 1.0.0__tar.gz → 1.2.0__tar.gz

{scanlib-1.0.0 → scanlib-1.2.0}/PKG-INFO

@@ -1,9 +1,32 @@
 Metadata-Version: 2.4
 Name: scanlib
-Version: 1.0.0
+Version: 1.2.0
 Summary: A multiplatform document scanning library for Python
 Author-email: Angelo Mottola <a.mottola@gmail.com>
 License: MIT
+Project-URL: Homepage, https://github.com/amottola/scanlib
+Project-URL: Documentation, https://python-scanlib.readthedocs.io/
+Project-URL: Repository, https://github.com/amottola/scanlib
+Project-URL: Changelog, https://github.com/amottola/scanlib/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/amottola/scanlib/issues
+Keywords: scanner,scanning,sane,wia,escl,airscan,twain,pdf,document
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: C
+Classifier: Topic :: Multimedia :: Graphics :: Capture :: Scanners
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -30,6 +53,8 @@ A multiplatform document scanning library for Python with platform-native scanni
 ## Features
 
 - **Cross-platform** — unified API across Windows (WIA 2.0), macOS (ImageCaptureCore), and Linux (SANE)
+- **eSCL / AirScan** — direct HTTP scanning of network scanners without OS drivers, enabled automatically on Linux and Windows
+- **Command-line interface** — `scanlib list`, `scanlib info`, and `scanlib scan` for quick scanning from the shell
 - **Output to PDF** — assemble scanned pages into a PDF and control page encoding (JPEG or PNG)
 - **Minimal dependencies** — no external image or PDF processing libraries; JPEG uses platform-native encoders, PNG uses stdlib `zlib`, PDF assembly uses only the standard library
 - **Multi-page scanning** — automatic document feeder support and flatbed multi-page with a simple callback
@@ -37,16 +62,54 @@ A multiplatform document scanning library for Python with platform-native scanni
 - **Thread-safe** — call from any thread; backend threading is handled internally
 - **Progress & cancellation** — monitor scan progress and abort mid-scan via callback
 
+## Backends
+
+| Platform | Backend | Scanner types | eSCL | System packages |
+|---|---|---|---|---|
+| **macOS 10.7+** | ImageCaptureCore | USB + network | Opt-in (`SCANLIB_ESCL=1`) | None |
+| **Windows 10+** | WIA 2.0 | USB | Always enabled | None |
+| **Linux** | SANE | USB | Always enabled | `libsane-dev libjpeg-dev` |
+
+The eSCL (AirScan) backend discovers and drives network scanners directly over HTTP — no OS-level scanner drivers needed. On Linux and Windows it runs alongside the platform backend automatically. On macOS, ImageCaptureCore already handles network scanners natively; set `SCANLIB_ESCL=1` to use the eSCL backend instead.
+
 ## Installation
 
 ```bash
 pip install scanlib
 ```
 
-Python 3.9+. Pre-built wheels available for all major platforms. On Linux, `libsane` and `libjpeg-turbo` are required at runtime (`apt install libsane-dev libturbojpeg0-dev`); on other platforms, no additional dependencies are required.
+Python 3.9+. Pre-built wheels available for all major platforms. On Linux, SANE and libjpeg must be installed at the system level:
+
+```bash
+# Debian / Ubuntu
+apt install libsane-dev libjpeg-dev
+
+# Fedora / RHEL
+dnf install sane-backends libjpeg-turbo-devel
+```
+
+On macOS and Windows, no additional system packages are required.
 
 ## Quick Start
 
+### Command line
+
+```bash
+# List available scanners
+scanlib list
+
+# Show scanner capabilities
+scanlib info -s 0
+
+# Scan to PDF
+scanlib scan -o document.pdf --dpi 300 --color-mode gray
+
+# Multi-page flatbed scan with interactive prompting
+scanlib scan -o multipage.pdf --pages ask
+```
+
+### Python API
+
 ```python
 import scanlib
 

scanlib-1.0.0/src/scanlib.egg-info/PKG-INFO → scanlib-1.2.0/README.md

@@ -1,24 +1,3 @@
-Metadata-Version: 2.4
-Name: scanlib
-Version: 1.0.0
-Summary: A multiplatform document scanning library for Python
-Author-email: Angelo Mottola <a.mottola@gmail.com>
-License: MIT
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: comtypes>=1.4; sys_platform == "win32"
-Requires-Dist: pyobjc-framework-ImageCaptureCore; sys_platform == "darwin"
-Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: pytest-timeout; extra == "dev"
-Requires-Dist: pre-commit; extra == "dev"
-Provides-Extra: docs
-Requires-Dist: sphinx; extra == "docs"
-Requires-Dist: furo; extra == "docs"
-Requires-Dist: sphinx-autodoc-typehints; extra == "docs"
-Dynamic: license-file
-
 # scanlib
 
 [![Tests](https://github.com/amottola/scanlib/actions/workflows/test.yml/badge.svg)](https://github.com/amottola/scanlib/actions/workflows/test.yml)
@@ -30,6 +9,8 @@ A multiplatform document scanning library for Python with platform-native scanni
 ## Features
 
 - **Cross-platform** — unified API across Windows (WIA 2.0), macOS (ImageCaptureCore), and Linux (SANE)
+- **eSCL / AirScan** — direct HTTP scanning of network scanners without OS drivers, enabled automatically on Linux and Windows
+- **Command-line interface** — `scanlib list`, `scanlib info`, and `scanlib scan` for quick scanning from the shell
 - **Output to PDF** — assemble scanned pages into a PDF and control page encoding (JPEG or PNG)
 - **Minimal dependencies** — no external image or PDF processing libraries; JPEG uses platform-native encoders, PNG uses stdlib `zlib`, PDF assembly uses only the standard library
 - **Multi-page scanning** — automatic document feeder support and flatbed multi-page with a simple callback
@@ -37,16 +18,54 @@ A multiplatform document scanning library for Python with platform-native scanni
 - **Thread-safe** — call from any thread; backend threading is handled internally
 - **Progress & cancellation** — monitor scan progress and abort mid-scan via callback
 
+## Backends
+
+| Platform | Backend | Scanner types | eSCL | System packages |
+|---|---|---|---|---|
+| **macOS 10.7+** | ImageCaptureCore | USB + network | Opt-in (`SCANLIB_ESCL=1`) | None |
+| **Windows 10+** | WIA 2.0 | USB | Always enabled | None |
+| **Linux** | SANE | USB | Always enabled | `libsane-dev libjpeg-dev` |
+
+The eSCL (AirScan) backend discovers and drives network scanners directly over HTTP — no OS-level scanner drivers needed. On Linux and Windows it runs alongside the platform backend automatically. On macOS, ImageCaptureCore already handles network scanners natively; set `SCANLIB_ESCL=1` to use the eSCL backend instead.
+
 ## Installation
 
 ```bash
 pip install scanlib
 ```
 
-Python 3.9+. Pre-built wheels available for all major platforms. On Linux, `libsane` and `libjpeg-turbo` are required at runtime (`apt install libsane-dev libturbojpeg0-dev`); on other platforms, no additional dependencies are required.
+Python 3.9+. Pre-built wheels available for all major platforms. On Linux, SANE and libjpeg must be installed at the system level:
+
+```bash
+# Debian / Ubuntu
+apt install libsane-dev libjpeg-dev
+
+# Fedora / RHEL
+dnf install sane-backends libjpeg-turbo-devel
+```
+
+On macOS and Windows, no additional system packages are required.
 
 ## Quick Start
 
+### Command line
+
+```bash
+# List available scanners
+scanlib list
+
+# Show scanner capabilities
+scanlib info -s 0
+
+# Scan to PDF
+scanlib scan -o document.pdf --dpi 300 --color-mode gray
+
+# Multi-page flatbed scan with interactive prompting
+scanlib scan -o multipage.pdf --pages ask
+```
+
+### Python API
+
 ```python
 import scanlib
 

{scanlib-1.0.0 → scanlib-1.2.0}/pyproject.toml

@@ -4,17 +4,47 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scanlib"
-version = "1.0.0"
+version = "1.2.0"
 description = "A multiplatform document scanning library for Python"
 readme = "README.md"
 license = {text = "MIT"}
 authors = [{name = "Angelo Mottola", email = "a.mottola@gmail.com"}]
+keywords = ["scanner", "scanning", "sane", "wia", "escl", "airscan", "twain", "pdf", "document"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: C",
+    "Topic :: Multimedia :: Graphics :: Capture :: Scanners",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
 requires-python = ">=3.9"
 dependencies = [
     "comtypes>=1.4; sys_platform == 'win32'",
     "pyobjc-framework-ImageCaptureCore; sys_platform == 'darwin'",
 ]
 
+[project.urls]
+Homepage = "https://github.com/amottola/scanlib"
+Documentation = "https://python-scanlib.readthedocs.io/"
+Repository = "https://github.com/amottola/scanlib"
+Changelog = "https://github.com/amottola/scanlib/blob/main/CHANGELOG.md"
+Issues = "https://github.com/amottola/scanlib/issues"
+
+[project.scripts]
+scanlib = "scanlib.__main__:main"
+
 [project.optional-dependencies]
 dev = ["pytest", "pytest-timeout", "pre-commit"]
 docs = ["sphinx", "furo", "sphinx-autodoc-typehints"]

{scanlib-1.0.0 → scanlib-1.2.0}/src/accel/_scanlib_accel.c

@@ -99,11 +99,17 @@ static PyObject *py_rgb_to_bgr(PyObject *Py_UNUSED(self), PyObject *args) {
 static PyObject *py_gray_to_bw(PyObject *Py_UNUSED(self), PyObject *args) {
     const char *data;
     Py_ssize_t data_len;
-    int width, height;
+    int width, height, threshold = 128;
 
-    if (!PyArg_ParseTuple(args, "y#ii", &data, &data_len, &width, &height))
+    if (!PyArg_ParseTuple(args, "y#ii|i", &data, &data_len, &width, &height,
+                          &threshold))
         return NULL;
 
+    if (threshold < 0 || threshold > 255) {
+        PyErr_SetString(PyExc_ValueError, "threshold must be 0-255");
+        return NULL;
+    }
+
     Py_ssize_t count = (Py_ssize_t)width * height;
     if (data_len < count) {
         PyErr_SetString(PyExc_ValueError, "pixel buffer too small");
@@ -130,7 +136,7 @@ static PyObject *py_gray_to_bw(PyObject *Py_UNUSED(self), PyObject *args) {
             int bits = width - x;
             if (bits > 8) bits = 8;
             for (int bit = 0; bit < bits; bit++) {
-                if (src[src_off + x + bit] >= 64)
+                if (src[src_off + x + bit] >= threshold)
                     byte_val |= (unsigned char)(0x80 >> bit);
             }
             dst[dst_off + x / 8] = byte_val;
@@ -704,6 +710,79 @@ static PyObject *py_encode_jpeg(PyObject *Py_UNUSED(self), PyObject *args) {
     return result;
 }
 
+/* ------------------------------------------------------------------ */
+/* decode_jpeg (Linux only, requires libjpeg)                         */
+/* ------------------------------------------------------------------ */
+
+static PyObject *py_decode_jpeg(PyObject *Py_UNUSED(self), PyObject *args) {
+    const char *data;
+    Py_ssize_t data_len;
+
+    if (!PyArg_ParseTuple(args, "y#", &data, &data_len))
+        return NULL;
+
+    if (data_len < 2) {
+        PyErr_SetString(PyExc_ValueError, "data too short for JPEG");
+        return NULL;
+    }
+
+    struct jpeg_decompress_struct cinfo;
+    struct my_error_mgr jerr;
+    volatile PyThreadState *gil_state = NULL;
+
+    cinfo.err = jpeg_std_error(&jerr.pub);
+    jerr.pub.error_exit = my_error_exit;
+
+    if (setjmp(jerr.setjmp_buffer)) {
+        if (gil_state)
+            PyEval_RestoreThread((PyThreadState *)gil_state);
+        jpeg_destroy_decompress(&cinfo);
+        PyErr_SetString(PyExc_RuntimeError, "libjpeg decoding error");
+        return NULL;
+    }
+
+    jpeg_create_decompress(&cinfo);
+    jpeg_mem_src(&cinfo, (const unsigned char *)data, (unsigned long)data_len);
+    jpeg_read_header(&cinfo, TRUE);
+
+    /* Force RGB or grayscale output */
+    if (cinfo.num_components == 1) {
+        cinfo.out_color_space = JCS_GRAYSCALE;
+    } else {
+        cinfo.out_color_space = JCS_RGB;
+    }
+
+    jpeg_start_decompress(&cinfo);
+
+    int width = (int)cinfo.output_width;
+    int height = (int)cinfo.output_height;
+    int components = (int)cinfo.output_components;
+    Py_ssize_t row_stride = (Py_ssize_t)width * components;
+    Py_ssize_t total = row_stride * height;
+
+    PyObject *result = PyBytes_FromStringAndSize(NULL, total);
+    if (!result) {
+        jpeg_destroy_decompress(&cinfo);
+        return NULL;
+    }
+
+    unsigned char *dst = (unsigned char *)PyBytes_AsString(result);
+
+    gil_state = PyEval_SaveThread();
+    while (cinfo.output_scanline < cinfo.output_height) {
+        unsigned char *row = dst + (Py_ssize_t)cinfo.output_scanline * row_stride;
+        JSAMPROW row_ptr = (JSAMPROW)row;
+        jpeg_read_scanlines(&cinfo, &row_ptr, 1);
+    }
+    PyEval_RestoreThread((PyThreadState *)gil_state);
+    gil_state = NULL;
+
+    jpeg_finish_decompress(&cinfo);
+    jpeg_destroy_decompress(&cinfo);
+
+    return Py_BuildValue("(Niii)", result, width, height, components);
+}
+
 #endif /* HAVE_JPEGLIB */
 
 /* ------------------------------------------------------------------ */
@@ -718,8 +797,9 @@ static PyMethodDef methods[] = {
      "rgb_to_bgr(data, width, height) -> bytes\n"
      "Convert 8-bit interleaved RGB to BGR (swap R and B channels)."},
     {"gray_to_bw", py_gray_to_bw, METH_VARARGS,
-     "gray_to_bw(data, width, height) -> bytes\n"
-     "Convert 8-bit grayscale to 1-bit packed (MSB first)."},
+     "gray_to_bw(data, width, height, threshold=128) -> bytes\n"
+     "Convert 8-bit grayscale to 1-bit packed (MSB first).\n"
+     "Pixels >= threshold become white (1), below become black (0)."},
     {"bw_to_gray", py_bw_to_gray, METH_VARARGS,
      "bw_to_gray(data, width, height) -> bytes\n"
      "Convert 1-bit packed (MSB first) to 8-bit grayscale."},
@@ -741,6 +821,10 @@ static PyMethodDef methods[] = {
     {"encode_jpeg", py_encode_jpeg, METH_VARARGS,
      "encode_jpeg(data, width, height, num_components, quality) -> bytes\n"
      "Encode raw pixels to JPEG using libjpeg."},
+    {"decode_jpeg", py_decode_jpeg, METH_VARARGS,
+     "decode_jpeg(data) -> tuple[bytes, int, int, int]\n"
+     "Decode JPEG bytes to raw pixels. Returns "
+     "(raw_data, width, height, num_components)."},
 #endif
     {NULL, NULL, 0, NULL}
 };

scanlib-1.2.0/src/scanlib/__init__.py

@@ -0,0 +1,249 @@
+"""scanlib — A multiplatform document scanning library for Python."""
+
+from __future__ import annotations
+
+import os
+import sys
+import threading
+from collections.abc import Iterator
+from importlib.metadata import version
+
+__version__ = version("scanlib")
+
+from ._types import (
+    DISCOVERY_TIMEOUT,
+    BackendNotAvailableError,
+    ColorMode,
+    FeederEmptyError,
+    ImageFormat,
+    NoScannerFoundError,
+    ScanArea,
+    ScanAborted,
+    ScanBackend,
+    ScanError,
+    ScanLibError,
+    Scanner,
+    ScannerDefaults,
+    ScannerNotOpenError,
+    ScanOptions,
+    ScanSource,
+    ScannedDocument,
+    ScannedPage,
+    SourceInfo,
+    build_pdf,
+)
+
+__all__ = [
+    "list_scanners",
+    "open_scanner",
+    "build_pdf",
+    "DISCOVERY_TIMEOUT",
+    "ColorMode",
+    "ImageFormat",
+    "ScanArea",
+    "Scanner",
+    "ScannerDefaults",
+    "ScannerNotOpenError",
+    "ScanOptions",
+    "ScanSource",
+    "ScannedDocument",
+    "ScannedPage",
+    "SourceInfo",
+    "ScanLibError",
+    "ScanError",
+    "ScanAborted",
+    "FeederEmptyError",
+    "NoScannerFoundError",
+    "BackendNotAvailableError",
+]
+
+
+# ---------------------------------------------------------------------------
+# Composite backend — merges a platform backend with eSCL
+# ---------------------------------------------------------------------------
+
+
+class _CompositeBackend:
+    """Merges results from a platform backend and the eSCL backend.
+
+    ``list_scanners`` runs both backends' discovery in parallel and
+    deduplicates by IP address.  Each scanner's ``_backend_impl`` points
+    to whichever backend discovered it.
+    """
+
+    def __init__(self, platform_backend: ScanBackend) -> None:
+        from .backends._escl import EsclBackend
+
+        self._platform = platform_backend
+        self._escl = EsclBackend()
+
+    def list_scanners(
+        self,
+        timeout: float = DISCOVERY_TIMEOUT,
+        cancel: threading.Event | None = None,
+    ) -> list[Scanner]:
+        # Run both discoveries in parallel.
+        platform_box: list[list[Scanner]] = [[]]
+        escl_box: list[list[Scanner]] = [[]]
+
+        def _run_platform() -> None:
+            try:
+                platform_box[0] = self._platform.list_scanners(
+                    timeout=timeout, cancel=cancel
+                )
+            except Exception:
+                platform_box[0] = []
+
+        def _run_escl() -> None:
+            try:
+                escl_box[0] = self._escl.list_scanners(timeout=timeout, cancel=cancel)
+            except Exception:
+                escl_box[0] = []
+
+        t_platform = threading.Thread(target=_run_platform, daemon=True)
+        t_escl = threading.Thread(target=_run_escl, daemon=True)
+        t_platform.start()
+        t_escl.start()
+
+        # Wait for eSCL first (fast, ~4s max), then give the platform
+        # backend a short grace period to finish.  Don't block on a
+        # slow platform backend when eSCL already has results.
+        t_escl.join(timeout=timeout + 2)
+        if t_platform.is_alive():
+            t_platform.join(timeout=2.0)
+
+        if cancel is not None and cancel.is_set():
+            return []
+
+        platform_scanners = platform_box[0]
+        escl_scanners = escl_box[0]
+
+        if not escl_scanners:
+            return platform_scanners
+
+        # Collect IPs from platform scanners for deduplication
+        from ._mdns import extract_ip_from_uri
+
+        platform_ips: set[str] = set()
+        for s in platform_scanners:
+            ip = extract_ip_from_uri(s.name)
+            if ip:
+                platform_ips.add(ip)
+
+        # Add eSCL scanners not already found by the platform backend
+        escl_ips = self._escl.get_scanner_ips()
+        for s in escl_scanners:
+            ip = escl_ips.get(s.id)
+            if ip and ip in platform_ips:
+                continue  # already discovered by platform backend
+            platform_scanners.append(s)
+
+        return platform_scanners
+
+    # Delegate remaining methods to the scanner's own _backend_impl
+    def open_scanner(self, scanner: Scanner) -> None:
+        scanner._backend_impl.open_scanner(scanner)
+
+    def close_scanner(self, scanner: Scanner) -> None:
+        scanner._backend_impl.close_scanner(scanner)
+
+    def scan_pages(
+        self, scanner: Scanner, options: ScanOptions
+    ) -> Iterator[ScannedPage]:
+        return scanner._backend_impl.scan_pages(scanner, options)
+
+    def abort_scan(self, scanner: Scanner) -> None:
+        scanner._backend_impl.abort_scan(scanner)
+
+
+# ---------------------------------------------------------------------------
+# Backend selection
+# ---------------------------------------------------------------------------
+
+_backend: ScanBackend | None = None
+
+
+def _get_backend() -> ScanBackend:
+    """Return the appropriate scanning backend for the current platform."""
+    global _backend
+    if _backend is not None:
+        return _backend
+
+    if sys.platform == "linux":
+        from .backends._sane import SaneBackend
+
+        _backend = _CompositeBackend(SaneBackend())
+
+    elif sys.platform == "darwin":
+        from .backends._macos import MacOSBackend
+
+        if os.environ.get("SCANLIB_ESCL", "").strip() == "1":
+            _backend = _CompositeBackend(MacOSBackend())
+        else:
+            _backend = MacOSBackend()
+
+    elif sys.platform == "win32":
+        from .backends._wia import WiaBackend
+
+        _backend = _CompositeBackend(WiaBackend())
+
+    else:
+        raise BackendNotAvailableError(f"Unsupported platform: {sys.platform}")
+
+    return _backend
+
+
+def list_scanners(
+    *,
+    timeout: float = DISCOVERY_TIMEOUT,
+    cancel: threading.Event | None = None,
+) -> list[Scanner]:
+    """Return all available scanners on the current platform.
+
+    *timeout* controls how long (in seconds) to wait for scanner
+    discovery.  The default is :data:`DISCOVERY_TIMEOUT` (15 s).
+
+    *cancel*, if given, is a :class:`threading.Event` that the caller can
+    set from another thread to interrupt discovery early.  When the event
+    is set the function returns immediately with an empty list.
+
+    The returned :class:`Scanner` objects are lightweight — no device sessions
+    are opened.  Use :meth:`Scanner.open` (or the context-manager protocol)
+    to start a session before scanning.
+    """
+    return _get_backend().list_scanners(timeout=timeout, cancel=cancel)
+
+
+def open_scanner(scanner_id: str) -> Scanner:
+    """Open a scanner directly by its ID, without discovery.
+
+    *scanner_id* is the :attr:`Scanner.id` string obtained from a
+    previous :func:`list_scanners` call (e.g. ``"escl:192.168.1.5:443"``
+    for eSCL, a SANE device URI, or a WIA device ID).
+
+    Returns an **opened** :class:`Scanner` ready for scanning.  The
+    caller must call :meth:`Scanner.close` (or use the context-manager
+    protocol) when done.
+
+    This avoids the latency of scanner discovery when the ID is already
+    known.
+    """
+    if scanner_id.startswith("escl:"):
+        from .backends._escl import EsclBackend
+
+        impl = EsclBackend()
+    else:
+        # Use the platform backend
+        top = _get_backend()
+        impl = top._platform if isinstance(top, _CompositeBackend) else top
+
+    scanner = Scanner(
+        name=scanner_id,
+        vendor=None,
+        model=None,
+        backend=impl.backend_name,
+        scanner_id=scanner_id,
+        _backend_impl=impl,
+    )
+    scanner.open()
+    return scanner