aiotja470-intercom 0.1.0__tar.gz

aiotja470_intercom-0.1.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: aiotja470_intercom
+Version: 0.1.0
+Summary: Asynchronous Python client for the Hager TJA470 Intercom API
+Author-email: Manuel Klimek <klimek@box4.net>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.8.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "test"
+
+# aiotja470_intercom
+
+Asynchronous Python client for the Hager TJA470 Intercom API. This package is designed to be integrated into Home Assistant.
+
+## Installation
+
+```bash
+pip install aiotja470_intercom
+```
+
+## Usage
+
+```python
+import asyncio
+from aiotja470_intercom import TJA470IntercomClient, AiohttpRunner
+
+async def main():
+    runner = AiohttpRunner()
+    client = TJA470IntercomClient(
+        host="192.168.1.100",
+        username="user",
+        password="password",
+        runner=runner
+    )
+
+    try:
+        # Check manifest
+        await client.get_manifest()
+
+        # Get free devices for pairing
+        devices = await client.get_free_devices()
+        print(devices)
+
+        # Retrieve provisioning config
+        config = await client.get_provisioning("your-uuid")
+        print(config)
+
+    finally:
+        await runner.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

aiotja470_intercom-0.1.0/README.md

@@ -0,0 +1,43 @@
+# aiotja470_intercom
+
+Asynchronous Python client for the Hager TJA470 Intercom API. This package is designed to be integrated into Home Assistant.
+
+## Installation
+
+```bash
+pip install aiotja470_intercom
+```
+
+## Usage
+
+```python
+import asyncio
+from aiotja470_intercom import TJA470IntercomClient, AiohttpRunner
+
+async def main():
+    runner = AiohttpRunner()
+    client = TJA470IntercomClient(
+        host="192.168.1.100",
+        username="user",
+        password="password",
+        runner=runner
+    )
+
+    try:
+        # Check manifest
+        await client.get_manifest()
+
+        # Get free devices for pairing
+        devices = await client.get_free_devices()
+        print(devices)
+
+        # Retrieve provisioning config
+        config = await client.get_provisioning("your-uuid")
+        print(config)
+
+    finally:
+        await runner.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

aiotja470_intercom-0.1.0/aiotja470_intercom/__init__.py

@@ -0,0 +1,24 @@
+from .client import TJA470IntercomClient
+from .exceptions import (
+    TJA470AuthError,
+    TJA470ConnectionError,
+    TJA470Error,
+    TJA470ResponseError,
+)
+from .models import CalledElement, FreeDevice, Manifest, ProvisioningInfo, SipInfo
+from .runner import AiohttpRunner, Runner
+
+__all__ = [
+    "TJA470IntercomClient",
+    "TJA470Error",
+    "TJA470ConnectionError",
+    "TJA470AuthError",
+    "TJA470ResponseError",
+    "Manifest",
+    "FreeDevice",
+    "ProvisioningInfo",
+    "SipInfo",
+    "CalledElement",
+    "Runner",
+    "AiohttpRunner",
+]

aiotja470_intercom-0.1.0/aiotja470_intercom/cli.py

