fix for longlongHash for architectures where sizeof(long long) == sizeof(long)

[wxWidgets.git] / wxPython / samples / ide / activegrid / util / objutils.py

diff --git a/wxPython/samples/ide/activegrid/util/objutils.py b/wxPython/samples/ide/activegrid/util/objutils.py
index 9658aa2a2aa5a52816c46ed3a241323739a1f17e..96e96df38c5e434ad22eef36c624aa22c8f4886c 100644 (file)
--- a/wxPython/samples/ide/activegrid/util/objutils.py
+++ b/wxPython/samples/ide/activegrid/util/objutils.py
@@ -14,36 +14,222 @@ import logging
 import traceback
 import sys
 import os
 import traceback
 import sys
 import os

+import __builtin__
+import types
+import activegrid.util.utillang as utillang
+import activegrid.util.datetimeparser as datetimeparser

 from types import *
 from types import *

+from activegrid.util.lang import *

 
 

+FUNCTION_HAS_ATTR = '_hasAttr'
+FUNCTION_GET_ATTR = '_getAttr'
+FUNCTION_SET_ATTR = '_setAttr'
+FUNCTION_DEL_ATTR = '_delAttr'
+
+def hasRawAttr(obj, name):
+    if obj == None:
+        return False
+    if name != FUNCTION_HAS_ATTR and hasattr(obj, FUNCTION_HAS_ATTR):
+        return obj._hasAttr(name)
+    return obj.__dict__.has_key(name)
+    
+def getRawAttr(obj, name):
+    if name != FUNCTION_GET_ATTR and hasattr(obj, FUNCTION_GET_ATTR):
+        return obj._getAttr(name)
+    return obj.__dict__.get(name)
+    
+def setRawAttr(obj, name, value):
+    if name != FUNCTION_SET_ATTR and hasattr(obj, FUNCTION_SET_ATTR):
+        obj._setAttr(name, value)
+    else:
+        obj.__dict__[name] = value
+    
+def delRawAttr(obj, name):
+    if name != FUNCTION_DEL_ATTR and hasattr(obj, FUNCTION_DEL_ATTR):
+        obj._delAttr(name)
+    else:
+        del obj.__dict__[name]
+
+def getStaticAttr(obj, attr):
+    if (isinstance(obj, types.TypeType)):
+        classDesc = obj
+    else:
+        classDesc = obj.__class__
+    if (hasattr(classDesc, attr)):
+        return getattr(classDesc, attr)
+    return None
+    
+def setStaticAttr(obj, attr, value):
+    if (isinstance(obj, types.TypeType)):
+        classDesc = obj
+    else:
+        classDesc = obj.__class__
+    setattr(classDesc, attr, value)
+
+def hasAttrFast(obj, name):
+    if hasRawAttr(obj, name):
+        return True
+    if hasattr(obj, '_complexType'):
+        complexType=obj._complexType
+        element=complexType.findElement(name)
+        if element:
+            return True
+    if hasattr(obj, name):
+        return True
+    return False
+
+def moduleForName(moduleName):
+    module = None
+    pathList = moduleName.split('.')
+    if (len(moduleName) > 0):
+        module = __import__(moduleName)
+        for name in pathList[1:]:
+            if (name in module.__dict__):
+                module = module.__dict__[name]
+            else:
+                module = None
+                break
+    return module
+    
+def typeForName(typeName):
+    i = typeName.rfind('.')
+    if (i >= 0):
+        module = moduleForName(typeName[:i])
+        if (module != None):
+            name = typeName[i+1:]
+            if (name in module.__dict__):
+                return module.__dict__[name]
+    elif __builtin__.__dict__.has_key(typeName):
+        return __builtin__.__dict__[typeName]
+    return None
+    
+def functionForName(functionName):
+    ftype = typeForName(functionName)
+    if (isinstance(ftype, (types.FunctionType, types.MethodType, types.BuiltinFunctionType, types.BuiltinMethodType))):
+        return ftype
+    return None
+    

 def classForName(className):
 def classForName(className):

