Python _winreg 模块，EnumValue() 实例源码

def get_shellfolders(branch=HKCU, key=SHELL_FOLDERS):
    """Return mapping of shell folder names (current user) to paths."""

    key = _winreg.OpenKey(branch, key)
    folders = {}
    i = 0
    while True:
        try:
            ret = _winreg.EnumValue(key, i)
            if ret[2] == _winreg.REG_EXPAND_SZ:
                folders[ret[0]] = expandvars(ret[1])
            else:
                folders[ret[0]] = ret[1]
        except WindowsError:
            break
        i +=1
    key.Close()
    return folders

def values(self):
        """The values of the registry key

        :type: [:class:`KeyValue`] - A list of values"""
        res = []
        with ExpectWindowsError(259):
            for i in itertools.count():
                name_value_type = _winreg.EnumValue(self.phkey, i)
                # _winreg doest not support REG_QWORD
                # See http://bugs.python.org/issue23026
                if name_value_type[2] == REG_QWORD:
                    name = name_value_type[0]
                    value = struct.unpack("<Q", name_value_type[1])[0]
                    type = name_value_type[2]
                    name_value_type = name, value, type
                res.append(name_value_type)
        return [KeyValue(*r) for r in res]

def disable_proxy():
    _,values_num,_ = winreg.QueryInfoKey(CONNECTIONS)
    for i in range(0, values_num):
        try:
            key, value,_ = winreg.EnumValue(CONNECTIONS, i)
        except:
            break

        List = INTERNET_PER_CONN_OPTION_LIST()
        Option = (INTERNET_PER_CONN_OPTION * 1)()
        nSize = c_ulong(sizeof(INTERNET_PER_CONN_OPTION_LIST))

        Option[0].dwOption = INTERNET_PER_CONN_FLAGS
        Option[0].Value.dwValue = PROXY_TYPE_DIRECT

        List.dwSize = sizeof(INTERNET_PER_CONN_OPTION_LIST)
        List.pszConnection = create_unicode_buffer(key)
        List.dwOptionCount = 1
        List.dwOptionError = 0
        List.pOptions = Option

        InternetSetOption(None, INTERNET_OPTION_PER_CONNECTION_OPTION, byref(List), nSize)

    InternetSetOption(None, INTERNET_OPTION_SETTINGS_CHANGED, None, 0)
    InternetSetOption(None, INTERNET_OPTION_REFRESH, None, 0)

def disable_proxy():
    _,values_num,_ = winreg.QueryInfoKey(CONNECTIONS)
    for i in range(0, values_num):
        try:
            key, value,_ = winreg.EnumValue(CONNECTIONS, i)
        except:
            break

        List = INTERNET_PER_CONN_OPTION_LIST()
        Option = (INTERNET_PER_CONN_OPTION * 1)()
        nSize = c_ulong(sizeof(INTERNET_PER_CONN_OPTION_LIST))

        Option[0].dwOption = INTERNET_PER_CONN_FLAGS
        Option[0].Value.dwValue = PROXY_TYPE_DIRECT

        List.dwSize = sizeof(INTERNET_PER_CONN_OPTION_LIST)
        List.pszConnection = create_unicode_buffer(key)
        List.dwOptionCount = 1
        List.dwOptionError = 0
        List.pOptions = Option

        InternetSetOption(None, INTERNET_OPTION_PER_CONNECTION_OPTION, byref(List), nSize)

    InternetSetOption(None, INTERNET_OPTION_SETTINGS_CHANGED, None, 0)
    InternetSetOption(None, INTERNET_OPTION_REFRESH, None, 0)

def disable_proxy():
    _,values_num,_ = winreg.QueryInfoKey(CONNECTIONS)
    for i in range(0, values_num):
        try:
            key, value,_ = winreg.EnumValue(CONNECTIONS, i)
        except:
            break

        List = INTERNET_PER_CONN_OPTION_LIST()
        Option = (INTERNET_PER_CONN_OPTION * 1)()
        nSize = c_ulong(sizeof(INTERNET_PER_CONN_OPTION_LIST))

        Option[0].dwOption = INTERNET_PER_CONN_FLAGS
        Option[0].Value.dwValue = PROXY_TYPE_DIRECT

        List.dwSize = sizeof(INTERNET_PER_CONN_OPTION_LIST)
        List.pszConnection = create_unicode_buffer(key)
        List.dwOptionCount = 1
        List.dwOptionError = 0
        List.pOptions = Option

        InternetSetOption(None, INTERNET_OPTION_PER_CONNECTION_OPTION, byref(List), nSize)

    InternetSetOption(None, INTERNET_OPTION_SETTINGS_CHANGED, None, 0)
    InternetSetOption(None, INTERNET_OPTION_REFRESH, None, 0)

