vsslctrl 0.1.0.dev1__py3-none-any.whl

vsslctrl/track.py

@@ -0,0 +1,337 @@
+import logging
+import base64
+from . import zone
+from typing import Dict, Union
+from urllib.parse import urlparse, urlunparse
+from .data_structure import VsslIntEnum, ZoneDataClass, TrackMetadataExtKeys
+
+
+class TrackMetadata(ZoneDataClass):
+    AIRPLAY_COVER_ART = "coverart.jpg"
+
+    class Keys:
+        TITLE = "title"
+        ALBUM = "album"
+        ARTIST = "artist"
+        GENRE = "genre"
+        DURATION = "duration"
+        PROGRESS = "progress"
+        COVER_ART_URL = "cover_art_url"
+        SOURCE = "source"
+        URL = "url"
+
+    #
+    # Stream Sources
+    #
+    # DO NOT CHANGE - VSSL Defined
+    #
+    class Sources(VsslIntEnum):
+        NOT_STREAMING = 0
+        AIRPLAY = 1
+        SPOTIFY = 4
+        TUNEIN = 9
+        ANALOG_IN = 15
+        APPLE_DEVICE = 16
+        DIRECT_URL = 17  # e.g play_url
+        BLUETOOTH = 19
+        TIDAL = 22
+        GOOGLECAST = 24
+        EXTERNAL = 25
+
+    #
+    # Transport Events
+    #
+    class Events:
+        PREFIX = "track."
+        CHANGE = PREFIX + "change"
+        UPDATES = PREFIX + "updates"
+        TITLE_CHANGE = PREFIX + "title_change"
+        ALBUM_CHANGE = PREFIX + "album_change"
+        ARTIST_CHANGE = PREFIX + "artist_change"
+        GENRE_CHANGE = PREFIX + "genre_change"
+        DURATION_CHANGE = PREFIX + "duration_change"
+        PROGRESS_CHANGE = PREFIX + "progress_change"
+        COVER_ART_URL_CHANGE = PREFIX + "cover_art_url_change"
+        SOURCE_CHANGE = PREFIX + "source_change"
+        URL_CHANGE = PREFIX + "url_change"
+
+    DEFAULTS = {
+        Keys.TITLE: None,
+        Keys.ALBUM: None,
+        Keys.ARTIST: None,
+        Keys.GENRE: None,
+        Keys.DURATION: 0,
+        Keys.PROGRESS: 0,
+        Keys.COVER_ART_URL: None,
+        Keys.SOURCE: Sources.NOT_STREAMING,
+        Keys.URL: None,
+    }
+
+    KEY_MAP = {
+        TrackMetadataExtKeys.DURATION: Keys.DURATION,
+        TrackMetadataExtKeys.TITLE: Keys.TITLE,
+        TrackMetadataExtKeys.ALBUM: Keys.ALBUM,
+        TrackMetadataExtKeys.ARTIST: Keys.ARTIST,
+        TrackMetadataExtKeys.COVER_ART_URL: Keys.COVER_ART_URL,
+        TrackMetadataExtKeys.SOURCE: Keys.SOURCE,
+        TrackMetadataExtKeys.GENRE: Keys.GENRE,
+        TrackMetadataExtKeys.URL: Keys.URL,
+    }
+
+    def __init__(self, zone: "zone.Zone"):
+        self.zone = zone
+
+        self._title: str = None
+        self._album: str = None
+        self._artist: str = None
+        self._genre: str = None
+        self._duration: int = 0
+        self._progress: int = 0
+        self._cover_art_url: str = None
+        self._source = self.Sources.NOT_STREAMING
+        self._url: str = None
+
+    def as_dict(self):
+        dic = super().as_dict()
+        dic["progress_display"] = self.progress_display
+        return dic
+
+    #
+    # VSSL doenst clear some vars on stopping of the stream, so we will do it
+    #
+    # Doing this will fire the change events on the bus. Instead of conditionally
+    # using the getter functions since we want the changes to be propogated
+    #
+    # VSSL has a happit of caching the last song played, so we need to clear it
+    #
+    def set_defaults(self):
+        for key, default_value in self.DEFAULTS.items():
+            self._update_property(key, default_value, True)
+
+    #
+    # Updade a property and emit and event if changed
+    #
+    # Transport state is ignored when part of a group for its initial pull from master
+    #
+    def _update_property(self, key: str, new_value, ignore_transport_state=False):
+        # Default if stopped
+        if self.zone.transport.is_stopped and not ignore_transport_state:
+            new_value = self.DEFAULTS[key]
+
+        if getattr(self, key) != new_value:
+            setattr(self, f"_{key}", new_value)  # set private var
+            new_set_value = getattr(self, key)
+
+            self.zone._event_publish(
+                getattr(self.Events, f"{key.upper()}_CHANGE"), new_set_value
+            )
+            self.zone._event_publish(self.Events.CHANGE, (key, new_set_value))
+
+    #
+    # Update the track properties from a group master when part of a group.
+    # This is handled via the Eventbus
+    #
+    async def _update_property_from_group_master(
+        self, data: Dict[str, int], *args, **kwargs
+    ) -> None:
+        if hasattr(self, data[0]):
+            setattr(self, data[0], data[1])
+
+    #
+    # Update from a JSON dict passed
+    #
+    def _map_response_dict(self, track_data: Dict[str, int]) -> None:
+        """Ignore the track data if zone is part of a group.
+
+        VSSL has a happit of caching old track meta when part of a group
+
+        """
+        if not self.zone.group.is_member:
+            for track_data_key, metadata_key in self.KEY_MAP.items():
+                if track_data_key in track_data:
+                    setattr(self, metadata_key, track_data[track_data_key])
+
+    """ TODO!
+
+        Now we added the child, lets propage the track to the new member.
+        This only needs to happen once, as after wards the track data will
+        be updated by the event bus
+
+        Sometime, the VSSL responses with old cached track metadata, on the member zones
+        but generally it responds with a BrowseView when its a member of a group
+
+        When a group is created, the child will get the group index first (generally this will be the same
+        as the index_id) then its transport state will be
+        updated on the VSSL side.
+        When the transport state is changed, the zone will request the track meta. VSSL will respond
+        with the last cached metadata from the zone and not the correct meta from the current zone master.
+
+    """
+
+    def _pull_from_zone(self, zone: int) -> None:
+        master = self.zone.vssl.get_zone(zone)
+
+        if not master:
+            self.zone._log_error(
+                f"Zone {zone} was not avaiable on VSSL, maybe we are not managing it or it has not be initialised yet"
+            )
+            return
+
+        for key, default_value in self.DEFAULTS.items():
+            if hasattr(master.track, key):
+                self._update_property(key, getattr(master.track, key), True)
+
+    #
+    # Track Title
+    #
+    @property
+    def title(self) -> str:
+        return self._title
+
+    @title.setter
+    def title(self, value: str) -> None:
+        self._update_property(self.Keys.TITLE, value)
+
+    #
+    # Track Album
+    #
+    @property
+    def album(self) -> str:
+        return self._album
+
+    @album.setter
+    def album(self, value: str) -> None:
+        self._update_property(self.Keys.ALBUM, value)
+
+    #
+    # Track Artist
+    #
+    @property
+    def artist(self) -> str:
+        return self._artist
+
+    @artist.setter
+    def artist(self, value: str) -> None:
+        self._update_property(self.Keys.ARTIST, value)
+
+    #
+    # Track Genre
+    #
+    @property
+    def genre(self) -> str:
+        return self._genre
+
+    @genre.setter
+    def genre(self, value: str) -> None:
+        self._update_property(self.Keys.GENRE, value)
+
+    #
+    # Track Duration
+    #
+    @property
+    def duration(self) -> int:
+        return self._duration
+
+    @duration.setter
+    def duration(self, value: int) -> None:
+        self._update_property(self.Keys.DURATION, value)
+
+    #
+    # Track Duration
+    #
+    @property
+    def progress(self) -> int:
+        return self._progress
+
+    @progress.setter
+    def progress(self, value: int) -> None:
+        self._update_property(self.Keys.PROGRESS, value)
+
+    @property
+    def progress_display(self):
+        milliseconds = self.progress if self.progress != None else 0
+
+        seconds, milliseconds = divmod(milliseconds, 1000)
+        minutes, seconds = divmod(seconds, 60)
+        hours, minutes = divmod(minutes, 60)
+
+        formatted_time = ""
+
+        if hours > 0:
+            formatted_time += "{}:".format(hours)
+
+        formatted_time += (
+            "{:02}:{:02}".format(minutes, seconds)
+            if hours > 0
+            else "{}:{:02}".format(minutes, seconds)
+        )
+
+        return formatted_time
+
+    #
+    # Track Cover Art
+    #
+    @property
+    def cover_art_url(self) -> str:
+        return self._cover_art_url
+
+    @cover_art_url.setter
+    def cover_art_url(self, value: str) -> None:
+        self._update_property(self.Keys.COVER_ART_URL, self.add_host_if_not_url(value))
+
+    def add_host_if_not_url(self, url):
+        """Using airplay, the cover_art will return a relative url of "coverart.jpg", so we will
+        need to add the host.
+
+        """
+        if not url:
+            return None
+        # Parse the URL
+        parsed_url = urlparse(url)
+        default_host = f"http://{self.zone.host}"
+        query = ""
+
+        # Check if the scheme and netloc are missing
+        if not parsed_url.scheme or not parsed_url.netloc:
+            # Add the default host if it's not a URL
+            # Join the default host with the original URL path
+            if not default_host.endswith("/") and not url.startswith("/"):
+                default_host += "/"
+
+            # Lets add a query string to the coverart.jpg URL so the latest coverart
+            # will always be downloaded if the album changes
+            if url == self.AIRPLAY_COVER_ART and self.album:
+                encoded_album = (
+                    base64.urlsafe_b64encode(self.album.encode()).decode().rstrip("=")
+                )[:6]
+                query = f"?album={encoded_album}"
+
+            return default_host + url + query
+
+        # Return the original URL if it is already a valid URL
+        return url
+
+    #
+    # Track Source
+    #
+    @property
+    def source(self) -> Sources:
+        return self._source
+
+    @source.setter
+    def source(self, src: Sources) -> None:
+        if self.Sources.is_valid(src):
+            self._update_property(self.Keys.SOURCE, self.Sources(src))
+        else:
+            self.zone._log_error(f"TrackMetadata.Sources {src} doesnt exist")
+
+    #
+    # Track URL
+    #
+    @property
+    def url(self) -> str:
+        return self._url
+
+    @url.setter
+    def url(self, value: str) -> None:
+        self._update_property(self.Keys.URL, value)

