modularized more... probably only Get* functions work

diff --git a/PLC/Legacy/NodeNetworks.py b/PLC/Legacy/NodeNetworks.py
index 4a1e404..8febd01 100644 (file)
--- a/PLC/Legacy/NodeNetworks.py
+++ b/PLC/Legacy/NodeNetworks.py
@@ -2,13 +2,9 @@
 # $Id$
 
 from PLC.Method import Method
-
-def import_deep(name):
-    mod = __import__(name)
-    components = name.split('.')
-    for comp in components[1:]:
-        mod = getattr(mod, comp)
-    return mod
+import v42legacy
+import sys
+current_module=sys.modules[__name__]
 
 methods = [
     "AddNodeNetwork",
@@ -21,63 +17,20 @@ methods = [
     "UpdateNodeNetworkSetting",
 ]
 
-# does any required renaming
-v42_to_v43_renaming = {
+# argument mapping
+v42_to_v43_argmap = {
     "nodenetwork_id":"interface_id",
     "nodenetwork_ids":"interface_ids",
     "nodenetworksetting_ids":"interface_tag_ids",
     }
+v43_to_v42_argmap = dict([ (v,k) for k,v in v42_to_v43_argmap.iteritems()])
+def v42rename (x): return v42_to_v43_argmap.get(x,x)
+def v43rename (x): return v43_to_v42_argmap.get(x,x)
 
-v43_to_v42_renaming = dict([ (v,k) for k,v in v42_to_v43_renaming.iteritems()])
-
-for k,v in v42_to_v43_renaming.iteritems():
-    v43_to_v42_renaming[v]=k
-
-def v42rename (x):
-    return v42_to_v43_renaming.get(x,x)
-
-def v43rename (x):
-    return v43_to_v42_renaming.get(x,x)
-
-
-# apply rename on list (columns) or dict (filter) args
-def patch_legacy (arg,rename):
-    if isinstance(arg,list):
-        for i in range(0,len(arg)):
-            arg[i] = patch_legacy(arg[i],rename)
-        return arg
-    if isinstance(arg,dict):
-        return dict ( [ (rename(k),v) for (k,v) in arg.iteritems() ] )
-    return rename(arg)
-
-def legacy_method (legacyname):
+# attach methods here
+for legacyname in methods:
     # new method name
     newname=legacyname.replace("NodeNetwork","Interface").replace("Setting","Tag")
-    # locate new class
-    newclass=getattr(import_deep("PLC.Methods."+newname),newname)
-    # create class for legacy name
-    legacyclass = type(legacyname,(newclass,), 
-                       {"__doc__":"Legacy method - please use %s instead"%newname})
-    # xxx should rewrite 'call' to handle any argument using nodenetwork_id(s)
-    for internal in ["roles","accepts","returns"]:
-        setattr(legacyclass,internal,getattr(newclass,internal))
-    # turn off type checking, as introspection code fails on wrapped_call
-    setattr(legacyclass,"skip_typecheck",True)
-    # rewrite call
-    def wrapped_call (self,auth,*args, **kwds):
-       print "%s: self.caller = %s, self=%s" % (legacyname,self.caller,self)
-        newargs=[patch_legacy(x,v42rename) for x in args]
-        newkwds=dict ( [ (k,patch_legacy(v,v42rename)) for (k,v) in kwds.iteritems() ] )
-        results = getattr(newclass,"call")(self,auth,*newargs,**newkwds)
-        return patch_legacy(results,v43rename)
-    setattr(legacyclass,"call",wrapped_call)
-
-    return legacyclass
-
-import sys
-current_module=sys.modules[__name__]
-
-# attach
-for legacyname in methods:
-    setattr(current_module,legacyname,legacy_method(legacyname))
+    path = "PLC.Methods."
+    setattr(current_module,legacyname,v42legacy.make_class(legacyname,newname,path,v42rename,v43rename))
 

diff --git a/PLC/Legacy/Types.py b/PLC/Legacy/Types.py
index c7eb749..9828730 100644 (file)
--- a/PLC/Legacy/Types.py
+++ b/PLC/Legacy/Types.py
@@ -2,15 +2,11 @@
 # $Id$
 
 from PLC.Method import Method
+import v42legacy
+import sys
+current_module=sys.modules[__name__]
 
-def import_deep(name):
-    mod = __import__(name)
-    components = name.split('.')
-    for comp in components[1:]:
-        mod = getattr(mod, comp)
-    return mod
-
-map = {
+v42_to_v43_methodmap = {
     "AddSliceAttributeType"         : "AddTagType",
     "DeleteSliceAttributeType"      : "DeleteTagType",
     "GetSliceAttributeTypes"        : "GetTagTypes",
@@ -21,45 +17,17 @@ map = {
     "UpdateNodeNetworkSettingType"  : "UpdateTagType",
 }    
 
-methods = map.keys()
-
-# does any required renaming
-def rename (x):
-    if x=='name':
-        return 'tagname'
-    else:
-        return x
-
-# apply rename on list (columns) or dict (filter) args
-def patch_legacy_arg (arg):
-    if isinstance(arg,list):
-        return [rename(x) for x in arg]
-    if isinstance(arg,dict):
-        return dict ( [ (rename(k),v) for (k,v) in arg.iteritems() ] )
-    return arg
+methods = v42_to_v43_methodmap.keys()
 
-def legacy_method (legacyname, newname):
-    # locate new class
-    newclass=getattr(import_deep("PLC.Methods."+newname),newname)
-    # create class for legacy name
-    legacyclass = type(legacyname,(newclass,), 
-                       {"__doc__":"Legacy method - please use %s instead"%newname})
-    for internal in ["roles","accepts","returns"]:
-        setattr(legacyclass,internal,getattr(newclass,internal))
-    # turn off type checking, as introspection code fails on wrapped_call
-    setattr(legacyclass,"skip_typecheck",True)
-    # rewrite call
-    def wrapped_call (self,auth,*args, **kwds):
-        newargs=[patch_legacy_arg(x) for x in args]
-        newkwds=dict ( [ (k,patch_legacy_arg(v)) for (k,v) in kwds.iteritems() ] )
-        return getattr(newclass,"call")(self,auth,*newargs,**newkwds)
-    setattr(legacyclass,"call",wrapped_call)
-
-    return legacyclass
-
-import sys
-current_module=sys.modules[__name__]
+v42_to_v43_argmap = { "name":"tagname" }
+v43_to_v42_argmap = dict([ (v,k) for k,v in v42_to_v43_argmap.iteritems()])
 
-for (legacyname,newname) in map.iteritems():
-    setattr(current_module,legacyname,legacy_method(legacyname,newname))
+def v42rename (x): return v42_to_v43_argmap.get(x,x)
+def v43rename (x): return v43_to_v42_argmap.get(x,x)
 
+# attach methods here
+for legacyname in methods:
+    # new method name
+    newname=v42_to_v43_methodmap[legacyname]
+    path = "PLC.Methods."
+    setattr(current_module,legacyname,v42legacy.make_class(legacyname,newname,path,v42rename,v43rename))

diff --git a/PLC/Legacy/v42legacy.py b/PLC/Legacy/v42legacy.py
new file mode 100644 (file)
index 0000000..fdf316f
--- /dev/null
+++ b/PLC/Legacy/v42legacy.py
@@ -0,0 +1,41 @@
+# $Id: $
+
+def import_deep(name):
+    mod = __import__(name)
+    components = name.split('.')
+    for comp in components[1:]:
+        mod = getattr(mod, comp)
+    return mod
+
+# apply rename on list (columns) or dict (filter) args
+def patch (arg,rename):
+    if isinstance(arg,list):
+        for i in range(0,len(arg)):
+            arg[i] = patch(arg[i],rename)
+        return arg
+    if isinstance(arg,dict):
+        return dict ( [ (rename(k),v) for (k,v) in arg.iteritems() ] )
+    return rename(arg)
+
+
+def make_class (legacyname,newname,path,v42rename,v43rename):
+    # locate new class
+    newclass=getattr(import_deep(path+newname),newname)
+    # create class for legacy name
+    legacyclass = type(legacyname,(newclass,), 
+                       {"__doc__":"Legacy method - please use %s instead"%newname})
+    for internal in ["roles","accepts","returns"]:
+        setattr(legacyclass,internal,getattr(newclass,internal))
+    # turn off type checking, as introspection code fails on wrapped_call
+    setattr(legacyclass,"skip_typecheck",True)
+    # rewrite call
+    def wrapped_call (self,auth,*args, **kwds):
+       # print "%s: self.caller = %s, self=%s" % (legacyname,self.caller,self)
+        newargs=[patch(x,v42rename) for x in args]
+        newkwds=dict ( [ (k,patch(v,v42rename)) for (k,v) in kwds.iteritems() ] )
+        results = getattr(newclass,"call")(self,auth,*newargs,**newkwds)
+        return patch(results,v43rename)
+    setattr(legacyclass,"call",wrapped_call)
+
+    return legacyclass
+