spotifywebapiPython 1.0.43__py3-none-any.whl → 1.0.44__py3-none-any.whl

spotifywebapipython/models/zeroconfresponse.py

@@ -0,0 +1,108 @@
+# external package imports.
+
+# our package imports.
+from ..sautils import export
+
+@export
+class ZeroconfResponse:
+    """
+    Spotify Web API Zeroconf basic response object.
+    """
+
+    def __init__(self, root:dict=None) -> None:
+        """
+        Initializes a new instance of the class.
+        
+        Args:
+            root (dict):
+                Spotify Web API JSON response in dictionary format, used to load object
+                attributes; otherwise, None to not load attributes.
+        """
+        self._SpotifyError:int = None
+        self._Status:int = None
+        self._StatusString:str = None
+        self._ResponseSource:str = None
+        
+        if (root is None):
+
+            pass
+        
+        else:
+
+            self._ResponseSource = root.get('responseSource', None)
+            self._SpotifyError = root.get('spotifyError', None)
+            self._Status = root.get('status', None)
+            self._StatusString = root.get('statusString', None)
+
+    
+    def __repr__(self) -> str:
+        return self.ToString()
+
+
+    def __str__(self) -> str:
+        return self.ToString()
+
+
+    @property
+    def ResponseSource(self) -> str:
+        """ 
+        Token type provided by the client (e.g. "accesstoken").
+        """
+        return self._ResponseSource
+
+
+    @property
+    def SpotifyError(self) -> int:
+        """ 
+        The last error code returned by a Spotify API call or the SpCallbackError() callback (e.g. 0, -119, etc).
+        """
+        return self._SpotifyError
+
+
+    @property
+    def Status(self) -> int:
+        """ 
+        A code indicating the result of the operation (e.g. 101, 402, etc).
+        """
+        return self._Status
+
+
+    @property
+    def StatusString(self) -> str:
+        """ 
+        The string describing the status code (e.g. "OK", "ERROR-SPOTIFY-ERROR", etc).
+        """
+        return self._StatusString
+
+
+    def ToDictionary(self) -> dict:
+        """
+        Returns a dictionary representation of the class.
+        """
+        result:dict = \
+        {
+            'SpotifyError': self._SpotifyError,
+            'Status': self._Status,
+            'StatusString': self._StatusString,
+            'ResponseSource': self._ResponseSource,
+        }
+        return result
+        
+
+    def ToString(self, includeTitle:bool=False) -> str:
+        """
+        Returns a displayable string representation of the class.
+        
+        Args:
+            includeTitle (str):
+                True to include the class name title prefix.
+        """
+        msg:str = ''
+        if includeTitle: 
+            msg = 'ZeroconfResponse:'
+        
+        if self._SpotifyError is not None: msg = '%s\n SpotifyError="%s"' % (msg, str(self._SpotifyError))
+        if self._Status is not None: msg = '%s\n Status="%s"' % (msg, str(self._Status))
+        if self._StatusString is not None: msg = '%s\n StatusString="%s"' % (msg, str(self._StatusString))
+        if self._ResponseSource is not None: msg = '%s\n ResponseSource="%s"' % (msg, str(self._ResponseSource))
+        return msg 

spotifywebapipython/spotifyclient.py

@@ -14,6 +14,7 @@ from lxml.etree import fromstring, Element
 from .oauthcli import AuthClient
 from .models import *
 from .models import UserProfile as UserProfileCurrentUser
+from .models.zeroconfblobbuilder import int_to_b64str
 from .sautils import export, GetUnixTimestampMSFromUtcNow, _xmlGetInnerText
 from .saappmessages import SAAppMessages
 from .spotifyapierror import SpotifyApiError