vsslctrl/transport.py

@@ -0,0 +1,242 @@
+import logging
+from typing import Dict, Union
+from .track import TrackMetadata
+from .utils import clamp_volume
+from .data_structure import VsslIntEnum, ZoneDataClass
+
+
+class ZoneTransport(ZoneDataClass):
+    class States(VsslIntEnum):
+        """Transport States
+
+        DO NOT CHANGE - VSSL Defined
+        """
+
+        STOP = 0
+        PLAY = 1
+        PAUSE = 2
+
+    class Repeat(VsslIntEnum):
+        """Repeat
+
+        DO NOT CHANGE - VSSL Defined
+        """
+
+        OFF = 0  # No repeat
+        ONE = 1  # Repeat single track
+        ALL = 2  # Repeat queue / playlist / album
+
+    class Events:
+        """Transport Events"""
+
+        PREFIX = "zone.transport."
+        STATE_CHANGE = PREFIX + "state_change"
+        STATE_CHANGE_STOP = PREFIX + "state_change.stop"
+        STATE_CHANGE_PLAY = PREFIX + "state_change.play"
+        STATE_CHANGE_PAUSE = PREFIX + "state_change.pause"
+
+        IS_REPEAT_CHANGE = PREFIX + "is_repeat_change"
+        IS_SHUFFLE_CHANGE = PREFIX + "is_shuffle_change"
+        HAS_NEXT_CHANGE = PREFIX + "has_next_change"
+        HAS_PREV_CHANGE = PREFIX + "has_prev_change"
+
+    DEFAULTS = {
+        "state": States.STOP,
+        "is_repeat": Repeat.OFF,
+        "is_shuffle": False,
+        "has_next": False,
+        "has_prev": False,
+    }
+
+    KEY_MAP = {
+        "Next": "has_next",
+        "Prev": "has_prev",
+        "Shuffle": "is_shuffle",
+        "Repeat": "is_repeat",
+    }
+
+    def __init__(self, zone: "zone.Zone"):
+        self.zone = zone
+
+        self._state = self.States.STOP
+        self._is_repeat = self.Repeat.OFF
+        self._is_shuffle = False
+        self._has_next = False
+        self._has_prev = False
+
+    def set_defaults(self):
+        """VSSL doenst clear some vars on stopping of the stream, so we will do it
+
+        Doing this will fire the change events on the bus. Instead of conditionally
+        using the getter functions since we want the changes to be propogated
+
+        VSSL has a happit of caching the last song played, so we need to clear it
+        """
+        for key, default_value in self.DEFAULTS.items():
+            set_func = f"_set_{key}"
+            if hasattr(self, set_func):
+                getattr(self, set_func)(default_value)
+
+    def _default_on_state_stop(self, value, default=None):
+        """Set value based on transport state."""
+        return default if self.state == self.States.STOP else value
+
+    def _map_response_dict(self, track_data: Dict[str, int]) -> None:
+        """Update from a JSON dict"""
+        for track_data_key, metadata_key in self.KEY_MAP.items():
+            if track_data_key in track_data:
+                self._set_property(metadata_key, track_data[track_data_key])
+
+    def _set_bool_property(self, prop_key: str, new_value: int, event: str) -> None:
+        """Set a bool property"""
+        new_value = self._default_on_state_stop(
+            not not new_value, self.DEFAULTS[prop_key]
+        )
+        cur_value = getattr(self, prop_key)
+
+        if cur_value != new_value:
+            setattr(self, f"_{prop_key}", new_value)
+            return True
+
+    #
+    # Transport State
+    #
+    @property
+    def state(self):
+        return self._state
+
+    @state.setter
+    def state(self, state: int):
+        if self.States.is_valid(state):
+            state = self.States(state)
+            self.zone.api_alpha.request_action_3D(state)
+
+            # Changing state wont work if we are part of a group
+            # So if we are wanting to stop, leave the group
+            if state == self.States.STOP and self.zone.group.is_member:
+                self.zone.group.leave()
+        else:
+            self.zone._log_error(f"ZoneTransport.States {state} doesnt exist")
+
+    def _set_state(self, state: int):
+        if self.state != state:
+            if self.States.is_valid(state):
+                self._state = self.States(state)
+                self.zone._event_publish(
+                    getattr(self.Events, f"STATE_CHANGE_{self.state.name.upper()}"),
+                    True,
+                )
+                return True
+            else:
+                self.zone._log_warning(f"ZoneTransport.States {state} doesnt exist")
+
+    #
+    # Transport Commands
+    #
+    def play(self):
+        self.state = self.States.PLAY
+
+    def stop(self):
+        """note: stopping a stream will disconnect the client as will pausing an Airplay stream.
+
+        note2: streams (Airplay, Chromecast, Spotify.Connect) have higher priority than analog inputs.
+        Therefore, if both input types are playing to a zone then the higher priority will play. Likewise,
+        if both types of input are playing to a zone and the stream is stopped then the zone will switch
+        to playing the lower priority content.
+
+        ref: https://vssl.gitbook.io/vssl-rest-api/zone-control/play-control
+        """
+        self.state = self.States.STOP
+
+    def pause(self):
+        self.state = self.States.PAUSE
+
+    #
+    # Transport States
+    #
+    @property
+    def is_playing(self):
+        return self.state == self.States.PLAY
+
+    @property
+    def is_stopped(self):
+        return self.state == self.States.STOP
+
+    @property
+    def is_paused(self):
+        return self.state == self.States.PAUSE
+
+    #
+    # Track Control
+    #
+    def next(self):
+        self.zone.api_bravo.request_action_40_next()
+
+    def prev(self):
+        self.zone.api_bravo.request_action_40_prev()
+
+    def back(self):
+        self.prev()
+        self.prev()
+
+    #
+    # Is the next button enabled
+    #
+    @property
+    def has_next(self):
+        return self._has_next
+
+    @has_next.setter
+    def set_has_next(self, val: int):
+        pass  # read-only
+
+    def _set_has_next(self, val: int):
+        return self._set_bool_property("has_next", val, self.Events.HAS_NEXT_CHANGE)
+
+    #
+    # Track Prev_flag
+    #
+    @property
+    def has_prev(self):
+        return self._has_prev
+
+    @has_prev.setter
+    def has_prev(self, val: int):
+        pass  # read-only
+
+    def _set_has_prev(self, val: int):
+        return self._set_bool_property("has_prev", val, self.Events.HAS_PREV_CHANGE)
+
+    #
+    # Track Shuffle
+    #
+    @property
+    def is_shuffle(self):
+        return self._is_shuffle
+
+    @is_shuffle.setter
+    def is_shuffle(self, val: int):
+        pass  # read-only
+
+    def _set_is_shuffle(self, val: int):
+        return self._set_bool_property("is_shuffle", val, self.Events.IS_SHUFFLE_CHANGE)
+
+    #
+    # Track Repeat
+    #
+    @property
+    def is_repeat(self):
+        return self._is_repeat
+
+    @is_repeat.setter
+    def is_repeat(self, val: int):
+        pass  # read-only
+
+    def _set_is_repeat(self, val: int):
+        val = self._default_on_state_stop(val, self.DEFAULTS["is_repeat"])
+        if self.is_repeat != val:
+            if self.Repeat.is_valid(val):
+                self._is_repeat = self.Repeat(val)
+                return True
+            else:
+                self.zone._log_error(f"ZoneTransport.Repeat {val} doesnt exist")

