spotifywebapiPython 1.0.36__py3-none-any.whl → 1.0.147__py3-none-any.whl

spotifywebapipython/spotifyconnectdeviceeventargs.py

@@ -0,0 +1,67 @@
+# our package imports.
+from .models import SpotifyConnectDevice
+
+
+class SpotifyConnectDeviceEventArgs:
+    """
+    Class used by various methods that inform interested parties that a Spotify
+    Connect device update has occured.
+
+    Threadsafety:
+        This class is fully thread-safe.
+    """
+    def __init__(self, device:SpotifyConnectDevice) -> None:
+        """
+        Initializes a new instance of the class.
+
+        Args:
+            device (SpotifyConnectDevice):
+                Spotify Connect device object that was affected.
+        """
+
+        # initialize instance.
+        self._DeviceObject:SpotifyConnectDevice = device
+
+
+    @property
+    def DeviceObject(self) -> SpotifyConnectDevice:
+        """
+        Spotify Connect device object that was affected.
+        """
+        return self._DeviceObject
+
+    @DeviceObject.setter
+    def DeviceObject(self, value:str) -> None:
+        """ 
+        Sets the DeviceObject property value.
+        """
+        if (isinstance(value, SpotifyConnectDevice)):
+            self._DeviceObject = value
+
+
+    def __str__(self) -> str:
+        """
+        Returns a string representation of the object.
+        
+        Returns:
+            A string in the form of "SpotifyConnectDeviceEventArgs: {status}".
+        """
+        return str.format("SpotifyConnectDeviceEventArgs: {0}", self._DeviceObject or "")
+
+
+class SpotifyConnectDeviceEventHandler:
+    """
+    Event handler type definition for an event.
+    """
+
+    def __init__(self, sender:object, e:SpotifyConnectDeviceEventArgs) -> None:
+        """
+        Initializes a new instance of the class.
+
+        Args:
+            sender (object):
+                The object which fired the event.
+            e (SpotifyConnectDeviceEventArgs):
+                Arguments that contain detailed information related to the event,
+                and canceling of its processing.
+        """

spotifywebapipython/spotifydiscovery.py

@@ -3,13 +3,16 @@ try:
     from queue import Queue, Empty
 except ImportError:
     from Queue import Queue, Empty
+import threading
+import time
 from zeroconf import Zeroconf, ServiceBrowser, ServiceInfo, ServiceStateChange, IPVersion
 
 # our package imports.
 from .saappmessages import SAAppMessages
+from .spotifyapierror import SpotifyApiError
 from .sautils import export
 from .models.device import Device
-from .spotifyclient import SpotifyClient, SpotifyApiError
+from .models import ZeroconfDiscoveryResult, ZeroconfProperty
 
 # get smartinspect logger reference; create a new session for this module name.
 from smartinspectpython.siauto import SIAuto, SILevel, SISession
@@ -30,42 +33,41 @@ class SpotifyDiscovery:
     Click the **Sample Code** links in the individual methods for sample code examples.
     """
 
-    def __init__(self, spotifyClient:SpotifyClient=None, areDevicesVerified:bool=False, printToConsole:bool=False) -> None:
+    def __init__(
+            self, 
+            zeroconfClient:Zeroconf=None,
+            printToConsole:bool=False
+            ) -> None:
         """
         Initializes a new instance of the class.
         
         Args:
-            spotifyClient (SpotifyClient):
-                A SpotifyClient instance that will be used to verify discovered devices.   
-                This can be null if the areDevicesVerified argument is False.  
-                This argument is required if the areDevicesVerified argument is True.  
-            areDevicesVerified (bool):
-                True to create a `SpotifyClient` instance for discovered devices, which
-                verifies that the device can be accessed and basic information obtained 
-                about its capabilities; otherwise, False to just identify the IPV4 Address, 
-                Port, and Device Name.  
-                Default is False.
+            zeroconfClient (Zeroconf)
+                A Zeroconf client instance that will be used to discover Spotify Connect devices,
+                or null to create a new instance of Zeroconf.
+                Default is null.
             printToConsole (bool):
                 True to print discovered device information to the console as the devices
                 are discovered; otherwise, False to not print anything to the console.
                 Default is False.
