Ooops! I didn't finish all the renaming needed here, so this was

attempting a recursive import and causing a fatal error.

1 files changed, 36 insertions, 36 deletions

diff --git a/Lib/plat-win/winreg.py b/Lib/plat-win/winreg.py
index 2694956..8c428cd 100644
--- a/Lib/plat-win/winreg.py
+++ b/Lib/plat-win/winreg.py
@@ -1,4 +1,4 @@
-import winreg
+import _winreg
 import sys
 import exceptions
 import array
@@ -9,37 +9,37 @@ class RegType:
     def __init__( self, msname, friendlyname ):
         self.msname=msname
         self.friendlyname=friendlyname
-        self.intval=getattr( winreg, msname )
+        self.intval=getattr( _winreg, msname )
 
     def __repr__( self ):
         return "<RegType %d: %s %s>" % \
                         (self.intval, self.msname, self.friendlyname )
 
 _typeConstants={ 
-    winreg.REG_NONE: 
+    _winreg.REG_NONE: 
         RegType( "REG_NONE", "None" ),
-    winreg.REG_SZ: 
+    _winreg.REG_SZ: 
         RegType( "REG_SZ", "String" ),
-    winreg.REG_EXPAND_SZ: 
+    _winreg.REG_EXPAND_SZ: 
         RegType("REG_EXPAND_SZ", "Expandable Template String" ),
-    winreg.REG_BINARY: 
+    _winreg.REG_BINARY: 
         RegType("REG_BINARY", "Binary Data"),
-    winreg.REG_DWORD : 
+    _winreg.REG_DWORD : 
         RegType("REG_DWORD", "Integer" ),
-#    winreg.REG_DWORD_LITTLE_ENDIAN : 
+#    _winreg.REG_DWORD_LITTLE_ENDIAN : 
 #        RegType("REG_DWORD_LITTLE_ENDIAN", "Integer"),
-    winreg.REG_DWORD_BIG_ENDIAN : 
+    _winreg.REG_DWORD_BIG_ENDIAN : 
         RegType("REG_DWORD_BIG_ENDIAN", "Big Endian Integer"),
-    winreg.REG_LINK : 
+    _winreg.REG_LINK : 
         RegType("REG_LINK", "Link"),
-    winreg.REG_MULTI_SZ : 
+    _winreg.REG_MULTI_SZ : 
         RegType("REG_MULTI_SZ", "List of Strings"),
-    winreg.REG_RESOURCE_LIST : 
+    _winreg.REG_RESOURCE_LIST : 
         RegType("REG_RESOURCE_LIST", "Resource List"),
-    winreg.REG_FULL_RESOURCE_DESCRIPTOR : 
+    _winreg.REG_FULL_RESOURCE_DESCRIPTOR : 
         RegType( "REG_FULL_RESOURCE_DESCRIPTOR", 
                                             "Full Resource Descriptor" ),
-    winreg.REG_RESOURCE_REQUIREMENTS_LIST: 
+    _winreg.REG_RESOURCE_REQUIREMENTS_LIST: 
         RegType( "REG_RESOURCE_REQUIREMENTS_LIST", 
                                             "Resource Requirements List" )
 }
@@ -128,7 +128,7 @@ class RegValuesDict( _DictBase ):
     
 class RegKeysDict( _DictBase ):
     def _nameFromNum( self, item ):
-        return winreg.EnumKey( self.key.handle, item )
+        return _winreg.EnumKey( self.key.handle, item )
 
     def __getitem__( self, item ):
         keyname=_getName( item, self._nameFromNum )
@@ -162,7 +162,7 @@ def deleteKey( keyname ):
 
 class RegKey:
     def _nameFromNum( self, item ):
-        (name,data,datatype)=winreg.EnumValue( self.handle, item )
+        (name,data,datatype)=_winreg.EnumValue( self.handle, item )
         return name
 
     def __nonzero__(self):
@@ -185,7 +185,7 @@ class RegKey:
         return "<Windows RegKey: %s>"% self.name
 
     def close(self ):
-        return winreg.CloseKey( self.handle )
+        return _winreg.CloseKey( self.handle )
 
     def getSubkeyNames( self ):
         return self.getSubkeys().keys()
@@ -194,20 +194,20 @@ class RegKey:
         return self.getValues().keys()
 
     def deleteSubkey( self, subkey ):