def has_sound(sound):
    """Find out if a particular event is configured with a default sound"""
    try:
        # Ask the mixer API for the number of devices it knows about.
        # When there are no devices, PlaySound will fail.
        if ctypes.windll.winmm.mixerGetNumDevs() is 0:
            return False

        key = _winreg.OpenKeyEx(_winreg.HKEY_CURRENT_USER,
                "AppEvents\Schemes\Apps\.Default\{0}\.Default".format(sound))
        value = _winreg.EnumValue(key, 0)[1]
        if value is not u"":
            return True
        else:
            return False
    except WindowsError:
        return False

def has_sound(sound):
    """Find out if a particular event is configured with a default sound"""
    try:
        # Ask the mixer API for the number of devices it knows about.
        # When there are no devices, PlaySound will fail.
        if ctypes.windll.winmm.mixerGetNumDevs() is 0:
            return False

        key = _winreg.OpenKeyEx(_winreg.HKEY_CURRENT_USER,
                "AppEvents\Schemes\Apps\.Default\{0}\.Default".format(sound))
        value = _winreg.EnumValue(key, 0)[1]
        if value is not u"":
            return True
        else:
            return False
    except WindowsError:
        return False

def loadFromRegistryCurrentUser(self):
        ''' Load configuration from Windows registry. '''
        # We manually build a .INI file in memory from the registry.
        inilines = ['[%s]' % applicationConfig.CONFIG_SECTIONNAME]
        try:
            import _winreg
        except ImportError, exc:
            raise ImportError, "applicationConfig.loadFromRegistryCurrentUser() can only be used under Windows (requires the _winreg module).\nCould not import module because: %s" % exc
        try:
            key = _winreg.OpenKey(
                _winreg.HKEY_CURRENT_USER, applicationConfig.CONFIG_REGPATH, 0, _winreg.KEY_READ)
            # Now get all values in this key:
            i = 0
            try:
                while True:
                    # mmm..strange, Should unpack to 3 values, but seems to
                    # unpack to more.  Bug of EnumValue() ?
                    valueobj = _winreg.EnumValue(key, i)
                    valuename = str(valueobj[0]).strip()
                    valuedata = str(valueobj[1]).strip()
                    valuetype = valueobj[2]
                    if valuetype != _winreg.REG_SZ:
                        raise TypeError, "The registry value %s does not have the correct type (REG_SZ). Please delete it." % valuename
                    else:
                        if valuename not in applicationConfig.NONEXPORTABLE_PARAMETERS:
                            # Build the .INI file.
                            inilines += ['%s=%s' % (valuename, str(valuedata))]
                    i += 1
            except EnvironmentError:
                # EnvironmentError means: "No more values to read". We simply
                # exit the 'While True' loop.
                pass
            # Then parse the generated .INI file.
            self.fromINI('\n'.join(inilines))
        except EnvironmentError:
            raise WindowsError, "Could not read configuration from registry !"
        _winreg.CloseKey(key)

def printNets(username, password):
    keypath = r"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\NetworkList\\Signatures\\Unmanaged"
    key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, keypath)

    print ('[*] Networks you have joined.')

    for i in range(1):
    try:
        guid = _winreg.EnumKey(key, i)
        netKey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, keypath+r"\\"+str(guid))

        (n, addr, t) = _winreg.EnumValue(netKey, 0)
        (n, name, t) = _winreg.EnumValue(netKey, 1)

        macAddr = val2addr(addr)

        print (' [+] ' + name + ' ' + macAddr)

        #wiglePrint(username, password, macAddr)
            _winreg.CloseKey(netKey)

    except Exception, e:
            print e
        break