-    pathList = className.split('.')
-    moduleName = '.'.join(pathList[:-1])
-    code = __import__(moduleName)
-    for name in pathList[1:]:
-        code = code.__dict__[name]
-    return code
+    ctype = typeForName(className)
+    if (isinstance(ctype, (types.ClassType, types.TypeType))):
+        return ctype
+    return None
+
+def newInstance(className, objargs=None):
+    "dynamically create an object based on the className and return it."

 
 

-def hasPropertyValue(obj, attr):
-    hasProp = False
-    try:
-        prop = obj.__class__.__dict__[attr]
-        if (isinstance(prop, property)):
-            hasProp = hasattr(obj, attr)
-            if (hasProp):
-                # It's a property and it has a value but sometimes we don't want it.
-                # If there is a _hasattr method execute it and the
-                # result will tell us whether to include this value
-                try:
-                    hasProp = obj._hasattr(attr)
-                except:
-                    pass
-    except KeyError:
-        pass
-    return hasProp
+    if not isinstance(objargs, list):
+        objargs = [objargs]

 
 

-def toDiffableString(value):
-    s = str(value)
+    if className == "None":
+        return None
+    elif className == "bool":
+        if ((len(objargs) < 1) or (objargs[0].lower() == "false") or (not objargs[0])):
+            return False
+        return True
+    if className == "str" or className == "unicode": # don't strip: blanks are significant
+        if len(objargs) > 0:
+            try:
+                return utillang.unescape(objargs[0]).encode()
+            except:
+                return "?"
+        else:
+            return ""
+            
+    if className == "date":
+        return datetimeparser.parse(objargs[0], asdate=True)
+    if className == "datetime":
+        return datetimeparser.parse(objargs[0])
+    if className == "time":
+        return datetimeparser.parse(objargs[0], astime=True)
+        
+    classtype = classForName(className)
+    if (classtype == None):
+        raise Exception("Could not find class %s" % className)
+        
+    if (len(objargs) > 0):
+        return classtype(*objargs)
+    else:
+        return classtype()
+
+def getClassProperty(classType, propertyName):
+    return getattr(classType, propertyName)
+    
+def toDiffableRepr(value, maxLevel=None):
+    if (value == None):
+        return "None"
+    if (maxLevel == None):
+        maxLevel = 8
+    maxLevel -= 1
+    if (maxLevel < 0):
+        return typeToString(value, PRINT_OBJ_DIFFABLE)
+##    if ((exclude != None) and not isinstance(value, (basestring, int))):
+##        for v in exclude:
+##            if (v is value):
+##                return "<recursive reference>"
+##        exclude.append(value)
+##    elif (isinstance(value, ObjectType) and hasattr(value, "__dict__")):
+##        if (exclude == None):
+##            exclude = []
+##        s = "%s(%s)" % (type(value), toDiffableString(value.__dict__, exclude))
+    if (not isinstance(value, (BooleanType, ClassType, ComplexType, DictType, DictionaryType, 
+                               FloatType, IntType, ListType, LongType, StringType, TupleType, 
+                               UnicodeType, BufferType, BuiltinFunctionType, BuiltinMethodType,
+                               CodeType, FrameType, FunctionType, GeneratorType, InstanceType,
+                               LambdaType, MethodType, ModuleType, SliceType, TracebackType,
+                               TypeType, XRangeType))):
+        if (hasattr(value, "_toDiffableString")):
+            s = value._toDiffableString(maxLevel)
+        elif (hasattr(value, "__str__")):
+            s = str(value)
+        elif (hasattr(value, "__dict__")):
+            s = "%s(%s)" % (type(value), toDiffableString(value.__dict__, maxLevel))
+        else:
+            s = str(type(value))
+        ix2 = s.find(" object at 0x")
+        if (ix2 > 0):
+            ix = s.rfind(".")
+            if (ix > 0):
+                s = "<class %s>" %s[ix+1:ix2]
+    elif (isinstance(value, bool)):
+        if (value):
+            return "True"
+        else:
+            return "False"
+    elif (isinstance(value, (tuple, list))):
+        items = []
+        for v in value:
+            if (isinstance(v, basestring)):
+                if (v.find("'") >= 0):
+                    items.append('"%s"' % v)
+                else:
+                    items.append("'%s'" % v)
+            else:
+                items.append(toDiffableString(v, maxLevel))
+        s = "[" + ", ".join(items) + "]"
+    elif (isinstance(value, dict)):
+        items = []
+        for key, val in value.iteritems():
+            if (isinstance(val, UnicodeType)):
+                items.append("'%s': u'%s'" % (key, toDiffableString(val, maxLevel)))
+            elif (isinstance(val, basestring)):
+                items.append("'%s': '%s'" % (key, toDiffableString(val, maxLevel)))
+            else:
+                items.append("'%s': %s" % (key, toDiffableString(val, maxLevel)))
+        s = "{" + ", ".join(items) + "}"
+    else:
+        s = str(value)
+    return s
+    
+def toDiffableString(value, maxLevel=None):
+##    if (value == None):
+##        return "None"
+##    if ((exclude != None) and not isinstance(value, (basestring, int))):
+##        for v in exclude:
+##            if (v is value):
+##                return "<recursive reference>"
+##        exclude.append(value)
+    s = toDiffableRepr(value, maxLevel)

     ds = ""
     i = s.find(" at 0x") 
     start = 0
     ds = ""
     i = s.find(" at 0x") 
     start = 0


