pycloudedge 0.1.6.dev2__tar.gz → 0.1.6.dev4__tar.gz

{pycloudedge-0.1.6.dev2 → pycloudedge-0.1.6.dev4}/PKG-INFO

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

pycloudedge-0.1.6.dev4/cloudedge/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.6.dev4'
+__version_tuple__ = version_tuple = (0, 1, 6, 'dev4')
+
+__commit_id__ = commit_id = 'ge76f5b0fa'

{pycloudedge-0.1.6.dev2 → pycloudedge-0.1.6.dev4}/cloudedge/client.py

@@ -37,9 +37,7 @@ from .iot_parameters import (
 )
 from .constants import (
     CA_KEY, CA_SECRET, DEFAULT_HEADERS, DEFAULT_TIMEOUT,
-    REGION_ENDPOINTS, REGION_EU, REGION_US, REGION_AP,
     REDIRECT_URL,
-    region_for_country,
 )
 from .validators import validate_email, validate_country_code, validate_phone_code
 from .logging_config import get_logger
@@ -132,7 +130,6 @@ class CloudEdgeClient:
         session_cache_file: str = ".cloudedge_session_cache",
         enable_network_ping: bool = True,
         ping_timeout: float = 2.0,
-        region: Optional[str] = None,
     ):
         """
         Initialize CloudEdge API client.
@@ -146,10 +143,6 @@ class CloudEdgeClient:
             session_cache_file (str): Path to session cache file
             enable_network_ping (bool): Enable ping-based online status when on same network
             ping_timeout (float): Ping timeout in seconds
-            region (str, optional): Force a specific region ("eu", "us", or "ap").
-                When *None* the region is derived automatically from *country_code*:
-                European countries → EU, Asia-Pacific/Oceania/ME/Africa → AP
-                (Singapore), everything else → US.
             
         Raises:
             ValidationError: If input validation fails
@@ -173,17 +166,18 @@ class CloudEdgeClient:
                 details={"field": "phone_code", "value": phone_code}
             )
         
+        normalized_country_code = country_code.upper()
+        if normalized_country_code == "UK":
+            normalized_country_code = "GB"
+
         self.username = username
         self.password = password
-        self.country_code = country_code.upper()
+        self.country_code = normalized_country_code
         self.phone_code = phone_code if phone_code.startswith('+') else f'+{phone_code}'
         
-        # Resolve region and endpoints
-        resolved_region = region if region in REGION_ENDPOINTS else region_for_country(self.country_code)
-        endpoints = REGION_ENDPOINTS[resolved_region]
-        self.region = resolved_region
-        self.BASE_URL = endpoints["base_url"]
-        self.OPENAPI_BASE_URL = endpoints["openapi_base_url"]
+        # Endpoints are discovered dynamically via _discover_endpoints()
+        self.BASE_URL: Optional[str] = None
+        self.OPENAPI_BASE_URL: Optional[str] = None
         
         # Setup proper logging
         self.logger = get_logger("client")
@@ -557,8 +551,11 @@ class CloudEdgeClient:
         contains the regional ``apiServer`` and ``openapi`` domain that must be
         used for the given account/country.
 
-        On success, ``self.BASE_URL`` and ``self.OPENAPI_BASE_URL`` are updated.
-        On failure the previously configured (static) endpoints are kept.
+        On success, ``self.BASE_URL`` and ``self.OPENAPI_BASE_URL`` are set.
+
+        Raises:
+            NetworkError: If the redirect API call fails or returns an
+                unexpected response and no endpoints were previously set.
         """
         import random
 
@@ -593,9 +590,6 @@ class CloudEdgeClient:
         ).hexdigest()
 
         # X-Ca-Sign: HMAC-SHA1 with CA_SECRET as key
-        # The app builds: "api=/ppstrongs/" + getRealUrl(path) + "|X-Ca-Key=...|..."
-        # getRealUrl("/ppstrongs/redirect") returns "/ppstrongs/redirect" unchanged,
-        # so the full string is "api=/ppstrongs//ppstrongs/redirect|..."
         ca_sign_data = (
             f"api=/ppstrongs//ppstrongs/redirect"
             f"|X-Ca-Key={CA_KEY}"
@@ -620,8 +614,9 @@ class CloudEdgeClient:
             )
             data = resp.json()
             if data.get("resultCode") != "1001":
-                self._log(f"Redirect discovery returned {data.get('resultCode')}")
-                return
+                raise NetworkError(
+                    f"Redirect discovery returned unexpected code: {data.get('resultCode')}"
+                )
 
             result = data.get("result", {})
             api_server = result.get("apiServer") or result.get("gwUrl") or ""
