xmcam-py 0.1.0__tar.gz

xmcam_py-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,74 @@
+name: Test, Build and Publish
+
+on:
+  push:
+    branches:
+      - 'main'
+    tags:
+      - 'v*'
+  pull_request:
+    branches:
+      - 'main'
+
+jobs:
+  test:
+    name: Test and Lint
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.9", "3.11", "3.12"]
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Lint with ruff
+        run: ruff check .
+
+      - name: Check formatting with Black
+        run: black --check .
+
+      - name: Type check with Mypy
+        run: mypy src
+
+      - name: Test with pytest
+        run: pytest
+
+  publish:
+    name: Build and Publish to PyPI
+    needs: test
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/v')
+    permissions:
+      id-token: write # OIDC authentication with PyPI (trusted publishing)
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+
+      - name: Install build tools
+        run: python -m pip install --upgrade build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish package to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

xmcam_py-0.1.0/.gitignore

@@ -0,0 +1,29 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Downloaded recordings / caches (never commit footage or caches)
+*.xmraw
+*.h264
+*.h265
+*.mp4
+*.jpg
+nagrania/
+recordings/
+cache/
+.xmcam-cache/
+
+# Local credentials / scratch (never commit secrets)
+*.secret
+.env
+secrets.*
+_scratch/

xmcam_py-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 theundefined
+
+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.

xmcam_py-0.1.0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.5
+Name: xmcam-py
+Version: 0.1.0
+Summary: Local-first Python library and CLI for Xiongmai (XM) / iCSee / XMeye IP cameras: discovery, ONVIF, and recording-archive listing/download over DVRIP. No cloud, no internet.
+Project-URL: Homepage, https://github.com/theundefined/xmcam-py
+Project-URL: Repository, https://github.com/theundefined/xmcam-py
+Project-URL: Issues, https://github.com/theundefined/xmcam-py/issues
+Author-email: theundefined <undefine@aramin.net>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: camera,cctv,dvrip,icsee,ip-camera,nvr,onvif,rtsp,sofia,surveillance,xiongmai,xm,xmeye
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Topic :: Multimedia :: Video
+Classifier: Topic :: Security
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: black>=24.0.0; extra == 'dev'
+Requires-Dist: build>=1.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.9.0; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: ruff>=0.3.0; extra == 'dev'
+Requires-Dist: twine>=5.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# xmcam
+
+**Local-first Python library and CLI for Xiongmai (XM) IP cameras** — the kind
+sold under countless brands and driven by the **iCSee** / **XMeye** mobile apps.
+Discover cameras on your LAN, read their capabilities over ONVIF, and **list and
+download the recording archive** straight off the SD card/disk over the native
+**DVRIP** protocol. Everything happens on the local network: **no cloud, no
+internet, no vendor account.**
+
+> Distribution name: `xmcam-py` · import name: `xmcam`
+
+## Why
+
+These cameras store footage locally but the official way to get it off the
+device is a clunky mobile app or a Windows-only VMS. There was no maintained
+Python tool for pulling the **archive** programmatically. `xmcam` fills that
+gap with a clean, dependency-free API and a scriptable CLI.
+
+## Features
+
+- **Discovery** — find cameras via ONVIF WS-Discovery, with Xiongmai detection.
+- **Credential recovery** — these cameras answer ONVIF **anonymously** and leak
+  the stream account in the RTSP URL; `xmcam` can recover the username/password
+  the way the app does (on hardware you own — see *Security & ethics*).
+- **Recording archive** — list recordings in any time range and download them,
+  single files, arbitrary ranges or a whole day.
+- **Transparent conversion** — the raw stream is Xiongmai's own container;
+  `xmcam` demuxes it to an elementary H.264/H.265 stream and (with `ffmpeg`)
+  remuxes to a playable **MP4** without re-encoding.
+- **Live** — build RTSP URLs and grab JPEG snapshots.
+- **PTZ** — pan/tilt/zoom over ONVIF where the hardware supports it.
+- **Config backup** and **clock sync**.
+- **Zero runtime dependencies** — pure standard library. `ffmpeg` is optional
+  and only needed for MP4 output.
+
+## Install
+
+```bash
+pip install xmcam-py
+# optional, for MP4 output:  install ffmpeg via your system package manager
+```
+
+## Quick start (CLI)
+
+Credentials are read from `--user/--password` or the `XMCAM_USER` / `XMCAM_PASS`
+environment variables (preferred — they stay out of your shell history).
+
+```bash
+# Find cameras on the LAN (pass your host interface IP for reliable multicast)
+xmcam discover --iface 192.0.2.5
+
+# Recover the camera account from anonymous ONVIF (hardware you own)
+xmcam creds 192.0.2.10
+
+# List today's recordings
+xmcam list 192.0.2.10 --start "2026-11-10 00:00:00" --end "2026-11-10 23:59:59"
+
+# Download a one-hour range to MP4
+export XMCAM_USER=... XMCAM_PASS=...
+xmcam pull 192.0.2.10 --start "2026-11-10 08:00:00" --end "2026-11-10 09:00:00" --out ./footage
+```
+
+## Quick start (library)
+
+```python
+from xmcam.dvrip import DVRIPClient
+from xmcam.files import list_recordings
+
+with DVRIPClient("192.0.2.10", user="rryp", password="...") as cam:
+    for rec in list_recordings(cam, "2026-11-10 08:00:00", "2026-11-10 09:00:00"):
+        print(rec.begin_time, rec.length_bytes, rec.filename)
+```
+
+## Security & ethics
+
+This library can recover camera credentials and pull footage over the LAN. That
+is possible because the firmware answers ONVIF **without authentication** and
+exposes the stream password in plaintext — a real weakness of these devices.
+**Use `xmcam` only on cameras you own or are explicitly authorised to
+administer.** It never contacts any cloud service and stores no credentials on
+disk; supply them per-run via environment variables.
+
+If you run these cameras: keep them off the internet (no P2P/cloud), put them on
+an isolated VLAN, and firewall ports 8899/34567/554.
+
+## Notes & limitations
+
+- **Discovery is multicast-based.** Some firmwares (seen on XM535 / V5.01) do not
+  answer WS-Discovery at all, even though they serve ONVIF and DVRIP. Such
+  cameras won't appear in `discover` — address them by IP directly.
+- **`stream-url` prints the password** inside the RTSP URL, because that is how
+  these cameras authenticate; the URL is only usable with it. Treat that output
+  as a secret (it may land in shell history/logs).
+- **`info`**: several DVRIP info blocks (`SystemInfo`, `StorageInfo`, ...) are
+  restricted for the auto-recovered account and come back empty; the command
+  shows what is available plus the ONVIF device information.
+- **Camera clock**: `synctime --show` reports whatever the camera believes the
+  time is — which is often UTC unless you configured a timezone on the device.
+
+## License
+
+MIT © theundefined

