def import_name(s1):
     if s1[0] in NON_TERMINAL:
         if s1[0] in NON_TERMINAL and s1[0] == 286:
             dot_name = ""
             module_name = ""
             for name in s1[1]:
                 if not isinstance(name, int):
                     module_name += name[1]
             if len(s1) == 2:
                 dot_name = module_name
             elif len(s1) == 4:
                 dot_name = s1[3][1]
             try:
                 module = importlib.import_module(module_name)
             except ImportError:
                 print("Import Error, No module named " + module_name)
                 exit()
             new_module = Module(module_name)
             new_module.SYMBOL_LIST = []
             syms = inspect.getmembers(module)
             for sym in syms:
                 if inspect.isfunction(sym[1]):
                     #new_module.SYMBOL_LIST.append(Function(dot_name+'.' + sym[0]))
                     new_module.SYMBOL_LIST.append(Function(sym[0]))
                 elif inspect.isbuiltin(sym[1]):
                     new_module.SYMBOL_LIST.append(Function(sym[0]))
                 elif inspect.ismethod(sym[1]):
                     pass
                 elif inspect.isgeneratorfunction:
                     new_module.SYMBOL_LIST.append(Function(sym[0]))
                 elif inspect.isgenerator(sym[1]):
                     pass
                 elif inspect.istraceback(sym[1]):
                     pass
                 elif inspect.isframe(sym[1]):
                     pass
                 elif inspect.iscode(sym[1]):
                     pass
                 elif inspect.isroutine(sym[1]):
                     pass
                 elif inspect.isabstract(sym[1]):
                     pass
                 elif inspect.ismemberdescriptor(sym[1]):
                     pass
                 elif inspect.isdatadescriptor(sym[1]):
                     pass
                 elif inspect.isdatadescriptor(sym[1]):
                     pass
                 elif inspect.isgetsetdescriptor(sym[1]):
                     pass
                 elif inspect.ismemberdescriptor(sym[1]):
                     pass
                 elif inspect.isclass(sym[1]):
                     new_module.SYMBOL_LIST.append(Class(sym[0], [], []))
                 else:
                     print(sym[0])
                 self.local_names.append(new_module)
         else:
             for j in range(1,len(s1)):
                 import_name(s1[j])
    def import_from(s1, module):
        syms = inspect.getmembers(module)
        str_syms = dir(module)
        name_as = ""
        if len(s1) == 4:
            name_as = s1[3][1]


        if not (s1[1][1] in str_syms):
            print("import error")
            exit()
        else:
            for sym in syms:
                if sym[0] == s1[1][1]:
                    if inspect.isfunction(sym[1]):
                        if len(s1) == 4:
                            GLOBAL_SYMBOL_LIST.append(Function(name_as))
                        else:
                            GLOBAL_SYMBOL_LIST.append(Function(sym[0]))
                    elif inspect.isbuiltin(sym[1]):
                        if len(s1) == 4:
                            GLOBAL_SYMBOL_LIST.append(Function(name_as))
                        else:
                            GLOBAL_SYMBOL_LIST.append(Function(sym[0]))
                    elif inspect.ismethod(sym[1]):
                        pass
                    elif inspect.isgeneratorfunction:
                        if len(s1) == 4:
                            GLOBAL_SYMBOL_LIST.append(Function(name_as))
                        else:
                            GLOBAL_SYMBOL_LIST.append(Function(sym[0]))
                    elif inspect.isgenerator(sym[1]):
                        pass
                    elif inspect.istraceback(sym[1]):
                        pass
                    elif inspect.isframe(sym[1]):
                        pass
                    elif inspect.iscode(sym[1]):
                        pass
                    elif inspect.isroutine(sym[1]):
                        pass
                    elif inspect.isabstract(sym[1]):
                        pass
                    elif inspect.ismemberdescriptor(sym[1]):
                        pass
                    elif inspect.isdatadescriptor(sym[1]):
                        pass
                    elif inspect.isdatadescriptor(sym[1]):
                        pass
                    elif inspect.isgetsetdescriptor(sym[1]):
                        pass
                    elif inspect.ismemberdescriptor(sym[1]):
                        pass
                    elif inspect.isclass(sym[1]):
                        if len(s1) == 4:
                            GLOBAL_SYMBOL_LIST.append(Class(name_as))
                        else:
                            GLOBAL_SYMBOL_LIST.append(Class(sym[0]))
                    else:
                        print(sym[0])
