vsslctrl 0.1.0.dev1__py3-none-any.whl

vsslctrl/core.py

@@ -0,0 +1,322 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import asyncio
+from typing import Dict, Union, List
+
+from .zone import Zone
+from .exceptions import VsslCtrlException, ZoneError, ZeroConfNotInstalled
+from .event_bus import EventBus
+from .settings import VsslSettings
+from .decorators import logging_helpers
+from .discovery import check_zeroconf_availability, fetch_zone_id_serial
+from .data_structure import DeviceModels
+
+
+@logging_helpers("VSSL:")
+class Vssl:
+    ENTITY_ID = 0
+
+    #
+    # VSSL Events
+    #
+    class Events:
+        PREFIX = "vssl."
+        MODEL_CHANGE = PREFIX + "model_changed"
+        MODEL_ZONE_QTY_CHANGE = PREFIX + "model_zone_qty_changed"
+        SW_VERSION_CHANGE = PREFIX + "sw_version_changed"
+        SERIAL_CHANGE = PREFIX + "serial_changed"
+        ALL = EventBus.WILDCARD
+
+    def __init__(
+        self,
+        model: DeviceModels = None,
+        zones: Union[str, List[str]] = None,
+    ):
+        self.event_bus = EventBus()
+        self.zones = {}
+        self._sw_version = None
+        self._serial = None
+        self._model = None
+        self._model_zone_qty = 0
+        self.settings = VsslSettings(self)
+
+        self.model = model
+
+        # Add zones if any are passed
+        if zones:
+            self.add_zones(zones)
+
+    #
+    # Initialise the zones
+    #
+    # We init all the zones sequentially, so we can do some error checking
+    # and fail if any of the zones are in error
+    #
+    async def initialise(self, init_timeout: int = 10):
+        if len(self.zones) < 1:
+            raise VsslCtrlException("No zones were added to VSSL before calling run()")
+
+        zones_to_init = self.zones.copy()
+
+        try:
+            key, first_zone = zones_to_init.popitem()
+
+            # If we pass a model to the zone, the zone count will be worked out from that,
+            # otherwise we will try and work it out once we receive some info about he device
+            if self.model_zone_qty is None:
+                future_model_zone_qty = self.event_bus.future(
+                    self.Events.MODEL_ZONE_QTY_CHANGE, self.ENTITY_ID
+                )
+
+            # Lets make sure the zone is initialised, otherwsie we fail all
+            await first_zone.initialise()
+
+            # Only continue after we now how many zones the device supports
+            try:
+                if self.model_zone_qty is None:
+                    await asyncio.wait_for(future_model_zone_qty, timeout=init_timeout)
+
+                if len(self.zones) > self.model_zone_qty:
+                    raise VsslCtrlException("")
+
+            except asyncio.TimeoutError:
+                message = f"Timed out waiting for model infomation from zone {first_zone.id}, exiting!"
+                self._log_critical(message)
+                await first_zone.disconnect()
+                raise VsslCtrlException(message)
+
+            except VsslCtrlException:
+                message = f"Device model only has {self.model_zone_qty} zones instead of {len(self.zones)}"
+                self._log_critical(message)
+                await first_zone.disconnect()
+                raise VsslCtrlException(message)
+
+            # Now we can init the rest of the zones
+            initialisations = [zone.initialise() for zone in zones_to_init.values()]
+            await asyncio.gather(*initialisations)
+
+        except ZoneError as e:
+            message = f"Error occured while initialising zones {e}"
+            self._log_critical(e)
+            await self.disconnect()
+            raise
+
+        return True
+
+    #
+    # Shutdown
+    #
+    async def shutdown(self):
+        await self.disconnect()
+        self.event_bus.stop()
+
+    #
+    # Discover host on the network using zero_conf package
+    #
+    async def discover(self, *args):
+        try:
+            check_zeroconf_availability()
+
+            from .discovery import VsslDiscovery
+
+            service = VsslDiscovery(*args)
+            return await service.discover()
+        except ZeroConfNotInstalled as e:
+            self._log_error(e)
+            raise
+
+    #
+    # Update a property and fire the event
+    #
+    #
+    # TODO, use the ZoneDataClass here too? Needs some reconfig
+    #
+    def _set_property(self, property_name: str, new_value):
+        current_value = getattr(self, property_name)
+        if current_value != new_value:
+            setattr(self, f"_{property_name}", new_value)
+            self.event_bus.publish(
+                getattr(self.Events, property_name.upper() + "_CHANGE"),
+                self.ENTITY_ID,
+                getattr(self, property_name),
+            )
+            self._log_debug(f"Set {property_name}: {getattr(self, property_name)}")
+
+    #
+    # Software Version
+    #
+    @property
+    def sw_version(self):
+        return self._sw_version
+
+    @sw_version.setter
+    def sw_version(self, sw: str):
+        pass  # read-only
+
+    #
+    # Serial Number
+    #
+    @property
+    def serial(self):
+        return self._serial
+
+    @serial.setter
+    def serial(self, serial: str):
+        pass  # read-only
+
+    #
+    # Model of the device
+    #
+    @property
+    def model(self):
+        return self._model
+
+    @model.setter
+    def model(self, model: str):
+        if self.model != model:
+            if DeviceModels.is_valid(model):
+                self._set_property("model", DeviceModels(model))
+            else:
+                message = f"DeviceModels {model} doesnt exist"
+                self._log_error(message)
+                raise VsslCtrlException(message)
+
+    #
+    # The amount of zones this VSSL has. This is not how many zones have been initialised
+    # but how many zones the model has in total. We can have 1, 3 or 6 zones.
+    #
+    @property
+    def model_zone_qty(self):
+        if not self._model_zone_qty and self.model is not None:
+            self._model_zone_qty = DeviceModels.zone_count(self.model.value)
+
+        return self._model_zone_qty
+
+    @model_zone_qty.setter
+    def model_zone_qty(self, model_zone_qty: int):
+        pass  # read-only
+
+    #
+    # Work out the model_zone_qty given device info
+    #
+    def _infer_model_zone_qty(self, data: Dict[str, int]):
+        if not self.model_zone_qty:
+            zone_count = sum(
+                1 for key in data if key.startswith("B") and key.endswith("Src")
+            )
+
+            if zone_count in (1, 3, 6):
+                self._model_zone_qty = zone_count
+            else:
+                self._model_zone_qty = 1
+
+            self.event_bus.publish(
+                self.Events.MODEL_ZONE_QTY_CHANGE, self.ENTITY_ID, self.model_zone_qty
+            )
+
+    #
+    # Disconnect / Shutdown
+    #
+    async def disconnect(self):
+        for zone in self.zones.values():
+            await zone.disconnect()
+
+    #
+    # Add a Zones using a List, index emplys the zone ID
+    #
+    def add_zones(self, zones=Union[str, List[str]]):
+        zones_list = [zones] if isinstance(zones, str) else zones
+
+        for index, ip in enumerate(zones_list):
+            self.add_zone(index + 1, ip)
+
+    #
+    # Add a Zone
+    #
+    def add_zone(self, zone_index: "Zone.IDs", host: str):
+        if Zone.IDs.is_not_valid(zone_index):
+            error = f"Zone.IDs {zone_index} doesnt exist"
+            self._log_error(error)
+            raise ZoneError(error)
+            return None
+
+        if zone_index in self.zones:
+            error = f"Zone {zone_index} already exists"
+            self._log_error(error)
+            raise ZoneError(error)
+            return None
+
+        # Check if any object in the dictionary has the specified value for the
+        # property
+        if any(zone.host == host for zone in self.zones.values()):
+            error = f"Zone with IP {host} already exists"
+            self._log_error(error)
+            raise ZoneError(error)
+            return None
+
+        self.zones[zone_index] = Zone(self, zone_index, host)
+
+        return self.zones[zone_index]
+
+    #
+    # Get a Zone by ID
+    #
+    def get_zone(self, zone_index: "Zone.IDs"):
+        if zone_index in self.zones:
+            return self.zones[zone_index]
+        else:
+            return None
+
+    #
+    # Get a Zone by group index
+    #
+    def get_zones_by_group_index(self, group_index: int):
+        zones = {}
+        if self.zones:
+            for zone_id in self.zones:
+                zone = self.zones[zone_id]
+                if zone.group.index == group_index:
+                    zones[zone_id] = zone
+        return zones
+
+    #
+    # Get a Zone that is connected to its APIs
+    #
+    def get_connected_zone(self):
+        if self.zones:
+            for zone_id in self.zones:
+                zone = self.zones[zone_id]
+                if zone.connected:
+                    return zone
+
+    #
+    # Get the device name
+    #
+    def _request_name(self):
+        zone = self.get_connected_zone()
+        if zone:
+            zone.api_alpha.request_action_19()
+
+    #
+    # Reboot Device (All Zones)
+    #
+    def reboot(self):
+        zone = self.get_connected_zone()
+        if zone:
+            zone.api_alpha.request_action_33_device()
+
+    #
+    # Zones Groups. Build a dict of zone according to group membership
+    #
+    @property
+    def zone_groups(self):
+        MASTER = "master"
+        MEMBERS = "members"
+
+        groups = []
+        for zone in self.zones.values():
+            if zone.group.is_master:
+                groups.append({MASTER: zone, MEMBERS: zone.group.members})
+
+        return groups