def disable_proxy():
    _,values_num,_ = winreg.QueryInfoKey(CONNECTIONS)
    for i in range(0, values_num):
        try:
            key, value,_ = winreg.EnumValue(CONNECTIONS, i)
        except:
            break

        List = INTERNET_PER_CONN_OPTION_LIST()
        Option = (INTERNET_PER_CONN_OPTION * 1)()
        nSize = c_ulong(sizeof(INTERNET_PER_CONN_OPTION_LIST))

        Option[0].dwOption = INTERNET_PER_CONN_FLAGS
        Option[0].Value.dwValue = PROXY_TYPE_DIRECT

        List.dwSize = sizeof(INTERNET_PER_CONN_OPTION_LIST)
        List.pszConnection = create_unicode_buffer(key)
        List.dwOptionCount = 1
        List.dwOptionError = 0
        List.pOptions = Option

        InternetSetOption(None, INTERNET_OPTION_PER_CONNECTION_OPTION, byref(List), nSize)

    InternetSetOption(None, INTERNET_OPTION_SETTINGS_CHANGED, None, 0)
    InternetSetOption(None, INTERNET_OPTION_REFRESH, None, 0)

def _delete_key_if_empty(self, service):
        key_name = r'Software\%s\Keyring' % service
        key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_name, 0,
            winreg.KEY_ALL_ACCESS)
        try:
            winreg.EnumValue(key, 0)
            return
        except WindowsError:
            pass
        winreg.CloseKey(key)

        # it's empty; delete everything
        while key_name != 'Software':
            parent, sep, base = key_name.rpartition('\\')
            key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, parent, 0,
                winreg.KEY_ALL_ACCESS)
            winreg.DeleteKey(key, base)
            winreg.CloseKey(key)
            key_name = parent

def __del_values(self):
        'Private class method.'
        try:
            while True:
                _winreg.DeleteValue(self.__self, _winreg.EnumValue(self.__self, 0)[0])
        except EnvironmentError:
            pass

def __iter__(self):
        'Iterate over the value names.'
        values, index = [], 0
        try:
            while True:
                values.append(_winreg.EnumValue(self.__self, index)[0])
                index += 1
        except EnvironmentError:
            for value in values:
                yield value

def __contains__(self, item):
        'Check for a value\'s existence.'
        item, index = item.lower(), 0
        try:
            while True:
                if _winreg.EnumValue(self.__self, index)[0].lower() == item:
                    return True
                index += 1
        except EnvironmentError:
            return False

def vals(self):
        # returns the list of values
        if not self._vals:
            self._vals=[]
            for i in xrange(reg.QueryInfoKey(self.wrk)[1]):
                try:
                    self._vals.append(Val(self, *reg.EnumValue(self.wrk, i)))
                except WindowsError: pass
        return self._vals

def __del_values(self):
        'Private class method.'
        try:
            while True:
                _winreg.DeleteValue(self.__key, _winreg.EnumValue(self.__key, 0)[0])
        except EnvironmentError:
            pass

def __contains__(self, item):
        'Check for a value\'s existence.'
        item = item.lower()
        for index in xrange(_winreg.QueryInfoKey(self.__key)[1]):
            if _winreg.EnumValue(self.__key, index)[0].lower() == item:
                return True
        return False

################################################################################

def __del_values(self):
        'Private class method.'
        try:
            while True:
                _winreg.DeleteValue(self.__key, _winreg.EnumValue(self.__key, 0)[0])
        except EnvironmentError:
            pass

def __iter__(self):
        'Iterate over the value names.'
        return iter(tuple(_winreg.EnumValue(self.__key, index)[0] for index in xrange(_winreg.QueryInfoKey(self.__key)[1])))

def __contains__(self, item):
        'Check for a value\'s existence.'
        item = item.lower()
        for index in xrange(_winreg.QueryInfoKey(self.__key)[1]):
            if _winreg.EnumValue(self.__key, index)[0].lower() == item:
                return True
        return False

################################################################################

def enumvalue(self, index):
            """ Enumerate the values of the currently open key """

            if not self._hkey: raise RegistryError,"Error: null key"
            try:
                return wreg.EnumValue(self._hkey, index)
            except EnvironmentError, e:
                raise RegistryError, e