@@ -635,8 +630,15 @@ class CloudEdgeClient:
                 self.OPENAPI_BASE_URL = openapi_domain.rstrip("/")
                 self._log(f"Discovered OpenAPI server: {self.OPENAPI_BASE_URL}")
 
+            if not self.BASE_URL:
+                raise NetworkError(
+                    "Redirect API did not return an apiServer"
+                )
+
+        except NetworkError:
+            raise
         except Exception as exc:
-            self._log(f"Endpoint discovery failed (will use static endpoints): {exc}")
+            raise NetworkError(f"Endpoint discovery failed: {exc}") from exc
 
     def authenticate(self) -> bool:
         """

pycloudedge-0.1.6.dev4/cloudedge/constants.py

@@ -0,0 +1,35 @@
+"""
+Configuration constants for CloudEdge API
+"""
+
+# Global redirect endpoint — used to discover the correct regional server.
+# This is the single source of truth: the redirect API returns the correct
+# ``apiServer`` and ``openapi`` domain for the given account/country.
+REDIRECT_URL = "https://apis.cloudedge360.com/ppstrongs/redirect"
+
+# API Keys (these are public keys from the mobile app)
+CA_KEY = "bc29be30292a4309877807e101afbd51"
+CA_SECRET = "35a69fd1-6527-4566-b190-921f9a651488"
+
+# Default Headers
+DEFAULT_HEADERS = {
+    "Accept-Language": "en-US,en;q=0.8",
+    "User-Agent": "Mozilla/5.0 (Linux; U; Android 10; en-us; Android SDK built for arm64 Build/QSR1.211112.002) AppleWebKit/533.1 (KHTML, like Gecko) Version/5.0 Mobile Safari/533.1",
+    "Content-Type": "application/x-www-form-urlencoded",
+    "Accept-Encoding": "gzip, deflate, br"
+}
+
+# API Constants
+PHONE_TYPE = "a"
+SOURCE_APP = "8"
+APP_VERSION = "5.5.1"
+IOT_TYPE = "4"
+APP_VERSION_CODE = "551"
+DEFAULT_LANGUAGE = "en"
+
+# Timeout values (seconds)
+DEFAULT_TIMEOUT = 30
+PING_TIMEOUT = 2.0
+
+# Cache settings
+DEFAULT_CACHE_FILE = ".cloudedge_session_cache"

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

@@ -0,0 +1,176 @@
+# 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.6.dev2 → pycloudedge-0.1.6.dev4}/pycloudedge.egg-info/PKG-INFO

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

{pycloudedge-0.1.6.dev2 → pycloudedge-0.1.6.dev4}/pycloudedge.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ pyproject.toml
 requirements-dev.txt
 requirements.txt
 setup.py
+test_3region_login.py
 cloudedge/__init__.py
 cloudedge/_version.py
 cloudedge/cli.py
@@ -19,6 +20,7 @@ cloudedge/logging_config.py
 cloudedge/mqtt.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

{pycloudedge-0.1.6.dev2 → pycloudedge-0.1.6.dev4}/pyproject.toml

@@ -66,6 +66,7 @@ cloudedge = "cloudedge.cli:main"
 
 [tool.setuptools_scm]
 write_to = "cloudedge/_version.py"
+version_scheme = "only-version"
 
 [tool.setuptools.packages.find]
 where = ["."]
@@ -113,4 +114,4 @@ testpaths = [
 ]
 python_files = "test_*.py"
 python_classes = "Test*"
-python_functions = "test_*"
+python_functions = "test_*"

pycloudedge-0.1.6.dev4/test_3region_login.py

@@ -0,0 +1,58 @@
+#!/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}")

{pycloudedge-0.1.6.dev2 → pycloudedge-0.1.6.dev4}/tests/test_basic.py

@@ -21,32 +21,32 @@ from cloudedge.iot_parameters import get_parameter_name, format_parameter_value
 
 class TestIoTParameters(unittest.TestCase):
     """Test IoT parameter functions."""
-    
+
     def test_get_parameter_name(self):
         """Test parameter name retrieval."""
         # Test known parameter
         self.assertEqual(get_parameter_name("167"), "FRONT_LIGHT_SWITCH")
         self.assertEqual(get_parameter_name("103"), "LED_ENABLE")
-        
+
         # Test unknown parameter
         self.assertEqual(get_parameter_name("99999"), "iot_99999")
-    
+
     def test_format_parameter_value(self):
         """Test parameter value formatting."""
         # Test boolean parameter
         self.assertEqual(format_parameter_value("LED_ENABLE", "1"), "Enabled")
         self.assertEqual(format_parameter_value("LED_ENABLE", "0"), "Disabled")
-        
+
         # Test percentage parameter
         self.assertEqual(format_parameter_value("BATTERY_PERCENT", 85), "85%")
-        
+
         # Test regular value
         self.assertEqual(format_parameter_value("UNKNOWN_PARAM", "test"), "test")
 
 
 class TestCloudEdgeClient(unittest.TestCase):
     """Test CloudEdge client functionality."""
-    
+
     def setUp(self):
         """Set up test client."""
         self.client = CloudEdgeClient(
@@ -54,9 +54,9 @@ class TestCloudEdgeClient(unittest.TestCase):
             password="testpass",
             country_code="US",
             phone_code="+1",
-            debug=False
+            debug=False,
         )
-    
+
     def test_client_initialization(self):
         """Test client initialization."""
         self.assertEqual(self.client.username, "test@example.com")
@@ -64,19 +64,19 @@ class TestCloudEdgeClient(unittest.TestCase):
         self.assertEqual(self.client.phone_code, "+1")
         self.assertFalse(self.client.debug)
         self.assertIsNone(self.client.session_data)
-    
+
     def test_format_sn(self):
         """Test serial number formatting."""
         # Test 9-digit SN
         self.assertEqual(self.client._format_sn("123456789"), "0000000123456789")
-        
+
         # Test longer SN
         self.assertEqual(self.client._format_sn("ABCD123456789"), "123456789")
-        
+
         # Test empty SN
         self.assertEqual(self.client._format_sn(""), "")
-    
-    @patch('cloudedge.client.requests.Session.post')
+
+    @patch("cloudedge.client.requests.Session.post")
     async def test_authenticate_success(self, mock_post):
         """Test successful authentication."""
         # Mock successful login response
@@ -90,23 +90,23 @@ class TestCloudEdgeClient(unittest.TestCase):
                 "iot": {
                     "pfKey": {
                         "accessid": "test_access_id",
-                        "accesskey": "test_access_key"
+                        "accesskey": "test_access_key",
                     }
-                }
-            }
+                },
+            },
         }
         mock_response.raise_for_status.return_value = None
         mock_post.return_value = mock_response
-        
+
         # Test authentication
         success = await self.client.authenticate()
-        
+
         self.assertTrue(success)
         self.assertIsNotNone(self.client.session_data)
         self.assertEqual(self.client.session_data["userToken"], "test_token")
         self.assertEqual(self.client.session_data["userID"], "test_user_id")
-    
-    @patch('cloudedge.client.requests.Session.post')
+
+    @patch("cloudedge.client.requests.Session.post")
     async def test_authenticate_failure(self, mock_post):
         """Test failed authentication."""
         # Mock failed login response
@@ -114,29 +114,26 @@ class TestCloudEdgeClient(unittest.TestCase):
         mock_response.status_code = 200
         mock_response.json.return_value = {
             "resultCode": "1002",
-            "resultMsg": "Invalid credentials"
+            "resultMsg": "Invalid credentials",
         }
         mock_response.raise_for_status.return_value = None
         mock_post.return_value = mock_response
-        
+
         # Test authentication failure
         with self.assertRaises(AuthenticationError):
             await self.client.authenticate()
-    
+
     async def test_get_devices_not_authenticated(self):
         """Test getting devices without authentication."""
         with self.assertRaises(AuthenticationError):
             await self.client.get_devices()
-    
-    @patch('cloudedge.client.requests.Session.post')
+
+    @patch("cloudedge.client.requests.Session.post")
     async def test_get_devices_success(self, mock_post):
         """Test successful device retrieval."""
         # Set up authenticated session
-        self.client.session_data = {
-            "userToken": "test_token",
-            "userID": "test_user_id"
-        }
-        
+        self.client.session_data = {"userToken": "test_token", "userID": "test_user_id"}
+
         # Mock device list response
         mock_response = Mock()
         mock_response.status_code = 200
@@ -151,42 +148,46 @@ class TestCloudEdgeClient(unittest.TestCase):
                         "deviceTypeName": "Camera",
                         "devTypeID": "1",
                         "hostKey": "hostkey123",
-                        "onLine": 1
+                        "onLine": 1,
                     }
                 ]
-            }
+            },
         }
         mock_response.raise_for_status.return_value = None
         mock_post.return_value = mock_response
-        
+
         # Test device retrieval
         devices = await self.client.get_devices()
-        
+
         self.assertEqual(len(devices), 1)
         device = devices[0]
         self.assertEqual(device["device_id"], "device1")
         self.assertEqual(device["name"], "Test Camera")
         self.assertTrue(device["online"])
-    
+
     async def test_find_device_by_name_not_authenticated(self):
         """Test finding device without authentication."""
         # Mock get_devices to raise AuthenticationError
-        with patch.object(self.client, 'get_devices', side_effect=AuthenticationError("Not authenticated")):
+        with patch.object(
+            self.client,
+            "get_devices",
+            side_effect=AuthenticationError("Not authenticated"),
+        ):
             result = await self.client.find_device_by_name("Test Device")
             self.assertIsNone(result)
 
 
 class TestAsyncMethods(unittest.IsolatedAsyncioTestCase):
     """Test async methods with proper async test support."""
-    
+
     async def test_client_methods_with_mock(self):
         """Test client methods with mocked dependencies."""
-        client = CloudEdgeClient("test", "test", "US", "+1")
-        
+        client = CloudEdgeClient("test@example.com", "test", "US", "+1")
+
         # Test that methods require authentication
         with self.assertRaises(AuthenticationError):
             await client.get_devices()
-        
+
         with self.assertRaises(AuthenticationError):
             await client.get_device_status("device1")
 
@@ -195,28 +196,28 @@ def run_tests():
     """Run all tests."""
     loader = unittest.TestLoader()
     suite = unittest.TestSuite()
-    
+
     # Add test classes
     suite.addTests(loader.loadTestsFromTestCase(TestIoTParameters))
     suite.addTests(loader.loadTestsFromTestCase(TestCloudEdgeClient))
     suite.addTests(loader.loadTestsFromTestCase(TestAsyncMethods))
-    
+
     # Run tests
     runner = unittest.TextTestRunner(verbosity=2)
     result = runner.run(suite)
-    
+
     return result.wasSuccessful()
 
 
 if __name__ == "__main__":
     print("CloudEdge API Library - Basic Tests")
     print("=" * 50)
-    
+
     success = run_tests()
-    
+
     if success:
         print("\n✅ All tests passed!")
         exit(0)
     else:
         print("\n❌ Some tests failed!")
-        exit(1)
+        exit(1)

{pycloudedge-0.1.6.dev2 → pycloudedge-0.1.6.dev4}/tests/test_improvements.py

@@ -59,6 +59,15 @@ class TestPhase1InputValidation:
         assert client.country_code == "US"
         assert client.phone_code == "+1"
 
+    def test_uk_country_code_normalizes_to_gb(self):
+        """Test that UK input normalizes to GB for CloudEdge APIs."""
+        client = CloudEdgeClient("user@example.com", "password", "UK", "+44")
+
+        assert client.country_code == "GB"
+        assert client.phone_code == "+44"
+        assert client.BASE_URL is None
+        assert client.OPENAPI_BASE_URL is None
+
 
 class TestPhase1Logging:
     """Test Phase 1: Proper logging implementation"""

pycloudedge-0.1.6.dev2/cloudedge/_version.py

@@ -1,34 +0,0 @@
-# file generated by setuptools-scm
-# don't change, don't track in version control
-
-__all__ = [
-    "__version__",
-    "__version_tuple__",
-    "version",
-    "version_tuple",
-    "__commit_id__",
-    "commit_id",
-]
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Tuple
-    from typing import Union
-
-    VERSION_TUPLE = Tuple[Union[int, str], ...]
-    COMMIT_ID = Union[str, None]
-else:
-    VERSION_TUPLE = object
-    COMMIT_ID = object
-
-version: str
-__version__: str
-__version_tuple__: VERSION_TUPLE
-version_tuple: VERSION_TUPLE
-commit_id: COMMIT_ID
-__commit_id__: COMMIT_ID
-
-__version__ = version = '0.1.6.dev2'
-__version_tuple__ = version_tuple = (0, 1, 6, 'dev2')
-
-__commit_id__ = commit_id = None

pycloudedge-0.1.6.dev2/cloudedge/constants.py

@@ -1,101 +0,0 @@
-"""
-Configuration constants for CloudEdge API
-"""
-
-# Region identifiers
-REGION_EU = "eu"
-REGION_US = "us"
-REGION_AP = "ap"
-
-# Per-region API endpoints (static fallback when redirect discovery fails)
-REGION_ENDPOINTS = {
-    REGION_EU: {
-        "base_url": "https://apis-eu-frankfurt.cloudedge360.com",
-        "openapi_base_url": "https://openapi-euce.mearicloud.com",
-    },
-    REGION_US: {
-        "base_url": "https://apis-us-west.cloudedge360.com",
-        "openapi_base_url": "https://openapi-uswe.mearicloud.com",
-    },
-    REGION_AP: {
-        "base_url": "https://apis-as-singapore.cloudedge360.com",
-        "openapi_base_url": "https://openapi-usce.mearicloud.com",
-    },
-}
-
-# Global redirect endpoint — used to discover the correct regional server
-REDIRECT_URL = "https://apis.cloudedge360.com/ppstrongs/redirect"
-
-# Default endpoints (EU) – kept for backward compatibility
-BASE_URL = REGION_ENDPOINTS[REGION_EU]["base_url"]
-OPENAPI_BASE_URL = REGION_ENDPOINTS[REGION_EU]["openapi_base_url"]
-
-# European country codes (ISO 3166-1 alpha-2)
-EU_COUNTRY_CODES = {
-    "AT", "BE", "BG", "HR", "CY", "CZ", "DK", "EE", "FI", "FR",
-    "DE", "GR", "HU", "IE", "IT", "LV", "LT", "LU", "MT", "NL",
-    "PL", "PT", "RO", "SK", "SI", "ES", "SE",
-    # EEA + EFTA + UK
-    "IS", "LI", "NO", "CH", "GB",
-    # Other European countries
-    "AL", "AD", "AM", "AZ", "BA", "BY", "GE", "GI", "XK", "MD",
-    "MC", "ME", "MK", "RS", "RU", "SM", "TR", "UA", "VA",
-}
-
-
-# Asia-Pacific / Oceania / Middle East / Africa country codes
-# These are routed through the Singapore gateway
-AP_COUNTRY_CODES = {
-    # East Asia
-    "JP", "KR", "TW", "HK", "MO",
-    # Southeast Asia
-    "SG", "MY", "TH", "VN", "PH", "ID", "MM", "KH", "LA", "BN", "TL",
-    # South Asia
-    "IN", "PK", "BD", "LK", "NP", "BT", "MV",
-    # Oceania
-    "AU", "NZ", "FJ", "PG", "WS", "TO", "VU", "SB", "KI", "MH", "FM",
-    "PW", "NR", "TV", "CK", "NU",
-    # Middle East
-    "AE", "SA", "QA", "KW", "BH", "OM", "JO", "LB", "IQ", "IR", "YE",
-    "SY", "PS", "IL",
-    # Africa
-    "ZA", "EG", "NG", "KE", "GH", "TZ", "UG", "ET", "MA", "DZ", "TN",
-    "SN", "CI", "CM", "AO", "MZ", "ZW", "BW", "NA", "MU", "MG", "RW",
-}
-
-
-def region_for_country(country_code: str) -> str:
-    """Return the region key for a given ISO 3166-1 alpha-2 country code."""
-    cc = country_code.upper()
-    if cc in EU_COUNTRY_CODES:
-        return REGION_EU
-    if cc in AP_COUNTRY_CODES:
-        return REGION_AP
-    return REGION_US
-
-# API Keys (these are public keys from the mobile app)
-CA_KEY = "bc29be30292a4309877807e101afbd51"
-CA_SECRET = "35a69fd1-6527-4566-b190-921f9a651488"
-
-# Default Headers
-DEFAULT_HEADERS = {
-    "Accept-Language": "en-US,en;q=0.8",
-    "User-Agent": "Mozilla/5.0 (Linux; U; Android 10; en-us; Android SDK built for arm64 Build/QSR1.211112.002) AppleWebKit/533.1 (KHTML, like Gecko) Version/5.0 Mobile Safari/533.1",
-    "Content-Type": "application/x-www-form-urlencoded",
-    "Accept-Encoding": "gzip, deflate, br"
-}
-
-# API Constants
-PHONE_TYPE = "a"
-SOURCE_APP = "8"
-APP_VERSION = "5.5.1"
-IOT_TYPE = "4"
-APP_VERSION_CODE = "551"
-DEFAULT_LANGUAGE = "en"
-
-# Timeout values (seconds)
-DEFAULT_TIMEOUT = 30
-PING_TIMEOUT = 2.0
-
-# Cache settings
-DEFAULT_CACHE_FILE = ".cloudedge_session_cache"