xmcam_py-0.1.0/README.md

@@ -0,0 +1,102 @@
+# xmcam
+
+**Local-first Python library and CLI for Xiongmai (XM) IP cameras** — the kind
+sold under countless brands and driven by the **iCSee** / **XMeye** mobile apps.
+Discover cameras on your LAN, read their capabilities over ONVIF, and **list and
+download the recording archive** straight off the SD card/disk over the native
+**DVRIP** protocol. Everything happens on the local network: **no cloud, no
+internet, no vendor account.**
+
+> Distribution name: `xmcam-py` · import name: `xmcam`
+
+## Why
+
+These cameras store footage locally but the official way to get it off the
+device is a clunky mobile app or a Windows-only VMS. There was no maintained
+Python tool for pulling the **archive** programmatically. `xmcam` fills that
+gap with a clean, dependency-free API and a scriptable CLI.
+
+## Features
+
+- **Discovery** — find cameras via ONVIF WS-Discovery, with Xiongmai detection.
+- **Credential recovery** — these cameras answer ONVIF **anonymously** and leak
+  the stream account in the RTSP URL; `xmcam` can recover the username/password
+  the way the app does (on hardware you own — see *Security & ethics*).
+- **Recording archive** — list recordings in any time range and download them,
+  single files, arbitrary ranges or a whole day.
+- **Transparent conversion** — the raw stream is Xiongmai's own container;
+  `xmcam` demuxes it to an elementary H.264/H.265 stream and (with `ffmpeg`)
+  remuxes to a playable **MP4** without re-encoding.
+- **Live** — build RTSP URLs and grab JPEG snapshots.
+- **PTZ** — pan/tilt/zoom over ONVIF where the hardware supports it.
+- **Config backup** and **clock sync**.
+- **Zero runtime dependencies** — pure standard library. `ffmpeg` is optional
+  and only needed for MP4 output.
+
+## Install
+
+```bash
+pip install xmcam-py
+# optional, for MP4 output:  install ffmpeg via your system package manager
+```
+
+## Quick start (CLI)
+
+Credentials are read from `--user/--password` or the `XMCAM_USER` / `XMCAM_PASS`
+environment variables (preferred — they stay out of your shell history).
+
+```bash
+# Find cameras on the LAN (pass your host interface IP for reliable multicast)
+xmcam discover --iface 192.0.2.5
+
+# Recover the camera account from anonymous ONVIF (hardware you own)
+xmcam creds 192.0.2.10
+
+# List today's recordings
+xmcam list 192.0.2.10 --start "2026-11-10 00:00:00" --end "2026-11-10 23:59:59"
+
+# Download a one-hour range to MP4
+export XMCAM_USER=... XMCAM_PASS=...
+xmcam pull 192.0.2.10 --start "2026-11-10 08:00:00" --end "2026-11-10 09:00:00" --out ./footage
+```
+
+## Quick start (library)
+
+```python
+from xmcam.dvrip import DVRIPClient
+from xmcam.files import list_recordings
+
+with DVRIPClient("192.0.2.10", user="rryp", password="...") as cam:
+    for rec in list_recordings(cam, "2026-11-10 08:00:00", "2026-11-10 09:00:00"):
+        print(rec.begin_time, rec.length_bytes, rec.filename)
+```
+
+## Security & ethics
+
+This library can recover camera credentials and pull footage over the LAN. That
+is possible because the firmware answers ONVIF **without authentication** and
+exposes the stream password in plaintext — a real weakness of these devices.
+**Use `xmcam` only on cameras you own or are explicitly authorised to
+administer.** It never contacts any cloud service and stores no credentials on
+disk; supply them per-run via environment variables.
+
+If you run these cameras: keep them off the internet (no P2P/cloud), put them on
+an isolated VLAN, and firewall ports 8899/34567/554.
+
+## Notes & limitations
+
+- **Discovery is multicast-based.** Some firmwares (seen on XM535 / V5.01) do not
+  answer WS-Discovery at all, even though they serve ONVIF and DVRIP. Such
+  cameras won't appear in `discover` — address them by IP directly.
+- **`stream-url` prints the password** inside the RTSP URL, because that is how
+  these cameras authenticate; the URL is only usable with it. Treat that output
+  as a secret (it may land in shell history/logs).
+- **`info`**: several DVRIP info blocks (`SystemInfo`, `StorageInfo`, ...) are
+  restricted for the auto-recovered account and come back empty; the command
+  shows what is available plus the ONVIF device information.
+- **Camera clock**: `synctime --show` reports whatever the camera believes the
+  time is — which is often UTC unless you configured a timezone on the device.
+
+## License
+
+MIT © theundefined