@@ -40,6 +41,8 @@ from .const import (
 CACHE_SOURCE_CACHED:str = "cached"
 CACHE_SOURCE_CURRENT:str = "current"
 
+SPOTIFY_DJ_PLAYLIST_ID = "37i9dqzf1eykqdzj48dyyq"
+
 # get smartinspect logger reference; create a new session for this module name.
 from smartinspectpython.siauto import SIAuto, SILevel, SISession, SIMethodParmListContext, SISourceId
 import logging
@@ -454,6 +457,19 @@ class SpotifyClient:
             
         elif responseData is not None:
             
+            # if response is a string (e.g. html response) and is not in the 2xx range then 
+            # we will assume it's an error, even though no json 'error' response body was returned!  
+            # this is usually due to a '503 Server Error' response.
+            if (response.status > 299) and (isinstance(responseData, str)):
+
+                errCode = response.status
+                errMessage = response.reason
+                
+                if responseUTF8 is not None:
+                    errMessage = responseUTF8
+
+                raise SpotifyWebApiError(errCode, errMessage, msg.MethodName, response.reason, _logsi)
+            
             # does json response contain error details?
             if CONST_ERROR in responseData:
                 
@@ -669,7 +685,8 @@ class SpotifyClient:
             uri:str = msg.Uri
             if (uri == self.SpotifyApiTokenUrl) \
             or (uri == self.SpotifyApiAuthorizeUrl) \
-            or (uri.startswith('https:')):
+            or (uri.startswith('https:')) \
+            or (uri.startswith('http:')):
                 url = uri
             else:
                 url = f'{self.SpotifyWebApiUrlBase}{uri}'
@@ -705,9 +722,13 @@ class SpotifyClient:
             # call the appropriate poolmanager request method.
             if msg.HasUrlParameters:
                 
-                # add querystring parameters to url.
+                # add querystring parameters to url; if url already has a partial parm
+                # string (e.g. has a '?xxx=...') then use the append separator (e.g. '...&xxx=...').
                 urlQS:str = urlencode(msg.UrlParameters)
-                url = url + '?' + urlQS
+                urlParmSep:str = '?'
+                if (url.find('?') > 0):
+                    urlParmSep = '&'
+                url = url + urlParmSep + urlQS
                 
                 _logsi.LogDictionary(SILevel.Verbose, "SpotifyClient http request: '%s' (with urlparms)" % (url), msg.UrlParameters, prettyPrint=True)
                 response = self._Manager.request_encode_url(method, url, headers=msg.RequestHeaders)
@@ -6551,6 +6572,27 @@ class SpotifyClient:
                 
             # ensure market was either supplied or implied; default if neither.
             market = self._ValidateMarket(market)
+            
+            # was the Spotify DJ playlist specified?
+            # the DJ is not fully integrated with the playlist API, so the GET request will fail.
+            # we will manually build a basic playlist object to return for the playlist.
+            if (playlistId is not None) and (playlistId.lower() == SPOTIFY_DJ_PLAYLIST_ID):
+                
+                # build basic playlist response.
+                result = Playlist()
+                result._Collaborative = False
+                result._Description = 'Spotify DJ Playlist'
+                result._ExternalUrls._Spotify = 'https://open.spotify.com/playlist/%s' % playlistId
+                result._Id = playlistId
+                result._Name = 'DJ'
+                result._Public = False
+                result._Type = 'playlist'
+                result._Uri = 'spotify:playlist:%s' % playlistId
+                               
+                # trace.
+                _logsi.LogVerbose("Spotify DJ Playlist detected; request will be bypassed, and a basic PlayList object returned")
+                _logsi.LogObject(SILevel.Verbose, TRACE_METHOD_RESULT_TYPE % (apiMethodName, type(result).__name__), result, excludeNonPublic=True)
+                return result
 
             # build spotify web api request parameters.
             urlParms:dict = {}
@@ -13777,3 +13819,251 @@ class SpotifyClient:
         
             # trace.
             _logsi.LeaveMethod(SILevel.Debug, apiMethodName)
+
+
+
+    def ZeroconfGetInformation(self, 
+                               actionUrl:str,
+                               ) -> ZeroconfGetInfo:
+        """
+        Retrieve Spotify Connect device information from the Spotify Zeroconf API `getInfo` endpoint.
+        
+        Args:
+            actionUrl (str):  
+                The Zeroconf action url to issue the request to.  
+                Example: `http://192.168.1.80:8200/zc?action=getInfo`
+                
+        Returns:
+            An `ZeroconfGetInfo` object that contains the response.
+                
+        Raises:
+            SpotifyWebApiError: 
+                If the Spotify Web API request was for a non-authorization service 
+                and the response contains error information.
+            SpotifApiError: 
+                If the method fails for any other reason.
+
+        <details>
+          <summary>Sample Code</summary>
+        ```python
+        .. include:: ../docs/include/samplecode/SpotifyClient/ZeroconfGetInformation.py
+        ```
+        </details>
+        """
+        apiMethodName:str = 'ZeroconfGetInformation'
+        apiMethodParms:SIMethodParmListContext = None
+        result:ZeroconfGetInfo = None
+        
+        try:
+            
+            # trace.
+            apiMethodParms = _logsi.EnterMethodParmList(SILevel.Debug, apiMethodName)
+            apiMethodParms.AppendKeyValue("actionUrl", actionUrl)
+            _logsi.LogMethodParmList(SILevel.Verbose, "Get Spotify Zeroconf getInfo response", apiMethodParms)
+                
+            # execute spotify zeroconf api request.
+            msg:SpotifyApiMessage = SpotifyApiMessage(apiMethodName, actionUrl)
+            self.MakeRequest('GET', msg)
+
+            # process results.
+            result = ZeroconfGetInfo(root=msg.ResponseData)
+        
+            # trace.
+            _logsi.LogObject(SILevel.Verbose, TRACE_METHOD_RESULT_TYPE % (apiMethodName, type(result).__name__), result, excludeNonPublic=True)
+            return result
+
+        except SpotifyWebApiError: raise  # pass handled exceptions on thru
+        except SpotifyWebApiAuthenticationError: raise  # pass handled exceptions on thru
+        except Exception as ex:
+            
+            # format unhandled exception.
+            raise SpotifyApiError(SAAppMessages.UNHANDLED_EXCEPTION.format(apiMethodName, str(ex)), ex, logsi=_logsi)
+
+        finally:
+        
+            # trace.
+            _logsi.LeaveMethod(SILevel.Debug, apiMethodName)
+
+
+    def ZeroconfResetUsers(self, 
+                           actionUrl:str,
+                           ) -> ZeroconfResponse:
+        """
+        Reset users for a Spotify Connect device by calling the Spotify Zeroconf API `resetUsers` endpoint.
+        
+        Args:
+            actionUrl (str):  
+                The Zeroconf action url to issue the request to.  
+                Example: `http://192.168.1.80:8200/zc?action=resetUsers`
+                
+        Returns:
+            An `ZeroconfResponse` object that contains the response.
+                
+        Raises:
+            SpotifyWebApiError: 
+                If the Spotify Web API request was for a non-authorization service 
+                and the response contains error information.
+            SpotifApiError: 
+                If the method fails for any other reason.
+
+        <details>
+          <summary>Sample Code</summary>
+        ```python
+        .. include:: ../docs/include/samplecode/SpotifyClient/ZeroconfResetUsers.py
+        ```
+        </details>
+        """
+        apiMethodName:str = 'ZeroconfResetUsers'
+        apiMethodParms:SIMethodParmListContext = None
+        result:ZeroconfResponse = None
+        
+        try:
+            
+            # trace.
+            apiMethodParms = _logsi.EnterMethodParmList(SILevel.Debug, apiMethodName)
+            apiMethodParms.AppendKeyValue("actionUrl", actionUrl)
+            _logsi.LogMethodParmList(SILevel.Verbose, "Get Spotify Zeroconf GetInfo response", apiMethodParms)
+                
+            # execute spotify zeroconf api request.
+            msg:SpotifyApiMessage = SpotifyApiMessage(apiMethodName, actionUrl)
+            self.MakeRequest('GET', msg)
+
+            # process results.
+            result = ZeroconfResponse(root=msg.ResponseData)
+        
+            # trace.
+            _logsi.LogObject(SILevel.Verbose, TRACE_METHOD_RESULT_TYPE % (apiMethodName, type(result).__name__), result, excludeNonPublic=True)
+            return result
+
+        except SpotifyWebApiError: raise  # pass handled exceptions on thru
+        except SpotifyWebApiAuthenticationError: raise  # pass handled exceptions on thru
+        except Exception as ex:
+            
+            # format unhandled exception.
+            raise SpotifyApiError(SAAppMessages.UNHANDLED_EXCEPTION.format(apiMethodName, str(ex)), ex, logsi=_logsi)
+
+        finally:
+        
+            # trace.
+            _logsi.LeaveMethod(SILevel.Debug, apiMethodName)
+
+
+    def ZeroconfAddUser(self, 
+                        actionUrl:str,
+                        getInfoResponse:ZeroconfGetInfo,
+                        username:str,
+                        password:str,
+                        ) -> ZeroconfResponse:
+        """
+        Add a user to a Spotify Connect device by calling the Spotify Zeroconf API `addUser` endpoint.
+        
+        Args:
+            actionUrl (str):  
+                The Zeroconf action url to issue the request to.  
+                Example: `http://192.168.1.80:8200/zc?action=addUser&version=1.0`
+                
+        Returns:
+            An `ZeroconfResponse` object that contains the response.
+                
+        Raises:
+            SpotifyWebApiError: 
+                If the Spotify Web API request was for a non-authorization service 
+                and the response contains error information.
+            SpotifApiError: 
+                If the method fails for any other reason.
+
+        <details>
+          <summary>Sample Code</summary>
+        ```python
+        .. include:: ../docs/include/samplecode/SpotifyClient/ZeroconfGetInformation.py
+        ```
+        </details>
+        """
+        apiMethodName:str = 'ZeroconfAddUser'
+        apiMethodParms:SIMethodParmListContext = None
+        result:ZeroconfResponse = None
+        
+        try:
+            
+            # trace.
+            apiMethodParms = _logsi.EnterMethodParmList(SILevel.Debug, apiMethodName)
+            apiMethodParms.AppendKeyValue("actionUrl", actionUrl)
+            apiMethodParms.AppendKeyValue("getInfoResponse", getInfoResponse)
+            apiMethodParms.AppendKeyValue("username", username)
+            apiMethodParms.AppendKeyValue("password", password)
+            _logsi.LogMethodParmList(SILevel.Verbose, "Get Spotify Zeroconf addUser response", apiMethodParms)
+            
+            raise NotImplemented()
+
+            # build credentials object.
+            self.credentials = ZeroconfCredentials(username, password)
+
+            # build authentication blob.
+            builder = ZeroconfBlobBuilder(self.credentials, getInfoResponse.DeviceId, getInfoResponse.PublicKey)
+            blob = builder.build()
+
+            # # call zeroconf to add the user to the device.
+            # r = self._add_user(
+            #     self.credentials.username.decode('ascii'),
+            #     int_to_b64str(builder.dh_keys.public_key),
+            #     blob)
+
+        # def _add_user(self, username: str, client_key: str, blob: str): # -> bool
+        #     respone = requests.post(
+        #         self.uri,
+        #         headers={
+        #             'Content-Type': 'application/x-www-form-urlencoded'
+        #         },
+        #         params={
+        #             'action': 'addUser',
+        #             'userName': username,
+        #             'clientKey': client_key,
+        #             'blob': blob
+        #         }
+        #     )
+        #     return respone
+
+            # build spotify zeroconf addUser parameters.
+            urlParms:dict = \
+            {
+                'userName': self.credentials.username.decode('ascii'),
+                'clientKey': int_to_b64str(builder.dh_keys.public_key),
+                'blob': blob,
+                'deviceId': getInfoResponse.DeviceId,
+                'deviceName': getInfoResponse.RemoteName,
+                'loginId': 'xxxxxxxxxxx',
+            }
+
+    # let params = [
+    #   3  ("action", "addUser"),
+    #   3  ("userName", username),
+    #   3  ("blob", blob),
+    #   3  ("clientKey", my_public_key),
+    #     ("deviceId", &device_id),
+    #     ("deviceName", "spotify-connect"),
+    #     ("loginId", &login_id),
+        
+            
+            # execute spotify zeroconf api request.
+            msg:SpotifyApiMessage = SpotifyApiMessage(apiMethodName, actionUrl)
+            msg.UrlParameters = urlParms
+            self.MakeRequest('POST', msg)
+
+            # process results.
+            result = ZeroconfResponse(root=msg.ResponseData)
+
+            # trace.
+            _logsi.LogObject(SILevel.Verbose, TRACE_METHOD_RESULT_TYPE % (apiMethodName, type(result).__name__), result, excludeNonPublic=True)
+            return result
+
+        except SpotifyWebApiError: raise  # pass handled exceptions on thru
+        except SpotifyWebApiAuthenticationError: raise  # pass handled exceptions on thru
+        except Exception as ex:
+            
+            # format unhandled exception.
+            raise SpotifyApiError(SAAppMessages.UNHANDLED_EXCEPTION.format(apiMethodName, str(ex)), ex, logsi=_logsi)
+
+        finally:
+        
+            # trace.
+            _logsi.LeaveMethod(SILevel.Debug, apiMethodName)

spotifywebapipython/spotifydiscovery.py

@@ -3,6 +3,7 @@ try:
     from queue import Queue, Empty
 except ImportError:
     from Queue import Queue, Empty
+from time import sleep
 from zeroconf import Zeroconf, ServiceBrowser, ServiceInfo, ServiceStateChange, IPVersion
 
 # our package imports.
@@ -10,6 +11,7 @@ from .saappmessages import SAAppMessages
 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
@@ -63,6 +65,7 @@ class SpotifyDiscovery:
         # 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 = {}
@@ -119,6 +122,15 @@ class SpotifyDiscovery:
         return self._DiscoveredDeviceNames
 
 
+    @property
+    def DiscoveryResults(self) -> list[ZeroconfDiscoveryResult]:
+        """
+        An array of `ZeroconfDiscoveryResult` items that contain discovery details for
+        each service that was discovered.
+        """
+        return self._DiscoveryResults
+
+
     @property
     def VerifiedDevices(self) -> dict:
         """
@@ -170,6 +182,23 @@ class SpotifyDiscovery:
             # create device instances for each ipv4 address found.
             for deviceIpAddress in ipAddressList:
                 
+                # create new result instance.
+                result:ZeroconfDiscoveryResult = ZeroconfDiscoveryResult()
+                result.DeviceName = deviceName
+                result.Domain = '.local'
+                result.HostIpv4Address = deviceIpAddress
+                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
+                
                 devicePort:int = serviceInfo.port
                 deviceKey:str = '%s:%i' % (deviceIpAddress, devicePort)
                 _logsi.LogVerbose("Discovered Spotify Connect device: %s - %s" % (deviceKey, deviceName))
@@ -177,20 +206,30 @@ class SpotifyDiscovery:
                     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) 
+                # 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, "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
 
+                # add the device result to the list.
+                self._DiscoveryResults.append(result)
+
                 # 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.
@@ -198,12 +237,15 @@ class SpotifyDiscovery:
                     
                     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
+                            result.SpotifyConnectIsInDeviceList = True
+
+                # trace.
+                _logsi.LogObject(SILevel.Verbose, "Discovered Spotify Connect device result: '%s' (%s:%i)" % (deviceName, deviceIpAddress, devicePort), result, excludeNonPublic=True)                        
+                #_logsi.LogArray(SILevel.Verbose, "Discovered Spotify Connect device result.Properties: '%s' (%s:%i)" % (deviceName, deviceIpAddress, devicePort), result.Properties)                        
 
         elif (serviceStateChange is ServiceStateChange.Removed):
             _logsi.LogVerbose("Discovered Spotify Connect device removal (ignored): '%s' (%s:%s)", serviceName, serviceType, serviceStateChange)
@@ -258,6 +300,52 @@ class SpotifyDiscovery:
         return self._DiscoveredDeviceNames
 
 
+    def BroadcastService(self, serviceInfo:ServiceInfo, port:int=5353) -> None:
+        """
+        Generate a Zeroconf / mDNS broadcast to announce a service, and sends the broadcast out.
+
+        Args:
+            serviceInfo (ServiceInfo): 
+                Service information to broadcast.
+            port (int): 
+                mDNS port number to send the broadcast on.  
+                Default is 5353.  
+        """
+        try:
+
+            # create the zeroconf service.
+            zeroconf:Zeroconf = Zeroconf(ip_version=IPVersion.V4Only)
+                   
+            # # TEST TODO - hardcoded serviceinfo properties for testing.
+            # serviceType:str = '_spotify-connect._tcp.local.'
+            # serviceName:str = 'Bose-ST10-95._spotify-connect._tcp.local.'
+            # parsedAddresses:list[str] = ['192.168.1.82']
+            # port:int = 8200
+            # hostTTL:int = 120
+            # priority:int = 0
+            # otherTTL:int = 4500
+            # server:str = 'Bose-SM2-987bf3244-95.local.'
+            # weight:int = 0
+            # properties:dict = {b'CPath': b'/zc', b'VERSION': b'1.0'}
+
+            # # create the zeroconf serviceinfo object.
+            # zcfServiceInfo:ServiceInfo = ServiceInfo(serviceType, serviceName, port, weight, priority, properties, server, hostTTL, otherTTL, parsed_addresses=parsedAddresses)
+        
+            # generate a broadcast packet to announce the service.
+            _logsi.LogVerbose("Generating Zeroconf Service Broadcast for service: '%s'" % serviceInfo.name)
+            dnsOutgoing = zeroconf.generate_service_broadcast(serviceInfo, serviceInfo.host_ttl, True)
+
+            # send the broadcast packet.
+            _logsi.LogVerbose("Sending Zeroconf Service Broadcast for service: '%s'" % serviceInfo.name)
+            zeroconf.send(dnsOutgoing, addr=None, port=port)
+           
+        except Exception as ex:
+            
+            # this is not really an exception, but more of an indicator that
+            # the timeout has been reached.
+            _logsi.LogException("Zeroconf Broadcast Service exception: %s" % str(ex), ex, logToSystemLogger=False)
+        
+
     def ToString(self, includeItems:bool=False) -> str:
         """
         Returns a displayable string representation of the class.
@@ -273,7 +361,6 @@ class SpotifyDiscovery:
         if includeItems == True:
             
             for key, deviceName in self._DiscoveredDeviceNames.items():
-                
                 device:Device
                 verifiedStatus:str = ''
                 device = self._VerifiedDevices.get(key, None)