def valuestodict(key):
    """Convert a registry key's values to a dictionary."""
    dict = {}
    size = winreg.QueryInfoKey(key)[1]
    for i in range(size):
        data = winreg.EnumValue(key, i)
        dict[data[0]] = data[1]
    return dict

def _enumerate_reg_values(key):
        return _RegKeyDict._enumerate_reg(key, _winreg.EnumValue)

def set_proxy(proxy_addr):
    _,values_num,_ = winreg.QueryInfoKey(CONNECTIONS)
    if values_num:
        for i in range(0, values_num):
            try:
                key,value,_ = winreg.EnumValue(CONNECTIONS, i)
            except:
                break

            if '://' in proxy_addr:
                set_proxy_auto(proxy_addr, key)
            else:
                set_proxy_server(proxy_addr, key)

def set_proxy(proxy_addr):
    _,values_num,_ = winreg.QueryInfoKey(CONNECTIONS)
    if values_num:
        for i in range(0, values_num):
            try:
                key,value,_ = winreg.EnumValue(CONNECTIONS, i)
            except:
                break

            if '://' in proxy_addr:
                set_proxy_auto(proxy_addr, key)
            else:
                set_proxy_server(proxy_addr, key)

def __init__(self):
        if self.info is not None:
            return
        info = []
        try:
            #XXX: Bad style to use so long `try:...except:...`. Fix it!
            import _winreg
            prgx = re.compile(r"family\s+(?P<FML>\d+)\s+model\s+(?P<MDL>\d+)"\
                              "\s+stepping\s+(?P<STP>\d+)",re.IGNORECASE)
            chnd=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, self.pkey)
            pnum=0
            while 1:
                try:
                    proc=_winreg.EnumKey(chnd,pnum)
                except _winreg.error:
                    break
                else:
                    pnum+=1
                    info.append({"Processor":proc})
                    phnd=_winreg.OpenKey(chnd,proc)
                    pidx=0
                    while True:
                        try:
                            name,value,vtpe=_winreg.EnumValue(phnd,pidx)
                        except _winreg.error:
                            break
                        else:
                            pidx=pidx+1
                            info[-1][name]=value
                            if name=="Identifier":
                                srch=prgx.search(value)
                                if srch:
                                    info[-1]["Family"]=int(srch.group("FML"))
                                    info[-1]["Model"]=int(srch.group("MDL"))
                                    info[-1]["Stepping"]=int(srch.group("STP"))
        except:
            print sys.exc_value,'(ignoring)'
        self.__class__.info = info

def valuestodict(key):
    """Convert a registry key's values to a dictionary."""
    dict = {}
    size = _winreg.QueryInfoKey(key)[1]
    for i in range(size):
        data = _winreg.EnumValue(key, i)
        dict[data[0]] = data[1]
    return dict

def valuestodict(key):
    """Convert a registry key's values to a dictionary."""
    dict = {}
    size = winreg.QueryInfoKey(key)[1]
    for i in range(size):
        data = winreg.EnumValue(key, i)
        dict[data[0]] = data[1]
    return dict

def portiter():
    key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, b'HARDWARE\\DEVICEMAP\\SERIALCOMM') # open the registry
    i = 0
    while True: # loop until we run out of devices
        try:
            name = bytes(winreg.EnumValue(key, i)[1]) # get the device name
            # EnumValue gets item number i, returning a tuple containing the name in position 1
        except OSError: # that's all the devices
            break
        yield name, port_prefix + name
        i += 1

def valuestodict(key):
    """Convert a registry key's values to a dictionary."""
    dict = {}
    size = winreg.QueryInfoKey(key)[1]
    for i in range(size):
        data = winreg.EnumValue(key, i)
        dict[data[0]] = data[1]
    return dict

def valuestodict(key):
    """Convert a registry key's values to a dictionary."""
    dict = {}
    size = winreg.QueryInfoKey(key)[1]
    for i in range(size):
        data = winreg.EnumValue(key, i)
        dict[data[0]] = data[1]
    return dict

def _enumerate_reg_values(key):
        return _RegKeyDict._enumerate_reg(key, _winreg.EnumValue)

