onvif-scanner 0.1.0__tar.gz

onvif_scanner-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Urban Parking
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

onvif_scanner-0.1.0/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: onvif-scanner
+Version: 0.1.0
+Summary: CLI tool to scan ONVIF cameras on local network via WS-Discovery
+Author-email: Riki Handoyo <jawakeror@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/jawak/onvif-scanner
+Project-URL: Repository, https://github.com/jawak/onvif-scanner
+Project-URL: Issues, https://github.com/jawak/onvif-scanner/issues
+Project-URL: Changelog, https://github.com/jawak/onvif-scanner/releases
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: System :: Networking :: Monitoring
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: onvif-zeep>=0.2.12
+Requires-Dist: wsdiscovery>=0.1.0
+Requires-Dist: click>=8.1
+Requires-Dist: rich>=13.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+# ONVIF Scanner
+
+[![PyPI version](https://img.shields.io/pypi/v/onvif-scanner.svg)](https://pypi.org/project/onvif-scanner/)
+[![Python versions](https://img.shields.io/pypi/pyversions/onvif-scanner.svg)](https://pypi.org/project/onvif-scanner/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![CI](https://github.com/jawak/onvif-scanner/actions/workflows/publish.yml/badge.svg)](https://github.com/jawak/onvif-scanner/actions/workflows/publish.yml)
+
+A simple CLI tool to scan for ONVIF cameras on the local network. It uses
+WS-Discovery (UDP multicast) to discover devices, then queries the ONVIF
+Device Service to retrieve: manufacturer, model, serial number, firmware, and
+the **RTSP URL**.
+
+## Features
+
+- **WS-Discovery multicast** on the local subnet (automatic, no manual IP input)
+- **Device query** — GetDeviceInformation + GetStreamUri (RTSP URL)
+- Output as a **table** (pretty, default) or **JSON** (stdout / file)
+- `--rtsp-only` filter — only show cameras that successfully returned an RTSP URL
+- Authenticated scan (`--username` / `--password`) for cameras that require auth
+- Per-device error isolation — a single camera failing does not break the entire scan
+
+## Install
+
+```bash
+cd onvif-scanner
+
+# Development mode (recommended)
+pip install -e .
+
+# Or run directly from source without installing
+python -m onvif-scanner --help
+```
+
+Requires Python 3.10+.
+
+## Usage
+
+```bash
+# Quick scan, pretty table output (default)
+onvif-scan
+
+# JSON to stdout
+onvif-scan --output json
+
+# Save to file
+onvif-scan --output-file cameras.json
+
+# Longer timeout (large / slow networks)
+onvif-scan --timeout 10
+
+# Authenticated scan (to get RTSP URLs from cameras that require auth)
+onvif-scan --username admin --password secret
+
+# Only show cameras that have an RTSP URL
+onvif-scan --rtsp-only
+
+# Debug logging (WS-Discovery + zeep)
+onvif-scan --verbose
+```
+
+## JSON Output
+
+```json
+{
+  "scan_time": "2026-07-19T10:00:00+07:00",
+  "scan_duration_seconds": 3.2,
+  "timeout_seconds": 5,
+  "camera_count": 2,
+  "cameras": [
+    {
+      "address": "192.168.1.100",
+      "device_url": "http://192.168.1.100/onvif/device_service",
+      "manufacturer": "Hikvision",
+      "model": "DS-2CD2143G2",
+      "firmware_version": "V5.6.5",
+      "serial_number": "DS-2CD2143G2-...-VVV111100",
+      "hardware_id": "880901",
+      "rtsp_url": "rtsp://192.168.1.100:554/Streaming/Channels/101",
+      "mac": null,
+      "scopes": ["onvif://www.onvif.org/Profile/Streaming"],
+      "authenticated": false,
+      "error": null
+    }
+  ]
+}
+```
+
+## Troubleshooting
+
+| Symptom | Cause | Solution |
+|---------|-------|----------|
+| `No ONVIF devices discovered` | Multicast UDP blocked by firewall / different VLAN | Make sure UDP port 3702 (multicast 239.255.255.250:3702) is allowed. The scan must run on the same subnet as the cameras. |
+| Camera discovered but `rtsp_url: null` | Camera requires auth for the Media service | Use `--username admin --password <pass>` |
+| Camera not discovered despite being online | ONVIF disabled in the camera's web UI | Enable ONVIF (Profile S) in the camera settings |
+| `ImportError: wsdiscovery` / `onvif-zeep` | Dependencies not installed | Re-run `pip install -e .` |
+| Scan is slow (>5s) | Large network / many devices | Increase `--timeout 10`, or add `--rtsp-only` to skip device queries |
+| zeep error: WSDL download | onvif-zeep requires internet access on first run (to download WSDL) | Ensure internet connectivity, or bundle the WSDL locally and pass `wsdl_dir` in `device.py` |
+
+## Compatible Devices
+
+Tested with: Hikvision, Dahua, generic ONVIF Profile S (Arducam, Reolink, Amcrest).
+
+Standards: ONVIF Core Spec + Profile S (Streaming).
+
+## Architecture
+
+```
+onvif_scanner/
+├── cli.py          # Click CLI + rich output (table/json/file)
+├── discovery.py    # WS-Discovery multicast via wsdiscovery lib
+├── device.py       # ONVIF Device Service query via onvif-zeep
+└── models.py       # dataclass DiscoveredDevice + Camera
+```
+
+Flow: `cli.py` → `discovery.discover_cameras()` (UDP multicast) → `device.query_device()` (HTTP SOAP per camera) → output (table/json/file).
+
+## Limitations (future work)
+
+- Multicast only (no unicast IP range probe for cross-VLAN discovery)
+- Single username/password (no multi-credential support)
+- No auto-registration to the parking DB (`cameras` table) — a `register` subcommand could be added
+- No streaming preview (RTSP URL only, no frame preview)
+
+## License
+
+MIT

onvif_scanner-0.1.0/README.md

@@ -0,0 +1,126 @@
+# ONVIF Scanner
+
+[![PyPI version](https://img.shields.io/pypi/v/onvif-scanner.svg)](https://pypi.org/project/onvif-scanner/)
+[![Python versions](https://img.shields.io/pypi/pyversions/onvif-scanner.svg)](https://pypi.org/project/onvif-scanner/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![CI](https://github.com/jawak/onvif-scanner/actions/workflows/publish.yml/badge.svg)](https://github.com/jawak/onvif-scanner/actions/workflows/publish.yml)
+
+A simple CLI tool to scan for ONVIF cameras on the local network. It uses
+WS-Discovery (UDP multicast) to discover devices, then queries the ONVIF
+Device Service to retrieve: manufacturer, model, serial number, firmware, and
+the **RTSP URL**.
+
+## Features
+
+- **WS-Discovery multicast** on the local subnet (automatic, no manual IP input)
+- **Device query** — GetDeviceInformation + GetStreamUri (RTSP URL)
+- Output as a **table** (pretty, default) or **JSON** (stdout / file)
+- `--rtsp-only` filter — only show cameras that successfully returned an RTSP URL
+- Authenticated scan (`--username` / `--password`) for cameras that require auth
+- Per-device error isolation — a single camera failing does not break the entire scan
+
+## Install
+
+```bash
+cd onvif-scanner
+
+# Development mode (recommended)
+pip install -e .
+
+# Or run directly from source without installing
+python -m onvif-scanner --help
+```
+
+Requires Python 3.10+.
+
+## Usage
+
+```bash
+# Quick scan, pretty table output (default)
+onvif-scan
+
+# JSON to stdout
+onvif-scan --output json
+
+# Save to file
+onvif-scan --output-file cameras.json
+
+# Longer timeout (large / slow networks)
+onvif-scan --timeout 10
+
+# Authenticated scan (to get RTSP URLs from cameras that require auth)
+onvif-scan --username admin --password secret
+
+# Only show cameras that have an RTSP URL
+onvif-scan --rtsp-only
+
+# Debug logging (WS-Discovery + zeep)
+onvif-scan --verbose
+```
+
+## JSON Output
+
+```json
+{
+  "scan_time": "2026-07-19T10:00:00+07:00",
+  "scan_duration_seconds": 3.2,
+  "timeout_seconds": 5,
+  "camera_count": 2,
+  "cameras": [
+    {
+      "address": "192.168.1.100",
+      "device_url": "http://192.168.1.100/onvif/device_service",
+      "manufacturer": "Hikvision",
+      "model": "DS-2CD2143G2",
+      "firmware_version": "V5.6.5",
+      "serial_number": "DS-2CD2143G2-...-VVV111100",
+      "hardware_id": "880901",
+      "rtsp_url": "rtsp://192.168.1.100:554/Streaming/Channels/101",
+      "mac": null,
+      "scopes": ["onvif://www.onvif.org/Profile/Streaming"],
+      "authenticated": false,
+      "error": null
+    }
+  ]
+}
+```
+
+## Troubleshooting
+
+| Symptom | Cause | Solution |
+|---------|-------|----------|
+| `No ONVIF devices discovered` | Multicast UDP blocked by firewall / different VLAN | Make sure UDP port 3702 (multicast 239.255.255.250:3702) is allowed. The scan must run on the same subnet as the cameras. |
+| Camera discovered but `rtsp_url: null` | Camera requires auth for the Media service | Use `--username admin --password <pass>` |
+| Camera not discovered despite being online | ONVIF disabled in the camera's web UI | Enable ONVIF (Profile S) in the camera settings |
+| `ImportError: wsdiscovery` / `onvif-zeep` | Dependencies not installed | Re-run `pip install -e .` |
+| Scan is slow (>5s) | Large network / many devices | Increase `--timeout 10`, or add `--rtsp-only` to skip device queries |
+| zeep error: WSDL download | onvif-zeep requires internet access on first run (to download WSDL) | Ensure internet connectivity, or bundle the WSDL locally and pass `wsdl_dir` in `device.py` |
+
+## Compatible Devices
+
+Tested with: Hikvision, Dahua, generic ONVIF Profile S (Arducam, Reolink, Amcrest).
+
+Standards: ONVIF Core Spec + Profile S (Streaming).
+
+## Architecture
+
+```
+onvif_scanner/
+├── cli.py          # Click CLI + rich output (table/json/file)
+├── discovery.py    # WS-Discovery multicast via wsdiscovery lib
+├── device.py       # ONVIF Device Service query via onvif-zeep
+└── models.py       # dataclass DiscoveredDevice + Camera
+```
+
+Flow: `cli.py` → `discovery.discover_cameras()` (UDP multicast) → `device.query_device()` (HTTP SOAP per camera) → output (table/json/file).
+
+## Limitations (future work)
+
+- Multicast only (no unicast IP range probe for cross-VLAN discovery)
+- Single username/password (no multi-credential support)
+- No auto-registration to the parking DB (`cameras` table) — a `register` subcommand could be added
+- No streaming preview (RTSP URL only, no frame preview)
+
+## License
+
+MIT

onvif_scanner-0.1.0/onvif_scanner/__init__.py

@@ -0,0 +1,3 @@
+"""ONVIF Scanner — discover ONVIF cameras on local network via WS-Discovery."""
+
+__version__ = "0.1.0"

onvif_scanner-0.1.0/onvif_scanner/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for `python -m onvif_scanner`."""
+
+from onvif_scanner.cli import cli
+
+if __name__ == "__main__":
+    cli()

onvif_scanner-0.1.0/onvif_scanner/cli.py

@@ -0,0 +1,182 @@
+"""CLI entry point for the ONVIF scanner."""
+
+from __future__ import annotations
+
+import json
+import logging
+import sys
+import time
+from datetime import datetime, timezone, timedelta
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.logging import RichHandler
+from rich.table import Table
+
+from onvif_scanner.device import query_device
+from onvif_scanner.discovery import discover_cameras
+
+WIB = timezone(timedelta(hours=7))
+
+console = Console()
+
+
+def _setup_logging(verbose: bool) -> None:
+    level = logging.DEBUG if verbose else logging.WARNING
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%H:%M:%S",
+        handlers=[RichHandler(console=console)],
+    )
+
+
+def _format_scan_time() -> tuple[str, str]:
+    now = datetime.now(WIB)
+    return now.isoformat(timespec="seconds"), now.strftime("%Y-%m-%d %H:%M:%S WIB")
+
+
+def _emit_table(cameras: list[dict]) -> None:
+    table = Table(title=f"ONVIF Camera Scan — {len(cameras)} device(s) discovered")
+    table.add_column("Address", style="cyan", no_wrap=True)
+    table.add_column("Manufacturer", style="magenta")
+    table.add_column("Model")
+    table.add_column("Serial", overflow="fold")
+    table.add_column("RTSP URL", style="green", overflow="fold")
+
+    for c in cameras:
+        if c.get("error") and not c.get("manufacturer"):
+            table.add_row(
+                c["address"],
+                "[red]ERROR[/red]",
+                "",
+                "",
+                c["error"][:80],
+            )
+        else:
+            table.add_row(
+                c["address"],
+                c.get("manufacturer") or "-",
+                c.get("model") or "-",
+                (c.get("serial_number") or "-")[:24],
+                c.get("rtsp_url") or "[red]none[/red]",
+            )
+
+    console.print(table)
+
+
+def _emit_json(payload: dict) -> None:
+    click.echo(json.dumps(payload, indent=2, ensure_ascii=False))
+
+
+def _write_file(payload: dict, path: Path) -> None:
+    path.write_text(json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8")
+    console.print(f"[green]Saved to[/green] {path}")
+
+
+@click.command()
+@click.option(
+    "--timeout",
+    default=5,
+    show_default=True,
+    type=click.IntRange(min=1, max=60),
+    help="WS-Discovery listen window (seconds).",
+)
+@click.option(
+    "--output",
+    "output_format",
+    default="table",
+    show_default=True,
+    type=click.Choice(["table", "json"]),
+    help="Output format. 'json' prints to stdout.",
+)
+@click.option(
+    "--output-file",
+    "output_file",
+    type=click.Path(dir_okay=False, writable=True, path_type=Path),
+    default=None,
+    help="Save JSON scan result to file (always JSON, regardless of --output).",
+)
+@click.option("--username", default=None, help="ONVIF username (for authenticated query).")
+@click.option(
+    "--password",
+    default=None,
+    help="ONVIF password. If --username set and this is empty, you'll be prompted.",
+    prompt=False,
+    hide_input=True,
+)
+@click.option(
+    "--rtsp-only",
+    is_flag=True,
+    default=False,
+    help="Only show cameras that returned an RTSP URL.",
+)
+@click.option("--verbose", "-v", is_flag=True, default=False, help="Enable debug logging.")
+def cli(
+    timeout: int,
+    output_format: str,
+    output_file: Path | None,
+    username: str | None,
+    password: str | None,
+    rtsp_only: bool,
+    verbose: bool,
+) -> None:
+    """Scan the local subnet for ONVIF cameras (WS-Discovery + device query)."""
+    _setup_logging(verbose)
+
+    # Prompt for password silently if username given without password
+    if username and not password:
+        password = click.prompt("Password", hide_input=True, default="", show_default=False)
+
+    scan_time_iso, scan_time_display = _format_scan_time()
+    console.print(f"[bold]Scan started:[/bold] {scan_time_display}")
+    start = time.time()
+
+    # 1. Discovery
+    try:
+        discovered = discover_cameras(timeout=timeout, verbose=verbose)
+    except RuntimeError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        sys.exit(2)
+    except Exception as e:
+        console.print(f"[red]Discovery failed:[/red] {e}")
+        sys.exit(1)
+
+    if not discovered:
+        console.print("[yellow]No ONVIF devices discovered.[/yellow]")
+
+    # 2. Query each device
+    cameras = []
+    for d in discovered:
+        cam = query_device(d, username=username, password=password, verbose=verbose)
+        cameras.append(cam.to_dict())
+
+    # 3. Post-filter
+    if rtsp_only:
+        cameras = [c for c in cameras if c.get("rtsp_url")]
+
+    duration = round(time.time() - start, 2)
+    payload = {
+        "scan_time": scan_time_iso,
+        "scan_duration_seconds": duration,
+        "timeout_seconds": timeout,
+        "camera_count": len(cameras),
+        "cameras": cameras,
+    }
+
+    # 4. Output
+    if output_file:
+        _write_file(payload, output_file)
+    elif output_format == "json":
+        _emit_json(payload)
+    else:
+        _emit_table(cameras)
+        console.print(
+            f"\n[dim]Scanned in {duration}s · {len(cameras)} camera(s) "
+            f"(discovered {len(discovered)} device(s))[/dim]"
+        )
+
+
+if __name__ == "__main__":
+    cli()

onvif_scanner-0.1.0/onvif_scanner/device.py

@@ -0,0 +1,111 @@
+"""Query ONVIF device service for manufacturer, model, serial, and RTSP URL."""
+
+from __future__ import annotations
+
+import logging
+from urllib.parse import urlparse
+
+from onvif_scanner.models import Camera, DiscoveredDevice
+
+logger = logging.getLogger(__name__)
+
+
+def query_device(
+    device: DiscoveredDevice,
+    username: str | None = None,
+    password: str | None = None,
+    verbose: bool = False,
+) -> Camera:
+    """Query a single ONVIF device for device info + RTSP stream URI.
+
+    Args:
+        device: discovered device (from discovery.discover_cameras).
+        username: ONVIF username (optional — some cameras expose info without auth).
+        password: ONVIF password.
+
+    Returns:
+        Camera dataclass. If query fails, `error` field is set and other fields stay None.
+    """
+    if verbose:
+        logging.getLogger("zeep").setLevel(logging.DEBUG)
+
+    parsed = urlparse(device.device_url)
+    host = parsed.hostname or device.address
+    port = parsed.port or 80
+
+    cam = Camera(
+        address=host,
+        device_url=device.device_url,
+        scopes=list(device.scopes),
+        authenticated=bool(username and password),
+    )
+
+    try:
+        from onvif import ONVIFCamera
+    except ImportError as e:
+        raise RuntimeError(
+            "onvif-zeep is not installed. Run: pip install onvif-zeep"
+        ) from e
+
+    logger.info("Querying %s (auth=%s)", host, cam.authenticated)
+
+    try:
+        # onvif-zeep auto-downloads WSDL if wsdl_dir is not provided.
+        # For offline ops, bundle WSDL in a known dir and pass wsdl_dir=...
+        client = ONVIFCamera(
+            host,
+            port,
+            username or "",
+            password or "",
+            no_cache=False,
+        )
+
+        # 1. GetDeviceInformation
+        try:
+            mgmt = client.create_devicemgmt_service()
+            info = mgmt.GetDeviceInformation()
+            cam.manufacturer = getattr(info, "Manufacturer", None)
+            cam.model = getattr(info, "Model", None)
+            cam.firmware_version = getattr(info, "FirmwareVersion", None)
+            cam.serial_number = getattr(info, "SerialNumber", None)
+            cam.hardware_id = getattr(info, "HardwareId", None)
+        except Exception as e:
+            logger.warning("GetDeviceInformation failed for %s: %s", host, e)
+            cam.error = f"GetDeviceInformation failed: {e}"
+
+        # 2. GetStreamUri (requires Media service + a profile token)
+        try:
+            media = client.create_media_service()
+            profiles = media.GetProfiles()
+            if not profiles:
+                logger.warning("No media profiles for %s", host)
+            else:
+                token = profiles[0].token
+                request = media.create_type("GetStreamUri")
+                request.ProfileToken = token
+                request.StreamSetup = {
+                    "Stream": "RTP-Unicast",
+                    "Transport": {"Protocol": "RTSP"},
+                }
+                stream_uri = media.GetStreamUri(request)
+                if stream_uri and hasattr(stream_uri, "Uri"):
+                    cam.rtsp_url = stream_uri.Uri
+                elif isinstance(stream_uri, str):
+                    cam.rtsp_url = stream_uri
+        except Exception as e:
+            logger.warning("GetStreamUri failed for %s: %s", host, e)
+            if not cam.error:
+                cam.error = f"GetStreamUri failed: {e}"
+
+        logger.info(
+            "OK %s: %s %s rtsp=%s",
+            host,
+            cam.manufacturer,
+            cam.model,
+            cam.rtsp_url,
+        )
+    except Exception as e:
+        logger.error("Device query failed for %s: %s", host, e)
+        cam.error = f"Device query failed: {e}"
+
+    return cam

onvif_scanner-0.1.0/onvif_scanner/discovery.py

@@ -0,0 +1,91 @@
+"""WS-Discovery multicast scanner for ONVIF devices."""
+
+from __future__ import annotations
+
+import logging
+from urllib.parse import urlparse
+
+from onvif_scanner.models import DiscoveredDevice
+
+logger = logging.getLogger(__name__)
+
+# WS-Discovery WITHOUT scope filter — `wsdiscovery` 2.1.2 has a QName bug
+# (`getQuotedValue`) on Python 3.13 when scopes are passed. We instead filter
+# ONVIF devices client-side by checking the xaddr contains "/onvif/".
+ONVIF_PATH_MARKER = "/onvif/"
+
+
+def discover_cameras(timeout: int = 5, verbose: bool = False) -> list[DiscoveredDevice]:
+    """Run WS-Discovery multicast on the local subnet and return ONVIF devices.
+
+    Args:
+        timeout: how long to listen for ProbeMatches (seconds).
+        verbose: enable detailed logging from WSDiscovery.
+
+    Returns:
+        List of DiscoveredDevice (deduped by device_url), filtered to ONVIF only.
+    """
+    if verbose:
+        logging.getLogger("WSDiscovery").setLevel(logging.DEBUG)
+
+    try:
+        from wsdiscovery.discovery import ThreadedWSDiscovery
+    except ImportError as e:
+        raise RuntimeError(
+            "wsdiscovery is not installed. Run: pip install wsdiscovery"
+        ) from e
+
+    logger.info("Starting WS-Discovery (timeout=%ss, no scope filter)", timeout)
+    wsd = ThreadedWSDiscovery()
+    wsd.start()
+    try:
+        services = wsd.searchServices(timeout=timeout)
+    finally:
+        wsd.stop()
+
+    logger.info("WS-Discovery returned %d raw service(s)", len(services))
+
+    devices: dict[str, DiscoveredDevice] = {}
+    for svc in services:
+        xaddrs = list(svc.getXAddrs())
+        if not xaddrs:
+            logger.debug("Skipping service without XAddrs: %s", svc.getEPR())
+            continue
+
+        # Filter: only keep ONVIF device service endpoints
+        onvif_xaddrs = [x for x in xaddrs if ONVIF_PATH_MARKER in x.lower()]
+        if not onvif_xaddrs:
+            logger.debug("Skipping non-ONVIF service: %s", xaddrs)
+            continue
+
+        # Use the first onvif xaddr — typically http://<ip>/onvif/device_service
+        device_url = onvif_xaddrs[0]
+        try:
+            host = urlparse(device_url).hostname or ""
+        except Exception:
+            host = ""
+
+        # Scopes returned by wsdiscovery may be QName objects — convert to str
+        raw_scopes: list[str] = []
+        for s in svc.getScopes():
+            try:
+                raw_scopes.append(str(s))
+            except Exception:
+                raw_scopes.append(repr(s))
+
+        # Deduplicate by device_url (some cameras advertise multiple XAddrs)
+        if device_url in devices:
+            existing = devices[device_url]
+            existing.scopes = list({*existing.scopes, *raw_scopes})
+            existing.xaddrs = list({*existing.xaddrs, *onvif_xaddrs})
+            continue
+
+        devices[device_url] = DiscoveredDevice(
+            address=host,
+            device_url=device_url,
+            scopes=raw_scopes,
+            xaddrs=onvif_xaddrs,
+        )
+        logger.debug("Discovered ONVIF device: %s (%s)", host, device_url)
+
+    return list(devices.values())

onvif_scanner-0.1.0/onvif_scanner/models.py

@@ -0,0 +1,37 @@
+"""Data models for discovered ONVIF cameras."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, asdict
+from typing import Optional
+
+
+@dataclass
+class DiscoveredDevice:
+    """Raw result from WS-Discovery (before device query)."""
+
+    address: str
+    device_url: str
+    scopes: list[str] = field(default_factory=list)
+    xaddrs: list[str] = field(default_factory=list)
+
+
+@dataclass
+class Camera:
+    """Fully-queried ONVIF camera with device info + RTSP URL."""
+
+    address: str
+    device_url: str
+    manufacturer: Optional[str] = None
+    model: Optional[str] = None
+    firmware_version: Optional[str] = None
+    serial_number: Optional[str] = None
+    hardware_id: Optional[str] = None
+    rtsp_url: Optional[str] = None
+    mac: Optional[str] = None
+    scopes: list[str] = field(default_factory=list)
+    authenticated: bool = False
+    error: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        return asdict(self)

onvif_scanner-0.1.0/onvif_scanner.egg-info/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: onvif-scanner
+Version: 0.1.0
+Summary: CLI tool to scan ONVIF cameras on local network via WS-Discovery
+Author-email: Riki Handoyo <jawakeror@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/jawak/onvif-scanner
+Project-URL: Repository, https://github.com/jawak/onvif-scanner
+Project-URL: Issues, https://github.com/jawak/onvif-scanner/issues
+Project-URL: Changelog, https://github.com/jawak/onvif-scanner/releases
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: System :: Networking :: Monitoring
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: onvif-zeep>=0.2.12
+Requires-Dist: wsdiscovery>=0.1.0
+Requires-Dist: click>=8.1
+Requires-Dist: rich>=13.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+# ONVIF Scanner
+
+[![PyPI version](https://img.shields.io/pypi/v/onvif-scanner.svg)](https://pypi.org/project/onvif-scanner/)
+[![Python versions](https://img.shields.io/pypi/pyversions/onvif-scanner.svg)](https://pypi.org/project/onvif-scanner/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![CI](https://github.com/jawak/onvif-scanner/actions/workflows/publish.yml/badge.svg)](https://github.com/jawak/onvif-scanner/actions/workflows/publish.yml)
+
+A simple CLI tool to scan for ONVIF cameras on the local network. It uses
+WS-Discovery (UDP multicast) to discover devices, then queries the ONVIF
+Device Service to retrieve: manufacturer, model, serial number, firmware, and
+the **RTSP URL**.
+
+## Features
+
+- **WS-Discovery multicast** on the local subnet (automatic, no manual IP input)
+- **Device query** — GetDeviceInformation + GetStreamUri (RTSP URL)
+- Output as a **table** (pretty, default) or **JSON** (stdout / file)
+- `--rtsp-only` filter — only show cameras that successfully returned an RTSP URL
+- Authenticated scan (`--username` / `--password`) for cameras that require auth
+- Per-device error isolation — a single camera failing does not break the entire scan
+
+## Install
+
+```bash
+cd onvif-scanner
+
+# Development mode (recommended)
+pip install -e .
+
+# Or run directly from source without installing
+python -m onvif-scanner --help
+```
+
+Requires Python 3.10+.
+
+## Usage
+
+```bash
+# Quick scan, pretty table output (default)
+onvif-scan
+
+# JSON to stdout
+onvif-scan --output json
+
+# Save to file
+onvif-scan --output-file cameras.json
+
+# Longer timeout (large / slow networks)
+onvif-scan --timeout 10
+
+# Authenticated scan (to get RTSP URLs from cameras that require auth)
+onvif-scan --username admin --password secret
+
+# Only show cameras that have an RTSP URL
+onvif-scan --rtsp-only
+
+# Debug logging (WS-Discovery + zeep)
+onvif-scan --verbose
+```
+
+## JSON Output
+
+```json
+{
+  "scan_time": "2026-07-19T10:00:00+07:00",
+  "scan_duration_seconds": 3.2,
+  "timeout_seconds": 5,
+  "camera_count": 2,
+  "cameras": [
+    {
+      "address": "192.168.1.100",
+      "device_url": "http://192.168.1.100/onvif/device_service",
+      "manufacturer": "Hikvision",
+      "model": "DS-2CD2143G2",
+      "firmware_version": "V5.6.5",
+      "serial_number": "DS-2CD2143G2-...-VVV111100",
+      "hardware_id": "880901",
+      "rtsp_url": "rtsp://192.168.1.100:554/Streaming/Channels/101",
+      "mac": null,
+      "scopes": ["onvif://www.onvif.org/Profile/Streaming"],
+      "authenticated": false,
+      "error": null
+    }
+  ]
+}
+```
+
+## Troubleshooting
+
+| Symptom | Cause | Solution |
+|---------|-------|----------|
+| `No ONVIF devices discovered` | Multicast UDP blocked by firewall / different VLAN | Make sure UDP port 3702 (multicast 239.255.255.250:3702) is allowed. The scan must run on the same subnet as the cameras. |
+| Camera discovered but `rtsp_url: null` | Camera requires auth for the Media service | Use `--username admin --password <pass>` |
+| Camera not discovered despite being online | ONVIF disabled in the camera's web UI | Enable ONVIF (Profile S) in the camera settings |
+| `ImportError: wsdiscovery` / `onvif-zeep` | Dependencies not installed | Re-run `pip install -e .` |
+| Scan is slow (>5s) | Large network / many devices | Increase `--timeout 10`, or add `--rtsp-only` to skip device queries |
+| zeep error: WSDL download | onvif-zeep requires internet access on first run (to download WSDL) | Ensure internet connectivity, or bundle the WSDL locally and pass `wsdl_dir` in `device.py` |
+
+## Compatible Devices
+
+Tested with: Hikvision, Dahua, generic ONVIF Profile S (Arducam, Reolink, Amcrest).
+
+Standards: ONVIF Core Spec + Profile S (Streaming).
+
+## Architecture
+
+```
+onvif_scanner/
+├── cli.py          # Click CLI + rich output (table/json/file)
+├── discovery.py    # WS-Discovery multicast via wsdiscovery lib
+├── device.py       # ONVIF Device Service query via onvif-zeep
+└── models.py       # dataclass DiscoveredDevice + Camera
+```
+
+Flow: `cli.py` → `discovery.discover_cameras()` (UDP multicast) → `device.query_device()` (HTTP SOAP per camera) → output (table/json/file).
+
+## Limitations (future work)
+
+- Multicast only (no unicast IP range probe for cross-VLAN discovery)
+- Single username/password (no multi-credential support)
+- No auto-registration to the parking DB (`cameras` table) — a `register` subcommand could be added
+- No streaming preview (RTSP URL only, no frame preview)
+
+## License
+
+MIT

onvif_scanner-0.1.0/onvif_scanner.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+onvif_scanner/__init__.py
+onvif_scanner/__main__.py
+onvif_scanner/cli.py
+onvif_scanner/device.py
+onvif_scanner/discovery.py
+onvif_scanner/models.py
+onvif_scanner.egg-info/PKG-INFO
+onvif_scanner.egg-info/SOURCES.txt
+onvif_scanner.egg-info/dependency_links.txt
+onvif_scanner.egg-info/entry_points.txt
+onvif_scanner.egg-info/requires.txt
+onvif_scanner.egg-info/top_level.txt
+tests/test_discovery.py

onvif_scanner-0.1.0/onvif_scanner.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

onvif_scanner-0.1.0/onvif_scanner.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+onvif-scan = onvif_scanner.cli:cli

onvif_scanner-0.1.0/onvif_scanner.egg-info/requires.txt

@@ -0,0 +1,8 @@
+onvif-zeep>=0.2.12
+wsdiscovery>=0.1.0
+click>=8.1
+rich>=13.0
+
+[dev]
+pytest>=7.0
+pytest-cov

onvif_scanner-0.1.0/onvif_scanner.egg-info/top_level.txt

@@ -0,0 +1 @@
+onvif_scanner

onvif_scanner-0.1.0/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "onvif-scanner"
+version = "0.1.0"
+description = "CLI tool to scan ONVIF cameras on local network via WS-Discovery"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Riki Handoyo", email = "jawakeror@gmail.com" }]
+dependencies = [
+    "onvif-zeep>=0.2.12",
+    "wsdiscovery>=0.1.0",
+    "click>=8.1",
+    "rich>=13.0",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Multimedia :: Video",
+    "Topic :: System :: Networking :: Monitoring",
+]
+
+[project.urls]
+Homepage = "https://github.com/jawak/onvif-scanner"
+Repository = "https://github.com/jawak/onvif-scanner"
+Issues = "https://github.com/jawak/onvif-scanner/issues"
+Changelog = "https://github.com/jawak/onvif-scanner/releases"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov",
+]
+
+[project.scripts]
+onvif-scan = "onvif_scanner.cli:cli"
+
+[tool.setuptools.packages.find]
+include = ["onvif_scanner*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

onvif_scanner-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

onvif_scanner-0.1.0/tests/test_discovery.py

@@ -0,0 +1,30 @@
+"""Basic unit tests for discovery (no real network needed)."""
+
+from __future__ import annotations
+
+from onvif_scanner.models import Camera, DiscoveredDevice
+
+
+def test_discovered_device_defaults():
+    d = DiscoveredDevice(address="192.168.1.10", device_url="http://192.168.1.10/onvif/device_service")
+    assert d.address == "192.168.1.10"
+    assert d.scopes == []
+    assert d.xaddrs == []
+
+
+def test_camera_to_dict_roundtrip():
+    cam = Camera(
+        address="192.168.1.10",
+        device_url="http://192.168.1.10/onvif/device_service",
+        manufacturer="Hikvision",
+        model="DS-2CD2143G2",
+        rtsp_url="rtsp://192.168.1.10:554/Streaming/Channels/101",
+        authenticated=True,
+    )
+    d = cam.to_dict()
+    assert d["address"] == "192.168.1.10"
+    assert d["manufacturer"] == "Hikvision"
+    assert d["rtsp_url"].startswith("rtsp://")
+    assert d["authenticated"] is True
+    assert d["scopes"] == []
+    assert d["error"] is None