-                
-        Specify False for the `areDevicesVerified` argument if you want to speed up
-        device discovery, as it takes extra time to verify device connections as they 
-        are discovered.
         """
         # validations.
-        if spotifyClient is not None and (not isinstance(spotifyClient, SpotifyClient)):
-            raise SpotifyApiError(SAAppMessages.ARGUMENT_TYPE_ERROR % ("__init__", 'spotifyClient', 'SpotifyClient', type(spotifyClient).__name__), logsi=_logsi)
-        if spotifyClient is None and areDevicesVerified == True:
-            raise SpotifyApiError("The spotifyClient argument is required if devices are to be verified (areDevicesVerified argument = True)", logsi=_logsi)
+        if zeroconfClient is not None and (not isinstance(zeroconfClient, Zeroconf)):
+            raise SpotifyApiError(SAAppMessages.ARGUMENT_TYPE_ERROR % ("__init__", 'zeroconfClient', 'Zeroconf', type(zeroconfClient).__name__), logsi=_logsi)
+
+        # create the zeroconf client if one was not specified.
+        if zeroconfClient is None:
+            _logsi.LogVerbose("Creating new Zeroconf instance for discovery")
+            zeroconfClient = Zeroconf()
+        else:
+            _logsi.LogObject(SILevel.Verbose, "Using existing Zeroconf instance for discovery", zeroconfClient)
 
         # initialize instance properties.
-        self._AreDevicesVerified:bool = areDevicesVerified
         self._DiscoveredDeviceNames:dict = {}
+        self._DiscoveryResults:list[ZeroconfDiscoveryResult] = []
         self._PrintToConsole:bool = printToConsole
-        self._SpotifyClient:SpotifyClient = spotifyClient
-        self._VerifiedDevices:dict = {}
+        self._ZeroconfClient = zeroconfClient
+        self._Zeroconf_Lock = threading.Lock()
 
 
     def __getitem__(self, key):
@@ -89,29 +91,25 @@ class SpotifyDiscovery:
         return self.ToString()
 
 
-    @property
-    def AreDevicesVerified(self) -> bool:
+    def ContainsId(self, value:str) -> bool:
+        """ 
+        Returns True if the `DiscoveryResults` collection contains the specified id value;
+        otherwise, False.
         """
-        Determines if a `Device` object is created for devices that are
-        discovered.  This property is set by what is passed to the class constructor.
-        
-        If False, then the `VerifiedDevices` property will be empty;
-        
-        If True, then the `VerifiedDevices` property will contain a `Device`
-        instance for each device that was detected as part of the discovery process
-        and was found in the Spotify User's player devices list.
-        """
-        return self._AreDevicesVerified
-        
+        item:ZeroconfDiscoveryResult = self.GetResultById(value)
+        if item is not None:
+            return True
+        return False
+
 
     @property
     def DiscoveredDeviceNames(self) -> dict:
         """
         A dictionary of discovered device names that were detected by the discovery process.
         
-        Dictionary keys will be in the form of "address:port", where "address" is the device
-        ipv4 address and the "port" is the ipv4 port number the Spotify Connect device
-        is listening on.
+        Dictionary keys will be in the form of "'name' (address:port)", where "name" is the
+        device name, "address" is the device server address and the "port" is the ipv4 port 
+        number the Spotify Connect device is listening on.
         
         Dictionary values will be the device names (e.g. "Web Player (Chrome)", etc.).  This SHOULD
         match the name of the device as displayed in the Spotify App, but is not guaranteed.
@@ -120,28 +118,159 @@ class SpotifyDiscovery:
 
 
     @property
-    def VerifiedDevices(self) -> dict:
+    def DiscoveryResults(self) -> list[ZeroconfDiscoveryResult]:
+        """
+        An array of `ZeroconfDiscoveryResult` items that contain discovery details for
+        each service that was discovered.
+        """
+        return self._DiscoveryResults
+
+
+    def GetIndexByKey(self, value:str) -> int:
+        """ 
+        Returns the index of the `DiscoveryResults` collection that contains 
+        the specified device key value; otherwise, -1.
         """
-        A dictionary of discovered `Device` instances that were detected on the network.
+        result:int = -1
+        if value is None:
+            return result
         
-        This property is only populated if the `AreDevicesVerified` property is True.
+        # convert case for comparison.
+        value = value.lower()
+
+        # process all discovered devices.
+        for i in range(len(self._DiscoveryResults)):
+            if (self._DiscoveryResults[i].Key.lower() == value):
+                result = i
+                break       
+        return result
+
+
+    def GetResultById(self, value:str) -> bool:
+        """ 
+        Returns a `ZeroconfDiscoveryResult` instance if the `DiscoveryResults` collection contains 
+        the specified device id value; otherwise, None.
+        """
+        result:ZeroconfDiscoveryResult = None
+        if value is None:
+            return result
         
-        Dictionary keys will be in the form of "address:port", where "address" is the device
-        ipv4 address and the "port" is the ipv4 port number the Spotify Connect device
-        is listening on.
+        # convert case for comparison.
+        value = value.lower()
         
-        Dictionary values will be `Device` instances that represent the discovered
-        device.
+        # process all discovered devices.
+        item:ZeroconfDiscoveryResult
+        for item in self._DiscoveryResults:
+            if (item.Id.lower() == value):
+                result = item
+                break
+        return result
+
+
+    @property
+    def ZeroconfClient(self) -> Zeroconf:
+        """ 
+        Zeroconf client instance that will be used to discover Spotify Connect devices.
         """
-        return self._VerifiedDevices
+        return self._ZeroconfClient
+    
+
+    def _GetZeroconfDiscoveryResult(
+        self,
+        zeroconf:Zeroconf, 
+        serviceType:str, 
+        serviceName:str, 
+        serviceStateChange:ServiceStateChange,
+        serviceStateChangeDesc:str
+        ) -> ZeroconfDiscoveryResult:
+        """
+        Builds a `ZeroconfDiscoveryResult` instance from Zeroconf Service Information data.
+        """
+        result:ZeroconfDiscoveryResult = None
 
+        try:
 
-    def _OnServiceStateChange(self,
-                              zeroconf:Zeroconf, 
-                              service_type:str, 
-                              name:str, 
-                              state_change:ServiceStateChange
-                              ) -> None:
+            # trace.
+            _logsi.EnterMethod(SILevel.Debug)
+            
+            # get device service information instance; if none, then we are done.
+            deviceName:str = (serviceName.split(".")[0])
+            serviceInfo:ServiceInfo = zeroconf.get_service_info(serviceType, serviceName)
+            if serviceInfo is None:
+                _logsi.LogVerbose("Spotify Connect Zeroconf discovery service notification ignored: \"%s\" (%s:%s) - no serviceinfo data" % (serviceName, serviceType, serviceStateChange))
+                return result
+
+            # get list of displayable (parsed) ipv4 addresses; if none, then we are done.
+            ipAddressList = serviceInfo.parsed_addresses(IPVersion.V4Only)
+            if (ipAddressList is None):
+                _logsi.LogVerbose("Spotify Connect Zeroconf discovery service notification ignored: \"%s\" (%s:%s) - no IP address list" % (serviceName, serviceType, serviceStateChange))
+                return result
+            
+            # trace.
+            _logsi.LogObject(SILevel.Verbose, "Spotify Connect Zeroconf service details: \"%s\" %s (serviceinfo object)" % (deviceName, ipAddressList), serviceInfo) 
+            
+            # create new discovery result instance.
+            result:ZeroconfDiscoveryResult = ZeroconfDiscoveryResult()
+            result.DeviceName = deviceName
+            result.Domain = '.local'
+            for item in ipAddressList:
+                result.HostIpAddresses.append(item)
+            result.HostIpPort = serviceInfo.port
+            result.HostTTL = serviceInfo.host_ttl
+            result.Key = serviceInfo.key
+            result.Name = serviceInfo.name
+            result.OtherTTL = serviceInfo.other_ttl
+            result.Priority = serviceInfo.priority
+            result.Server = serviceInfo.server
+            result.ServerKey = serviceInfo.server_key
+            result.ServiceInfo = serviceInfo
+            result.ServiceType = serviceType
+            result.Weight = serviceInfo.weight
+            result.Id = "\"%s\" (%s:%s)" % (result.DeviceName, result.HostIpAddress, result.HostIpPort)
+
+            # process service info propertys.
+            # note that the property keys and values must first be decoded to utf-8 encoding.
+            if serviceInfo.properties is not None:
+                dspProperties:dict = {}
+                for key, value in serviceInfo.properties.items():
+                    keyStr = key.decode('utf-8')
+                    valueStr = value.decode('utf-8')
+                    result.Properties.append(ZeroconfProperty(keyStr, valueStr)) 
+                    dspProperties[keyStr] = valueStr
+                    # check for Spotify Connect common properties.
+                    if keyStr.lower() == 'cpath':
+                        result.SpotifyConnectCPath = valueStr
+                    elif keyStr.lower() == 'version':
+                        result.SpotifyConnectVersion = valueStr
+                _logsi.LogDictionary(SILevel.Verbose, "Spotify Connect Zeroconf service details: \"%s\" %s (serviceinfo properties)" % (deviceName, ipAddressList), dspProperties) 
+
+            # trace.
+            _logsi.LogObject(SILevel.Verbose, "Spotify Connect Zeroconf Discovery Result: %s (object)" % (result.Id), result, excludeNonPublic=True)                        
+
+            # return discovery result.
+            return result
+
+        except Exception as ex:
+            
+            # trace.
+            _logsi.LogException("Could not load ZeroconfDiscoveryResult instance from Zeroconf serviceinfo object.", ex, logToSystemLogger=False)
+            
+            # ignore exception
+            return None
+            
+        finally:
+            
+            # trace.
+            _logsi.LeaveMethod(SILevel.Debug)
+
+
+    def _OnServiceStateChange(
+        self,
+        zeroconf:Zeroconf, 
+        service_type:str, 
+        name:str, 
+        state_change:ServiceStateChange
+        ) -> None:
         """
         Called by the zeroconf ServiceBrowser when a service state has changed (e.g. added,
         removed, or updated).  In our case, we only care about devices that were added.
