phue2 0.0.1.dev279__py3-none-any.whl

phue2/__init__.py

@@ -0,0 +1,37 @@
+"""
+phue2 - A modernized Philips Hue Python library
+Based on the original phue by Nathanaël Lécaudé
+Original protocol hacking by rsmck: http://rsmck.co.uk/hue
+
+Published under the MIT license
+
+"Hue Personal Wireless Lighting" is a trademark owned by Koninklijke Philips Electronics N.V.
+"""
+
+from .exceptions import PhueException, PhueRegistrationException, PhueRequestTimeout
+from .light import Light
+from .sensor import Sensor, SensorState, SensorConfig
+from .group import Group, AllLights
+from .scene import Scene
+from .bridge import Bridge
+from ._internal.console import console
+
+import logging
+
+logger = logging.getLogger("phue2")
+
+
+__all__ = [
+    "Bridge",
+    "PhueException",
+    "PhueRegistrationException",
+    "PhueRequestTimeout",
+    "Light",
+    "Group",
+    "AllLights",
+    "Scene",
+    "Sensor",
+    "SensorState",
+    "SensorConfig",
+    "console",
+]

phue2/__main__.py

@@ -0,0 +1,408 @@
+"""Command-line interface for the phue library."""
+
+import argparse
+import json
+import logging
+import os
+import sys
+
+from phue2 import Bridge, PhueRegistrationException
+from phue2._internal.console import (
+    BLUE,
+    BOLD,
+    CYAN,
+    GREEN,
+    MAGENTA,
+    RED,
+    YELLOW,
+    console,
+    styled_text,
+)
+
+DISABLE_STYLING = False
+
+
+def styled_for_cli(text: str, style: str) -> str:
+    """Apply styling if enabled, otherwise return plain text.
+
+    This helper makes tests less brittle by allowing them to match
+    on the plain text content.
+
+    Args:
+        text: Text to style
+        style: Style to apply
+
+    Returns:
+        Styled text if styling is enabled, otherwise plain text
+    """
+    if DISABLE_STYLING:
+        return text
+    return styled_text(text, style)
+
+
+def parse_args(
+    argv: list[str] | None = None,
+) -> tuple[argparse.ArgumentParser, argparse.Namespace]:
+    """Parse command line arguments.
+
+    Args:
+        argv: Command line arguments (defaults to sys.argv[1:])
+
+    Returns:
+        Tuple of (parser, parsed_args)
+    """
+    # Set up argument parser
+    parser = argparse.ArgumentParser(
+        description="Control Philips Hue lights from the command line"
+    )
+    parser.add_argument(
+        "--host", help="IP address of the Hue bridge (auto-detected if not provided)"
+    )
+    parser.add_argument("--config-file-path", help="Path to the config file")
+    parser.add_argument("--debug", action="store_true", help="Enable debug logging")
+
+    # Command subparsers
+    subparsers = parser.add_subparsers(dest="command", help="Command to execute")
+
+    # List command (with ls alias)
+    list_parser = subparsers.add_parser(
+        "list", aliases=["ls"], help="List available resources"
+    )
+    list_parser.add_argument(
+        "resource",
+        nargs="?",
+        choices=["lights", "groups", "scenes"],
+        default="lights",
+        help="Resource type to list",
+    )
+
+    # Get command
+    get_parser = subparsers.add_parser("get", help="Get resource details")
+    get_parser.add_argument(
+        "resource", choices=["light", "group", "scene"], help="Resource type"
+    )
+    get_parser.add_argument("name", help="Resource name or ID")
+
+    # Set command
+    set_parser = subparsers.add_parser("set", help="Set resource state")
+    set_parser.add_argument(
+        "resource", choices=["light", "group"], help="Resource type"
+    )
+    set_parser.add_argument("name", help="Resource name or ID")
+    set_parser.add_argument("--on", action="store_true", help="Turn on")
+    set_parser.add_argument("--off", action="store_true", help="Turn off")
+    set_parser.add_argument("--bri", type=int, help="Set brightness (0-254)")
+    set_parser.add_argument("--hue", type=int, help="Set hue (0-65535)")
+    set_parser.add_argument("--sat", type=int, help="Set saturation (0-254)")
+
+    # Parse arguments
+    return parser, parser.parse_args(argv)
+
+
+def get_bridge_from_config(config_path: str | None = None) -> Bridge | None:
+    """Attempt to create a Bridge using existing config.
+
+    Args:
+        config_path: Path to config file (uses default if None)
+
+    Returns:
+        Bridge instance if successful, None otherwise
+    """
+    if not config_path:
+        config_path = os.path.expanduser("~/.python_hue")
+
+    if not os.path.exists(config_path):
+        return None
+
+    try:
+        with open(config_path) as f:
+            config = json.loads(f.read())
+
+        # Try each bridge in the config
+        for ip in config:
+            if "username" in config[ip]:
+                try:
+                    bridge = Bridge(ip=ip, config_file_path=config_path)
+                    console.info(
+                        f"{styled_for_cli('Using saved connection to bridge at', MAGENTA)} {styled_for_cli(ip, YELLOW)}"
+                    )
+                    return bridge
+                except Exception:
+                    continue
+    except Exception:
+        pass
+
+    return None
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Run the phue command-line interface.
+
+    Args:
+        argv: Command line arguments (defaults to sys.argv[1:])
+
+    Returns:
+        Exit code
+    """
+    # Parse arguments
+    parser, args = parse_args(argv)
+
+    # Configure logging
+    log_level = logging.DEBUG if args.debug else logging.WARNING
+    logging.basicConfig(level=log_level)
+
+    # Get bridge - first try config if no host specified
+    bridge = None
+    if not args.host:
+        bridge = get_bridge_from_config(args.config_file_path)
+
+    # If not connected and host provided, connect to specified host
+    if not bridge and args.host:
+        console.info(f"Connecting to bridge at {args.host}...")
+        while True:
+            try:
+                bridge = Bridge(args.host, config_file_path=args.config_file_path)
+                console.success("Successfully connected to the bridge!")
+                break
+            except PhueRegistrationException:
+                console.warning(
+                    "Link button not pressed. Press the link button on your bridge."
+                )
+                input("Press Enter to try again...")
+            except Exception as e:
+                console.error(f"Failed to connect to the bridge: {e}")
+                return 1
+
+    # If we still don't have a bridge but command specified, error out
+    if not bridge and args.command:
+        console.error(
+            "No bridge connection available. Please specify --host or ensure config file exists."
+        )
+        return 1
+
+    # If we still don't have a bridge and no command specified, show general help
+    if not bridge and not args.command:
+        console.error(
+            "No bridge connection available. Please specify --host or ensure config file exists."
+        )
+        args_parser = argparse.ArgumentParser(
+            description="Control Philips Hue lights from the command line"
+        )
+        args_parser.print_help()
+        return 1
+
+    # If no command specified but we have a bridge, show command help
+    if bridge and not args.command:
+        console.info(
+            f"{styled_for_cli('Connected to bridge.', GREEN)} {styled_for_cli('Use a command to continue.', CYAN)}"
+        )
+        parser.print_help()
+        return 0
+
+    # Process commands
+
+    # Handle list/ls command
+    if args.command in ["list", "ls"]:
+        if not bridge:
+            console.error("No bridge connection available")
+            return 1
+
+        if args.resource == "lights":
+            lights = bridge.lights
+            console.info(styled_for_cli(f"LIGHTS ({len(lights)}):", YELLOW + BOLD))
+            for light in lights:
+                status = "ON" if light.on else "OFF"
+                status_styled = styled_for_cli(status, GREEN if light.on else RED)
+                name = str(light.name)
+                name_styled = styled_for_cli(name, CYAN)
+                console.info(f"  {name_styled:<25} {status_styled}")
+
+        elif args.resource == "groups":
+            groups = bridge.groups
+            console.info(styled_for_cli(f"GROUPS ({len(groups)}):", YELLOW + BOLD))
+            for group in groups:
+                name = str(group.name)
+                name_styled = styled_for_cli(name, CYAN)
+                console.info(f"  {name_styled}")
+
+        elif args.resource == "scenes":
+            scenes = bridge.scenes
+            console.info(styled_for_cli(f"SCENES ({len(scenes)}):", YELLOW + BOLD))
+            for scene in scenes:
+                name = str(scene.name)
+                name_styled = styled_for_cli(name, CYAN)
+                console.info(f"  {name_styled}")
+
+    # Handle get command
+    elif args.command == "get":
+        if not bridge:
+            console.error("No bridge connection available")
+            return 1
+
+        resource = args.resource
+        name = args.name
+
+        if resource == "light":
+            # Try by ID first, then by name
+            light = None
+            try:
+                light_id = int(name)
+                light = bridge.lights_by_id.get(light_id)
+            except ValueError:
+                pass
+
+            if not light:
+                light = bridge.lights_by_name.get(name)
+
+            if not light:
+                console.error(f"Light '{name}' not found")
+                return 1
+
+            console.info(styled_for_cli(f"LIGHT: {light.name}", YELLOW + BOLD))
+            console.info(
+                f"  {styled_for_cli('Status:', BLUE)}      {styled_for_cli('ON' if light.on else 'OFF', GREEN if light.on else RED)}"
+            )
+            console.info(f"  {styled_for_cli('Type:', BLUE)}        {light.type}")
+            console.info(
+                f"  {styled_for_cli('Brightness:', BLUE)}  {light.brightness}/254"
+            )
+            console.info(f"  {styled_for_cli('Hue:', BLUE)}         {light.hue}/65535")
+            console.info(
+                f"  {styled_for_cli('Saturation:', BLUE)}  {light.saturation}/254"
+            )
+            console.info(f"  {styled_for_cli('Reachable:', BLUE)}   {light.reachable}")
+
+        elif resource == "group":
+            # Try to find group by name
+            group_id = None
+            try:
+                group_id = bridge.get_group_id_by_name(name)
+            except Exception:
+                pass
+
+            if group_id is None:
+                try:
+                    group_id = int(name)
+                except ValueError:
+                    group_id = None
+
+            if group_id is None:
+                console.error(f"Group '{name}' not found")
+                return 1
+
+            group = bridge.get_group(group_id)
+
+            console.info(styled_for_cli(f"GROUP: {group['name']}", YELLOW + BOLD))
+            console.info(f"  {styled_for_cli('Type:', BLUE)}    {group['type']}")
+            console.info(
+                f"  {styled_for_cli('Lights:', BLUE)}  {', '.join(group['lights'])}"
+            )
+
+        elif resource == "scene":
+            # This needs bridge.get_scene() implementation which isn't shown
+            console.error("Scene details not yet implemented")
+            return 1
+
+    # Handle set command
+    elif args.command == "set":
+        if not bridge:
+            console.error("No bridge connection available")
+            return 1
+
+        resource = args.resource
+        name = args.name
+        changed = False
+
+        if resource == "light":
+            # Try by ID first, then by name
+            light = None
+            try:
+                light_id = int(name)
+                light = bridge.lights_by_id.get(light_id)
+            except ValueError:
+                pass
+
+            if not light:
+                light = bridge.lights_by_name.get(name)
+
+            if not light:
+                console.error(f"Light '{name}' not found")
+                return 1
+
+            # Apply state changes
+            if args.on:
+                light.on = True
+                changed = True
+            elif args.off:
+                light.on = False
+                changed = True
+
+            if args.bri is not None:
+                light.brightness = args.bri
+                changed = True
+
+            if args.hue is not None:
+                light.hue = args.hue
+                changed = True
+
+            if args.sat is not None:
+                light.saturation = args.sat
+                changed = True
+
+            if changed:
+                console.success(f"Updated light '{light.name}'")
+            else:
+                console.warning("No changes specified")
+
+        elif resource == "group":
+            # Try to find group by name
+            group_id = None
+            try:
+                group_id = bridge.get_group_id_by_name(name)
+            except Exception:
+                pass
+
+            if group_id is None:
+                try:
+                    group_id = int(name)
+                except ValueError:
+                    group_id = None
+
+            if group_id is None:
+                console.error(f"Group '{name}' not found")
+                return 1
+
+            # Apply state changes
+            state_changes: dict[str, object] = {}
+            changed = False
+
+            if args.on:
+                state_changes["on"] = True
+                changed = True
+            elif args.off:
+                state_changes["on"] = False
+                changed = True
+
+            if args.bri is not None:
+                state_changes["bri"] = args.bri
+                changed = True
+
+            if args.hue is not None:
+                state_changes["hue"] = args.hue
+                changed = True
+
+            if args.sat is not None:
+                state_changes["sat"] = args.sat
+                changed = True
+
+            if changed:
+                bridge.set_group(group_id, state_changes)
+                console.success(f"Updated group {name}")
+            else:
+                console.warning("No changes specified")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

phue2/_internal/__init__.py

@@ -0,0 +1 @@
+"""Utilities for the phue package."""

phue2/_internal/console.py

@@ -0,0 +1,175 @@
+"""Terminal utilities for displaying colorful output in the console."""
+
+from __future__ import annotations
+
+import platform
+from collections.abc import Callable
+from typing import TypeVar
+
+# Check if we're running on Windows
+COLORS_ENABLED = platform.system() != "Windows"
+
+# ANSI color/style codes - used only if COLORS_ENABLED is True
+RESET = "\033[0m"
+BOLD = "\033[1m"
+GREEN = "\033[32m"
+YELLOW = "\033[33m"
+RED = "\033[31m"
+BLUE = "\033[34m"
+CYAN = "\033[36m"
+MAGENTA = "\033[35m"
+
+
+def styled_text(text: str, *styles: str) -> str:
+    """Apply ANSI styles to text if colors are enabled.
+
+    Args:
+        text: The text to style
+        *styles: ANSI style codes to apply
+
+    Returns:
+        The styled text, or the original text if colors are disabled
+    """
+    if not COLORS_ENABLED or not styles:
+        return text
+
+    style = "".join(styles)
+    return f"{style}{text}{RESET}"
+
+
+def create_printer(style: str) -> Callable[[str], None]:
+    """Create a function that prints text with the given style.
+
+    Args:
+        style: ANSI style code (will be ignored on Windows)
+
+    Returns:
+        A function that prints text with the given style if supported
+    """
+
+    def printer(text: str) -> None:
+        print(styled_text(text, style))
+
+    return printer
+
+
+print_success = create_printer(f"{GREEN}{BOLD}")
+print_info = create_printer(CYAN)
+print_error = create_printer(f"{RED}{BOLD}")
+print_warning = create_printer(f"{YELLOW}{BOLD}")
+print_header = create_printer(f"{BLUE}{BOLD}")
+
+
+T = TypeVar("T")
+
+
+class TerminalUI:
+    """A simple UI class for terminal-based interfaces."""
+
+    @staticmethod
+    def header(title: str) -> None:
+        """Print a header with a title.
+
+        Args:
+            title: The title to display
+        """
+        print(f"\n{styled_text('╔' + '═' * 50 + '╗', BLUE, BOLD)}")
+        print(
+            f"{styled_text('║', BLUE, BOLD)} {styled_text(title.center(48), CYAN, BOLD)} {styled_text('║', BLUE, BOLD)}"
+        )
+        print(f"{styled_text('╚' + '═' * 50 + '╝', BLUE, BOLD)}")
+
+    @staticmethod
+    def section(title: str) -> None:
+        """Print a section divider with a title.
+
+        Args:
+            title: The title to display
+        """
+        print(f"\n{styled_text(f'▓▒░ {title} ░▒▓', YELLOW, BOLD)}")
+
+    @staticmethod
+    def success(message: str) -> None:
+        """Print a success message.
+
+        Args:
+            message: The message to display
+        """
+        print(f"{styled_text(f'✓ {message}', GREEN, BOLD)}")
+
+    @staticmethod
+    def info(message: str) -> None:
+        """Print an info message.
+
+        Args:
+            message: The message to display
+        """
+        print(f"{styled_text(message, CYAN)}")
+
+    @staticmethod
+    def error(message: str) -> None:
+        """Print an error message.
+
+        Args:
+            message: The message to display
+        """
+        print(f"{styled_text(f'✗ {message}', RED, BOLD)}")
+
+    @staticmethod
+    def warning(message: str) -> None:
+        """Print a warning message.
+
+        Args:
+            message: The message to display
+        """
+        print(f"{styled_text(f'⚠ {message}', YELLOW, BOLD)}")
+
+    @staticmethod
+    def box(title: str, messages: list[str], style: str = MAGENTA) -> None:
+        """Print a box with a title and messages.
+
+        Args:
+            title: The box title
+            messages: The messages to display inside the box
+            style: ANSI style code for the box
+        """
+        # Find the longest message to size the box
+        width = max(len(title), max(len(m) for m in messages)) + 4
+
+        # Print the box
+        print(
+            f"{styled_text(f'┌─ {title} ' + '─' * (width - len(title) - 4) + '┐', style, BOLD)}"
+        )
+        for msg in messages:
+            print(
+                f"{styled_text(f'│ {msg}' + ' ' * (width - len(msg) - 2) + '│', style, BOLD)}"
+            )
+        print(f"{styled_text('└' + '─' * (width - 2) + '┘', style, BOLD)}")
+
+    @staticmethod
+    def table(
+        items: list[T], formatter: Callable[[T], str], border_style: str = CYAN
+    ) -> None:
+        """Print a simple table of items.
+
+        Args:
+            items: List of items to display
+            formatter: Function to format each item
+            border_style: ANSI style code for the table border
+        """
+        if not items:
+            print(styled_text("No items to display", CYAN))
+            return
+
+        # Create header and footer
+        print(f"{styled_text('╭─ Items ' + '─' * 40 + '╮', border_style)}")
+
+        # Print each item
+        for item in items:
+            print(f"{styled_text('│', border_style)} {formatter(item)}")
+
+        # Footer
+        print(f"{styled_text('╰' + '─' * 48 + '╯', border_style)}")
+
+
+console = TerminalUI()