Beispiel #3
0
    def import_name(s1):
        if s1[0] in NON_TERMINAL:
            if s1[0] in NON_TERMINAL and s1[0] == 286:
                dot_name = ""
                module_name = ""
                for name in s1[1]:
                    if type(name) != type(1):
                        module_name += name[1]
                if len(s1) == 2:
                    dot_name = module_name
                elif len(s1) == 4:
                    dot_name = s1[3][1]
                try:
                    module = importlib.import_module(module_name)
                except ImportError:
                    print("Import Error, No module named " + module_name)
                    exit()

                a = dir(module)
                syms = inspect.getmembers(module)
                for sym in syms:
                    if inspect.isfunction(sym[1]):
                        GLOBAL_SYMBOL_LIST.append(Function(dot_name + "." + sym[0]))
                    elif inspect.isbuiltin(sym[1]):
                        GLOBAL_SYMBOL_LIST.append(Function(dot_name + "." + sym[0]))
                    elif inspect.ismethod(sym[1]):
                        pass
                    elif inspect.isgeneratorfunction:
                        GLOBAL_SYMBOL_LIST.append(Function(dot_name + "." + sym[0]))
                    elif inspect.isgenerator(sym[1]):
                        pass
                    elif inspect.istraceback(sym[1]):
                        pass
                    elif inspect.isframe(sym[1]):
                        pass
                    elif inspect.iscode(sym[1]):
                        pass
                    elif inspect.isroutine(sym[1]):
                        pass
                    elif inspect.isabstract(sym[1]):
                        pass
                    elif inspect.ismemberdescriptor(sym[1]):
                        pass
                    elif inspect.isdatadescriptor(sym[1]):
                        pass
                    elif inspect.isdatadescriptor(sym[1]):
                        pass
                    elif inspect.isgetsetdescriptor(sym[1]):
                        pass
                    elif inspect.ismemberdescriptor(sym[1]):
                        pass
                    elif inspect.isclass(sym[1]):
                        GLOBAL_SYMBOL_LIST.append(Class(dot_name + "." + sym[0], [], []))
                    else:
                        print(sym[0])
            else:
                for j in range(1, len(s1)):
                    import_name(s1[j])
 def parse_import(st):
     if st[0] == 283:
         import_name(st[2])
     elif st[0] == 284:
         module_name = ""
         if type(st[2]) != type(1):
             for name in st[2]:
                 if type(name) != type(1):
                     module_name += name[1]
         try:
             module = importlib.import_module(module_name)
         except ImportError:
             print("Import Error, No module named " + module_name)
             exit()
         if len(st)==5 and st[4][1] == "*":
             syms = inspect.getmembers(module)
             str_syms = dir(module)
             name_as = ""
             for sym in syms:
                 if inspect.isfunction(sym[1]):
                     GLOBAL_SYMBOL_LIST.append(Function(sym[0]))
                 elif inspect.isbuiltin(sym[1]):
                     GLOBAL_SYMBOL_LIST.append(Function(sym[0]))
                 elif inspect.ismethod(sym[1]):
                     pass
                 elif inspect.isgeneratorfunction:
                     GLOBAL_SYMBOL_LIST.append(Function(sym[0]))
                 elif inspect.isgenerator(sym[1]):
                     pass
                 elif inspect.istraceback(sym[1]):
                     pass
                 elif inspect.isframe(sym[1]):
                     pass
                 elif inspect.iscode(sym[1]):
                     pass
                 elif inspect.isroutine(sym[1]):
                     pass
                 elif inspect.isabstract(sym[1]):
                     pass
                 elif inspect.ismemberdescriptor(sym[1]):
                     pass
                 elif inspect.isdatadescriptor(sym[1]):
                     pass
                 elif inspect.isdatadescriptor(sym[1]):
                     pass
                 elif inspect.isgetsetdescriptor(sym[1]):
                     pass
                 elif inspect.ismemberdescriptor(sym[1]):
                     pass
                 elif inspect.isclass(sym[1]):
                     GLOBAL_SYMBOL_LIST.append(Class(sym[0]))
                 else:
                     print(sym[0])
         else:
             for counter in range(len(st[4])):
                 if not isinstance(st[4][counter],int) and st[4][counter][0] == 285:
                     import_from(st[4][counter], module)
Beispiel #5
0
def get_size(obj, seen=None):
    """Recursively finds size of objects in bytes"""
    size = sys.getsizeof(obj)
    if seen is None:
        seen = set()
    obj_id = id(obj)
    if obj_id in seen:
        return 0
    # Important mark as seen *before* entering recursion to gracefully handle
    # self-referential objects
    seen.add(obj_id)
    if hasattr(obj, '__dict__'):
        for cls in obj.__class__.__mro__:
            if '__dict__' in cls.__dict__:
                d = cls.__dict__['__dict__']
                if inspect.isgetsetdescriptor(d) or inspect.ismemberdescriptor(d):
                    size += get_size(obj.__dict__, seen)
                break
    if isinstance(obj, dict):
        size += sum((get_size(v, seen) for v in obj.values()))
        size += sum((get_size(k, seen) for k in obj.keys()))
    elif hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes, bytearray)):
        size += sum((get_size(i, seen) for i in obj))
        
    if hasattr(obj, '__slots__'): # can have __slots__ with __dict__
        size += sum(get_size(getattr(obj, s), seen) for s in obj.__slots__ if hasattr(obj, s))
        
    return size
