pycloudedge 0.1.8__tar.gz → 0.1.9__tar.gz

{pycloudedge-0.1.8 → pycloudedge-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycloudedge
-Version: 0.1.8
+Version: 0.1.9
 Summary: Python library for CloudEdge cameras
 Home-page: https://github.com/fradaloisio/pycloudedge
 Author: Francesco D'Aloisio

{pycloudedge-0.1.8 → pycloudedge-0.1.9}/cloudedge/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.8'
-__version_tuple__ = version_tuple = (0, 1, 8)
+__version__ = version = '0.1.9'
+__version_tuple__ = version_tuple = (0, 1, 9)
 
-__commit_id__ = commit_id = 'g47e440bf5'
+__commit_id__ = commit_id = None

{pycloudedge-0.1.8 → pycloudedge-0.1.9}/cloudedge/client.py

@@ -17,6 +17,7 @@ import subprocess
 import socket
 import ipaddress
 import logging
+import math
 import tempfile
 from typing import Dict, List, Optional, Union, Any
 from urllib.parse import quote, urlencode
@@ -512,10 +513,15 @@ class CloudEdgeClient:
         iv = "01234567".encode('utf-8')
         
         try:
-            from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+            from cryptography.hazmat.primitives.ciphers import Cipher, modes
             from cryptography.hazmat.primitives import padding
 
-            algorithm = algorithms.TripleDES(key)
+            try:
+                from cryptography.hazmat.decrepit.ciphers.algorithms import TripleDES
+            except ImportError:  # cryptography < 43
+                from cryptography.hazmat.primitives.ciphers.algorithms import TripleDES
+
+            algorithm = TripleDES(key)
             cipher = Cipher(algorithm, modes.CBC(iv))
             encryptor = cipher.encryptor()
             
@@ -606,14 +612,24 @@ class CloudEdgeClient:
             with open(self.session_cache_file, 'r') as f:
                 session_data = json.load(f)
 
-            # Check if session is still valid (not older than 24 hours)
-            login_time = session_data.get('loginTime', 0)
-            if time.time() - login_time > 86400:  # 24 hours
-                self._log("Session cache expired")
+            if not isinstance(session_data, dict):
+                return None
+            token = session_data.get("userToken")
+            user_id = session_data.get("userID")
+            if not isinstance(token, str) or not token or not isinstance(user_id, (str, int)) or not user_id:
+                return None
+
+            login_time = session_data.get("loginTime")
+            if (
+                not isinstance(login_time, (int, float))
+                or not math.isfinite(login_time)
+                or not 0 <= time.time() - login_time < 86400
+            ):
+                self._log("Session cache expired or has an invalid timestamp")
                 return None
 
             return session_data
-        except (json.JSONDecodeError, KeyError, OSError):
+        except (json.JSONDecodeError, UnicodeDecodeError, OSError):
             self._log("Invalid or unreadable session cache file")
             return None
 
@@ -769,6 +785,13 @@ class CloudEdgeClient:
                 self.BASE_URL = self.session_data["apiServer"]
             if self.session_data.get("openapiServer"):
                 self.OPENAPI_BASE_URL = self.session_data["openapiServer"]
+            # Older caches may predate endpoint discovery. Keep the valid token,
+            # but discover its regional URLs before making authenticated requests.
+            if not self.BASE_URL or not self.OPENAPI_BASE_URL:
+                self._discover_endpoints()
+                self.session_data["apiServer"] = self.BASE_URL
+                self.session_data["openapiServer"] = self.OPENAPI_BASE_URL
+                self._save_session_cache(self.session_data)
             # Fetch MQTT config if not already present in the cached session
             if not self.session_data.get("mqtt"):
                 try:
@@ -1307,7 +1330,11 @@ class CloudEdgeClient:
                 except AuthenticationError:
                     raise
                 except Exception as e:
-                    self._log(f"Failed to get devices from home '{home_name}': {e}")
+                    # A partial inventory would make callers remove devices
+                    # (and stop streams) during a temporary API outage.
+                    raise CloudEdgeError(
+                        f"Failed to get devices from home '{home_name}': {e}"
+                    ) from e
                     
             return all_devices
 
@@ -1993,18 +2020,17 @@ class CloudEdgeClient:
         # First try the get_all_devices method for comprehensive search
         devices = self.get_all_devices()
         
-        # Search for exact match first
-        for device in devices:
-            if device.get('name', '').lower() == device_name.lower():
-                return device
-                
-        # If exact match not found, try partial match
-        for device in devices:
-            if device_name.lower() in device.get('name', '').lower():
-                return device
-                
-        return None
-        
+        name = device_name.lower()
+        matches = [device for device in devices if device.get("name", "").lower() == name]
+        if not matches:
+            matches = [device for device in devices if name in device.get("name", "").lower()]
+        if len(matches) > 1:
+            raise DeviceNotFoundError(
+                f"Device name '{device_name}' is ambiguous; use a unique device name",
+                details={"device_name": device_name, "matches": len(matches)},
+            )
+        return matches[0] if matches else None
+
     def set_device_parameter(
         self,
         device_name: str,

{pycloudedge-0.1.8 → pycloudedge-0.1.9}/pycloudedge.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycloudedge
-Version: 0.1.8
+Version: 0.1.9
 Summary: Python library for CloudEdge cameras
 Home-page: https://github.com/fradaloisio/pycloudedge
 Author: Francesco D'Aloisio

{pycloudedge-0.1.8 → pycloudedge-0.1.9}/pycloudedge.egg-info/SOURCES.txt

@@ -1,13 +1,10 @@
 .env.example
-.gitignore
 LICENSE
 MANIFEST.in
 README.md
 pyproject.toml
-requirements-dev.txt
 requirements.txt
 setup.py
-test_3region_login.py
 cloudedge/__init__.py
 cloudedge/_version.py
 cloudedge/cli.py
@@ -27,7 +24,6 @@ cloudedge/p2p/meari_signaling.py
 cloudedge/p2p/p2p_streamer.py
 cloudedge/p2p/root_discovery.py
 cloudedge/p2p/turn_client.py
-docs/plans/2026-03-30-streaming-video.md
 examples/README.md
 examples/basic_example.py
 examples/device_control.py
@@ -38,12 +34,11 @@ pycloudedge.egg-info/SOURCES.txt
 pycloudedge.egg-info/dependency_links.txt
 pycloudedge.egg-info/entry_points.txt
 pycloudedge.egg-info/requires.txt
-pycloudedge.egg-info/scm_file_list.json
-pycloudedge.egg-info/scm_version.json
 pycloudedge.egg-info/top_level.txt
 tests/test_basic.py
 tests/test_improvements.py
 tests/test_kcp_tunnel.py
 tests/test_mqtt.py
+tests/test_reliability.py
 tests/test_stream_profiles.py
 tests/test_streaming_helpers.py

pycloudedge-0.1.9/tests/test_reliability.py

@@ -0,0 +1,94 @@
+"""Regressions for malformed caches and incomplete device discovery."""
+import json
+import time
+from unittest.mock import Mock
+
+import pytest
+
+from cloudedge import CloudEdgeClient, CloudEdgeError, NetworkError
+
+
+@pytest.fixture
+def client(tmp_path):
+    return CloudEdgeClient(
+        "user@example.test", "password", "IT", "+39",
+        session_cache_file=str(tmp_path / "session.json"),
+    )
+
+
+@pytest.mark.parametrize("data", [
+    [], ["token"], None, "invalid", 42,
+    *({"loginTime": stamp, "userToken": "token", "userID": "id"}
+      for stamp in ("yesterday", None, float("nan"), float("inf"))),
+    {"loginTime": time.time() + 86400, "userToken": "token", "userID": "id"},
+    {"loginTime": time.time()},
+    {"loginTime": time.time(), "userToken": "token"},
+    {"loginTime": time.time(), "userToken": 123, "userID": "id"},
+])
+def test_invalid_cache_is_ignored(client, data):
+    with open(client.session_cache_file, "w") as file:
+        json.dump(data, file)
+    assert client._load_session_cache() is None
+
+
+def test_valid_cache_is_reused(client):
+    session = {"loginTime": time.time(), "userToken": "token", "userID": "id"}
+    client._save_session_cache(session)
+    assert client._load_session_cache() == session
+
+
+def test_legacy_cache_discovers_missing_endpoints_without_logging_in(client):
+    client._save_session_cache({
+        "loginTime": time.time(), "userToken": "token", "userID": "id", "mqtt": {"host": "host"},
+    })
+    def discover():
+        client.BASE_URL = "https://api.example.test"
+        client.OPENAPI_BASE_URL = "https://openapi.example.test"
+    client._discover_endpoints = Mock(side_effect=discover)
+    client._session.post = Mock(side_effect=AssertionError("Must reuse the token"))
+    assert client.authenticate() is True
+    assert client.BASE_URL == "https://api.example.test"
+    assert client.OPENAPI_BASE_URL == "https://openapi.example.test"
+    assert client._load_session_cache()["apiServer"] == client.BASE_URL
+
+
+def test_failed_home_discovery_does_not_return_partial_inventory(client):
+    client.session_data = {"userToken": "token"}
+    client.get_devices = Mock(return_value=[])
+    client.get_homes = Mock(return_value=[
+        {"home_id": "a", "name": "A"}, {"home_id": "b", "name": "B"},
+    ])
+    client.get_devices_by_home = Mock(side_effect=[
+        [{"serial_number": "sn-a"}], NetworkError("temporarily unavailable"),
+    ])
+    with pytest.raises(CloudEdgeError, match="temporarily unavailable"):
+        client.get_all_devices()
+
+
+@pytest.mark.parametrize("names, query", [
+    (["Camera", "Camera"], "Camera"),
+    (["Camera North", "Camera South"], "Camera"),
+])
+def test_ambiguous_device_names_do_not_control_arbitrary_camera(client, names, query):
+    from cloudedge import DeviceNotFoundError
+    client.get_all_devices = Mock(return_value=[{"name": name} for name in names])
+    client.set_device_config = Mock()
+    with pytest.raises(DeviceNotFoundError, match="ambiguous"):
+        client.set_device_parameter(query, "LED_ENABLE", 1)
+    client.set_device_config.assert_not_called()
+
+
+def test_exact_name_takes_precedence_over_partial_match(client):
+    exact = {"name": "Camera", "serial_number": "sn"}
+    client.get_all_devices = Mock(return_value=[{"name": "Camera North"}, exact])
+    assert client.find_device_by_name("camera") == exact
+
+
+def test_password_encryption_matches_independent_3des_implementation(client):
+    import base64
+    from Crypto.Cipher import DES
+    from Crypto.Util.Padding import pad
+    # The vendor key repeats the same 8-byte block, so EDE reduces to DES.
+    cipher = DES.new(b"12345678", DES.MODE_CBC, b"01234567")
+    expected = base64.b64encode(cipher.encrypt(pad(b"password", 8))).decode()
+    assert client._des_encode("password") == expected

pycloudedge-0.1.8/.gitignore

@@ -1,124 +0,0 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-.hypothesis/
-.pytest_cache/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-.python-version
-
-# celery beat schedule file
-celerybeat-schedule
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-.env_*
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# setuptools_scm generated version file
-cloudedge/_version.py
-
-# CloudEdge specific
-.cloudedge_session_cache
-.home_id
-
-publish.sh

pycloudedge-0.1.8/docs/plans/2026-03-30-streaming-video.md

@@ -1,176 +0,0 @@
-# Streaming Video Implementation Plan
-
-> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
-
-**Goal:** Deliver a real end-to-end live video stream for the Garage camera on branch `streming_video`, first in `pycloudedge`, then through `cloudedge-ha`.
-
-**Architecture:** Keep `pycloudedge` as the proprietary P2P/HEVC extractor and keep `cloudedge-ha` as the Home Assistant bridge that remuxes raw HEVC into a local MPEG-TS `stream_source`. Validate the path incrementally: baseline tests, direct Garage streaming, then Home Assistant bridge integration.
-
-**Tech Stack:** Python, pytest, CloudEdge OpenAPI + proprietary P2P signaling, HEVC, ffmpeg, Home Assistant camera `stream` integration.
-
-### Task 1: Restore a trustworthy `pycloudedge` baseline
-
-**Files:**
-- Modify: `tests/test_basic.py`
-- Test: `tests/test_basic.py::TestAsyncMethods::test_client_methods_with_mock`
-- Test: `tests/test_basic.py`
-
-**Step 1: Confirm the failing test is a real baseline regression**
-
-Run: `.venv/bin/pytest tests/test_basic.py::TestAsyncMethods::test_client_methods_with_mock -v`
-Expected: FAIL with `ValidationError: Invalid email format: test`
-
-**Step 2: Apply the minimal fix in the test**
-
-Replace the invalid username with a valid email literal already accepted by the constructor.
-
-```python
-client = CloudEdgeClient("test@example.com", "test", "US", "+1")
-```
-
-**Step 3: Re-run the targeted test**
-
-Run: `.venv/bin/pytest tests/test_basic.py::TestAsyncMethods::test_client_methods_with_mock -v`
-Expected: PASS
-
-**Step 4: Re-run the full `pycloudedge` suite**
-
-Run: `.venv/bin/pytest`
-Expected: all tests pass, or only pre-existing warnings remain
-
-### Task 2: Make direct Garage streaming reproducible from `pycloudedge`
-
-**Files:**
-- Modify: `tests/test_improvements.py` or create `tests/test_streaming_helpers.py`
-- Modify if needed: `examples/stream_test.py`
-- Modify if needed: `cloudedge/client.py`
-- Modify if needed: `cloudedge/p2p/p2p_streamer.py`
-
-**Step 1: Write a failing helper-level test for the smallest bug you need to fix**
-
-Examples:
-- Annex B conversion for one access unit
-- Keyframe gating behavior
-- signaling candidate ordering
-- phone code normalization or env parsing if that blocks the real script
-
-Use a focused unit test instead of mocking the whole live session.
-
-**Step 2: Run the focused test and watch it fail**
-
-Run: `.venv/bin/pytest <targeted test path> -v`
-Expected: FAIL for the exact missing behavior
-
-**Step 3: Implement the minimal code change**
-
-Touch only the production function proved by the test.
-
-**Step 4: Re-run the focused test and then the full suite**
-
-Run:
-- `.venv/bin/pytest <targeted test path> -v`
-- `.venv/bin/pytest`
-
-Expected: PASS
-
-**Step 5: Validate against the real Garage camera**
-
-Run in order:
-- `.venv/bin/pip install -e .[examples,mqtt]`
-- `.venv/bin/python examples/stream_test.py /Users/fdaloisio/mygit/pycloudedge/.env`
-
-Success criteria:
-- authentication succeeds
-- Garage is selected
-- stream login succeeds
-- continuous video frames are received
-
-If playback inspection is needed and the environment supports it:
-- `.venv/bin/python examples/stream_test.py /Users/fdaloisio/mygit/pycloudedge/.env --ffplay`
-
-### Task 3: Capture objective evidence that the live stream is real
-
-**Files:**
-- Create if needed: `examples/stream_record.py`
-- Modify if needed: `examples/stream_test.py`
-
-**Step 1: Write a failing test for any new helper introduced for recording/probing**
-
-If you need a new helper to write frames to `ffmpeg`, test that helper first. Keep the test offline and deterministic.
-
-**Step 2: Implement the smallest helper needed**
-
-Examples:
-- write Annex B frames to ffmpeg stdin
-- stop after first valid keyframe plus N seconds
-- emit a non-secret summary line for verification
-
-**Step 3: Run a real recording/probe command**
-
-Examples:
-- `.venv/bin/python examples/stream_test.py /Users/fdaloisio/mygit/pycloudedge/.env`
-- `ffmpeg -hide_banner -loglevel warning -f hevc -i <captured stream> -t 10 -f null -`
-- `ffprobe <captured artifact>`
-
-Expected: ffmpeg/ffprobe recognizes a valid video stream and reports video packets/frames.
-
-### Task 4: Verify and harden the Home Assistant bridge path
-
-**Files:**
-- Modify if needed: `/Users/fdaloisio/.config/superpowers/worktrees/cloudedge-ha/streming_video/custom_components/cloudedge/stream_bridge.py`
-- Modify if needed: `/Users/fdaloisio/.config/superpowers/worktrees/cloudedge-ha/streming_video/custom_components/cloudedge/camera.py`
-- Modify if needed: `/Users/fdaloisio/.config/superpowers/worktrees/cloudedge-ha/streming_video/custom_components/cloudedge/__init__.py`
-
-**Step 1: Write a failing unit test for the smallest HA-side bug you discover**
-
-Focus on pure logic where possible:
-- `stream_source()` behavior
-- keyframe gating
-- bootstrap keyframe handling
-- bridge lifecycle / idle stop behavior
-
-**Step 2: Run the targeted test and watch it fail**
-
-Use the project’s chosen Python test command once test scaffolding exists.
-
-**Step 3: Implement the minimal bridge fix**
-
-Keep the architecture unchanged: `pycloudedge` provides raw frames, `cloudedge-ha` remuxes them and exposes `tcp://127.0.0.1:<port>`.
-
-**Step 4: Validate the runtime path**
-
-At minimum verify:
-- `async_get_stream_source()` returns a local TCP source
-- `ffmpeg` starts successfully
-- the bridge accepts a client and emits MPEG-TS bytes
-
-If a local HA harness must be created, keep it minimal and non-destructive.
-
-### Task 5: Document and verify the finished streaming path
-
-**Files:**
-- Modify: `README.md` in `pycloudedge` if examples change
-- Modify: `README.md` in `cloudedge-ha` if runtime requirements or caveats change
-- Modify: `docs/plans/2026-03-30-streaming-video.md`
-
-**Step 1: Re-run all relevant automated checks**
-
-Run:
-- `.venv/bin/pytest`
-- any new targeted HA-side tests
-
-**Step 2: Re-run the real Garage validation**
-
-Run the final direct streaming command again and confirm frame/stream evidence still holds.
-
-**Step 3: Update docs with the exact supported path**
-
-Document:
-- branch requirements
-- local dependency requirements (`ffmpeg`, local `pycloudedge` build)
-- what works now
-- what remains unsupported, especially audio if still absent
-
-**Step 4: Record final verification evidence**
-
-Capture the exact commands run and the observed non-secret success signals so the work can be reproduced.

pycloudedge-0.1.8/pycloudedge.egg-info/scm_file_list.json

@@ -1,44 +0,0 @@
-{
-  "files": [
-    ".env.example",
-    ".gitignore",
-    "LICENSE",
-    "MANIFEST.in",
-    "README.md",
-    "cloudedge/__init__.py",
-    "cloudedge/cli.py",
-    "cloudedge/client.py",
-    "cloudedge/constants.py",
-    "cloudedge/exceptions.py",
-    "cloudedge/image_decrypt.py",
-    "cloudedge/iot_parameters.py",
-    "cloudedge/logging_config.py",
-    "cloudedge/mqtt.py",
-    "cloudedge/p2p/__init__.py",
-    "cloudedge/p2p/kcp_tunnel.py",
-    "cloudedge/p2p/meari_signaling.py",
-    "cloudedge/p2p/p2p_streamer.py",
-    "cloudedge/p2p/root_discovery.py",
-    "cloudedge/p2p/turn_client.py",
-    "cloudedge/stream_profiles.py",
-    "cloudedge/utils.py",
-    "cloudedge/validators.py",
-    "docs/plans/2026-03-30-streaming-video.md",
-    "examples/README.md",
-    "examples/basic_example.py",
-    "examples/device_control.py",
-    "examples/network_ping_status.py",
-    "examples/stream_test.py",
-    "pyproject.toml",
-    "requirements-dev.txt",
-    "requirements.txt",
-    "setup.py",
-    "test_3region_login.py",
-    "tests/test_basic.py",
-    "tests/test_improvements.py",
-    "tests/test_kcp_tunnel.py",
-    "tests/test_mqtt.py",
-    "tests/test_stream_profiles.py",
-    "tests/test_streaming_helpers.py"
-  ]
-}

pycloudedge-0.1.8/pycloudedge.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.1.8",
-  "distance": 0,
-  "node": "g47e440bf58e0591d17669ec5680062e56e5c1862",
-  "dirty": false,
-  "branch": "release/v0.1.8",
-  "node_date": "2026-07-22"
-}

pycloudedge-0.1.8/requirements-dev.txt

@@ -1,11 +0,0 @@
-# Core dependencies for CloudEdge API library
-requests>=2.25.0
-cryptography>=3.4.0
-
-# Optional dependencies for examples
-python-dotenv>=0.19.0\
-
-# dev dependencies
-pytest>=6.0.0
-twine>=6.2.0
-build>=1.3.0

pycloudedge-0.1.8/test_3region_login.py

@@ -1,58 +0,0 @@
-#!/usr/bin/env python3
-"""Test login with 3 region accounts after endpoint refactoring."""
-import sys, os
-
-PROJECT_ROOT = "/Users/fdaloisio/mygit/pycloudedge"
-sys.path.insert(0, PROJECT_ROOT)
-
-from cloudedge import CloudEdgeClient
-
-ACCOUNTS = [
-    (".env", "EU/Italy"),
-    (".env_usa", "US"),
-    (".env_australia", "Australia"),
-]
-
-def load_env(path):
-    env = {}
-    with open(path) as f:
-        for line in f:
-            line = line.strip()
-            if line and not line.startswith("#") and "=" in line:
-                k, v = line.split("=", 1)
-                env[k] = v
-    return env
-
-for env_file, label in ACCOUNTS:
-    env_path = os.path.join(PROJECT_ROOT, env_file)
-    env = load_env(env_path)
-    # Use a separate cache file per account to avoid cross-contamination
-    cache_file = f"/tmp/.cloudedge_cache_{env['CLOUDEDGE_COUNTRY_CODE'].lower()}"
-    # Remove old cache to force fresh discovery
-    if os.path.exists(cache_file):
-        os.remove(cache_file)
-    print(f"\n{'='*60}")
-    print(f"  Testing {label} ({env['CLOUDEDGE_COUNTRY_CODE']})")
-    print(f"{'='*60}")
-    try:
-        client = CloudEdgeClient(
-            username=env["CLOUDEDGE_USERNAME"],
-            password=env["CLOUDEDGE_PASSWORD"],
-            country_code=env["CLOUDEDGE_COUNTRY_CODE"],
-            phone_code=env["CLOUDEDGE_PHONE_CODE"],
-            debug=True,
-            session_cache_file=cache_file,
-        )
-        success = client.authenticate()
-        print(f"  ✅ Login OK")
-        print(f"     BASE_URL:         {client.BASE_URL}")
-        print(f"     OPENAPI_BASE_URL: {client.OPENAPI_BASE_URL}")
-        
-        # Get list of cameras
-        devices = client.get_devices()
-        print(f"     Found {len(devices)} devices:")
-        for dev in devices:
-            status = "Online" if dev.get("online") else "Offline"
-            print(f"       - {dev.get('name', 'Unknown')} (SN: {dev.get('serial_number', 'Unknown')}) [{status}]")
-    except Exception as e:
-        print(f"  ❌ Login FAILED: {e}")