@@ -0,0 +1,233 @@
+import argparse
+import asyncio
+import json
+import logging
+import os
+import sys
+import uuid
+from typing import Any, Dict
+
+from aiotja470_intercom.client import TJA470IntercomClient
+from aiotja470_intercom.runner import AiohttpRunner
+from aiotja470_intercom.exceptions import TJA470AuthError
+
+CONFIG_FILE = os.path.expanduser("~/.tja470_config.json")
+
+def load_config() -> Dict[str, Any]:
+    if not os.path.exists(CONFIG_FILE):
+        return {}
+    with open(CONFIG_FILE, "r") as f:
+        return json.load(f)
+
+def save_config(config: Dict[str, Any]) -> None:
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(config, f, indent=4)
+
+class CustomParser(argparse.ArgumentParser):
+    def error(self, message):
+        sys.stderr.write(f'error: {message}\n\n')
+        self.print_help()
+        sys.exit(2)
+
+async def async_main():
+    parser = CustomParser(description="TJA-470 Intercom CLI")
+    parser.add_argument("--debug", action="store_true", help="Enable debug logging (prints raw HTTP requests and responses)")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # `pair` command
+    pair_parser = subparsers.add_parser("pair", help="Authenticate and pair a new client UUID")
+    pair_parser.add_argument("--host", required=True, help="IP address of the TJA-470")
+    pair_parser.add_argument("--username", required=True, help="Username for the TJA-470")
+    pair_parser.add_argument("--password", required=True, help="Password for the TJA-470")
+    pair_parser.add_argument("--uuid", help="Optional custom UUID. If omitted, a random one is generated.")
+
+    # `status` command
+    status_parser = subparsers.add_parser("status", help="Show current connection status and device information")
+
+    # `run` command
+    run_parser = subparsers.add_parser("run", help="Run commands using the cached session")
+    run_parser.add_argument("--open-door", action="store_true", help="Open the door (door ID 1)")
+    run_parser.add_argument("--switch-camera", action="store_true", help="Switch the camera feed")
+    run_parser.add_argument("--provisioning", action="store_true", help="Print the provisioning info")
+
+    args = parser.parse_args()
+
+    if args.debug:
+        logging.basicConfig(level=logging.DEBUG, format="%(levelname)s: %(message)s")
+
+    if args.command == "pair":
+        await run_pair(args)
+    elif args.command == "status":
+        await run_status(args)
+    elif args.command == "run":
+        await run_command(args)
+
+async def run_pair(args):
+    client_uuid = args.uuid if args.uuid else str(uuid.uuid4())
+    print(f"Connecting to TJA470 at {args.host}...")
+    runner = AiohttpRunner()
+    client = TJA470IntercomClient(
+        host=args.host,
+        username=args.username,
+        password=args.password,
+        runner=runner
+    )
+
+    try:
+        print("Checking API manifest...")
+        await client.get_manifest()
+
+        print("Fetching free devices...")
+        devices = await client.get_free_devices()
+        
+        if not devices:
+            print("\n❌ No free devices found!")
+            print("Please create/free a mobile client in the TJA-470 UI.")
+            sys.exit(1)
+            
+        target_device = devices[0]
+        
+        print(f"\nRegistering UUID '{client_uuid}' to device ID {target_device.id}...")
+        await client.set_uid(target_device.id, client_uuid)
+        print("UUID registered successfully!")
+
+        # Save config
+        config = {
+            "host": args.host,
+            "username": args.username,
+            "password": args.password,
+            "uuid": client_uuid,
+            "cookies": client.get_cookies()
+        }
+        save_config(config)
+        print(f"\n✅ Configuration and session cookies saved to {CONFIG_FILE}!")
+        print("You can now use `tja470 run ...` commands.")
+
+    except Exception as e:
+        print(f"\n❌ An error occurred: {e}")
+    finally:
+        await runner.close()
+
+
+async def run_command(args):
+    config = load_config()
+    if not config:
+        print(f"❌ Configuration not found at {CONFIG_FILE}.")
+        print("Please run `tja470 pair` first.")
+        sys.exit(1)
+
+    runner = AiohttpRunner()
+    client = TJA470IntercomClient(
+        host=config["host"],
+        username=config["username"],
+        password=config["password"],
+        runner=runner
+    )
+
+    # Load cached cookies
+    cached_cookies = config.get("cookies", {})
+    if cached_cookies:
+        client.set_cookies(cached_cookies)
+
+    try:
+        uuid = config["uuid"]
+
+        # Validate session by getting manifest (this will re-authenticate with basic auth if cookie is expired)
+        try:
+            await client.get_manifest()
+        except TJA470AuthError:
+            print("❌ Authentication failed. Your credentials might be invalid.")
+            sys.exit(1)
+
+        # Update cached cookies just in case they were refreshed
+        new_cookies = client.get_cookies()
+        if new_cookies != cached_cookies:
+            config["cookies"] = new_cookies
+            save_config(config)
+
+        if args.provisioning:
+            print("\nRetrieving provisioning configuration...")
+            prov = await client.get_provisioning(uuid)
+            print("\n✅ Provisioning Configuration:")
+            print(f"  SIP ID: {prov.sip_info.sip_id}")
+            print(f"  SIP Password: {prov.sip_info.sip_password}")
+            print(f"  RTSP Video URL: {prov.rtsp_video_url}")
+
+        if args.open_door:
+            print("\n🚪 Opening the door...")
+            await client.open_door(door_id=1)
+            print("Door opened successfully!")
+
+        if args.switch_camera:
+            print("\n📷 Switching the camera feed...")
+            await client.switch_camera(uuid)
+            print("Camera switched successfully!")
+
+    except Exception as e:
+        print(f"\n❌ An error occurred: {e}")
+    finally:
+        await runner.close()
+
+
+async def run_status(args):
+    config = load_config()
+    if not config:
+        print(f"❌ Configuration not found at {CONFIG_FILE}.")
+        print("Please run `tja470 pair` first.")
+        sys.exit(1)
+
+    print("Checking connection to TJA-470...")
+    runner = AiohttpRunner()
+    client = TJA470IntercomClient(
+        host=config["host"],
+        username=config["username"],
+        password=config["password"],
+        runner=runner
+    )
+
+    if config.get("cookies"):
+        client.set_cookies(config["cookies"])
+
+    try:
+        # Check authentication
+        await client.get_manifest()
+        
+        # Save cookies if updated
+        new_cookies = client.get_cookies()
+        if new_cookies != config.get("cookies", {}):
+            config["cookies"] = new_cookies
+            save_config(config)
+
+        print("\n✅ Authentication successful!")
+        print(f"Host: {config['host']}")
+        print(f"UUID: {config['uuid']}")
+        
+        print("\nFetching provisioning data...")
+        prov = await client.get_provisioning(config["uuid"])
+        print("\n📋 Intercom Information:")
+        print(f"  SIP ID: {prov.sip_info.sip_id}")
+        print(f"  SIP Password: {'*' * len(prov.sip_info.sip_password)}")
+        print(f"  RTSP Video URL: {prov.rtsp_video_url}")
+        
+        if prov.called_elements:
+            print("\n  Extensions (Called Elements):")
+            for ext in prov.called_elements:
+                print(f"    - Name: {ext.name or 'Unknown'} (SIP ID: {ext.sip_id})")
+        
+    except TJA470AuthError:
+        print("\n❌ Authentication failed. Your session or credentials might be invalid.")
+        print("Try running `tja470 pair` again.")
+    except Exception as e:
+        print(f"\n❌ An error occurred while fetching status: {e}")
+    finally:
+        await runner.close()
+
+
+def main():
+    try:
+        asyncio.run(async_main())
+    except KeyboardInterrupt:
+        pass
+
+if __name__ == "__main__":
+    main()