Beispiel #6
0
def struct_code(thing):
    """ returns code structure, given an object or a path to an object."""
    result = dict()
    obj, result['name'] = resolve(thing)    
    result['type'], name = describe(obj)
    module = inspect.getmodule(obj)
    result['module_name'] = module.__name__
    result['module_doc'] = module.__doc__

    try:
        result['file'] = inspect.getabsfile(obj)
    except TypeError:
        result['file'] = '(built-in)'
    
    if type(obj) is _OLD_INSTANCE_TYPE:
        # If the passed object is an instance of an old-style class,
        # document its available methods instead of its value.
        obj = obj.__class__
    elif not (inspect.ismodule(obj) or
              inspect.isclass(obj) or
              inspect.isroutine(obj) or
              inspect.isgetsetdescriptor(obj) or
              inspect.ismemberdescriptor(obj) or
              isinstance(obj, property)):
        # If the passed object is a piece of data or an instance,
        # document its available methods instead of its value.
        obj = type(obj)
    code_struct = PyCodeStruct()
    result['struct'] = code_struct.struct(obj, result['name'])
    return result
Beispiel #7
0
    def test_getset(self):
        obj = self.obj_constructor(**self.obj_data[0])
        data_desc = []
        for x in inspect.getmembers(obj.__class__):
            if (inspect.isdatadescriptor(x[1]) or\
                inspect.isgetsetdescriptor(x[1]) or\
               inspect.ismemberdescriptor(x[1])) and not x[0].startswith("__"):
                data_desc.append(x)

        for attr in data_desc:
            #z = getattr(obj, x[0])
            attr_types = self.obj_getset[attr[0]]
            for _type, vals in _iteritems(self.obj_types):
                if _type not in attr_types:
                    with self.assertRaises(TypeError):
                        setattr(obj, attr[0], vals[0])
                else:
                    for val in vals:
                        setattr(obj, attr[0], val)

            with self.assertRaises(TypeError):
                self.assertTrue(delattr(obj, x[0]), x[0])

            setattr(obj, attr[0], self.obj_types[self.obj_getset[attr[0]][0]][0])
            z = getattr(obj, attr[0])
            self.assertTrue(self.obj_types[self.obj_getset[attr[0]][0]][0] == z)
Beispiel #8
0
 def test_excluding_predicates(self):
     #XXX: Jython's PySystemState needs more work before this
     #will be doable.
     if not test_support.is_jython:
         self.istest(inspect.isbuiltin, 'sys.exit')
     self.istest(inspect.isbuiltin, '[].append')
     self.istest(inspect.isclass, 'mod.StupidGit')
     self.istest(inspect.iscode, 'mod.spam.func_code')
     self.istest(inspect.isframe, 'tb.tb_frame')
     self.istest(inspect.isfunction, 'mod.spam')
     self.istest(inspect.ismethod, 'mod.StupidGit.abuse')
     self.istest(inspect.ismethod, 'git.argue')
     self.istest(inspect.ismodule, 'mod')
     self.istest(inspect.istraceback, 'tb')
     self.istest(inspect.isdatadescriptor, '__builtin__.file.closed')
     self.istest(inspect.isdatadescriptor, '__builtin__.file.softspace')
     if hasattr(types, 'GetSetDescriptorType'):
         self.istest(inspect.isgetsetdescriptor,
                     'type(tb.tb_frame).f_locals')
     #XXX: This detail of PyFrames is not yet supported in Jython
     elif not test_support.is_jython:
         self.failIf(inspect.isgetsetdescriptor(type(tb.tb_frame).f_locals))
     if hasattr(types, 'MemberDescriptorType'):
         self.istest(inspect.ismemberdescriptor, 'datetime.timedelta.days')
     else:
         self.failIf(inspect.ismemberdescriptor(datetime.timedelta.days))
 def print_variable_type(self, objType):
     default_vars=["__builtins__", "__doc__","__path__", "__cached__", "__file__", "__name__", "__package__", "__version__"]
     self.dprint("[ %s ]" %objType.__name__)
     self.indent();self.indent()
     for ModObj in self.Modules:
         for name in dir(ModObj):
             obj = getattr(ModObj, name)
             #print(name, ":", type(obj))
             if not (inspect.isclass(obj) or
                 inspect.isfunction(obj)  or
                 inspect.isroutine(obj)  or
                 inspect.isfunction(obj)  or
                 inspect.isgeneratorfunction(obj)  or
                 inspect.isgenerator(obj)  or
                 inspect.istraceback(obj)  or
                 inspect.isframe(obj)      or
                 inspect.iscode(obj)       or
                 inspect.isabstract(obj)   or
                 inspect.ismethoddescriptor(obj)  or
                 inspect.isdatadescriptor(obj)    or
                 inspect.isgetsetdescriptor(obj)  or
                 inspect.ismemberdescriptor(obj)  or
                 inspect.isbuiltin(obj)):
                 if name not in default_vars:
                     if type(obj) is  objType:
                         ObjName = ModObj.__name__ + '.' + name
                         self.dprint("%s" %ObjName)
     self.dedent();self.dedent()