vsslctrl/utils.py

@@ -0,0 +1,75 @@
+import asyncio
+
+
+#
+# Hex to Int
+#
+def hex_to_int(str: str, base: int = 16):
+    return int(str, base)
+
+
+#
+# Clamp Volume
+#
+def clamp_volume(vol: int):
+    return max(0, min(int(vol), 100))
+
+
+#
+# Cancel a task if it exsists
+#
+def cancel_task(task: asyncio.Task):
+    if isinstance(task, asyncio.Task) and not task.done():
+        try:
+            task.cancel()
+        except asyncio.CancelledError:
+            pass
+
+
+#
+# Groups dicts by property
+#
+def group_list_by_property(input_list, property_key):
+    grouped_dict = {}
+    for item in input_list:
+        property_value = item.get(property_key)
+        if property_value is not None:
+            grouped_dict.setdefault(property_value, []).append(item)
+    return grouped_dict
+
+
+#
+# Repeat Timer
+#
+class RepeatTimer:
+    def __init__(self, interval, function, start_delay=False, *args, **kwargs):
+        self.interval = interval
+        self.function = function
+        self.start_delay = start_delay
+        self.args = args
+        self.kwargs = kwargs
+        self.task = None
+        self.running = False
+
+    async def _run(self):
+        while self.running:
+            if self.start_delay:
+                await asyncio.sleep(self.interval)
+
+            if asyncio.iscoroutinefunction(self.function):
+                await self.function(*self.args, **self.kwargs)
+            else:
+                self.function(*self.args, **self.kwargs)
+
+            if not self.start_delay:
+                await asyncio.sleep(self.interval)
+
+    def start(self):
+        if not self.running:
+            self.running = True
+            self.task = asyncio.create_task(self._run())
+
+    def cancel(self):
+        if self.running:
+            self.running = False
+            self.task.cancel()