vsslctrl/data_structure.py

@@ -0,0 +1,242 @@
+import re
+from enum import Enum, IntEnum
+from abc import ABC, abstractmethod
+from .decorators import sterilizable
+
+
+class VsslEnum(Enum):
+    @classmethod
+    def is_valid(cls, value):
+        try:
+            cls(value)
+            return True
+        except ValueError:
+            return False
+
+    @classmethod
+    def is_not_valid(cls, value):
+        return not cls.is_valid(value)
+
+    @classmethod
+    def get(cls, value, default=None):
+        try:
+            return cls(value)
+        except ValueError:
+            return default
+
+
+class VsslIntEnum(VsslEnum, IntEnum):
+    """IntEnum"""
+
+
+class DeviceModels(VsslEnum):
+    A1 = "a1"
+    A3 = "a3"
+    A6 = "a6"
+    A1X = "a1x"
+    A3X = "a3x"
+    A6X = "a6x"
+
+    @staticmethod
+    # Get the amount of zones the model has by pulling out the number in the model
+    def zone_count(model: str):
+        if DeviceModels.is_valid(model.lower()):
+            pattern = r"\d+"
+            match = re.search(pattern, model)
+            if match:
+                number = int(match.group())
+                return number
+        return 1
+
+
+""" JSON Structure
+
+ DO NOT CHANGE - VSSL Defined
+
+ {'B1Src': '3', 'B2Src': '4', 'B3Src': '5', 'B1Nm': '', 'B2Nm': 'Optical In', 'dev': 'Device Name', 'ver': 'p15305.016.3701'}
+
+"""
+
+
+class DeviceStatusExtKeys:
+    ANALOG_OUTPUT_1_SOURCE = "B1Src"
+    ANALOG_OUTPUT_2_SOURCE = "B2Src"
+    ANALOG_OUTPUT_3_SOURCE = "B3Src"
+    ANALOG_OUTPUT_4_SOURCE = "B4Src"
+    ANALOG_OUTPUT_5_SOURCE = "B5Src"
+    ANALOG_OUTPUT_6_SOURCE = "B6Src"
+    UNKNOWN = "B1Nm"  # Party mode bus?
+    OPTICAL_INPUT_NAME = "B2Nm"  # For A.3x this is the optical input name
+    DEVICE_NAME = "dev"
+    SW_VERSION = "ver"
+
+    @staticmethod
+    def add_zone_to_bus_key(zone_id: int):
+        return f"B{zone_id}Src"
+
+
+""" JSON Structure
+
+ DO NOT CHANGE - VSSL Defined
+
+ {'id': '1', 'ac': '0', 'mc': 'XXXXXXXXXXXX', 'vol': '20', 'mt': '0', 'pa': '0', 'rm': '0', 'ts': '14',
+     'alex': '14', 'nmd': '0', 'ird': '14', 'lb': '24', 'tp': '13', 'wr': '0', 'as': '0', 'rg': '0'}
+
+"""
+
+
+class ZoneStatusExtKeys:
+    ID = "id"
+    TRANSPORT_STATE = "ac"
+    SERIAL_NUMBER = "mc"
+    VOLUME = "vol"
+    MUTE = "mt"
+    PARTY_MODE = "pa"
+    GROUP_INDEX = "rm"
+    TRACK_SOURCE = "lb"
+    DISABLED = "wr"
+
+
+""" JSON Structure
+
+ DO NOT CHANGE - VSSL Defined
+
+ {'mono': '0', 'AiNm': 'Analog In 1', 'eq1': '100', 'eq2': '100', 'eq3': '100', 'eq4': '100',
+     'eq5': '100', 'eq6': '100', 'eq7': '100', 'voll': '75', 'volr': '75', 'vold': '0'}
+
+"""
+
+
+class ZoneEQStatusExtKeys:
+    MONO = "mono"
+    ANALOG_INPUT_NAME = "AiNm"
+    HZ60 = "eq1"
+    HZ200 = "eq2"
+    HZ500 = "eq3"
+    KHZ1 = "eq4"
+    KHZ4 = "eq5"
+    KHZ8 = "eq6"
+    KHZ15 = "eq7"
+    VOL_MAX_LEFT = "voll"
+    VOL_MAX_RIGHT = "volr"
+    VOL_DEFAULT_ON = "vold"
+
+
+""" JSON Structure
+
+ DO NOT CHANGE - VSSL Defined
+
+ {'ECO': '0', 'eqsw': '1', 'inSrc': '0', 'SP': '0', 'BF1': '0', 'BF2': '0', 'BF3': '0',
+    'GRM': '0', 'GRS': '255', 'Pwr': '0', 'Bvr': '1', 'fxv': '24', 'AtPwr': '1'}
+
+"""
+
+
+class ZoneRouterStatusExtKeys:
+    EQ_ENABLED = "eqsw"
+    INPUT_SOURCE = "inSrc"
+    SOURCE_PRIORITY = "SP"
+    ANALOG_OUTPUT_FIXED_VOLUME_PREFIX = "BF"
+    GROUP_SOURCE = "GRS"
+    GROUP_MASTER = "GRM"
+    POWER_STATE = "Pwr"
+    ANALOG_INPUT_FIXED_GAIN = "fxv"
+    ADAPTIVE_POWER = "AtPwr"
+
+    @staticmethod
+    def add_zone_to_ao_fixed_volume_key(zone_id: int):
+        return f"BF{zone_id}"
+
+
+""" JSON Structure
+
+ DO NOT CHANGE - VSSL Defined
+
+ {'Album': 'International Skankers', 'Artist': 'Ashkabad', 'BitDepth': 16,
+    'BitRate': '320000', 'CoverArtUrl': 'https://i.scdn.co/image/ab67616d0000b2730cbb03a339c6ffd18d10eab2',
+    'Current Source': 4, 'Current_time': -1, 'DSDType': '', 'Fav': False, 'FileSize': 0, 'Genre': '',
+    'Index': 0, 'Mime': 'Ogg', 'Next': False, 'PlayState': 0, 'PlayUrl': 'spotify:track:0IHTiLO5qBYhf7Hmn0UDBN',
+    'Prev': False, 'Repeat': 0, 'SampleRate': '44100', 'Seek': False, 'Shuffle': 0, 'SinglePlay': False,
+    'TotalTime': 203087, 'TrackName': 'Beijing'}
+
+"""
+
+
+class TrackMetadataExtKeys:
+    COMMAND_ID = "CMD ID"
+    WINDOW_CONTENTS = "Window CONTENTS"
+    WINDOW_TITLE = "Title"
+    DURATION = "TotalTime"
+    TITLE = "TrackName"
+    ALBUM = "Album"
+    ARTIST = "Artist"
+    COVER_ART_URL = "CoverArtUrl"
+    SOURCE = "Current Source"
+    GENRE = "Genre"
+    URL = "PlayUrl"
+
+
+@sterilizable
+class VsslDataClass(ABC):
+    def _set_property(self, property_name: str, new_value):
+        log = False
+        direct_setter = f"_set_{property_name}"
+
+        if hasattr(self, direct_setter):
+            log = getattr(self, direct_setter)(new_value)
+        else:
+            current_value = getattr(self, property_name)
+            if current_value != new_value:
+                setattr(self, f"_{property_name}", new_value)
+                log = True
+
+        if log:
+            updated_value = getattr(self, property_name)
+
+            message = ""
+            if isinstance(updated_value, IntEnum):
+                message = f"{self.__class__.__name__} set {property_name}: {updated_value.name} ({updated_value.value})"
+            else:
+                message = (
+                    f"{self.__class__.__name__} set {property_name}: {updated_value}"
+                )
+
+            self._vssl._log_debug(message)
+
+            self._vssl.event_bus.publish(
+                getattr(self.Events, property_name.upper() + "_CHANGE"),
+                self._vssl.ENTITY_ID,
+                updated_value,
+            )
+
+
+@sterilizable
+class ZoneDataClass(ABC):
+    def _set_property(self, property_name: str, new_value):
+        log = False
+        direct_setter = f"_set_{property_name}"
+
+        if hasattr(self, direct_setter):
+            log = getattr(self, direct_setter)(new_value)
+        else:
+            current_value = getattr(self, property_name)
+            if current_value != new_value:
+                setattr(self, f"_{property_name}", new_value)
+                log = True
+
+        if log:
+            updated_value = getattr(self, property_name)
+
+            message = ""
+            if isinstance(updated_value, IntEnum):
+                message = f"{self.__class__.__name__} set {property_name}: {updated_value.name} ({updated_value.value})"
+            else:
+                message = (
+                    f"{self.__class__.__name__} set {property_name}: {updated_value}"
+                )
+
+            self.zone._log_debug(message)
+
+            self.zone._event_publish(
+                getattr(self.Events, property_name.upper() + "_CHANGE"), updated_value
+            )