Beispiel #10
0
    def test_union1(self):
        obj1 = self.__union_prep1()
        obj2 = self.obj_constructor(**self.obj_data[1])
        obj = obj1 + obj2
        for x in inspect.getmembers(obj.__class__):
            if (inspect.isdatadescriptor(x[1]) or\
               inspect.isgetsetdescriptor(x[1]) or\
               inspect.ismemberdescriptor(x[1])) and\
               not x[0].startswith("__") and\
               not inspect.ismethod(x[1]):
                if getattr(obj2, x[0]):
                    self.assertTrue(getattr(obj, x[0]) == getattr(obj2, x[0]))
                else:
                    self.assertTrue(getattr(obj, x[0]) == getattr(obj1, x[0]))

        for member, v in _iteritems(self.obj_list_members):
            _list = getattr(obj, member)
            self.assertTrue(len(_list) == 4)

        for member, v in _iteritems(self.obj_dict_members):
            _d1 = dict([(k, v) for k, v in _iteritems(getattr(obj1, member))])
            _d2 = dict([(k, v) for k, v in _iteritems(getattr(obj2, member))])
            _d1.update(_d2)
            _dict = getattr(obj, member)
            _d = dict([(k,v) for k,v in _iteritems(_dict)])
            self.assertTrue(_d == _d1)
Beispiel #11
0
def test_headers():
    ''' Print the attribute names, sizes and offsets in the C structure
Assuming that the sizes are correct and add up to an offset of 4100 bytes,
everything should add up correctly. This information was taken from the
WinSpec 2.6 Spectroscopy Software User Manual version 2.6B, page 251.

If this table doesn't add up, something changed in the definitions of the
datatype widths. Fix this in winspec.structs file and let me know!
'''

    import inspect, re

    A = Header()
    
    for i in [Header, AxisCalibration, ROIinfo]:
        fields = []

        print '\n{:30s}[{:4s}]\tsize'.format(i, 'offs')
        
        for name,obj in inspect.getmembers(i):
            if inspect.isdatadescriptor(obj) and not inspect.ismemberdescriptor(obj) \
                and not inspect.isgetsetdescriptor(obj):
                
                fields.append((name, obj))

        fields.sort(key=lambda x: re.search('(?<=ofs=)([0-9]+)', str(x[1])).group(0),
                cmp=lambda x,y: cmp(int(x),int(y))); fields

        for name, obj in fields:
            print '{:30s}[{:4d}]\t{:4d}'.format(name, obj.size, obj.offset)
Beispiel #12
0
def get_size(obj, seen=None):
    """Recursively finds size of objects in bytes
    https://github.com/bosswissam/pysize/blob/master/pysize.py
    単体では動くが、locals().keys()を渡して回すとエラー
    """
    size = sys.getsizeof(obj)
    if seen is None:
        seen = set()
    obj_id = id(obj)
    if obj_id in seen:
        return 0
    # Important mark as seen *before* entering recursion to gracefully handle
    # self-referential objects
    seen.add(obj_id)
    if hasattr(obj, '__dict__'):
        for cls in obj.__class__.__mro__:
            if '__dict__' in cls.__dict__:
                d = cls.__dict__['__dict__']
                if inspect.isgetsetdescriptor(d) or inspect.ismemberdescriptor(d):
                    size += get_size(obj.__dict__, seen)
                break
    #以下でtype型を検出したときにTypeError, その他にUnsupportedOperationがRaiseされること有り
    if isinstance(obj, dict):
        size += sum((get_size(v, seen) for v in obj.values()))
        size += sum((get_size(k, seen) for k in obj.keys()))
    elif hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes, bytearray)):
        size += sum((get_size(i, seen) for i in obj))
    return size