@@ -54,22 +240,43 @@ def toDiffableString(value):
         ds += s[start:i]
         start = j
         i = s.find(" at 0x", start) 
         ds += s[start:i]
         start = j
         i = s.find(" at 0x", start) 

-    return ds + s[start:]
-
+    ds = ds + s[start:]
+    i = ds.find("\\src\\")
+    if (i < 0):
+        i = ds.find("/src/")
+    else:
+        ds = ds.replace("\\", "/")
+    if (i > 0):
+        i += 4
+        if (ds[i:i+5] == "\\php\\"):
+            i += 4
+        elif (ds[i:i+8] == "\\python\\"):
+            i += 7
+        ds = "filepath: ..." + ds[i:]
+    return ds
+        

 def toString(value, options=0):
     if ((options & PRINT_OBJ_DIFFABLE) > 0):
         return toDiffableString(value)
 def toString(value, options=0):
     if ((options & PRINT_OBJ_DIFFABLE) > 0):
         return toDiffableString(value)

+    elif (not isinstance(value, basestring)):
+        return str(value)

     return value
 
     return value
 

-def toTypeString(obj):
+def typeToString(obj, options=0):

     if (isinstance(obj, BooleanType)):
         return "bool"
     elif (isinstance(obj, UnicodeType)):
     if (isinstance(obj, BooleanType)):
         return "bool"
     elif (isinstance(obj, UnicodeType)):

+        if ((options & PRINT_OBJ_DIFFABLE) > 0):
+            return "string"

         return "unicode"
     elif (isinstance(obj, basestring)):
         return "string"
     elif (isinstance(obj, IntType)):
         return "int"
         return "unicode"
     elif (isinstance(obj, basestring)):
         return "string"
     elif (isinstance(obj, IntType)):
         return "int"

+    elif (isinstance(obj, LongType)):
+        if ((options & PRINT_OBJ_DIFFABLE) > 0):
+            return "int"
+        return "long"

     elif (isinstance(obj, FloatType)):
         return "float"
     elif (type(obj) == ListType):
     elif (isinstance(obj, FloatType)):
         return "float"
     elif (type(obj) == ListType):


@@ -79,18 +286,46 @@ def toTypeString(obj):
     elif (isinstance(obj, TupleType)):
         return "tuple"
     elif (isinstance(obj, InstanceType)):
     elif (isinstance(obj, TupleType)):
         return "tuple"
     elif (isinstance(obj, InstanceType)):

-        return type(obj)
+##        ds = str(type(obj))
+        ds = "<class %s.%s> " % (obj.__module__, obj.__class__.__name__)

     else:
     else:

-        return type(obj)
+        ds = str(type(obj))
+    if (options == 0):
+        import activegrid.util.aglogging
+        options = activegrid.util.aglogging.testMode(0, PRINT_OBJ_DIFFABLE)
+    if ((options & PRINT_OBJ_DIFFABLE) > 0):
+        if (ds.startswith("<class ")):
+            ix = ds.rfind(".")
+            if (ix < 0):
+                ix = 8
+            ds = "<class %s>" % ds[ix+1:-2]
+    return ds
+    
+def nameToString(name, options=0):
+    if (name.startswith("_v_")):
+        return name[3:]
+    if ((options & PRINT_OBJ_DIFFABLE) > 0):
+        ix = name.find("__")
+        if ((ix > 1) and name.startswith("_")):
+            name = name[ix:]
+        return toDiffableString(name)
+    return name

             
 PRINT_OBJ_GETATTR = 1
 PRINT_OBJ_HIDE_INTERNAL = 2
 PRINT_OBJ_COMPACT = 4
 PRINT_OBJ_NONONE = 8
 PRINT_OBJ_DIFFABLE = 16
             
 PRINT_OBJ_GETATTR = 1
 PRINT_OBJ_HIDE_INTERNAL = 2
 PRINT_OBJ_COMPACT = 4
 PRINT_OBJ_NONONE = 8
 PRINT_OBJ_DIFFABLE = 16

+PRINT_OBJ_HIDE_EXCLUDED = 32

 PRINT_OBJ_INTERNAL = 512
 
 PRINT_OBJ_INTERNAL = 512
 

-def printObject(out, object, name="", indent=0, flags=0, exclude=None, maxIndent=30):
+def printObject(out, object, name=None, indent=0, flags=0, exclude=None, remove=None, maxIndent=30):
+    if (name == None):
+        name = ""
+##    elif (name.endswith("_") and not name.endswith("__")):
+##        name = name[:-1]
+    if ((remove != None) and (name in asDict(remove))):
+        return False

     if ((maxIndent != None) and (indent > maxIndent)):
         print >> out, " "*indent, "%s: %s" % (name, toString(str(object), flags)),
         if ((flags & PRINT_OBJ_INTERNAL) == 0):
     if ((maxIndent != None) and (indent > maxIndent)):
         print >> out, " "*indent, "%s: %s" % (name, toString(str(object), flags)),
         if ((flags & PRINT_OBJ_INTERNAL) == 0):