vsslctrl/decorators.py

@@ -0,0 +1,61 @@
+import json
+import logging
+
+
+def sterilizable(cls):
+    # Define __iter__ method
+    def __iter__(self):
+        if hasattr(self.__class__, "DEFAULTS"):
+            for key in getattr(self.__class__, "DEFAULTS"):
+                yield key, getattr(self, key)
+        else:
+            for attr_name in dir(self):
+                if not attr_name.startswith("_"):  # Exclude private attributes
+                    yield attr_name, getattr(self, attr_name)
+
+    cls.__iter__ = __iter__
+
+    def _as_dict(self):
+        return dict(self)
+
+    cls.as_dict = _as_dict
+
+    def _as_json(self):
+        return json.dumps(self.as_dict())
+
+    cls.as_json = _as_json
+
+    return cls
+
+
+def logging_helpers(prefix=""):
+    def decorator(cls):
+        logger = logging.getLogger(__name__)
+
+        def _is_log_level(self, level: str):
+            level = level.upper()
+            if hasattr(logging, level):
+                return getattr(logging, level) == logger.getEffectiveLevel()
+            else:
+                return False
+
+        setattr(cls, "_is_log_level", _is_log_level)
+
+        LOG_LEVELS = {"debug", "info", "warning", "error", "critical"}
+
+        def create_log_function(log_level, prefix=prefix):  # Pass prefix here
+            def log_function(self, message):  # Rename prefix to custom_prefix
+                final_prefix = getattr(self, "_log_prefix", prefix)
+                log_level(f"{final_prefix} {message}")
+
+            return log_function
+
+        for level in LOG_LEVELS:
+            log_func = getattr(logger, level)
+            setattr(
+                cls, f"_log_{level}", create_log_function(log_func)
+            )  # Pass prefix here
+
+        return cls
+
+    return decorator