Beispiel #13
0
 def get_scope_objects(names):
     """
     Looks for the names defined with dir() in an objects and divides
     them into different object types.
     """
     classes = {}
     funcs = {}
     stmts = {}
     members = {}
     for n in names:
         if '__' in n and n not in mixin_funcs:
             continue
         try:
             # this has a builtin_function_or_method
             exe = getattr(scope, n)
         except AttributeError:
             # happens e.g. in properties of
             # PyQt4.QtGui.QStyleOptionComboBox.currentText
             # -> just set it to None
             members[n] = None
         else:
             if inspect.isclass(scope):
                 if is_in_base_classes(scope, n, exe):
                     continue
             if inspect.isbuiltin(exe) or inspect.ismethod(exe) \
                         or inspect.ismethoddescriptor(exe):
                 funcs[n] = exe
             elif inspect.isclass(exe):
                 classes[n] = exe
             elif inspect.ismemberdescriptor(exe):
                 members[n] = exe
             else:
                 stmts[n] = exe
     return classes, funcs, stmts, members
Beispiel #14
0
 def test_excluding_predicates(self):
     #self.istest(inspect.isbuiltin, 'sys.exit')  # Not valid for Jython
     self.istest(inspect.isbuiltin, '[].append')
     self.istest(inspect.iscode, 'mod.spam.func_code')
     self.istest(inspect.isframe, 'tb.tb_frame')
     self.istest(inspect.isfunction, 'mod.spam')
     self.istest(inspect.ismethod, 'mod.StupidGit.abuse')
     self.istest(inspect.ismethod, 'git.argue')
     self.istest(inspect.ismodule, 'mod')
     self.istest(inspect.istraceback, 'tb')
     self.istest(inspect.isdatadescriptor, '__builtin__.file.closed')
     self.istest(inspect.isdatadescriptor, '__builtin__.file.softspace')
     self.istest(inspect.isgenerator, '(x for x in xrange(2))')
     self.istest(inspect.isgeneratorfunction, 'generator_function_example')
     if hasattr(types, 'GetSetDescriptorType'):
         self.istest(inspect.isgetsetdescriptor,
                     'type(tb.tb_frame).f_locals')
     else:
         self.assertFalse(inspect.isgetsetdescriptor(type(tb.tb_frame).f_locals))
     if hasattr(types, 'MemberDescriptorType'):
         # Not valid for Jython
         # self.istest(inspect.ismemberdescriptor, 'datetime.timedelta.days')
         pass
     else:
         self.assertFalse(inspect.ismemberdescriptor(datetime.timedelta.days))
	def handleSlots(self, obj):
		pyobj = obj.pyobj

		flat = self.flatTypeDict(type(pyobj))

		# Relies on type dictionary being flattened.
		for name, member in flat.iteritems():
			assert not isinstance(name, program.AbstractObject), name
			assert not isinstance(member, program.AbstractObject), member

			# TODO Directly test for slot wrapper?
			# TODO slot wrapper for methods?
			isMember = inspect.ismemberdescriptor(member)

			# HACK some getsets may as well be members
			isMember |= inspect.isgetsetdescriptor(member) and member in self.getsetMember

			if isMember:
				try:
					value = member.__get__(pyobj, type(pyobj))
				except:
					print "Error getting attribute %s" % name
					print "obj", pyobj
					for k, v in inspect.getmembers(pyobj):
						print '\t', k, repr(v)
					raise
				mangledName = self.compiler.slots.uniqueSlotName(member)
				obj.addSlot(self.__getObject(mangledName), self.__getObject(value))
Beispiel #16
0
def print_offsets():
    ''' Print the attribute names, sizes and offsets in the C structure
    
    Assuming that the sizes are correct and add up to an offset of 4100 bytes, 
    everything should add up correctly. This information was taken from the 
    WinSpec 2.6 Spectroscopy Software User Manual version 2.6B, page 251.

    If this table doesn't add up, something changed in the definitions of the 
    datatype widths. Fix this in winspec.structs file and let me know!
    '''

    import inspect, re

    A = Header()

    for i in [Header, AxisCalibration, ROIinfo]:
        fields = []

        print('\n{:30s}[{:4s}]\tsize'.format(repr(i), 'offs'))
        
        for name,obj in inspect.getmembers(i):
            if inspect.isdatadescriptor(obj) and not inspect.ismemberdescriptor(obj) \
                and not inspect.isgetsetdescriptor(obj):
                
                fields.append((name, obj))

        fields = sorted(fields, key=lambda x: x[1].offset)

        for name, obj in fields:
            print('{:30s}[{:4d}]\t{:4d}'.format(name, obj.size, obj.offset))