aiotja470_intercom-0.1.0/aiotja470_intercom/client.py

@@ -0,0 +1,91 @@
+import aiohttp
+from typing import Any, Dict, List, Optional
+
+from .exceptions import TJA470ResponseError, TJA470AuthError
+from .models import FreeDevice, Manifest, ProvisioningInfo
+from .runner import Runner
+
+class TJA470IntercomClient:
+    """Client for the Hager TJA470 Intercom API."""
+
+    def __init__(
+        self,
+        host: str,
+        username: str,
+        password: str,
+        runner: Runner,
+    ) -> None:
+        self.host = host
+        self._auth = aiohttp.BasicAuth(username, password)
+        self._runner = runner
+
+    @property
+    def base_url(self) -> str:
+        return f"http://{self.host}/API"
+
+    def get_cookies(self) -> dict[str, str]:
+        """Get the current cookies for the API base URL."""
+        return self._runner.get_cookies(self.base_url)
+
+    def set_cookies(self, cookies: dict[str, str]) -> None:
+        """Set cookies for the API base URL."""
+        self._runner.set_cookies(self.base_url, cookies)
+
+    async def _request(self, method: str, url: str, json: Optional[Dict[str, Any]] = None) -> Any:
+        try:
+            return await self._runner.request(method, url, json=json)
+        except TJA470AuthError:
+            return await self._runner.request(method, url, auth=self._auth, json=json)
+
+    async def get_manifest(self) -> Manifest:
+        """Verify authentication and retrieve the API manifest."""
+        url = f"{self.base_url}/manifest"
+        response = await self._request("GET", url)
+        if isinstance(response, dict):
+            return Manifest(raw_data=response)
+        elif isinstance(response, str):
+            # Sometimes manifest might just return empty string or non-json if successful
+            return Manifest()
+        else:
+            return Manifest()
+
+    async def get_free_devices(self) -> List[FreeDevice]:
+        """List devices available for pairing."""
+        url = f"{self.base_url}/runtime/provisioning/freedevices"
+        response = await self._request("GET", url)
+        
+        if not isinstance(response, list):
+            raise TJA470ResponseError("Expected a list of free devices")
+
+        return [FreeDevice.from_dict(item) for item in response]
+
+    async def set_uid(self, device_id: int, uid: str) -> None:
+        """Register the UUID as client to the device."""
+        url = f"{self.base_url}/runtime/pairing/setuid"
+        payload = {
+            "id": device_id,
+            "uid": uid,
+            "description": ""
+        }
+        await self._request("POST", url, json=payload)
+
+    async def get_provisioning(self, uid: str) -> ProvisioningInfo:
+        """Retrieve the configuration details for the client."""
+        url = f"{self.base_url}/runtime/provisioning"
+        payload = {"uid": uid}
+        response = await self._request("POST", url, json=payload)
+        
+        if not isinstance(response, dict):
+            raise TJA470ResponseError("Expected a dictionary for provisioning info")
+
+        return ProvisioningInfo.from_dict(response)
+
+    async def switch_camera(self, uid: str) -> None:
+        """Switch the camera between different intercom views."""
+        url = f"{self.base_url}/runtime/command/camera/switch/{uid}"
+        await self._request("POST", url, json={})
+
+    async def open_door(self, door_id: int = 1) -> None:
+        """Trigger the door release."""
+        url = f"{self.base_url}/runtime/command/doorrelease/{door_id}"
+        await self._request("POST", url, json={})

