path: root/Lib/plat-win/winreg.py

import winreg
import sys
import exceptions
import array
from types import *
import string

class RegType:
    def __init__( self, msname, friendlyname ):
        self.msname=msname
        self.friendlyname=friendlyname
        self.intval=getattr( winreg, msname )

    def __repr__( self ):
        return "<RegType %d: %s %s>" % \
                        (self.intval, self.msname, self.friendlyname )

_typeConstants={ 
    winreg.REG_NONE: 
        RegType( "REG_NONE", "None" ),
    winreg.REG_SZ: 
        RegType( "REG_SZ", "String" ),
    winreg.REG_EXPAND_SZ: 
        RegType("REG_EXPAND_SZ", "Expandable Template String" ),
    winreg.REG_BINARY: 
        RegType("REG_BINARY", "Binary Data"),
    winreg.REG_DWORD : 
        RegType("REG_DWORD", "Integer" ),
#    winreg.REG_DWORD_LITTLE_ENDIAN : 
#        RegType("REG_DWORD_LITTLE_ENDIAN", "Integer"),
    winreg.REG_DWORD_BIG_ENDIAN : 
        RegType("REG_DWORD_BIG_ENDIAN", "Big Endian Integer"),
    winreg.REG_LINK : 
        RegType("REG_LINK", "Link"),
    winreg.REG_MULTI_SZ : 
        RegType("REG_MULTI_SZ", "List of Strings"),
    winreg.REG_RESOURCE_LIST : 
        RegType("REG_RESOURCE_LIST", "Resource List"),
    winreg.REG_FULL_RESOURCE_DESCRIPTOR : 
        RegType( "REG_FULL_RESOURCE_DESCRIPTOR", 
                                            "Full Resource Descriptor" ),
    winreg.REG_RESOURCE_REQUIREMENTS_LIST: 
        RegType( "REG_RESOURCE_REQUIREMENTS_LIST", 
                                            "Resource Requirements List" )
}

regtypes={}
for constant in _typeConstants.values():
    regtypes[constant.msname]=constant

class _DictBase:
    def __init__( self, key ):
        self.key=key

    def clear( self ):
        keys=list( self.keys() )
        map( self.__delitem__, keys )

    def get( self, item, defaultVal=None ):
        try:
            return self.__getitem__( item )
        except (IndexError, EnvironmentError, WindowsError):
            return defaultVal

    def has_key( self, item ):
        try:
            self.__getitem__( item )
            return 1
        except (IndexError, EnvironmentError, WindowsError):
            return 0

    def keys( self ):
        keys=[] 
        try:
            for i in xrange( 0, sys.maxint ):
                keyname = self._nameFromNum( i  )
                keys.append( keyname )
        except (IndexError, EnvironmentError, WindowsError):
            pass
        return keys

    def values( self ):
        values=[]  # map() doesn't use the IndexError semantics...
        for i in self:
            values.append( i )
        return values

    def items( self ):
        return map( None, self.keys(), self.values() )

    def __len__( self ):
        return len( self.keys() )

def _getName( item, nameFromNum ):
    if type( item ) == IntType:
        try:
            keyname = nameFromNum( item )
        except (WindowsError, EnvironmentError):
            raise IndexError, item

    elif type( item )==StringType: 
        keyname=item
    else:
        raise exceptions.TypeError, \
                "Requires integer index or string key name" 
    return keyname


class RegValuesDict( _DictBase ):
    def _nameFromNum( self, i ):
        return self.key._nameFromNum( i )

    def __getitem__( self, item ):
        return self.key.getValueNameDataAndType( item )

    def __setitem__( self, name, val):
        if type( val )==TupleType:
            data, datatype=val
            assert isinstance( datatype, RegType )
            self.key.setValue( name, data, datatype )
        else:
            self.key.setValue( name, val )

    def __delitem__( self, item ):
        valname=_getName( item, self._nameFromNum )
        self.key.deleteValue( valname )

    
class RegKeysDict( _DictBase ):
    def _nameFromNum( self, item ):
        return winreg.EnumKey( self.key.handle, item )

    def __getitem__( self, item ):
        keyname=_getName( item, self._nameFromNum )
        return self.key.openSubkey( keyname )

    def __delitem__( self, item ):
        keyname=_getName( item, self._nameFromNum )
        self.key.deleteSubkey( keyname )

def openKey( keyname, samFlags=None ):
    lst=string.split( keyname, "\\", 1 )
    if len( lst )==2:
        hivename,path=lst
        return hives[hivename].openSubkey( path )
    else:
        hivename=lst[0]
        return hives[hivename]

def createKey( keyname ):
    lst=string.split( keyname, "\\", 1 )
    assert len( lst )==2
    hivename,path=lst
    return hives[hivename].createSubkey( path )

def deleteKey( keyname ):
    lst=string.split( keyname, "\\", 1 )
    assert len( lst )==2
    hivename,path=lst
    return hives[hivename].deleteSubkey( path )