def describe_module(module, kind, constants=[]):
    """
    Describe the module object passed as argument
    including its classes and functions.
    """

    module_name = module.__name__

    if kind == object_types.LIBRARY:
        klass = Library(module_name)
    else:
        klass = Module(module_name, kind)
        
    klass.docs = getdoc(module)
    klass.comments = getcomments(module)
    
    klass.filename = module.__file__
    inheritance_diagram = []
    
    count = 0
   
    for name in dir(module):
        
        if name in EXCLUDED_ATTRS:
            continue
        
        obj = getattr(module, name)

        if ismodule(obj):
            continue

        if ismemberdescriptor(obj) or isgetsetdescriptor(obj):
            continue
        
        if isclass(obj):
            count += 1
            describe_class(obj, klass, module_name, constants)

            if obj.__module__ == module.__name__:
                inheritance_diagram.append(obj)
            
        elif isbuiltin(obj):
            count += 1
        elif ismethod(obj) or isfunction(obj) or ismethoddescriptor(obj) or \
             isinstance(obj, types.MethodType):
            count +=1
            describe_func(obj, klass, module_name)
        else:
            attribute = Attribute(module_name + '.' + name, type(obj), obj)
            klass.Add(attribute)

            if constants:
                attribute.is_redundant = name not in constants

    if kind not in [object_types.PACKAGE, object_types.LIBRARY]:
        if inheritance_diagram and len(inheritance_diagram) < 20:
            klass.inheritance_diagram = inheritance.InheritanceDiagram(inheritance_diagram, klass)

    return klass, count
Beispiel #18
0
def get_class_descriptors(cls: 'Type[object]') -> Sequence[str]:
    import inspect  # Lazy import for minor startup speed win
    # Maintain a cache of type -> attributes defined by descriptors in the class
    # (that is, attributes from __slots__ and C extension classes)
    if cls not in fields_cache:
        members = inspect.getmembers(
            cls,
            lambda o: inspect.isgetsetdescriptor(o) or inspect.ismemberdescriptor(o))
        fields_cache[cls] = [x for x, y in members if x != '__weakref__' and x != '__dict__']
    return fields_cache[cls]
Beispiel #19
0
def helpNonVerbose(thing, title='Python Library Documentation: %s', forceload=0):
    """
    Utility method to return python help in the form of a string
    (based on the code in pydoc.py)
    Note: only a string (including unicode) should be passed in for "thing"
    """
    
    import pydoc as pydocs
    import inspect
    import string

    result=""

    # Important for converting an incoming c++ unicode character string!
    thingStr=str(thing)

    """Display text documentation, given an object or a path to an object."""
    try:
        # Possible two-stage object resolution!
        # Sometimes we get docs for strings, other times for objects
        #
        try:
            object, name = pydocs.resolve(thingStr, forceload)
        except:
            # Get an object from a string
            thingObj=eval(thingStr)
            object, name = pydocs.resolve(thingObj, forceload)
        desc = pydocs.describe(object)
        module = inspect.getmodule(object)
        if name and '.' in name:
            desc += ' in ' + name[:name.rfind('.')]
        elif module and module is not object:
            desc += ' in module ' + module.__name__
        if not (inspect.ismodule(object) or
                inspect.isclass(object) or
                inspect.isroutine(object) or
                inspect.isgetsetdescriptor(object) or
                inspect.ismemberdescriptor(object) or
                isinstance(object, property)):
            # If the passed object is a piece of data or an instance,
            # document its available methods instead of its value.
            object = type(object)
            desc += ' object'
        text = pydocs.TextDoc()
        result=pydocs.plain(title % desc + '\n\n' + text.document(object, name))
        
        # Remove multiple empty lines
        result = [ line for line in result.splitlines() if line.strip() ]
        result = string.join(result,"\n")

    except:
        pass

    return result
Beispiel #20
0
 def struct(self, obj, name=None, *args):
 
     """Generate structure for an object."""
     
     args = (obj, name) + args
     if inspect.isgetsetdescriptor(obj): return self.struct_data(*args)
     if inspect.ismemberdescriptor(obj): return self.struct_data(*args)
     if inspect.ismodule(obj): return self.struct_module(*args)
     if inspect.isclass(obj): return self.struct_class(*args)
     if inspect.isroutine(obj): return self.struct_routine(*args)
     if isinstance(obj, property): return self.struct_property(*args)
     return self.struct_date(*args)
Beispiel #21
0
 def _clonable(of):
     sets = of.__dict__.copy()
     sets.update(type(of).__dict__.copy())
     final = sets.copy()
     for key in sets:
         v = sets[key]
         if isfunction(v) or ismethod(v) or isgeneratorfunction(v) or isgenerator(v) \
         or isroutine(v) or isabstract(v) or isclass(v) or ismodule(v) or istraceback(v) \
         or isframe(v) or iscode(v) or isbuiltin(v) or ismethoddescriptor(v) \
         or isdatadescriptor(v) or isgetsetdescriptor(v) or ismemberdescriptor(v) \
         or v is None or v == '__main__' or key == '__module__': final.pop(key)
     return final