aiotja470_intercom-0.1.0/aiotja470_intercom/exceptions.py

@@ -0,0 +1,11 @@
+class TJA470Error(Exception):
+    """Base exception for TJA470 errors."""
+
+class TJA470ConnectionError(TJA470Error):
+    """Exception raised for connection errors."""
+
+class TJA470AuthError(TJA470Error):
+    """Exception raised for authentication errors."""
+
+class TJA470ResponseError(TJA470Error):
+    """Exception raised for unexpected responses."""

aiotja470_intercom-0.1.0/aiotja470_intercom/models.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+@dataclass
+class Manifest:
+    """Representation of a Manifest response."""
+    raw_data: Dict[str, Any] = field(default_factory=dict)
+
+@dataclass
+class FreeDevice:
+    """Representation of a free device."""
+    id: int
+    name: Optional[str] = None
+    mac: Optional[str] = None
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "FreeDevice":
+        return cls(
+            id=data.get("id", -1),
+            name=data.get("name"),
+            mac=data.get("mac")
+        )
+
+@dataclass
+class SipInfo:
+    """SIP connection details."""
+    sip_id: str
+    sip_password: str
+
+@dataclass
+class CalledElement:
+    """A called element, e.g. a station."""
+    sip_id: str
+    name: Optional[str] = None
+
+@dataclass
+class ProvisioningInfo:
+    """Provisioning details including SIP info and camera streams."""
+    sip_info: SipInfo
+    rtsp_video_url: str
+    called_elements: List[CalledElement] = field(default_factory=list)
+    raw_data: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ProvisioningInfo":
+        sip_info = SipInfo(
+            sip_id=data.get("sipId", ""),
+            sip_password=data.get("sipPassword", "")
+        )
+        called_elements = []
+        for element in data.get("calledElements", []):
+            called_elements.append(
+                CalledElement(
+                    sip_id=element.get("sipId", ""),
+                    name=element.get("name")
+                )
+            )
+        return cls(
+            sip_info=sip_info,
+            rtsp_video_url=data.get("rtspVideoUrl", ""),
+            called_elements=called_elements,
+            raw_data=data
+        )