@@ -149,84 +278,134 @@ class SpotifyDiscovery:
         IMPORTANT - This method is executed on a different thread, so be careful about 
         multi-threaded operations!
         """
-        serviceType:str = service_type
-        serviceName:str = name
-        serviceStateChange:ServiceStateChange = state_change
+
+        # this method can be tested by issuing the following commands from an MS-DOS
+        # command prompt to simulate Zeroconf registration updates.
+
+        # - add a new Spotify Connect instance registration:
+        # > dns-sd -R "MyTestSC1" _spotify-connect._tcp. local 8080 cpath=/zcXXX version=1.0
         
-        # process by the state change value.
-        if (serviceStateChange is ServiceStateChange.Added):
-            _logsi.LogVerbose("Discovered Spotify Connect device service: '%s' (%s:%s)" % (serviceName, serviceType, serviceStateChange))
+        # - update a new Spotify Connect instance registration; 
+        # - if you change the name, service type, or port number, a NEW registration is created!
+        # - for updates, the only thing you can really update is the TXT record properties.
+        # > dns-sd -R "MyTestSC1" _spotify-connect._tcp. local 8080 cpath=/zcYYY version=1.0
+        
+        # - remove an existing Spotify Connect instance registration; 
+        # > the only way to remove an entry is to kill the process the entry was created under!
+        
+        # enter the following section one thread at a time (threadsafe).
+        with self._Zeroconf_Lock:
+
+            # copy passed parameters to thread-safe storage.
+            serviceType:str = service_type
+            serviceName:str = name
+            serviceStateChange:ServiceStateChange = state_change
+            serviceStateChangeDesc:str = None
+
+            try:
+
+                # trace.
+                _logsi.EnterMethod(SILevel.Debug)
+
+                # process by the state change value.
+                if (serviceStateChange is ServiceStateChange.Added) \
+                or (serviceStateChange is ServiceStateChange.Updated):
+
+                    # set service state change description.
+                    serviceStateChangeDesc = "Added"
+                    if (serviceStateChange is ServiceStateChange.Updated):
+                        serviceStateChangeDesc = "Updated"
+
+                    # trace.
+                    _logsi.LogVerbose("Spotify Connect Zeroconf discovery service notification: \"%s\" (%s)" % (serviceName, serviceStateChangeDesc))
+
+                    # build discovery result instance from service state information.
+                    # if nothing returned, then don't bother!
+                    result:ZeroconfDiscoveryResult = self._GetZeroconfDiscoveryResult(zeroconf, serviceType, serviceName, serviceStateChange, serviceStateChangeDesc)
+                    if (result is None):
+                        return
+
+                    # add device name to list of registered names.
+                    self._DiscoveredDeviceNames[result.Id] = result.DeviceName
+
+                    # add / update discovered results by serviceinfo key value. 
+                    # we use the serviceinfo KEY value (not SERVERKEY) since some manufacturers use random ip port 
+                    # numbers, and the port number could have been updated.  in this case, the key SHOULD remain the same.
+                    # note that a different serviceinfo key SHOULD be created for speaker groups; at least they are for BOSE devices.
+                    idx:int = self.GetIndexByKey(result.Key)
+                    if (idx == -1):
+                        self._DiscoveryResults.append(result)  # add new result
+                        _logsi.LogVerbose("Spotify Connect Zeroconf service discovery result was added: %s (%s)" % (result.Id, serviceStateChangeDesc))
+                    else:
+                        self._DiscoveryResults[idx] = result   # update existing result
+                        _logsi.LogVerbose("Spotify Connect Zeroconf service discovery result was updated: %s (%s)" % (result.Id, serviceStateChangeDesc))
+
+                    # trace.
+                    if (self._PrintToConsole == True):
+                        print("Spotify Connect Zeroconf service %s: %s" % (serviceStateChangeDesc, result.Id))
+
+                elif (serviceStateChange is ServiceStateChange.Removed):
+
+                    # set service state change description.
+                    serviceStateChangeDesc = "Removed"
+
+                    # trace.
+                    _logsi.LogVerbose("Spotify Connect Zeroconf discovery service notification: \"%s\" (%s)" % (serviceName, serviceStateChangeDesc))
+
+                    # build discovery result instance from service state information.
+                    # if nothing returned, then don't bother!
+                    result:ZeroconfDiscoveryResult = self._GetZeroconfDiscoveryResult(zeroconf, serviceType, serviceName, serviceStateChange, serviceStateChangeDesc)
+                    if (result is None):
+                        return
+
+                    # remove device name from list of registered names.
+                    self._DiscoveredDeviceNames.pop(result.Id, None)
+
+                    # remove device from results collection;
+                    # the reversed() function creates an iterator that traverses the list in reverse order. 
+                    # This ensures that removing an element doesn't affect the indices of the subsequent 
+                    # elements we're going to iterate over.
+                    resultCompare:str = result.Id.lower()
+                    for i in reversed(range(len(self._DiscoveryResults))):
+                        if (self._DiscoveryResults[i].Id.lower() == resultCompare):
+
+                            # remove discovery result.
+                            result = self._DiscoveryResults.pop(i)
+
+                            # trace.
+                            _logsi.LogVerbose("Spotify Connect Zeroconf service %s: %s" % (serviceStateChangeDesc, result.Id))
+                            if (self._PrintToConsole == True):
+                                print("Spotify Connect Zeroconf service %s: %s" % (serviceStateChangeDesc, result.Id))
+
+                            break
+
+            except Exception as ex:
             
-            deviceName:str = (serviceName.split(".")[0])
-            serviceInfo:ServiceInfo = zeroconf.get_service_info(service_type, serviceName)
-            if serviceInfo is None:
-                return
+                # trace.
+                _logsi.LogException("Unhandled exception occured while processing Spotify Connect Zeroconf discovery service notification (%s)" % (serviceStateChange), ex, logToSystemLogger=False)
             
-            # get list of displayable (parsed) ipv4 addresses that were detected; if none, then we are done.
-            ipAddressList = serviceInfo.parsed_addresses(IPVersion.V4Only)
-            if (ipAddressList is None):
-                return
+                # ignore exception
+                return None
             
-            # create device instances for each ipv4 address found.
-            for deviceIpAddress in ipAddressList:
-                
-                devicePort:int = serviceInfo.port
-                deviceKey:str = '%s:%i' % (deviceIpAddress, devicePort)
-                _logsi.LogVerbose("Discovered Spotify Connect device: %s - %s" % (deviceKey, deviceName))
-                if (self._PrintToConsole == True):
-                    print("Discovered Spotify Connect device: %s - %s" % (deviceKey, deviceName))
-                _logsi.LogObject(SILevel.Verbose, "Discovered Spotify Connect device ServiceInfo: %s - %s" % (deviceKey, deviceName), serviceInfo) 
-                
-                # # trace service info propertys if desired.
-                # # note that the property keys and values must first be decoded to utf-8 encoding.
-                # if _logsi.IsOn(SILevel.Verbose):
-                #     if serviceInfo.properties is not None:
-                #         dspProperties:dict = {}
-                #         for key, value in serviceInfo.properties.items():
-                #             dspProperties[key.decode('utf-8')] = value.decode('utf-8')
-                #         _logsi.LogDictionary(SILevel.Verbose, "Discovered Spotify Connect device ServiceInfo.Properties: '%s' (%s:%i)" % (deviceName, deviceIpAddress, devicePort), dspProperties) 
-
-                # add the device name to the list (if not already added) using its 
-                # ipv4 address and port number as the key.
-                if deviceKey not in self._DiscoveredDeviceNames.keys():
-                    self._DiscoveredDeviceNames[deviceKey] = deviceName
-
-                # are we verifying devices connections?  if so, then create a SpotifyClient
-                # object, which will verify the connection and gather basic capabilities of the device.
-                # we will also add the SpotifyClient instance using the same key as the device name list.
-                if self._AreDevicesVerified == True:
-                    
-                    if deviceKey not in self._VerifiedDevices.keys():
-                        
-                        #device:SpotifyClient = SpotifyClient(host=deviceIpAddress, port=devicePort)
-                        
-                        # get Spotify Connect player device by it's Name value.
-                        device:Device = self._SpotifyClient.GetPlayerDevice(deviceName)
-                        if device is not None:
-                            self._VerifiedDevices[deviceKey] = device
-
-        elif (serviceStateChange is ServiceStateChange.Removed):
-            _logsi.LogVerbose("Discovered Spotify Connect device removal (ignored): '%s' (%s:%s)", serviceName, serviceType, serviceStateChange)
-            pass
-
-        elif (serviceStateChange is ServiceStateChange.Updated):
-            _logsi.LogVerbose("Discovered Spotify Connect device update (ignored): '%s' (%s:%s)", serviceName, serviceType, serviceStateChange)
-            pass
-
-
-    def DiscoverDevices(self, timeout:int=5) -> dict:
+            finally:
+            
+                # trace.
+                _logsi.LeaveMethod(SILevel.Debug)
+
+
+    def DiscoverDevices(self, timeout:float=2) -> dict:
         """
         Discover Spotify Connect devices on the local network via the 
         ZeroConf (aka MDNS) service.
 
         Args:
-            timeout (int): 
+            timeout (float): 
                 Maximum amount of time to wait (in seconds) for the 
                 discovery to complete.  
-                Default is 5 seconds.
+                Default is 2 seconds.
                 
         Returns:
-            A dictionary of discovered `SpotifyClient` objects.
+            A dictionary of `ZeroconfDiscoveryResult` objects.
 
         <details>
           <summary>Sample Code</summary>
@@ -235,26 +414,43 @@ class SpotifyDiscovery:
         ```
         </details>
         """
+        browser:ServiceBrowser = None
+
         # using Queue as a timer (timeout functionality).
         discoveryQueueTimer = Queue()
-
-        # create the zeroconf service and our listener callback.
-        zeroconf:Zeroconf = Zeroconf()
-        
-        # create the zeroconf service browser that will start device discovery.
-        _logsi.LogVerbose("Discovery of Spotify Connect devices via Zeroconf is starting ...")
-        ServiceBrowser(zeroconf, "_spotify-connect._tcp.local.", handlers=[self._OnServiceStateChange])
-        
+       
         try:
-            # give the ServiceBrowser time to discover
+
+            # create the zeroconf service browser that will start device discovery.
+            _logsi.LogVerbose("Discovery of Spotify Connect devices via Zeroconf is starting")
+            browser = ServiceBrowser(self._ZeroconfClient, "_spotify-connect._tcp.local.", handlers=[self._OnServiceStateChange])
+            
+            # trace.
+            _logsi.LogObject(SILevel.Verbose, "ZeroconfClient object after ServiceBrowser creation", self._ZeroconfClient)
+            
+            # give the ServiceBrowser time to discover.
             discoveryQueueTimer.get(timeout=timeout)
             
         except Empty:
             
             # this is not really an exception, but more of an indicator that
             # the timeout has been reached.
-            _logsi.LogVerbose("Discovery of Spotify Connect devices via Zeroconf has ended.")
+            _logsi.LogVerbose("Discovery of Spotify Connect devices via Zeroconf has reached its timeout of %f seconds" % timeout)
+            
+        finally:
+            
+            if (browser is not None):
+                
+                # remove the zeroconf service browser with associated listener and free resources.
+                _logsi.LogVerbose("Releasing Zeroconf ServiceBrowser instance")
+                browser.cancel()
+                del browser
+                _logsi.LogObject(SILevel.Verbose, "ZeroconfClient object after ServiceBrowser resources released", self._ZeroconfClient)
+
+            # trace.
+            _logsi.LogVerbose("Discovery of Spotify Connect devices via Zeroconf has ended")
         
+        # return result to caller.
         return self._DiscoveredDeviceNames
 
 
@@ -273,12 +469,6 @@ class SpotifyDiscovery:
         if includeItems == True:
             
             for key, deviceName in self._DiscoveredDeviceNames.items():
-                
-                device:Device
-                verifiedStatus:str = ''
-                device = self._VerifiedDevices.get(key, None)
-                if device is not None:
-                    verifiedStatus = ' (verified - ID=%s)' % device.Id
-                msg = "%s\n- %s - %s %s" % (msg, key, deviceName, verifiedStatus)
+                msg = "%s\n- %s" % (msg, key)
             
         return msg

spotifywebapipython/zeroconfapi/__init__.py

@@ -0,0 +1,23 @@
+# import all classes from the namespace.
+from .authenticationtypes import AuthenticationTypes
+from .blobbuilder import BlobBuilder
+from .credentials import Credentials
+from .spotifyzeroconfapierror import SpotifyZeroconfApiError
+from .zeroconfconnect import ZeroconfConnect
+from .zeroconfresponse import ZeroconfResponse
+from .zeroconfgetinfo import ZeroconfGetInfo
+from .zeroconfgetinfoalias import ZeroconfGetInfoAlias
+from .zeroconfgetinfodrmmediaformat import ZeroconfGetInfoDrmMediaFormat
+
+# all classes to import when "import *" is specified.
+__all__ = [
+    'AuthenticationTypes',
+    'BlobBuilder', 
+    'Credentials',
+    'SpotifyZeroconfApiError',
+    'ZeroconfConnect',
+    'ZeroconfGetInfo',
+    'ZeroconfGetInfoAlias',
+    'ZeroconfGetInfoDrmMediaFormat',
+    'ZeroconfResponse',
+]