diff options
Diffstat (limited to 'lib/python2.7/site-packages/wx-3.0-msw/wx/py/introspect.py')
| -rw-r--r-- | lib/python2.7/site-packages/wx-3.0-msw/wx/py/introspect.py | 389 |
1 files changed, 389 insertions, 0 deletions
diff --git a/lib/python2.7/site-packages/wx-3.0-msw/wx/py/introspect.py b/lib/python2.7/site-packages/wx-3.0-msw/wx/py/introspect.py new file mode 100644 index 0000000..0a14f89 --- /dev/null +++ b/lib/python2.7/site-packages/wx-3.0-msw/wx/py/introspect.py @@ -0,0 +1,389 @@ +"""Provides a variety of introspective-type support functions for +things like call tips and command auto completion.""" + +__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>" +__cvsid__ = "$Id$" +__revision__ = "$Revision$"[11:-2] + +import cStringIO +import inspect +import sys +import tokenize +import types +import wx + +def getAutoCompleteList(command='', locals=None, includeMagic=1, + includeSingle=1, includeDouble=1): + """Return list of auto-completion options for command. + + The list of options will be based on the locals namespace.""" + attributes = [] + # Get the proper chunk of code from the command. + root = getRoot(command, terminator='.') + try: + if locals is not None: + object = eval(root, locals) + else: + object = eval(root) + except: + pass + else: + attributes = getAttributeNames(object, includeMagic, + includeSingle, includeDouble) + return attributes + +def getAttributeNames(object, includeMagic=1, includeSingle=1, + includeDouble=1): + """Return list of unique attributes, including inherited, for object.""" + attributes = [] + dict = {} + if not hasattrAlwaysReturnsTrue(object): + # Add some attributes that don't always get picked up. + special_attrs = ['__bases__', '__class__', '__dict__', '__name__', + 'func_closure', 'func_code', 'func_defaults', + 'func_dict', 'func_doc', 'func_globals', 'func_name'] + attributes += [attr for attr in special_attrs \ + if hasattr(object, attr)] + if includeMagic: + try: attributes += object._getAttributeNames() + except: pass + # Special code to allow traits to be caught by autocomplete + if hasattr(object,'trait_get'): + try: + for i in object.trait_get().keys(): + if i not in attributes: + if hasattr(object, i): + attributes += i + except: + pass + # Get all attribute names. + str_type = str(type(object)) + if str_type == "<type 'array'>": + attributes += dir(object) + else: + attrdict = getAllAttributeNames(object) + # Store the object's dir. + object_dir = dir(object) + for (obj_type_name, technique, count), attrlist in attrdict.items(): + # This complexity is necessary to avoid accessing all the + # attributes of the object. This is very handy for objects + # whose attributes are lazily evaluated. + if type(object).__name__ == obj_type_name and technique == 'dir': + attributes += attrlist + else: + attributes += [attr for attr in attrlist \ + if attr not in object_dir and hasattr(object, attr)] + + # Remove duplicates from the attribute list. + for item in attributes: + dict[item] = None + attributes = dict.keys() + # new-style swig wrappings can result in non-string attributes + # e.g. ITK http://www.itk.org/ + attributes = [attribute for attribute in attributes \ + if type(attribute) == str] + attributes.sort(lambda x, y: cmp(x.upper(), y.upper())) + if not includeSingle: + attributes = filter(lambda item: item[0]!='_' \ + or item[1:2]=='_', attributes) + if not includeDouble: + attributes = filter(lambda item: item[:2]!='__', attributes) + return attributes + +def hasattrAlwaysReturnsTrue(object): + return hasattr(object, 'bogu5_123_aTTri8ute') + +def getAllAttributeNames(object): + """Return dict of all attributes, including inherited, for an object. + + Recursively walk through a class and all base classes. + """ + attrdict = {} # (object, technique, count): [list of attributes] + # !!! + # Do Not use hasattr() as a test anywhere in this function, + # because it is unreliable with remote objects: xmlrpc, soap, etc. + # They always return true for hasattr(). + # !!! + try: + # This could(?) fail if the type is poorly defined without + # even a name. + key = type(object).__name__ + except: + key = 'anonymous' + # Wake up sleepy objects - a hack for ZODB objects in "ghost" state. + wakeupcall = dir(object) + del wakeupcall + # Get attributes available through the normal convention. + attributes = dir(object) + attrdict[(key, 'dir', len(attributes))] = attributes + # Get attributes from the object's dictionary, if it has one. + try: + attributes = object.__dict__.keys() + attributes.sort() + except: # Must catch all because object might have __getattr__. + pass + else: + attrdict[(key, '__dict__', len(attributes))] = attributes + # For a class instance, get the attributes for the class. + try: + klass = object.__class__ + except: # Must catch all because object might have __getattr__. + pass + else: + if klass is object: + # Break a circular reference. This happens with extension + # classes. + pass + else: + attrdict.update(getAllAttributeNames(klass)) + # Also get attributes from any and all parent classes. + try: + bases = object.__bases__ + except: # Must catch all because object might have __getattr__. + pass + else: + if isinstance(bases, types.TupleType): + for base in bases: + if type(base) is types.TypeType: + # Break a circular reference. Happens in Python 2.2. + pass + else: + attrdict.update(getAllAttributeNames(base)) + return attrdict + +def getCallTip(command='', locals=None): + """For a command, return a tuple of object name, argspec, tip text. + + The call tip information will be based on the locals namespace.""" + calltip = ('', '', '') # object name, argspec, tip text. + # Get the proper chunk of code from the command. + root = getRoot(command, terminator='(') + try: + if locals is not None: + object = eval(root, locals) + else: + object = eval(root) + except: + return calltip + name = '' + object, dropSelf = getBaseObject(object) + try: + name = object.__name__ + except AttributeError: + pass + tip1 = '' + argspec = '' + if inspect.isbuiltin(object): + # Builtin functions don't have an argspec that we can get. + pass + elif inspect.isfunction(object): + # tip1 is a string like: "getCallTip(command='', locals=None)" + argspec = apply(inspect.formatargspec, inspect.getargspec(object)) + if dropSelf: + # The first parameter to a method is a reference to an + # instance, usually coded as "self", and is usually passed + # automatically by Python; therefore we want to drop it. + temp = argspec.split(',') + if len(temp) == 1: # No other arguments. + argspec = '()' + elif temp[0][:2] == '(*': # first param is like *args, not self + pass + else: # Drop the first argument. + argspec = '(' + ','.join(temp[1:]).lstrip() + tip1 = name + argspec + doc = '' + if callable(object): + try: + doc = inspect.getdoc(object) + except: + pass + if doc: + # tip2 is the first separated line of the docstring, like: + # "Return call tip text for a command." + # tip3 is the rest of the docstring, like: + # "The call tip information will be based on ... <snip> + firstline = doc.split('\n')[0].lstrip() + if tip1 == firstline or firstline[:len(name)+1] == name+'(': + tip1 = '' + else: + tip1 += '\n\n' + docpieces = doc.split('\n\n') + tip2 = docpieces[0] + tip3 = '\n\n'.join(docpieces[1:]) + tip = '%s%s\n\n%s' % (tip1, tip2, tip3) + else: + tip = tip1 + calltip = (name, argspec[1:-1], tip.strip()) + return calltip + +def getRoot(command, terminator=None): + """Return the rightmost root portion of an arbitrary Python command. + + Return only the root portion that can be eval()'d without side + effects. The command would normally terminate with a '(' or + '.'. The terminator and anything after the terminator will be + dropped.""" + command = command.split('\n')[-1] + if command.startswith(sys.ps2): + command = command[len(sys.ps2):] + command = command.lstrip() + command = rtrimTerminus(command, terminator) + tokens = getTokens(command) + if not tokens: + return '' + if tokens[-1][0] is tokenize.ENDMARKER: + # Remove the end marker. + del tokens[-1] + if not tokens: + return '' + if terminator == '.' and \ + (tokens[-1][1] <> '.' or tokens[-1][0] is not tokenize.OP): + # Trap decimals in numbers, versus the dot operator. + return '' + else: + # Strip off the terminator. + if terminator and command.endswith(terminator): + size = 0 - len(terminator) + command = command[:size] + command = command.rstrip() + tokens = getTokens(command) + tokens.reverse() + line = '' + start = None + prefix = '' + laststring = '.' + emptyTypes = ('[]', '()', '{}') + for token in tokens: + tokentype = token[0] + tokenstring = token[1] + line = token[4] + if tokentype is tokenize.ENDMARKER: + continue + if tokentype in (tokenize.NAME, tokenize.STRING, tokenize.NUMBER) \ + and laststring != '.': + # We've reached something that's not part of the root. + if prefix and line[token[3][1]] != ' ': + # If it doesn't have a space after it, remove the prefix. + prefix = '' + break + if tokentype in (tokenize.NAME, tokenize.STRING, tokenize.NUMBER) \ + or (tokentype is tokenize.OP and tokenstring == '.'): + if prefix: + # The prefix isn't valid because it comes after a dot. + prefix = '' + break + else: + # start represents the last known good point in the line. + start = token[2][1] + elif len(tokenstring) == 1 and tokenstring in ('[({])}'): + # Remember, we're working backwords. + # So prefix += tokenstring would be wrong. + if prefix in emptyTypes and tokenstring in ('[({'): + # We've already got an empty type identified so now we + # are in a nested situation and we can break out with + # what we've got. + break + else: + prefix = tokenstring + prefix + else: + # We've reached something that's not part of the root. + break + laststring = tokenstring + if start is None: + start = len(line) + root = line[start:] + if prefix in emptyTypes: + # Empty types are safe to be eval()'d and introspected. + root = prefix + root + return root + +def getTokens(command): + """Return list of token tuples for command.""" + + # In case the command is unicode try encoding it + if type(command) == unicode: + try: + command = command.encode(wx.GetDefaultPyEncoding()) + except UnicodeEncodeError: + pass # otherwise leave it alone + + f = cStringIO.StringIO(command) + # tokens is a list of token tuples, each looking like: + # (type, string, (srow, scol), (erow, ecol), line) + tokens = [] + # Can't use list comprehension: + # tokens = [token for token in tokenize.generate_tokens(f.readline)] + # because of need to append as much as possible before TokenError. + try: +## This code wasn't backward compatible with Python 2.1.3. +## +## for token in tokenize.generate_tokens(f.readline): +## tokens.append(token) + + # This works with Python 2.1.3 (with nested_scopes). + def eater(*args): + tokens.append(args) + tokenize.tokenize_loop(f.readline, eater) + except tokenize.TokenError: + # This is due to a premature EOF, which we expect since we are + # feeding in fragments of Python code. + pass + return tokens + +def rtrimTerminus(command, terminator=None): + """Return command minus anything that follows the final terminator.""" + if terminator: + pieces = command.split(terminator) + if len(pieces) > 1: + command = terminator.join(pieces[:-1]) + terminator + return command + +def getBaseObject(object): + """Return base object and dropSelf indicator for an object.""" + if inspect.isbuiltin(object): + # Builtin functions don't have an argspec that we can get. + dropSelf = 0 + elif inspect.ismethod(object): + # Get the function from the object otherwise + # inspect.getargspec() complains that the object isn't a + # Python function. + try: + if object.im_self is None: + # This is an unbound method so we do not drop self + # from the argspec, since an instance must be passed + # as the first arg. + dropSelf = 0 + else: + dropSelf = 1 + object = object.im_func + except AttributeError: + dropSelf = 0 + elif inspect.isclass(object): + # Get the __init__ method function for the class. + constructor = getConstructor(object) + if constructor is not None: + object = constructor + dropSelf = 1 + else: + dropSelf = 0 + elif callable(object): + # Get the __call__ method instead. + try: + object = object.__call__.im_func + dropSelf = 1 + except AttributeError: + dropSelf = 0 + else: + dropSelf = 0 + return object, dropSelf + +def getConstructor(object): + """Return constructor for class object, or None if there isn't one.""" + try: + return object.__init__.im_func + except AttributeError: + for base in object.__bases__: + constructor = getConstructor(base) + if constructor is not None: + return constructor + return None |