@@ -98,12 +333,11 @@ def printObject(out, object, name="", indent=0, flags=0, exclude=None, maxIndent
         return True
     finalNewLine = False
     printed = True
         return True
     finalNewLine = False
     printed = True

-##    if (exclude == None):
-##        exclude = []
-    if ((flags & PRINT_OBJ_COMPACT) > 0):
-        if (exclude and object in exclude):
+    if ((flags & (PRINT_OBJ_COMPACT | PRINT_OBJ_HIDE_EXCLUDED)) > 0):
+        if ((exclude != None) and ((object in exclude) or (name in exclude))):

             return
             return

-        indent = 0
+        if ((flags & PRINT_OBJ_COMPACT) > 0):
+            indent = 0

     if ((flags & PRINT_OBJ_INTERNAL) == 0):
         finalNewLine = True
     flags |= PRINT_OBJ_INTERNAL
     if ((flags & PRINT_OBJ_INTERNAL) == 0):
         finalNewLine = True
     flags |= PRINT_OBJ_INTERNAL


@@ -113,23 +347,23 @@ def printObject(out, object, name="", indent=0, flags=0, exclude=None, maxIndent
         else:
             finalNewLine = False
             printed = False
         else:
             finalNewLine = False
             printed = False

-    elif (name.startswith("_") and ((flags & PRINT_OBJ_HIDE_INTERNAL) > 0)):
+    elif (name.startswith("_") and ((flags & PRINT_OBJ_HIDE_INTERNAL) > 0) and not name.startswith("_v_")):

         finalNewLine = False
         printed = False
     elif (isinstance(object, (list, tuple))):
         if ((exclude != None) and object in exclude):
         finalNewLine = False
         printed = False
     elif (isinstance(object, (list, tuple))):
         if ((exclude != None) and object in exclude):

-            print >> out, " "*indent, name, " : ", toTypeString(object), " of length = ", len(object), " (already printed)",
+            print >> out, " "*indent, name, " : ", typeToString(object, flags), " of length = ", len(object), " (already printed)",

         elif ((exclude != None) and name in exclude):
         elif ((exclude != None) and name in exclude):

-            print >> out, " "*indent, name, " : ", toTypeString(object), " of length = ", len(object), " (excluded)",
+            print >> out, " "*indent, name, " : ", typeToString(object, flags), " of length = ", len(object), " (excluded)",

         else:
             if ((exclude != None) and (len(object) > 0)): exclude.append(object)
         else:
             if ((exclude != None) and (len(object) > 0)): exclude.append(object)

-            print >> out, " "*indent, name, " : ", toTypeString(object), " of length = %d" % len(object),
+            print >> out, " "*indent, name, " : ", typeToString(object, flags), " of length = %d" % len(object),

             for i, o in enumerate(object):
                 print >> out
             for i, o in enumerate(object):
                 print >> out

-                printObject(out, o, name="[%d]" % i, indent=indent+2, flags=flags, exclude=exclude, maxIndent=maxIndent)
+                printObject(out, o, name="[%d]" % i, indent=indent+2, flags=flags, exclude=exclude, remove=remove, maxIndent=maxIndent)

     elif (isinstance(object, dict)):
         if ((exclude != None) and object in exclude):
     elif (isinstance(object, dict)):
         if ((exclude != None) and object in exclude):

-            print >> out, " "*indent, name, " : ", toTypeString(object), " (already printed)",
+            print >> out, " "*indent, name, " : ", typeToString(object, flags), " (already printed)",

         else:
             if ((exclude != None) and (len(object) > 0)): exclude.append(object)
             if (len(name) > 0):
         else:
             if ((exclude != None) and (len(object) > 0)): exclude.append(object)
             if (len(name) > 0):


@@ -147,51 +381,62 @@ def printObject(out, object, name="", indent=0, flags=0, exclude=None, maxIndent
                     n = key
                     if (not (isinstance(n, basestring))):
                         n = str(n)
                     n = key
                     if (not (isinstance(n, basestring))):
                         n = str(n)

+                    else:
+                        n = nameToString(n, flags)

                     if ((not n.startswith("_") or ((flags & PRINT_OBJ_HIDE_INTERNAL) == 0))):
                     if ((not n.startswith("_") or ((flags & PRINT_OBJ_HIDE_INTERNAL) == 0))):

-                        if printObject(out, object[key], name=n, indent=indent+2, flags=(flags | PRINT_OBJ_INTERNAL), exclude=exclude, maxIndent=maxIndent):
+                        if printObject(out, object[key], name=n, indent=indent+2, flags=(flags | PRINT_OBJ_INTERNAL), exclude=exclude, remove=remove, maxIndent=maxIndent):

                             if ((flags & PRINT_OBJ_COMPACT) == 0):
                                 print >> out
                             else:
                                 print >> out, ",",
             print >> out, " "*indent, "}",
     elif (hasattr(object, "__dict__")):
                             if ((flags & PRINT_OBJ_COMPACT) == 0):
                                 print >> out
                             else:
                                 print >> out, ",",
             print >> out, " "*indent, "}",
     elif (hasattr(object, "__dict__")):

-        if ((exclude != None) and object in exclude):
-            print >> out, " "*indent, name, " : ", toTypeString(object), " (already printed) = ", toDiffableString(object),
+        if (name.startswith("_")): ## and ((flags & PRINT_OBJ_HIDE_INTERNAL) > 0)):
+            print >> out, " "*indent, name, " : ", typeToString(object, flags),
+        elif ((exclude != None) and ((object in exclude) or (object.__dict__ in exclude))):
+            print >> out, " "*indent, name, " : ", typeToString(object, flags), " (already printed)",

         else:
             if (exclude != None): exclude.append(object)
         else:
             if (exclude != None): exclude.append(object)

-            if (name.startswith("_")): ## and ((flags & PRINT_OBJ_HIDE_INTERNAL) > 0)):
-                print >> out, " "*indent, name, " : ", toTypeString(object),
-            elif ((exclude != None) and object.__dict__ in exclude):
-                print >> out, " "*indent, name, " : ", toTypeString(object), " (already printed)",
+            print >> out, " "*indent, name, " : ", typeToString(object, flags),
+            if ((flags & PRINT_OBJ_GETATTR) == 0):
+                if ((flags & PRINT_OBJ_COMPACT) == 0):
+                    print >> out
+                printObject(out, object.__dict__, indent=indent, flags=flags, exclude=exclude, remove=remove, maxIndent=maxIndent)

             else:
             else:

-                print >> out, " "*indent, name, " : ", toTypeString(object),
-                if ((flags & PRINT_OBJ_GETATTR) == 0):
-                    if ((flags & PRINT_OBJ_COMPACT) == 0):
+                if ((flags & PRINT_OBJ_COMPACT) == 0):
+                    print >> out
+##                    indent += 2
+                print >> out, " "*indent, "{",
+                keys = object.__dict__.keys()
+                keys.sort()
+                printed = True
+                for key in keys:
+                    if ((exclude != None) and (key in exclude)):
+                        continue
+                    if (printed and ((flags & PRINT_OBJ_COMPACT) == 0)):

                         print >> out
                         print >> out

-                    printObject(out, object.__dict__, indent=indent, flags=flags, exclude=exclude, maxIndent=maxIndent)
-                else:
-                    keys = object.__dict__.keys()
-                    keys.sort()
-                    for n in keys:
-                        if ((flags & PRINT_OBJ_COMPACT) == 0):
-                            print >> out
-                        printObject(out, getattr(object, n), name=n, indent=indent+2, flags=flags, exclude=exclude, maxIndent=maxIndent)
+                    n = nameToString(key, flags)
+                    printed = printObject(out, getattr(object, n), name=n, indent=indent+2, flags=flags, exclude=exclude, remove=remove, maxIndent=maxIndent)
+                if ((flags & PRINT_OBJ_COMPACT) == 0):
+                    print >> out
+                print >> out, " "*indent, "}",

     elif (indent < 0):
         print >> out, object,
     elif isinstance(object, basestring):
         if ((exclude != None) and name in exclude):
     elif (indent < 0):
         print >> out, object,
     elif isinstance(object, basestring):
         if ((exclude != None) and name in exclude):

-            print >> out, " "*indent, name, " : ", toTypeString(object), " of length = ", len(object), " (excluded)",
+            print >> out, " "*indent, name, " : ", typeToString(object, flags), " of length = ", len(object), " (excluded)",

         elif (len(object) > 100):
         elif (len(object) > 100):

-            print >> out, " "*indent, name, ":", toTypeString(object), "[%d] = %s...%s" % (len(object), object[:50], object[-50:]),
+            object = toString(object, flags)
+            print >> out, " "*indent, name, ":", typeToString(object, flags), "[%d] = %s...%s" % (len(object), object[:50], object[-50:]),

         else:
         else:

-            print >> out, " "*indent, name, ":", toTypeString(object), "=", str(object),
+            print >> out, " "*indent, name, ":", typeToString(object, flags), "=", toString(object, flags),

 ##    elif (isinstance(object, float)):
 ##        val = str(object)
 ##        if (len(val) > 17):
 ##            val = val[:17]
 ##        print >> out, " "*indent, name, ":", type(object), "=", val,
     else:
 ##    elif (isinstance(object, float)):
 ##        val = str(object)
 ##        if (len(val) > 17):
 ##            val = val[:17]
 ##        print >> out, " "*indent, name, ":", type(object), "=", val,
     else:

-        print >> out, " "*indent, name, ":", toTypeString(object), "=", str(object),
+        print >> out, " "*indent, name, ":", typeToString(object, flags), "=", toString(object, flags),

     if (finalNewLine):
         print >> out
     return printed
     if (finalNewLine):
         print >> out
     return printed