win32api and the registry

This may be of use to someone, I wrote a module that lets you treat the win32 registry as if it were a python dictionary (supports everything UserDict does). It's written with 2.2 in mind (full support for iterators and such) so if you're going to use it with an older python you'll have to strip it down.
<lj-cut text="the code">
<pre>
import win32api, win32con, cPickle, struct

def massageRegistryValue((obj, objtype)):
if objtype == win32con.REG_BINARY and obj[:8]=='PyPickle':
obj = obj[8:]
return cPickle.loads(obj)
#elif objtype == win32con.REG_DWORD:
# return struct.unpack('=I',obj)
#elif objtype == win32con.REG_DWORD_LITTLE_ENDIAN:
# return struct.unpack('<I',obj)
#elif objtype == win32con.REG_DWORD_BIG_ENDIAN:
# return struct.unpack('>I',obj)
#elif objtype == win32con.REG_MULTI_SZ:
# return obj[:-2].split('\0')
elif objtype == win32con.REG_NONE:
return None
elif objtype in (win32con.REG_SZ, win32con.REG_EXPAND_SZ, win32con.REG_RESOURCE_LIST, win32con.REG_LINK, win32con.REG_BINARY, win32con.REG_DWORD, win32con.REG_DWORD_LITTLE_ENDIAN, win32con.REG_DWORD_BIG_ENDIAN, win32con.REG_MULTI_SZ):
return obj
else:
raise NotImplementedError, "Registry type 0x%08X not supported"%objtype

class RegistryDict:
keyhandle = None
def __init__(self, keyhandle = win32con.HKEY_LOCAL_MACHINE, keypath = [], flags = None):
"""If flags=None, then it will create the key.. otherwise pass a win32con.KEY_* sam"""
self.open(keyhandle,keypath,flags)

def __getitem__(self, item):
try:
return massageRegistryValue(win32api.RegQueryValueEx(self.keyhandle, str(item)))
except Exception,e:
pass
try:
return RegistryDict(self.keyhandle, item, win32con.KEY_ALL_ACCESS)
except Exception,e:
pass
raise KeyError, item

def has_key(self, key):
try:
f = self[key]
return True
except:
return False

def copy(self):
return dict(self.items())

def __repr__(self):
return repr(self.copy())

def __str__(self):
return repr(self)

def __cmp__(self,other):
return cmp(self.copy(),other)

def __hash__(self):
raise TypeError, "RegistryDict objects are unhashable"

def clear(self):
for k in self.keys():
del self[k]

def items(self):
#print "RegistryDict.items()"
i = 0
items = []
try:
while 1:
s,obj,objtype = win32api.RegEnumValue(self.keyhandle, i)
items.append((s,massageRegistryValue((obj,objtype))))
i += 1
except Exception,e:
pass
#print "%r %s"%(e,e)

i = 0
try:
while 1:
s = win32api.RegEnumKey(self.keyhandle, i)
items.append((s,RegistryDict(self.keyhandle, [s], win32con.KEY_ALL_ACCESS)))
i += 1
except Exception,e:
pass
#print "%r %s"%(e,e)

return items

def keys(self):
#print "RegistryDict.keys()"
def kkv((k,v)):
return k
return map(kkv, self.items())

def values(self):
#print "RegistryDict.values()"
def vkv((k,v)):
return v
return map(vkv, self.items())

def __delitem__(self, item):
win32api.RegDeleteValue(self.keyhandle, str(item))

def __contains__(self,item):
return self.has_key(item)

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

def __iter__(self):
return self.iterkeys()

def iteritems(self):
return iter(self.items())

def iterkeys(self):
return iter(self.keys())

def itervalues(self):
return iter(self.values())

def popitem(self):
try:
(k,v) = self.items()[0]
del self[k]
return (k,v)
except:
raise KeyError, "RegistryDict is empty"

def get(self,key,default=None):
try:
v = self[key]
except:
return default

def setdefault(self,key,default=None):
try:
return self[key]
except:
self[key] = default
return default

def update(self,d):
for (k,v) in d.items():
self[k] = v

def __setitem__(self, item, value):
if type(value)==dict or isinstance(item,RegistryDict):
d = RegistryDict(self.keyhandle, str(item))
d.clear()
d.update(value)
elif type(value)==str:
valuetype = win32con.REG_SZ
elif type(value)==int:
valuetype = win32con.REG_DWORD
#value = struct.pack('=I',value)
else:
valuetype = win32con.REG_BINARY
value = ''.join(('PyPickle',cPickle.dumps(value)))
win32api.RegSetValueEx(self.keyhandle, str(item), 0, valuetype, value)

def open(self, keyhandle, keypath, flags):
if self.keyhandle:
self.close()
if type(keypath)==str:
keypath = keypath.split('\\')
if flags is None:
for subkey in keypath:
keyhandle = win32api.RegCreateKey(keyhandle, subkey)
else:
for subkey in keypath:
keyhandle = win32api.RegOpenKeyEx(keyhandle, subkey, 0, flags)
self.keyhandle = keyhandle

def close(self):
try:
win32api.RegCloseKey(self.keyhandle)
except:
pass

def __del__(self):
self.close()
</pre>