Beispiel #22
0
 def import_builtin():
     module = importlib.import_module("builtins")
     syms = inspect.getmembers(module)
     for sym in syms:
         if inspect.isfunction(sym[1]):
             GLOBAL_SYMBOL_LIST.append(Function(sym[0]))
         elif inspect.isbuiltin(sym[1]):
             GLOBAL_SYMBOL_LIST.append(Function(sym[0]))
         elif inspect.ismethod(sym[1]):
             pass
         elif inspect.isgeneratorfunction:
             # print(sym[0])
             GLOBAL_SYMBOL_LIST.append(Function(sym[0]))
         elif inspect.isgenerator(sym[1]):
             pass
         elif inspect.istraceback(sym[1]):
             pass
         elif inspect.isframe(sym[1]):
             pass
         elif inspect.iscode(sym[1]):
             pass
         elif inspect.isroutine(sym[1]):
             pass
         elif inspect.isabstract(sym[1]):
             pass
         elif inspect.ismemberdescriptor(sym[1]):
             pass
         elif inspect.isdatadescriptor(sym[1]):
             pass
         elif inspect.isdatadescriptor(sym[1]):
             pass
         elif inspect.isgetsetdescriptor(sym[1]):
             pass
         elif inspect.ismemberdescriptor(sym[1]):
             pass
         elif inspect.isclass(sym[1]):
             GLOBAL_SYMBOL_LIST.append(Class(sym[0]))
         else:
             print(sym[0])
Beispiel #23
0
def is_data_object(obj):
    """Return True of obj holds data

    This routine is used to distinguish objects we should show help
    for (like modules, classes, methods, and so forth) from other
    types of object.
    
    """
    
    # Test borrowed from pydoc.py
    return not (inspect.ismodule(obj) or
                inspect.isclass(obj) or
                inspect.isroutine(obj) or
                inspect.isgetsetdescriptor(obj) or
                inspect.ismemberdescriptor(obj) or
                isinstance(obj, property))
Beispiel #24
0
def _is_visible_type(attribute):
    return not (
        inspect.isfunction(attribute)
        or inspect.ismethod(attribute)
        or inspect.isbuiltin(attribute)
        or inspect.isroutine(attribute)
        or inspect.isclass(attribute)
        or inspect.ismodule(attribute)
        or inspect.istraceback(attribute)
        or inspect.isframe(attribute)
        or inspect.iscode(attribute)
        or inspect.isabstract(attribute)
        or inspect.ismethoddescriptor(attribute)
        or inspect.isdatadescriptor(attribute)
        or inspect.isgetsetdescriptor(attribute)
        or inspect.ismemberdescriptor(attribute)
    )
Beispiel #25
0
def dump_value(value, depth=0):
    if depth > 10:
        return 'max_recursion_depth_exceeded'
    if isinstance(value, type):
        return dump_class(value, depth + 1)
    if inspect.isfunction(value):
        return dump_function(value)
    if callable(value):
        return {'type': 'callable'}  # TODO more information
    if isinstance(value, types.ModuleType):
        return {'type': 'module'}  # TODO module name
    if inspect.isdatadescriptor(value):
        return {'type': 'datadescriptor'}

    if inspect.ismemberdescriptor(value):
        return {'type': 'memberdescriptor'}
    return dump_simple(value)
Beispiel #26
0
 def document(self, object, name=None, *args):
     """Generate documentation for an object."""
     args = (object, name) + args
     # 'try' clause is to attempt to handle the possibility that inspect
     # identifies something in a way that pydoc itself has issues handling;
     # think 'super' and how it is a descriptor (which raises the exception
     # by lacking a __name__ attribute) and an instance.
     if inspect.isgetsetdescriptor(object): return self.docdata(*args)
     if inspect.ismemberdescriptor(object): return self.docdata(*args)
     try:
         if inspect.ismodule(object): return self.docmodule(*args)
         if inspect.isclass(object): return self.docclass(*args)
         if inspect.isroutine(object): return self.docroutine(*args)
     except AttributeError:
         pass
     if isinstance(object, property): return self.docproperty(*args)
     return self.docother(*args)
def getClassInfo(_class):

    parentClassName = inspect.getclasstree([_class])[0][0].__name__

    writeDefinition("class %s(%s):\n" % (_class.__name__, parentClassName))
    writeDefinition("\n")

    indent()

    for memberName in _class.__dict__:
        member = getattr(_class, memberName)
        if inspect.isbuiltin(member):
            getMemberInfo(member, isBuiltIn=True)
            continue
        if inspect.ismethod(member):
            getMemberInfo(member)
            continue
        if inspect.isfunction(member):
            getMemberInfo(member)
            continue
        if inspect.isroutine(member):
            getMemberInfo(member, isBuiltIn=True)
            continue
        if inspect.istraceback(member):
            getMemberInfo(member)
            continue
        if inspect.isframe(member):
            getMemberInfo(member)
            continue
        if inspect.iscode(member):
            getMemberInfo(member)
            continue
        if inspect.ismethoddescriptor(member):
            getMemberInfo(member)
            continue
        if inspect.isdatadescriptor(member):
            getMemberInfo(member)
            continue
        if inspect.isgetsetdescriptor(member):
            getMemberInfo(member)
            continue
        if inspect.ismemberdescriptor(member):
            getMemberInfo(member)

    dedent()