class RegKey:
    def _nameFromNum( self, item ):
        (name,data,datatype)=winreg.EnumValue( self.handle, item )
        return name

    def __nonzero__(self):
        if self.handle:
            return 1
        else:
            return 0

    def __cmp__ (self, other ):
        if hasattr( other, "handle" ) and hasattr( other, "name" ):
            return cmp( self.name, other.name )
        else:
            return cmp( self.handle, other )

    def __init__( self, name, handle=None ):
        self.name=name
        self.handle=handle

    def __repr__( self ):
        return "<Windows RegKey: %s>"% self.name

    def close(self ):
        return winreg.CloseKey( self.handle )

    def getSubkeyNames( self ):
        return self.getSubkeys().keys()

    def getValueNames( self ):
        return self.getValues().keys()

    def deleteSubkey( self, subkey ):
        return winreg.DeleteKey( self.handle, subkey )
        
    def deleteValue( self, valname ):
        return winreg.DeleteValue( self.handle, valname )

    def createSubkey( self, keyname ):
        handle=winreg.CreateKey( self.handle, keyname )
        return RegKey( self.name+"\\"+keyname, handle)

    def openSubkey( self, keyname, samFlags=None ):
        if samFlags:
            handle=winreg.OpenKey( self.handle, keyname, 0, samFlags )
        else:
            handle=winreg.OpenKey( self.handle, keyname, 0 )
        return RegKey( self.name+"\\"+keyname, handle )

    def getSubkeys( self ):
        return RegKeysDict( self )

    def getValues( self ):
        return RegValuesDict( self )

    def getValueNameDataAndType( self, valname ):
        try:
            if type( valname )==IntType:
                (valname,data,datatype)=winreg.EnumValue( self.handle, valname )
            else:
                keyname=_getName( valname, self._nameFromNum )
                (data,datatype)=winreg.QueryValueEx( self.handle, keyname )
        except (WindowsError, EnvironmentError):
            raise IndexError, valname

        if datatype==winreg.REG_BINARY:
            # use arrays for binary data
            data=array.array( 'c', data )

        return (valname, data, _typeConstants[datatype] )

    def getValueData( self, valname ):
        name, data, type=self.getValueNameDataAndType( valname )
        return data

    def setValue( self, valname, data, regtype=None ):
        if regtype:
            typeint=regtype.intval
        else:
            if type( data )==StringType:
                typeint=winreg.REG_SZ
            elif type( data )==IntType:
                typeint=winreg.REG_DWORD
            elif type( data )==array.ArrayType:
                typeint=winreg.REG_BINARY
                data=data.tostring()
        winreg.SetValueEx( self.handle, valname, 0, typeint, data )

    def flush(self ):
        winreg.FlushKey( self.keyobbj )

    def save( self, filename ):
        winreg.SaveKey( self.keyobj, filename )

    def load( self, subkey, filename ):
        return winreg.RegLoadKey( self.handle, subkey, filename )


class RemoteKey( RegKey ):
    def __init__( self, machine, topLevelKey ):
        assert topLevelKey in _hivenames 
        self.handle =  winreg.ConnectRegistry( machine, parentKey )
        self.name=r"\\%s\%s" % (machine, topLevelKey )

_hivenames = ["HKEY_CLASSES_ROOT","HKEY_CURRENT_USER","HKEY_LOCAL_MACHINE",
                "HKEY_USERS","HKEY_CURRENT_CONFIG","HKEY_DYN_DATA",
                "HKEY_PERFORMANCE_DATA"]
hives={}
for name in _hivenames:
    hives[name]=RegKey( name, getattr( winreg, name ) )
hives["HKLM"]=hives["HKEY_LOCAL_MACHINE"]
hives["HKCR"]=hives["HKEY_CLASSES_ROOT"]
hives["HKCU"]=hives["HKEY_CURRENT_USER"]

_flagnames = ["KEY_ALL_ACCESS","KEY_CREATE_LINK", "KEY_CREATE_SUB_KEY",
             "KEY_ENUMERATE_SUB_KEYS", "KEY_EXECUTE", "KEY_NOTIFY", 
             "KEY_QUERY_VALUE", "KEY_READ", "KEY_SET_VALUE"]
flags={}
for name in _flagnames:
    flags[name]=getattr( winreg, name )

_RegNotifyChangeKeyValueOptions=[ "REG_NOTIFY_CHANGE_ATTRIBUTES",
            "REG_NOTIFY_CHANGE_SECURITY", "REG_NOTIFY_CHANGE_LAST_SET",
            "REG_NOTIFY_CHANGE_NAME", "REG_LEGAL_CHANGE_FILTER" ]

_RegRestoreKeyOptions=["REG_WHOLE_HIVE_VOLATILE", 
    "REG_NO_LAZY_FLUSH",
    "REG_OPTION_VOLATILE",
    "REG_REFRESH_HIVE",
    "REG_OPTION_NON_VOLATILE",
    "REG_OPTION_BACKUP_RESTORE" ]

_RegCreateKeyExOptions=[
    "REG_LEGAL_OPTION",
    "REG_OPTION_RESERVED",
    "REG_OPTION_VOLATILE",
    "REG_OPTION_NON_VOLATILE",
    "REG_OPTION_BACKUP_RESTORE",
    "REG_CREATED_NEW_KEY",
    "REG_OPENED_EXISTING_KEY",
    "REG_OPTION_CREATE_LINK"]

def test():
    import testreg

#unusednames=_RegNotifyChangeKeyValueOptions+_RegRestoreKeyOptions+_RegCreateKeyExOptions

#typeConstantNames=map( lambda x: x.msname, typeConstants.values() )

#allnames=_hivenames+_flagnames+typeConstantNames+unusednames
#winregnames=winreg.__dict__.keys()
#for name in winregnames:
#    if name not in allnames:
#        print name