def load(self):
        if USE_WINDOWS:
            import _winreg
            try:
                key = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, self.keyname)
            except:
                return
            try:
                self.values = {}
                for j in range(1000):
                    try:
                        name, data, dtype = _winreg.EnumValue(key, j)
                    except EnvironmentError:
                        break
                    self.values[name] = str(data)
            finally:
                key.Close()
        else:
            try:
                f = open(self.filename, 'r')
            except (IOError, OSError):
                return
            try:
                self.values = {}
                for line in f.read().split("\n"):
                    if not '=' in line: continue
                    k, v = line.split("=", 1)
                    self.values[k.strip()] = v.strip()
            finally:
                f.close()

def __init__(self):
        if self.info is not None:
            return
        info = []
        try:
            #XXX: Bad style to use so long `try:...except:...`. Fix it!
            import _winreg

            prgx = re.compile(r"family\s+(?P<FML>\d+)\s+model\s+(?P<MDL>\d+)" \
                              "\s+stepping\s+(?P<STP>\d+)", re.IGNORECASE)
            chnd = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, self.pkey)
            pnum = 0
            while 1:
                try:
                    proc = _winreg.EnumKey(chnd, pnum)
                except _winreg.error:
                    break
                else:
                    pnum += 1
                    info.append({"Processor": proc})
                    phnd = _winreg.OpenKey(chnd, proc)
                    pidx = 0
                    while True:
                        try:
                            name, value, vtpe = _winreg.EnumValue(phnd, pidx)
                        except _winreg.error:
                            break
                        else:
                            pidx = pidx + 1
                            info[-1][name] = value
                            if name == "Identifier":
                                srch = prgx.search(value)
                                if srch:
                                    info[-1]["Family"] = int(srch.group("FML"))
                                    info[-1]["Model"] = int(srch.group("MDL"))
                                    info[-1]["Stepping"] = int(srch.group("STP"))
        except:
            print(  str(sys.exc_info()) +  '(ignoring)' )

        self.__class__.info = info

def set_proxy(proxy_addr):
    _,values_num,_ = winreg.QueryInfoKey(CONNECTIONS)
    if values_num:
        for i in range(0, values_num):
            try:
                key,value,_ = winreg.EnumValue(CONNECTIONS, i)
            except:
                break

            if '://' in proxy_addr:
                set_proxy_auto(proxy_addr, key)
            else:
                set_proxy_server(proxy_addr, key)

def windows_ports():
    path = 'HARDWARE\\DEVICEMAP\\SERIALCOMM'
    try:
        key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path)
    except WindowsError:
        raise Exception

    for i in itertools.count():
        try:
            val = winreg.EnumValue(key, i)
            yield (str(val[1]))  # , str(val[0]))
        except EnvironmentError:
            break

def valuesToDict(key):
    """Convert a registry key's values to a dictionary."""
    dict={}
    size=_winreg.QueryInfoKey(key)[1]
    for i in xrange(size):
        dict[_winreg.EnumValue(key, i)[0]]=_winreg.EnumValue(key, i)[1]
    return dict

def serialList():
    baselist=[]
    if os.name=="nt":
        try:
            key=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,"HARDWARE\\DEVICEMAP\\SERIALCOMM")
            i=0
            while(1):
                baselist+=[_winreg.EnumValue(key,i)[1]]
                i+=1
        except:
            pass
    baselist = baselist \
               + glob.glob("/dev/ttyUSB*") \
               + glob.glob("/dev/ttyACM*") \
               + glob.glob("/dev/tty.usb*") \
               + glob.glob("/dev/cu.*") \
               + glob.glob("/dev/cuaU*") \
               + glob.glob("/dev/rfcomm*")

    additionalPorts = settings().get(["serial", "additionalPorts"])
    for additional in additionalPorts:
        baselist += glob.glob(additional)

    prev = settings().get(["serial", "port"])
    if prev in baselist:
        baselist.remove(prev)
        baselist.insert(0, prev)
    if settings().getBoolean(["devel", "virtualPrinter", "enabled"]):
        baselist.append("VIRTUAL")
    return baselist