xmcam_py-0.1.0/pyproject.toml

@@ -0,0 +1,76 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "xmcam-py"
+version = "0.1.0"
+description = "Local-first Python library and CLI for Xiongmai (XM) / iCSee / XMeye IP cameras: discovery, ONVIF, and recording-archive listing/download over DVRIP. No cloud, no internet."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "theundefined", email = "undefine@aramin.net" }]
+keywords = [
+    "xiongmai", "xm", "icsee", "xmeye", "dvrip", "sofia", "onvif",
+    "ip-camera", "cctv", "nvr", "rtsp", "surveillance", "camera",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: System Administrators",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Multimedia :: Video",
+    "Topic :: System :: Networking",
+    "Topic :: Security",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7",
+    "ruff>=0.3.0",
+    "black>=24.0.0",
+    "mypy>=1.9.0",
+    "build>=1.0.0",
+    "twine>=5.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/theundefined/xmcam-py"
+Repository = "https://github.com/theundefined/xmcam-py"
+Issues = "https://github.com/theundefined/xmcam-py/issues"
+
+[project.scripts]
+xmcam = "xmcam.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/xmcam"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"
+
+[tool.black]
+line-length = 120
+target-version = ["py39"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py39"
+
+[tool.ruff.lint]
+# Classic default rule set (pyflakes + a few pycodestyle error checks), pinned
+# so a ruff upgrade does not silently start failing CI on unrelated rules.
+select = ["E4", "E7", "E9", "F"]
+
+[tool.mypy]
+ignore_missing_imports = true

xmcam_py-0.1.0/release.sh

@@ -0,0 +1,113 @@
+#!/bin/bash
+
+# Exit immediately if a command exits with a non-zero status.
+set -e
+
+# Configuration
+PROJECT_NAME="xmcam-py"
+DEFAULT_INITIAL_VERSION="v0.1.0"
+VERSION_BUMP_TYPE="patch" # Can be major, minor, patch
+
+# Function to display usage
+usage() {
+  echo "Usage: $0 [major|minor|patch|vX.Y.Z]"
+  echo "  Automatically bumps the version, creates a git tag, and pushes it."
+  echo "  If a version is specified (vX.Y.Z), it will use that exact version."
+  exit 1
+}
+
+# Parse arguments
+if [ "$#" -eq 1 ]; then
+  if [[ "$1" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+    NEW_VERSION_ARG="$1"
+  elif [[ "$1" =~ ^(major|minor|patch)$ ]]; then
+    VERSION_BUMP_TYPE="$1"
+  else
+    usage
+  fi
+elif [ "$#" -ne 0 ]; then
+  usage
+fi
+
+# Fetch all tags to ensure we have the latest
+echo "Fetching latest tags..."
+git fetch origin --tags
+
+# Get the latest version tag
+LAST_TAG=$(git describe --tags --abbrev=0 --match "v[0-9]*.[0-9]*.[0-9]*" 2>/dev/null || echo "$DEFAULT_INITIAL_VERSION")
+
+# If no semantic version tags exist, start with the default initial version and assume 0.0.0 for first bump
+if [ "$LAST_TAG" = "$DEFAULT_INITIAL_VERSION" ] && [ "$(git tag --list "$DEFAULT_INITIAL_VERSION")" = "" ]; then
+    echo "No semantic version tags found. Starting with $DEFAULT_INITIAL_VERSION."
+    CURRENT_VERSION_SEMVER="0.0.0" # Base for first bump
+else
+    CURRENT_VERSION_SEMVER=$(echo "$LAST_TAG" | sed 's/^v//')
+fi
+
+# Determine the new version
+if [ -n "$NEW_VERSION_ARG" ]; then
+    NEW_VERSION=$(echo "$NEW_VERSION_ARG" | sed 's/^v//')
+    echo "Using specified version: v$NEW_VERSION"
+else
+    # Split version into major, minor, patch
+    IFS='.' read -r MAJOR MINOR PATCH <<< "$CURRENT_VERSION_SEMVER"
+
+    case "$VERSION_BUMP_TYPE" in
+        major)
+            MAJOR=$((MAJOR + 1))
+            MINOR=0
+            PATCH=0
+            ;;
+        minor)
+            MINOR=$((MINOR + 1))
+            PATCH=0
+            ;;
+        patch)
+            PATCH=$((PATCH + 1))
+            ;;
+        *)
+            echo "Invalid bump type: $VERSION_BUMP_TYPE. Must be major, minor, or patch."
+            usage
+            ;;
+    esac
+    NEW_VERSION="${MAJOR}.${MINOR}.${PATCH}"
+    echo "Bumping $VERSION_BUMP_TYPE version: v$CURRENT_VERSION_SEMVER -> v$NEW_VERSION"
+fi
+
+# Update version in pyproject.toml
+sed -i "s/^version = \".*\"/version = \"$NEW_VERSION\"/" pyproject.toml
+
+# Create commit for version bump only if there are changes
+git add pyproject.toml
+if ! git diff --cached --quiet; then
+    git commit -m "Bump version to v$NEW_VERSION"
+    echo "Committed version bump."
+else
+    echo "Version in pyproject.toml is already up to date. Skipping commit."
+fi
+
+# Create new tag if it doesn't exist
+NEW_TAG="v$NEW_VERSION"
+if git rev-parse "$NEW_TAG" >/dev/null 2>&1; then
+    echo "Tag $NEW_TAG already exists."
+else
+    echo "Creating git tag: $NEW_TAG"
+    git tag "$NEW_TAG" -m "$PROJECT_NAME Release $NEW_VERSION"
+fi
+
+# Push commit and tag
+echo "Pushing changes and tag to origin..."
+git push origin main || echo "Main already up to date or push failed (skipping)"
+git push origin "$NEW_TAG"
+
+# Get repository owner and name
+REPO_URL=$(git config --get remote.origin.url)
+REPO_OWNER=$(echo "$REPO_URL" | sed -E 's/.*github.com[:/]([^/]+)\/.*/\1/')
+REPO_NAME=$(echo "$REPO_URL" | sed -E 's/.*github.com[:/][^/]+\/([^/\. ]+)(\.git)?/\1/')
+REPO_PATH="$REPO_OWNER/$REPO_NAME"
+
+# Construct Actions URL
+ACTIONS_URL="https://github.com/$REPO_PATH/actions/workflows/ci.yml"
+echo "Monitor action status here: $ACTIONS_URL"
+
+echo "Release process initiated with tag $NEW_TAG. Check GitHub Actions for build status."

