tradfri

#!/usr/bin/env python3
import asyncio
import logging, sys

from ikeatradfri import cli, config, console, devices, exceptions, signal_handler

from pytradfri import Gateway
from pytradfri.api.aiocoap_api import APIFactory
from pytradfri import error as pyerror

from concurrent.futures import CancelledError


hostConfig = {}


def hexToRgb(hex):
    rgb = {}

    rgb["red"] = int(hex[:2], 16)
    rgb["green"] = int(hex[2:4], 16)
    rgb["blue"] = int(hex[-2:], 16)

    return rgb


async def run(args):

    api_factory = APIFactory(
        hostConfig["Gateway"], hostConfig["Identity"], hostConfig["Passkey"]
    )
    api = api_factory.request
    gateway = Gateway()

    try:
        if args.command == "on":
            device = await devices.get_device(api, gateway, args.ID)
            await device.set_state(True)

        if args.command == "off":
            device = await devices.get_device(api, gateway, args.ID)
            await device.set_state(False)

        if args.command == "name":
            device = await devices.get_device(api, gateway, args.ID)
            await device.set_name(args.NAME)

        if args.command == "level":
            device = await devices.get_device(api, gateway, args.ID)
            await device.set_level(args.value, transition_time=args.transition_time)

        if args.command == "wb":
            device = await devices.get_device(api, gateway, args.ID)
            from ikeatradfri.colors import hex_whites

            for key, a in hex_whites.items():
                if a["Name"].lower() == args.value.lower():
                    await device.set_hex(a["Hex"], args.transition_time)
                    break

        if args.command == "hex":
            from ikeatradfri import colors

            device = await devices.get_device(api, gateway, args.ID)
            if args.value == "show":
                print(
                    "Current hex: {} ({}) in colorspace: {}".format(
                        device.hex,
                        colors.color_name_for_hex(device.hex, device.colorspace),
                        device.colorspace,
                    )
                )
                if args.list:
                    print(colors.list_hexes(device.colorspace))
            else:
                await device.set_hex(args.value.lower(), args.transition_time)

        if args.command == "list":
            await console.list_devices(api, gateway, expand_groups=args.expand_groups)

        if args.command == "pair":
            from ikeatradfri import pair

            shutdown = asyncio.Future()
            await pair.pair(api_factory, shutdown)

        if args.command == "raw":
            device = await devices.get_device(api, gateway, args.ID)
            print(device.raw)

        if args.command == "hsb":
            device = await devices.get_device(api, gateway, args.ID)
            await device.set_hsb(
                int(args.hue) * 65535 / 360,
                int(args.saturation) * 65279 / 100,
                args.brightness,
            )

        if args.command == "rgb":
            device = await devices.get_device(api, gateway, args.ID)
            await device.set_rgb(args.red, args.green, args.blue)

        if args.command == "test":
            device = await devices.get_device(api, gateway, 65551)
            print(device.hex)

        if args.command == "color":
            from ikeatradfri import colors

            device = await devices.get_device(api, gateway, args.ID)

            if args.color_command == "list":
                print(colors.list_hexes(colorspace=device.colorspace, levels=True))

            if args.color_command == "set":
                device = await devices.get_device(api, gateway, args.ID)
                await device.set_hex(
                    colors.color(level=args.color, colorspace=device.colorspace)["Hex"]
                )

    except devices.UnsupportedDeviceCommand:
        logging.error(
            "Unsupported command '{0}' for device {1}".format(args.command, args.ID)
        )

    except pyerror.ClientError:
        logging.critical("Device not found")

    except Exception:
        raise

    await api_factory.shutdown()


def exception_handler(loop, context):
    print("Caught the following exception")
    print(context["message"])
    # print(context['exception'])


if __name__ == "__main__":

    args, parser = cli.getArgs()

    if args.version:
        print("{} version {}".format(parser.prog, cli.get_version()))
        exit()

    if args.debug:
        logging.basicConfig(format="%(levelname)s:%(message)s", level=logging.DEBUG)
    elif args.verbose:
        logging.basicConfig(format="%(levelname)s:%(message)s", level=logging.INFO)
    else:
        logging.basicConfig(format="%(levelname)s:%(message)s", level=logging.CRITICAL)

    loop = asyncio.get_event_loop()
    if args.verbose is None and args.debug is None:
        loop.set_exception_handler(exception_handler)
    # loop.set_debug(True)

    if args.command == "config":
        config.handle_config_command(args)
        exit()

    try:
        hostConfig = config.get_config(args)
    except exceptions.ConfigNotFound:
        logging.critical("No config file found!")
        exit()
    except exceptions.NoGatewaySpecified:
        logging.critical("No gateway specified!")
        exit()

    try:
        if args.command == "service":
            from ikeatradfri import service

            if args.service_command == "create":
                service.create_service_file(args.user, args.group)
                exit()
            else:
                service.show_service_file()

        if args.command == "server":
            from ikeatradfri import tcp_server
            from ikeatradfri import http_server

            loop = asyncio.get_event_loop()
            loop.create_task(signal_handler.handle_signals(loop))

            server = {
                "Tcp": lambda: loop.create_task(
                    tcp_server.tcp_server().main(hostConfig)
                ),
                "Http": lambda: loop.create_task(http_server.start(hostConfig)),
                "Both": lambda: loop.create_task(
                    tcp_server.tcp_server().main(hostConfig)
                )
                and loop.create_task(http_server.start(hostConfig)),
            }

            server.get(hostConfig["Server_type"], lambda: "nothing")()
            loop.run_forever()

        elif args.command == "observe":
            from ikeatradfri import observe

            loop.create_task(signal_handler.handle_signals(loop))
            loop.create_task(observe.observe())
            loop.run_forever()
        else:
            loop.run_until_complete(run(args))
    except KeyboardInterrupt:
        print("Received exit, exiting")
    except CancelledError:
        logging.debug("Cancelled")
        loop.stop()
    except exceptions.ConfigNotFound:
        print("NoConfig")
        pass
    except pyerror.ServerError:
        logging.critical("Gateway error!")
    except pyerror.RequestTimeout:
        logging.error("Gateway error: Timeout")