atvnotif 0.1.0__tar.gz

atvnotif-0.1.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: atvnotif
+Version: 0.1.0
+Summary: A Python client for sending encrypted notifications to Android TV Notifier
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/atvnotif/atvnotif.py
+Project-URL: Repository, https://github.com/atvnotif/atvnotif.py
+Project-URL: Bug Tracker, https://github.com/atvnotif/atvnotif.py/issues
+Keywords: android-tv,notifications,home-automation,atvnotif
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Operating System :: OS Independent
+Classifier: Topic :: Home Automation
+Classifier: Topic :: Communications
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=35.0.0
+Requires-Dist: httpx>=0.20.0
+Requires-Dist: zeroconf>=0.33.0
+
+# atvnotif
+
+[![PyPI](https://img.shields.io/pypi/v/atvnotif)](https://pypi.org/project/atvnotif/)
+[![Supported Python Versions](https://img.shields.io/pypi/pyversions/atvnotif)](https://pypi.org/project/atvnotif/)
+[![License](https://img.shields.io/github/license/atvnotif/atvnotif.py)](https://github.com/atvnotif/atvnotif.py/blob/main/LICENSE)
+
+A Python client library for sending encrypted notifications to the **Android TV Notifier** app (`com.smrtprjcts.atvnotif`).
+
+## Installation
+
+```bash
+pip install atvnotif
+```
+
+## Usage
+
+```python
+import asyncio
+from atvnotif import ATVNotifier
+
+async def main():
+    # Replace with your TV's IP address and pairing code (remove hyphens or leave them, the library cleans it)
+    notifier = ATVNotifier("192.168.1.100", "1234-5678-ABCD")
+    
+    await notifier.async_notify(
+        message="Someone is at the door!",
+        title="Doorbell Alert",
+        duration=10,
+        position=0,  # Top-Right
+        notif_sound=True
+    )
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

atvnotif-0.1.0/README.md

@@ -0,0 +1,35 @@
+# atvnotif
+
+[![PyPI](https://img.shields.io/pypi/v/atvnotif)](https://pypi.org/project/atvnotif/)
+[![Supported Python Versions](https://img.shields.io/pypi/pyversions/atvnotif)](https://pypi.org/project/atvnotif/)
+[![License](https://img.shields.io/github/license/atvnotif/atvnotif.py)](https://github.com/atvnotif/atvnotif.py/blob/main/LICENSE)
+
+A Python client library for sending encrypted notifications to the **Android TV Notifier** app (`com.smrtprjcts.atvnotif`).
+
+## Installation
+
+```bash
+pip install atvnotif
+```
+
+## Usage
+
+```python
+import asyncio
+from atvnotif import ATVNotifier
+
+async def main():
+    # Replace with your TV's IP address and pairing code (remove hyphens or leave them, the library cleans it)
+    notifier = ATVNotifier("192.168.1.100", "1234-5678-ABCD")
+    
+    await notifier.async_notify(
+        message="Someone is at the door!",
+        title="Doorbell Alert",
+        duration=10,
+        position=0,  # Top-Right
+        notif_sound=True
+    )
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

atvnotif-0.1.0/atvnotif/__init__.py

@@ -0,0 +1,5 @@
+from .client import ATVNotifier
+from .discover import discover_devices
+from .qr import decode_qr_image
+
+__all__ = ["ATVNotifier", "discover_devices", "decode_qr_image"]

atvnotif-0.1.0/atvnotif/client.py

@@ -0,0 +1,149 @@
+import os
+import json
+import httpx
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+class ATVNotifier:
+    """Client class to communicate and send encrypted notifications to Android TV Notifier."""
+
+    def __init__(self, host: str, pairing_code: str, port: int = 7878):
+        self.host = host
+        self.port = port
+        self.pairing_code = pairing_code
+        self.key = self._derive_key(pairing_code)
+
+    def _derive_key(self, pairing_code: str) -> bytes:
+        """Derives the 32-byte AES key from the pairing code by reversing and repeating it."""
+        cleaned = pairing_code.replace("-", "")
+        reversed_code = cleaned[::-1]
+        padded = (reversed_code * 32)[:32]
+        return padded.encode("utf-8")
+
+    def encrypt_payload(self, data: dict) -> bytes:
+        """Encrypts the JSON payload using AES-256-GCM with a random 12-byte IV."""
+        json_payload = json.dumps(data)
+        return self.encrypt_raw_string(json_payload)
+
+    def encrypt_raw_string(self, text: str) -> bytes:
+        """Encrypts a raw string using AES-256-GCM with a random 12-byte IV."""
+        aesgcm = AESGCM(self.key)
+        iv = os.urandom(12)
+        ciphertext = aesgcm.encrypt(iv, text.encode("utf-8"), None)
+        return iv + ciphertext
+
+    def decrypt_payload(self, encrypted_data: bytes) -> str:
+        """Decrypts a response payload using AES-256-GCM."""
+        if len(encrypted_data) < 28:
+            raise ValueError("Encrypted data too short")
+        iv = encrypted_data[:12]
+        ciphertext = encrypted_data[12:]
+        aesgcm = AESGCM(self.key)
+        decrypted = aesgcm.decrypt(iv, ciphertext, None)
+        return decrypted.decode("utf-8")
+
+    async def async_get_apps(self) -> list[str]:
+        """Retrieves a list of installed apps on the TV."""
+        url = f"http://{self.host}:{self.port}/apps"
+        encrypted_body = self.encrypt_payload({})
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                url,
+                content=encrypted_body,
+                headers={"Content-Type": "application/octet-stream"},
+                timeout=10.0,
+            )
+            response.raise_for_status()
+            decrypted_resp = self.decrypt_payload(response.content)
+            return json.loads(decrypted_resp)
+
+    async def async_get_info(self) -> str:
+        """Retrieves TV info (usually the device name)."""
+        url = f"http://{self.host}:{self.port}/info"
+        encrypted_body = self.encrypt_payload({})
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                url,
+                content=encrypted_body,
+                headers={"Content-Type": "application/octet-stream"},
+                timeout=10.0,
+            )
+            response.raise_for_status()
+            return response.text
+
+    async def async_open_app(self, package_name: str) -> bool:
+        """Opens an application on the TV by package name."""
+        url = f"http://{self.host}:{self.port}/open"
+        encrypted_body = self.encrypt_raw_string(package_name)
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                url,
+                content=encrypted_body,
+                headers={"Content-Type": "application/octet-stream"},
+                timeout=10.0,
+            )
+            response.raise_for_status()
+            return response.text.strip().lower() == "true"
+
+
+    async def async_notify(
+        self,
+        message: str,
+        title: str = None,
+        sender: str = "Home Assistant",
+        duration: int = 5,
+        position: int = 0,
+        priority: int = 1,
+        bg_color: int = None,
+        title_color: int = None,
+        msg_color: int = None,
+        title_size: float = None,
+        msg_size: float = None,
+        icon: str = None,
+        small_icon: str = None,
+        big_image: str = None,
+        interact: bool = False,
+        notif_sound: bool = True,
+        wakeup: bool = True,
+    ) -> httpx.Response:
+        """Sends an encrypted notification payload asynchronously to the TV."""
+        payload = {
+            "msg": message,
+            "src": sender,
+            "duration": duration,
+            "position": position,
+            "prio": priority,
+            "interact": interact,
+            "notifSound": notif_sound,
+            "wakeup": wakeup,
+        }
+        if title:
+            payload["title"] = title
+        if bg_color is not None:
+            payload["bgColor"] = bg_color
+        if title_color is not None:
+            payload["titleColor"] = title_color
+        if msg_color is not None:
+            payload["msgColor"] = msg_color
+        if title_size is not None:
+            payload["titleSize"] = title_size
+        if msg_size is not None:
+            payload["msgSize"] = msg_size
+        if icon:
+            payload["icon"] = icon
+        if small_icon:
+            payload["smallIcon"] = small_icon
+        if big_image:
+            payload["bigImg"] = big_image
+
+        encrypted_body = self.encrypt_payload(payload)
+        url = f"http://{self.host}:{self.port}/notify"
+
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                url,
+                content=encrypted_body,
+                headers={"Content-Type": "application/octet-stream"},
+                timeout=10.0,
+            )
+            response.raise_for_status()
+            return response

atvnotif-0.1.0/atvnotif/discover.py

@@ -0,0 +1,90 @@
+import time
+import uuid
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+def decode_base58_uuid(s: str) -> str:
+    """Decodes a Base58 string into a standard UUID string."""
+    alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+    try:
+        num = 0
+        for char in s:
+            num = num * 58 + alphabet.index(char)
+        val = num.to_bytes(16, 'big')
+        return str(uuid.UUID(bytes=val))
+    except Exception as e:
+        _LOGGER.debug("Failed to decode base58 UUID from %s: %s", s, e)
+        return None
+
+def discover_devices(timeout: float = 5.0) -> list[dict]:
+    """Scans the network for ATV Notifier devices using zeroconf.
+    
+    Returns a list of dicts, e.g.:
+    [
+        {
+            "name": "Vodafone Vodafone TV 3",
+            "host": "192.168.2.104",
+            "port": 7878,
+            "pairing_code": "60ce69b0-ced7-4872-ba77-66f8dcaf8ba4"
+        }
+    ]
+    """
+    try:
+        from zeroconf import Zeroconf, ServiceBrowser
+    except ImportError:
+        _LOGGER.warning("zeroconf library is not installed. Discovery is disabled.")
+        return []
+
+    found_devices = []
+
+    class ATVNotifListener:
+        def remove_service(self, zc, type_, name):
+            pass
+
+        def update_service(self, zc, type_, name):
+            pass
+
+        def add_service(self, zc, type_, name):
+            info = zc.get_service_info(type_, name)
+            if not info:
+                return
+            
+            # Resolve properties
+            props = {}
+            for k, v in info.properties.items():
+                try:
+                    # Zeroconf keys/values might be bytes
+                    key_str = k.decode("utf-8") if isinstance(k, bytes) else str(k)
+                    val_str = v.decode("utf-8") if isinstance(v, bytes) else str(v)
+                    props[key_str] = val_str
+                except Exception:
+                    pass
+
+            name_attr = props.get("n", info.server.split(".")[0])
+            base58_uuid = props.get("i")
+            pairing_code = decode_base58_uuid(base58_uuid) if base58_uuid else None
+
+            # Get host address
+            host = None
+            if info.addresses:
+                import socket
+                # Convert first address to string
+                host = socket.inet_ntoa(info.addresses[0])
+
+            if host:
+                found_devices.append({
+                    "name": name_attr,
+                    "host": host,
+                    "port": info.port or 7878,
+                    "pairing_code": pairing_code
+                })
+
+    zc = Zeroconf()
+    listener = ATVNotifListener()
+    browser = ServiceBrowser(zc, "_atvnotif._tcp.local.", listener)
+    
+    time.sleep(timeout)
+    zc.close()
+
+    return found_devices

atvnotif-0.1.0/atvnotif/qr.py

@@ -0,0 +1,184 @@
+import base64
+import json
+import re
+import io
+import logging
+from .discover import decode_base58_uuid
+
+_LOGGER = logging.getLogger(__name__)
+
+def parse_qr_json(qr_text: str) -> dict:
+    """Decodes and parses the reversed-base64 JSON QR code content."""
+    try:
+        # First try direct base64 decode of reversed or non-reversed text
+        # The TV app reverses bytes and base64 encodes them. 
+        # When we base64 decode, we get a reversed JSON string.
+        # So we try direct base64 decode, then reverse the string.
+        for text_candidate in [qr_text, qr_text[::-1]]:
+            # Try to base64 decode
+            for pad in ['', '=', '==', '===']:
+                try:
+                    decoded_bytes = base64.b64decode(text_candidate + pad)
+                    # Try both normal and reversed byte order
+                    for byte_candidate in [decoded_bytes, decoded_bytes[::-1]]:
+                        try:
+                            decoded_str = byte_candidate.decode('utf-8')
+                            # Check if it looks like JSON
+                            if '{' in decoded_str and '}' in decoded_str:
+                                # Try parsing
+                                data = json.loads(decoded_str)
+                                if "ip" in data or "i" in data or "n" in data:
+                                    # Convert pairing code to UUID format if present
+                                    if "i" in data:
+                                        data["pairing_code"] = decode_base58_uuid(data["i"])
+                                    return data
+                        except Exception:
+                            pass
+                except Exception:
+                    pass
+    except Exception as e:
+        _LOGGER.debug("Failed parsing QR JSON from raw text %s: %s", qr_text, e)
+    return None
+
+def decode_qr_image(img_input, try_ocr: bool = True) -> dict:
+    """Decodes a QR code from a file path, bytes, or file-like object.
+    
+    If QR code decoding fails and try_ocr is True, attempts to extract
+    the IP address using OCR.
+    
+    Returns a dict with resolved properties:
+    {
+        "ip": "192.168.2.104",
+        "pairing_code": "60ce69b0-ced7-4872-ba77-66f8dcaf8ba4",
+        "name": "Vodafone Vodafone TV 3"
+    }
+    """
+    try:
+        import cv2
+        import numpy as np
+    except ImportError:
+        raise ImportError("opencv-python and numpy are required to decode QR codes. Run 'pip install opencv-python numpy'")
+
+    # Load image from path or bytes
+    img = None
+    if isinstance(img_input, str):
+        if img_input.startswith(("http://", "https://")):
+            try:
+                import urllib.request
+                req = urllib.request.Request(
+                    img_input,
+                    headers={"User-Agent": "Mozilla/5.0"}
+                )
+                with urllib.request.urlopen(req, timeout=10.0) as response:
+                    img_bytes = response.read()
+                nparr = np.frombuffer(img_bytes, np.uint8)
+                img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+            except Exception as e:
+                raise ValueError(f"Failed to fetch image from URL {img_input}: {e}")
+        else:
+            img = cv2.imread(img_input)
+    elif isinstance(img_input, bytes):
+        nparr = np.frombuffer(img_input, np.uint8)
+        img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+    elif hasattr(img_input, "read"):
+        img_bytes = img_input.read()
+        nparr = np.frombuffer(img_bytes, np.uint8)
+        img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+        
+    if img is None:
+        raise ValueError("Failed to load image from input source")
+
+    # Grayscale
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+    # Prepare candidates for QR decoding (original, inverted, adaptive threshold, etc.)
+    candidates = [
+        gray,
+        255 - gray,  # Inverted (since TV app shows white-on-black QR code)
+    ]
+    
+    # Try OTSU thresholding
+    try:
+        _, otsu = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+        candidates.append(otsu)
+        candidates.append(255 - otsu)
+    except Exception:
+        pass
+
+    # Try decoding with OpenCV QRCodeDetector
+    detector = cv2.QRCodeDetector()
+    for candidate in candidates:
+        try:
+            data, bbox, _ = detector.detectAndDecode(candidate)
+            if data:
+                parsed = parse_qr_json(data)
+                if parsed:
+                    return parsed
+        except Exception:
+            pass
+
+    # Fallback 1: Try pyzbar if installed
+    try:
+        from pyzbar.pyzbar import decode as pyzbar_decode
+        from PIL import Image
+        pil_img = Image.fromarray(gray)
+        decoded_objs = pyzbar_decode(pil_img)
+        for obj in decoded_objs:
+            qr_text = obj.data.decode("utf-8")
+            parsed = parse_qr_json(qr_text)
+            if parsed:
+                return parsed
+    except ImportError:
+        pass
+    except Exception as e:
+        _LOGGER.debug("pyzbar decoding failed: %s", e)
+
+    # Fallback 2: Try calling zbarimg CLI if available
+    # Save a temporary inverted/preprocessed version of the image to pass to zbarimg
+    import subprocess
+    import tempfile
+    import os
+    for i, candidate in enumerate(candidates):
+        try:
+            with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
+                tmp_path = tmp.name
+            cv2.imwrite(tmp_path, candidate)
+            try:
+                res = subprocess.run(["zbarimg", "-q", tmp_path], capture_output=True, text=True)
+                if res.returncode == 0:
+                    # zbarimg outputs: "QR-Code:<data>"
+                    output_text = res.stdout.strip()
+                    if output_text.startswith("QR-Code:"):
+                        qr_text = output_text[len("QR-Code:"):]
+                        parsed = parse_qr_json(qr_text)
+                        if parsed:
+                            os.remove(tmp_path)
+                            return parsed
+            finally:
+                if os.path.exists(tmp_path):
+                    os.remove(tmp_path)
+        except Exception as e:
+            _LOGGER.debug("zbarimg subprocess attempt failed for candidate %d: %s", i, e)
+
+    # OCR Fallback for IP address extraction if QR code decoding failed
+    if try_ocr:
+        try:
+            import pytesseract
+            # Try to run OCR on grayscale
+            ocr_text = pytesseract.image_to_string(gray)
+            # Find IP address pattern
+            ip_pattern = re.compile(r'\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b')
+            match = ip_pattern.search(ocr_text)
+            if match:
+                return {
+                    "ip": match.group(0),
+                    "pairing_code": None,
+                    "name": None,
+                    "ocr_extracted": True
+                }
+        except ImportError:
+            _LOGGER.debug("pytesseract is not installed; OCR fallback skipped.")
+        except Exception as e:
+            _LOGGER.debug("OCR extraction failed: %s", e)
+
+    raise ValueError("Failed to decode QR code from the image")

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

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: atvnotif
+Version: 0.1.0
+Summary: A Python client for sending encrypted notifications to Android TV Notifier
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/atvnotif/atvnotif.py
+Project-URL: Repository, https://github.com/atvnotif/atvnotif.py
+Project-URL: Bug Tracker, https://github.com/atvnotif/atvnotif.py/issues
+Keywords: android-tv,notifications,home-automation,atvnotif
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Operating System :: OS Independent
+Classifier: Topic :: Home Automation
+Classifier: Topic :: Communications
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=35.0.0
+Requires-Dist: httpx>=0.20.0
+Requires-Dist: zeroconf>=0.33.0
+
+# atvnotif
+
+[![PyPI](https://img.shields.io/pypi/v/atvnotif)](https://pypi.org/project/atvnotif/)
+[![Supported Python Versions](https://img.shields.io/pypi/pyversions/atvnotif)](https://pypi.org/project/atvnotif/)
+[![License](https://img.shields.io/github/license/atvnotif/atvnotif.py)](https://github.com/atvnotif/atvnotif.py/blob/main/LICENSE)
+
+A Python client library for sending encrypted notifications to the **Android TV Notifier** app (`com.smrtprjcts.atvnotif`).
+
+## Installation
+
+```bash
+pip install atvnotif
+```
+
+## Usage
+
+```python
+import asyncio
+from atvnotif import ATVNotifier
+
+async def main():
+    # Replace with your TV's IP address and pairing code (remove hyphens or leave them, the library cleans it)
+    notifier = ATVNotifier("192.168.1.100", "1234-5678-ABCD")
+    
+    await notifier.async_notify(
+        message="Someone is at the door!",
+        title="Doorbell Alert",
+        duration=10,
+        position=0,  # Top-Right
+        notif_sound=True
+    )
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

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

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+atvnotif/__init__.py
+atvnotif/client.py
+atvnotif/discover.py
+atvnotif/qr.py
+atvnotif.egg-info/PKG-INFO
+atvnotif.egg-info/SOURCES.txt
+atvnotif.egg-info/dependency_links.txt
+atvnotif.egg-info/requires.txt
+atvnotif.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,3 @@
+cryptography>=35.0.0
+httpx>=0.20.0
+zeroconf>=0.33.0

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

@@ -0,0 +1 @@
+atvnotif

atvnotif-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "atvnotif"
+version = "0.1.0"
+description = "A Python client for sending encrypted notifications to Android TV Notifier"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+keywords = ["android-tv", "notifications", "home-automation", "atvnotif"]
+dependencies = [
+    "cryptography>=35.0.0",
+    "httpx>=0.20.0",
+    "zeroconf>=0.33.0"
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+    "Topic :: Home Automation",
+    "Topic :: Communications",
+    "Framework :: AsyncIO",
+]
+
+[project.urls]
+Homepage = "https://github.com/atvnotif/atvnotif.py"
+Repository = "https://github.com/atvnotif/atvnotif.py"
+"Bug Tracker" = "https://github.com/atvnotif/atvnotif.py/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["atvnotif*"]

atvnotif-0.1.0/setup.cfg

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