aiotja470_intercom-0.1.0/aiotja470_intercom/runner.py

@@ -0,0 +1,116 @@
+import aiohttp
+import logging
+from typing import Any, Dict, Optional, Protocol, Union
+
+from .exceptions import TJA470ConnectionError, TJA470AuthError, TJA470ResponseError
+
+_LOGGER = logging.getLogger(__name__)
+
+class Runner(Protocol):
+    """Protocol for executing HTTP requests."""
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        auth: Optional[aiohttp.BasicAuth] = None,
+        json: Optional[Dict[str, Any]] = None,
+    ) -> Union[Dict[str, Any], str, bytes, None]:
+        """Execute the HTTP request and return the parsed JSON, text, or bytes."""
+        ...
+
+    def get_cookies(self, url: str) -> Dict[str, str]:
+        """Get the cookies currently stored for a specific URL."""
+        ...
+
+    def set_cookies(self, url: str, cookies: Dict[str, str]) -> None:
+        """Set cookies for a specific URL."""
+        ...
+
+    async def close(self) -> None:
+        """Close the underlying session/resources."""
+        ...
+
+
+class AiohttpRunner(Runner):
+    """Runner implementation using aiohttp.ClientSession."""
+
+    def __init__(self, session: Optional[aiohttp.ClientSession] = None) -> None:
+        self._session = session
+        self._close_session = False
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        if self._session is None:
+            jar = aiohttp.CookieJar(unsafe=True)
+            self._session = aiohttp.ClientSession(cookie_jar=jar)
+            self._close_session = True
+        return self._session
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        auth: Optional[aiohttp.BasicAuth] = None,
+        json: Optional[Dict[str, Any]] = None,
+    ) -> Union[Dict[str, Any], str, bytes, None]:
+        session = await self._get_session()
+        
+        _LOGGER.debug(f"Request: {method} {url}")
+        if json is not None:
+            _LOGGER.debug(f"Request JSON: {json}")
+
+        from yarl import URL
+        req_cookies = session.cookie_jar.filter_cookies(URL(url))
+        if req_cookies:
+            _LOGGER.debug(f"Sending Cookies: {req_cookies}")
+
+        try:
+            async with session.request(method, url, auth=auth, json=json) as response:
+                _LOGGER.debug(f"Response Status: {response.status}")
+                _LOGGER.debug(f"Response Headers: {response.headers}")
+
+                if response.status == 401 or response.status == 403:
+                    raise TJA470AuthError("Authentication failed")
+                
+                response.raise_for_status()
+                
+                content_type = response.headers.get("Content-Type", "")
+                if "application/json" in content_type:
+                    data = await response.json()
+                elif "text/" in content_type:
+                    data = await response.text()
+                else:
+                    data = await response.read()
+
+                _LOGGER.debug(f"Response Content: {data}")
+                return data
+
+        except aiohttp.ClientConnectorError as e:
+            raise TJA470ConnectionError(f"Connection failed: {e}") from e
+        except aiohttp.ClientResponseError as e:
+            raise TJA470ResponseError(f"HTTP Error {e.status}: {e.message}") from e
+        except Exception as e:
+            raise TJA470Error(f"An unexpected error occurred: {e}") from e
+
+    def get_cookies(self, url: str) -> Dict[str, str]:
+        if not self._session:
+            return {}
+        # We iterate over all cookies in the jar to ensure we don't miss any due to path/domain mismatches
+        cookies = {}
+        for cookie in self._session.cookie_jar:
+            cookies[cookie.key] = cookie.value
+        return cookies
+
+    def set_cookies(self, url: str, cookies: Dict[str, str]) -> None:
+        if not self._session:
+            # We must instantiate the session first to have a cookie jar
+            jar = aiohttp.CookieJar(unsafe=True)
+            self._session = aiohttp.ClientSession(cookie_jar=jar)
+            self._close_session = True
+        
+        from yarl import URL
+        self._session.cookie_jar.update_cookies(cookies, response_url=URL(url))
+
+    async def close(self) -> None:
+        if self._session and self._close_session:
+            await self._session.close()

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

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: aiotja470_intercom
+Version: 0.1.0
+Summary: Asynchronous Python client for the Hager TJA470 Intercom API
+Author-email: Manuel Klimek <klimek@box4.net>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.8.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "test"
+
+# aiotja470_intercom
+
+Asynchronous Python client for the Hager TJA470 Intercom API. This package is designed to be integrated into Home Assistant.
+
+## Installation
+
+```bash
+pip install aiotja470_intercom
+```
+
+## Usage
+
+```python
+import asyncio
+from aiotja470_intercom import TJA470IntercomClient, AiohttpRunner
+
+async def main():
+    runner = AiohttpRunner()
+    client = TJA470IntercomClient(
+        host="192.168.1.100",
+        username="user",
+        password="password",
+        runner=runner
+    )
+
+    try:
+        # Check manifest
+        await client.get_manifest()
+
+        # Get free devices for pairing
+        devices = await client.get_free_devices()
+        print(devices)
+
+        # Retrieve provisioning config
+        config = await client.get_provisioning("your-uuid")
+        print(config)
+
+    finally:
+        await runner.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

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

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+aiotja470_intercom/__init__.py
+aiotja470_intercom/cli.py
+aiotja470_intercom/client.py
+aiotja470_intercom/exceptions.py
+aiotja470_intercom/models.py
+aiotja470_intercom/runner.py
+aiotja470_intercom.egg-info/PKG-INFO
+aiotja470_intercom.egg-info/SOURCES.txt
+aiotja470_intercom.egg-info/dependency_links.txt
+aiotja470_intercom.egg-info/entry_points.txt
+aiotja470_intercom.egg-info/requires.txt
+aiotja470_intercom.egg-info/top_level.txt
+tests/test_client.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+tja470 = aiotja470_intercom.cli:main

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

@@ -0,0 +1,5 @@
+aiohttp>=3.8.0
+
+[test]
+pytest>=7.0
+pytest-asyncio>=0.21.0

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

@@ -0,0 +1 @@
+aiotja470_intercom

aiotja470_intercom-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aiotja470_intercom"
+version = "0.1.0"
+authors = [
+  { name="Manuel Klimek", email="klimek@box4.net" },
+]
+description = "Asynchronous Python client for the Hager TJA470 Intercom API"
+readme = "README.md"
+requires-python = ">=3.11"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Framework :: AsyncIO",
+]
+dependencies = [
+    "aiohttp>=3.8.0",
+]
+
+[project.scripts]
+tja470 = "aiotja470_intercom.cli:main"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21.0",
+]
+
+[tool.setuptools.packages.find]
+include = ["aiotja470_intercom*"]

aiotja470_intercom-0.1.0/setup.cfg

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

aiotja470_intercom-0.1.0/tests/test_client.py

@@ -0,0 +1,134 @@
+import pytest
+import aiohttp
+from typing import Any, Dict, Optional, Union
+
+from aiotja470_intercom.client import TJA470IntercomClient
+from aiotja470_intercom.exceptions import TJA470ResponseError
+from aiotja470_intercom.models import FreeDevice, Manifest, ProvisioningInfo
+
+class MockRunner:
+    def __init__(self):
+        self.requests = []
+        self.next_response: Union[Dict[str, Any], str, list, Exception] = {}
+        self.cookies = {}
+        
+    async def request(
+        self,
+        method: str,
+        url: str,
+        auth: Optional[aiohttp.BasicAuth] = None,
+        json: Optional[Dict[str, Any]] = None,
+    ) -> Union[Dict[str, Any], str, bytes, list, None]:
+        self.requests.append({"method": method, "url": url, "auth": auth, "json": json})
+        if isinstance(self.next_response, Exception):
+            raise self.next_response
+        return self.next_response
+
+    def get_cookies(self, url: str) -> Dict[str, str]:
+        return self.cookies.get(url, {})
+
+    def set_cookies(self, url: str, cookies: Dict[str, str]) -> None:
+        if url not in self.cookies:
+            self.cookies[url] = {}
+        self.cookies[url].update(cookies)
+
+    async def close(self) -> None:
+        pass
+
+
+@pytest.fixture
+def runner():
+    return MockRunner()
+
+@pytest.fixture
+def client(runner):
+    return TJA470IntercomClient("127.0.0.1", "testuser", "testpass", runner)
+
+@pytest.mark.asyncio
+async def test_get_manifest(client, runner):
+    runner.next_response = {"status": "ok"}
+    manifest = await client.get_manifest()
+    
+    assert isinstance(manifest, Manifest)
+    assert manifest.raw_data == {"status": "ok"}
+    assert len(runner.requests) == 1
+    assert runner.requests[0]["method"] == "GET"
+    assert "manifest" in runner.requests[0]["url"]
+
+@pytest.mark.asyncio
+async def test_get_free_devices(client, runner):
+    runner.next_response = [
+        {"id": 42, "name": "Test Device", "mac": "00:11:22:33:44:55"}
+    ]
+    devices = await client.get_free_devices()
+    
+    assert len(devices) == 1
+    assert isinstance(devices[0], FreeDevice)
+    assert devices[0].id == 42
+    assert devices[0].name == "Test Device"
+    assert devices[0].mac == "00:11:22:33:44:55"
+
+@pytest.mark.asyncio
+async def test_get_free_devices_error(client, runner):
+    runner.next_response = {"error": "not a list"}
+    with pytest.raises(TJA470ResponseError):
+        await client.get_free_devices()
+
+@pytest.mark.asyncio
+async def test_set_uid(client, runner):
+    runner.next_response = ""
+    await client.set_uid(42, "test-uuid")
+    
+    assert len(runner.requests) == 1
+    req = runner.requests[0]
+    assert req["method"] == "POST"
+    assert "setuid" in req["url"]
+    assert req["json"] == {"id": 42, "uid": "test-uuid", "description": ""}
+
+@pytest.mark.asyncio
+async def test_get_provisioning(client, runner):
+    runner.next_response = {
+        "sipId": "1001",
+        "sipPassword": "secretpassword",
+        "rtspVideoUrl": "rtsp://127.0.0.1/stream",
+        "calledElements": [
+            {"sipId": "1002", "name": "Station 1"}
+        ]
+    }
+    config = await client.get_provisioning("test-uuid")
+    
+    assert isinstance(config, ProvisioningInfo)
+    assert config.sip_info.sip_id == "1001"
+    assert config.sip_info.sip_password == "secretpassword"
+    assert config.rtsp_video_url == "rtsp://127.0.0.1/stream"
+    assert len(config.called_elements) == 1
+    assert config.called_elements[0].sip_id == "1002"
+    assert config.called_elements[0].name == "Station 1"
+
+@pytest.mark.asyncio
+async def test_get_provisioning_error(client, runner):
+    runner.next_response = ["not", "a", "dict"]
+    with pytest.raises(TJA470ResponseError):
+        await client.get_provisioning("test-uuid")
+
+@pytest.mark.asyncio
+async def test_switch_camera(client, runner):
+    runner.next_response = ""
+    await client.switch_camera("test-uuid")
+    
+    assert len(runner.requests) == 1
+    assert "camera/switch/test-uuid" in runner.requests[0]["url"]
+
+@pytest.mark.asyncio
+async def test_open_door(client, runner):
+    runner.next_response = ""
+    await client.open_door(1)
+    
+    assert len(runner.requests) == 1
+    assert "doorrelease/1" in runner.requests[0]["url"]
+
+def test_cookies(client, runner):
+    client.set_cookies({"session_id": "12345"})
+    cookies = client.get_cookies()
+    assert cookies == {"session_id": "12345"}
+