xmcam_py-0.1.0/src/xmcam/__init__.py

@@ -0,0 +1,96 @@
+"""xmcam - local-first toolkit for Xiongmai (XM) / iCSee / XMeye IP cameras.
+
+The package is organised into focused modules:
+
+* :mod:`xmcam.discovery`   - find cameras on the LAN (WS-Discovery)
+* :mod:`xmcam.onvif`       - anonymous ONVIF reads (device info, users, stream URIs)
+* :mod:`xmcam.credentials` - recover the camera account from anonymous ONVIF
+* :mod:`xmcam.dvrip`       - low-level DVRIP ("Sofia") client
+* :mod:`xmcam.files`       - list the recording archive (OPFileQuery)
+* :mod:`xmcam.playback`    - download/stream recordings (OPPlayBack)
+* :mod:`xmcam.media`       - demux the XM container and remux to MP4
+* :mod:`xmcam.live`        - live RTSP URLs and JPEG snapshots
+* :mod:`xmcam.ptz`         - PTZ control (where supported)
+* :mod:`xmcam.config_backup` - export/import camera configuration
+* :mod:`xmcam.timesync`    - read/set the camera clock
+
+Everything runs on the local network - no cloud, no internet.
+"""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+from .dvrip import DVRIP_PORT, DVRIPClient, OK_CODES, RET_MEANING, sofia_hash
+from .exceptions import (
+    DownloadError,
+    LoginError,
+    OnvifError,
+    ProtocolError,
+    XMCamError,
+    XMConnectionError,
+)
+from .models import Camera, Credentials, DeviceInfo, Recording, StreamUri
+
+# High-level modules and their most-used entry points.
+from . import (  # noqa: E402
+    config_backup,
+    credentials,
+    discovery,
+    files,
+    live,
+    media,
+    onvif,
+    playback,
+    ptz,
+    timesync,
+)
+from .credentials import recover_credentials
+from .discovery import discover
+from .files import list_recordings, list_recordings_range
+from .media import convert_raw, demux, have_ffmpeg
+from .playback import download_recording, iter_recording
+
+__all__ = [
+    "__version__",
+    # low-level
+    "DVRIPClient",
+    "DVRIP_PORT",
+    "OK_CODES",
+    "RET_MEANING",
+    "sofia_hash",
+    # models
+    "Camera",
+    "Credentials",
+    "DeviceInfo",
+    "Recording",
+    "StreamUri",
+    # exceptions
+    "XMCamError",
+    "XMConnectionError",
+    "ProtocolError",
+    "LoginError",
+    "DownloadError",
+    "OnvifError",
+    # high-level entry points
+    "discover",
+    "recover_credentials",
+    "list_recordings",
+    "list_recordings_range",
+    "download_recording",
+    "iter_recording",
+    "demux",
+    "convert_raw",
+    "have_ffmpeg",
+    # modules
+    "discovery",
+    "onvif",
+    "credentials",
+    "files",
+    "playback",
+    "media",
+    "live",
+    "ptz",
+    "config_backup",
+    "timesync",
+]