def readValues(keyPath):
    # return Dict of name:value from key
    explorer = OpenKey(HKEY_LOCAL_MACHINE, keyPath, 0, KEY_READ | KEY_WOW64_64KEY)
    valuesDict = {}
    for i in range(QueryInfoKey(explorer)[1]):
        name, value, type = EnumValue(explorer, i)
        valuesDict[name] = value
    return valuesDict

def next(self):
        try:
            v = _winreg.EnumValue(self.key.hkey,self.index)
        except WindowsError:
            raise StopIteration
        else:
            self.index += 1
            return Value(v[1],v[0],v[2])

def valuestodict(key):
    """Convert a registry key's values to a dictionary."""
    dict = {}
    size = winreg.QueryInfoKey(key)[1]
    for i in range(size):
        data = winreg.EnumValue(key, i)
        dict[data[0]] = data[1]
    return dict

def valuestodict(key):
    """Convert a registry key's values to a dictionary."""
    dict = {}
    size = winreg.QueryInfoKey(key)[1]
    for i in range(size):
        data = winreg.EnumValue(key, i)
        dict[data[0]] = data[1]
    return dict

def iteritems_data(self):
        i = 0
        # yield data
        try:
            while 1:
                s, obj, objtype = _winreg.EnumValue(self.keyhandle, i)
                yield s, self.massageIncomingRegistryValue((obj, objtype))
                i += 1
        except:
            pass

def is_pseudo_protocal_key(input_key_name) :
    key=None

    try :
        key=_winreg.OpenKey(_winreg.HKEY_CLASSES_ROOT,input_key_name)
    except :  #  Cannot Open This Key ..
        return False

    key_index=0
    value_index=0
    exist_value=False
    exist_key=False

    try :
        while True :
            value_name,value_value,value_type=_winreg.EnumValue(key,value_index)
            value_index+=1

            if 'URL Protocol'==value_name :
                exist_value=True
    except :
        pass

    try :
        while True :
            key_name=_winreg.EnumKey(key,key_index)
            key_index+=1

            if 'shell'==key_name :
                try :
                    pseudo_protocal_command=_winreg.OpenKey(_winreg.HKEY_CLASSES_ROOT,input_key_name+'\\shell\\open\\command')
                    exist_key=True
                except :
                    pass
    except :
        pass

    if exist_value and exist_key :
        return True

    return False

def get_pseudo_protocal_shell(key_name) :
    pseudo_protocal_command_key=_winreg.OpenKey(_winreg.HKEY_CLASSES_ROOT,key_name+'\\shell\\open\\command')

    try :
        value_name,value_value,value_type=_winreg.EnumValue(pseudo_protocal_command_key,0)

        return value_value
    except :
        return '<except>'

def get_process(keyList):
    try:
        i = 0
        while True:
            name, value, type = _winreg.EnumValue(key,i)
            keyList[str(name)] = value
            i+=1
    except WindowsError:
        pass
    return keyList

def valuestodict(key):
    """Convert a registry key's values to a dictionary."""
    dict = {}
    size = winreg.QueryInfoKey(key)[1]
    for i in range(size):
        data = winreg.EnumValue(key, i)
        dict[data[0]] = data[1]
    return dict

def getRegisterValueInAutoRun(key='audioTerm'):
    import _winreg
    try:
        r = _winreg.OpenKey(
                 _winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Windows\CurrentVersion\Run")

        p1,num,p3 = _winreg.QueryInfoKey(r)
        for n in range(num):
            p1,p2,p3 =  _winreg.EnumValue(r,n)
            if p1 == key:
                return p2
    except:
        traceback.print_exc()
        return None

def getRegisterValueInAutoRun(key='audioTerm'):
    import _winreg
    try:
        r = _winreg.OpenKey(
                 _winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Windows\CurrentVersion\Run")

        p1,num,p3 = _winreg.QueryInfoKey(r)
        for n in range(num):
            p1,p2,p3 =  _winreg.EnumValue(r,n)
            if p1 == key:
                return p2
    except:
        traceback.print_exc()
        return None

def valuestodict(key):
    """Convert a registry key's values to a dictionary."""
    dict = {}
    size = winreg.QueryInfoKey(key)[1]
    for i in range(size):
        data = winreg.EnumValue(key, i)
        dict[data[0]] = data[1]
    return dict