-        return winreg.DeleteKey( self.handle, subkey )
+        return _winreg.DeleteKey( self.handle, subkey )
         
     def deleteValue( self, valname ):
-        return winreg.DeleteValue( self.handle, valname )
+        return _winreg.DeleteValue( self.handle, valname )
 
     def createSubkey( self, keyname ):
-        handle=winreg.CreateKey( self.handle, 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 )
+            handle=_winreg.OpenKey( self.handle, keyname, 0, samFlags )
         else:
-            handle=winreg.OpenKey( self.handle, keyname, 0 )
+            handle=_winreg.OpenKey( self.handle, keyname, 0 )
         return RegKey( self.name+"\\"+keyname, handle )
 
     def getSubkeys( self ):
@@ -219,14 +219,14 @@ class RegKey:
     def getValueNameDataAndType( self, valname ):
         try:
             if type( valname )==IntType:
-                (valname,data,datatype)=winreg.EnumValue( self.handle, valname )
+                (valname,data,datatype)=_winreg.EnumValue( self.handle, valname )
             else:
                 keyname=_getName( valname, self._nameFromNum )
-                (data,datatype)=winreg.QueryValueEx( self.handle, keyname )
+                (data,datatype)=_winreg.QueryValueEx( self.handle, keyname )
         except (WindowsError, EnvironmentError):
             raise IndexError, valname
 
-        if datatype==winreg.REG_BINARY:
+        if datatype==_winreg.REG_BINARY:
             # use arrays for binary data
             data=array.array( 'c', data )
 
@@ -241,28 +241,28 @@ class RegKey:
             typeint=regtype.intval
         else:
             if type( data )==StringType:
-                typeint=winreg.REG_SZ
+                typeint=_winreg.REG_SZ
             elif type( data )==IntType:
-                typeint=winreg.REG_DWORD
+                typeint=_winreg.REG_DWORD
             elif type( data )==array.ArrayType:
-                typeint=winreg.REG_BINARY
+                typeint=_winreg.REG_BINARY
                 data=data.tostring()
-        winreg.SetValueEx( self.handle, valname, 0, typeint, data )
+        _winreg.SetValueEx( self.handle, valname, 0, typeint, data )
 
     def flush(self ):
-        winreg.FlushKey( self.keyobbj )
+        _winreg.FlushKey( self.keyobbj )
 
     def save( self, filename ):
-        winreg.SaveKey( self.keyobj, filename )
+        _winreg.SaveKey( self.keyobj, filename )
 
     def load( self, subkey, filename ):
-        return winreg.RegLoadKey( self.handle, 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.handle =  _winreg.ConnectRegistry( machine, parentKey )
         self.name=r"\\%s\%s" % (machine, topLevelKey )
 
 _hivenames = ["HKEY_CLASSES_ROOT","HKEY_CURRENT_USER","HKEY_LOCAL_MACHINE",
@@ -270,7 +270,7 @@ _hivenames = ["HKEY_CLASSES_ROOT","HKEY_CURRENT_USER","HKEY_LOCAL_MACHINE",
                 "HKEY_PERFORMANCE_DATA"]
 hives={}
 for name in _hivenames:
-    hives[name]=RegKey( name, getattr( winreg, name ) )
+    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"]
@@ -280,7 +280,7 @@ _flagnames = ["KEY_ALL_ACCESS","KEY_CREATE_LINK", "KEY_CREATE_SUB_KEY",
              "KEY_QUERY_VALUE", "KEY_READ", "KEY_SET_VALUE"]
 flags={}
 for name in _flagnames:
-    flags[name]=getattr( winreg, name )
+    flags[name]=getattr( _winreg, name )
 
 _RegNotifyChangeKeyValueOptions=[ "REG_NOTIFY_CHANGE_ATTRIBUTES",
             "REG_NOTIFY_CHANGE_SECURITY", "REG_NOTIFY_CHANGE_LAST_SET",
@@ -311,7 +311,7 @@ def test():
 #typeConstantNames=map( lambda x: x.msname, typeConstants.values() )
 
 #allnames=_hivenames+_flagnames+typeConstantNames+unusednames
-#winregnames=winreg.__dict__.keys()
+#winregnames=_winreg.__dict__.keys()
 #for name in winregnames:
 #    if name not in allnames:
 #        print name