Beispiel #28
0
def describe(thing):
    """Produce a short description of the given thing.
    returns thing's type and name """
    
    # inspect.isgeneratorfunction(object)
    # inspect.isgenerator(object)
    # inspect.istraceback(object)
    # inspect.isframe(object)
    # inspect.iscode(object)
    # inspect.isroutine(object)
    # inspect.isabstract(object)
    # inspect.ismethoddescriptor(object)
    # inspect.isdatadescriptor(object)
    
    if inspect.ismodule(thing):
        if thing.__name__ in sys.builtin_module_names:
            return ('built-in module', thing.__name__)
        if hasattr(thing, '__path__'):
            return ('package', thing.__name__)
        else:
            return ('module', thing.__name__)
    if inspect.isbuiltin(thing):
        return ('built-in function', thing.__name__)
    if inspect.isgetsetdescriptor(thing):
        return (
            'getset descriptor', 
            '%s.%s.%s' % (  thing.__objclass__.__module__, 
                            thing.__objclass__.__name__,
                            thing.__name__))
    if inspect.ismemberdescriptor(thing):
        return (
            'member descriptor', 
            '%s.%s.%s' % (  thing.__objclass__.__module__, 
                            thing.__objclass__.__name__,
                            thing.__name__))
    if inspect.isclass(thing):
        return ('class', thing.__name__)
    if inspect.isfunction(thing):
        return ('function', thing.__name__)
    if inspect.ismethod(thing):
        return ('method', thing.__name__)
    if type(thing) is types.InstanceType:
        return ('instance of', thing.__class__.__name__)
    return (type(thing).__name__, '')
def determine_object_type(obj):
    if inspect.ismodule(obj):
        return 'Module', obj.__str__()
    elif inspect.isclass(obj):
        return 'Class', obj.__str__()
    elif inspect.ismethod(obj):
        return 'Method', obj.__str__()
    elif inspect.isfunction(obj):
        return 'Function', obj.__str__()
    elif inspect.isgeneratorfunction(obj):
        return 'Generator Function', obj.__str__()
    elif inspect.isgenerator(obj):
        return 'Generator', obj.__str__()
    elif inspect.iscoroutinefunction(obj):
        return 'Coroutine Function', obj.__str__()
    elif inspect.iscoroutine(obj):
        return 'Coroutine', obj.__str__()
    elif inspect.isawaitable(obj):
        return 'Awaitable', obj.__str__()
    elif inspect.istraceback(obj):
        return 'Traceback', obj.__str__()
    elif inspect.isframe(obj):
        return 'Frame', obj.__str__()
    elif inspect.iscode(obj):
        return 'Code', obj.__str__()
    elif inspect.isbuiltin(obj):
        return 'Builtin', obj.__str__()
    elif inspect.isroutine(obj):
        return 'Routine', obj.__str__()
    elif inspect.isabstract(obj):
        return 'Abstract Base Class', obj.__str__()
    elif inspect.ismethoddescriptor(obj):
        return 'Method Descriptor', obj.__str__()
    elif inspect.isdatadescriptor(obj):
        return 'Data Descriptor', obj.__str__()
    elif inspect.isgetsetdescriptor(obj):
        return 'Getset Descriptor', obj.__str__()
    elif inspect.ismemberdescriptor(obj):
        return 'Member Descriptor', obj.__str__()
    elif inspect.isbuiltin(obj):
        return type(obj), obj.__str__()
    else:
        return type(obj), obj.__str__()
Beispiel #30
0
def _propsdict(obj):
    """Returns the @properties in an object.
    Example:
    >>> class PropertyCarrier(object):
    ...     __slots__ = 'prop2'
    ...     def __init__(self):
    ...         self.prop2 = 3
    ...     @property
    ...     def prop(self):
    ...         return self.prop2
    ...     @prop.setter
    ...     def prop(self, prop):
    ...         self.prop2 = prop
    >>> _propsdict(PropertyCarrier())
    {'prop': 3}
    """
    descriptors = inspect.getmembers(obj.__class__, inspect.isdatadescriptor)
    # All data descriptors except slots and __weakref__
    # See: http://docs.python.org/2/reference/datamodel.html
    return {dname: value.__get__(obj) for dname, value in descriptors if
            '__weakref__' != dname and not inspect.ismemberdescriptor(value)}