def _loadSCPD(self, serviceType, timeout):
        """Internal method to load the action definitions.

        :param str serviceType: the service type to load
        :param int timeout: the timeout for downloading
        """

        if serviceType not in self.__deviceServiceDefinitions.keys():
            raise ValueError("Can not load SCPD, no service type defined for: " + serviceType)

        if "scpdURL" not in self.__deviceServiceDefinitions[serviceType].keys():
            raise ValueError("No SCPD URL defined for: " + serviceType)

        # remove actions for given service type
        self.__deviceSCPD.pop(serviceType, None)

        uri = self.__deviceServiceDefinitions[serviceType]["scpdURL"]

        # setup proxies
        proxies = {}
        if self.__httpsProxy:
            proxies = {"https": self.__httpsProxy}

        if self.__httpProxy:
            proxies = {"http": self.__httpProxy}

        # setup authentication
        auth = None
        if self.__password:
            auth = HTTPDigestAuth(self.__username, self.__password)

        # build the URL
        location = self.__protocol + "://" + self.__hostname + ":" + str(self.port) + uri

        # some devices response differently without a User-Agent
        headers = {"User-Agent": "Mozilla/5.0; SimpleTR64-2"}

        # http request
        request = requests.get(location, auth=auth, proxies=proxies, headers=headers, timeout=timeout,
                               verify=self.__verify)

        if request.status_code != 200:
            errorStr = DeviceTR64._extractErrorString(request)
            raise ValueError('Could not load SCPD for "' + serviceType + '" from ' + location + ': ' +
                             str(request.status_code) + ' - ' + request.reason + " -- " + errorStr)

        data = request.text.encode('utf-8')
        if len(data) == 0:
            return

        # parse XML return
        try:
            root = ET.fromstring(data)
        except Exception as e:
            raise ValueError("Can not parse SCPD content for '" + serviceType + "' from '" + location + "': " + str(e))

        actions = {}
        variableTypes = {}
        variableParameterDict = {}

        # iterate through the full XML tree
        for element in root.getchildren():
            tagName = element.tag.lower()

            # go deeper for action lists
            if tagName.endswith("actionlist"):
                # remember the actions and where a specific variable gets referenced
                self._parseSCPDActions(element, actions, variableParameterDict)

            # go deeper for the variable declarations
            elif tagName.endswith("servicestatetable"):
                self._parseSCPDVariableTypes(element, variableTypes)

        # everything have been parsed now merge the variable declarations into the action parameters
        for name in variableParameterDict.keys():
            if name not in variableTypes.keys():
                raise ValueError("Variable reference in action can not be resolved: " + name)

            # iterate through all arguments where this variable have been referenced
            for argument in variableParameterDict[name]:
                # fill in the type of this variable/argument
                argument["dataType"] = variableTypes[name]["dataType"]

                # if the variable declaration includes a default value add it to the action parameter as well
                if "defaultValue" in variableTypes[name].keys():
                    argument["defaultValue"] = variableTypes[name]["defaultValue"]

        self.__deviceSCPD[serviceType] = actions
Internal method to load the action definitions.

        :param str serviceType: the service type to load
        :param int timeout: the timeout for downloading