def test_collate(self): options = {'A': 1} mod = inspection.module(fn1) functions = inspection.functions(mod) functions.extend(inspection.methods(Person)) functions = {f[1]: options for f in functions} collator = collation.Collator() classes, functions = collator(functions) self.assertEqual(classes, [ collation.Class(Person, methods={ m.name: m for m in [ collation.Method(Person.walk), collation.Method(Person.run) ] }) ]) self.assertEqual(functions, [ collation.Module( mod, functions={ f.name: f for f in [collation.Function(fn1), collation.Method(fn2)] }) ])
def __exception(cls): """ Return raised exception. :return: A return document. :rtype: Return """ info = sys.exc_info() inst = info[1] xclass = inst.__class__ exval = '\n'.join(tb.format_exception(*info)) mod = inspection.module(xclass) if mod: mod = mod.__name__ args = None if issubclass(xclass, Exception): args = inst.args state = dict(inst.__dict__) state['trace'] = exval inst = Return(exval=exval, xmodule=mod, xclass=xclass.__name__, xstate=state, xargs=args) inst.dump() # validate return inst
def find(mod): """ Yield all functions in the specified module. Args: mod (module): A module. Yields: function: Each function. """ for fn in Remote.functions: if inspection.module(fn) == mod: yield fn
def __call__(self, functions): """ Collate functions by module|class. Args: functions (dict): Dictionary of {function: {options}} Returns: tuple: of ([Class], [Module]) """ classes = [] self.classes.clear() self.functions.clear() for fn, options in functions.items(): mod = inspection.module(fn) classes.extend(inspection.classes(mod)) self._bind(classes, fn, options) return list(self.classes.values()), list(self.functions.values())
def test_operators(self): impl = inspection.module(fn1) mod = collation.Module(impl) # iadd fn = collation.Function(fn1) mod += fn self.assertEqual(list(mod.functions.values())[0], fn) # hash self.assertEqual(hash(mod), hash(impl.__name__)) # index self.assertEqual(mod['fn1'], fn) # eq self.assertEqual(collation.Module(impl), collation.Module(impl)) # neq self.assertNotEqual(collation.Module(impl), collation.Module(mock.Mock(__name__=''))) # iter self.assertEqual(list(mod.functions.values()), list(mod))
def _bind(self, classes, fn, options): """ Bind the function (fn) to its class when part of a method for to it's module for unbound function. This populates the self.classes and self.functions dictionaries. Args: classes (list): A list of know classes. fn (function): A function to bind. options (dict): Options associated with a decorated function. """ for name, cls in classes: for _, function_ in inspection.methods(cls): if function_ == fn: container = self.classes.setdefault( cls.__name__, Class(cls)) container += Method(fn, options) return mod = inspection.module(fn) container = self.functions.setdefault(mod.__name__, Module(mod)) container += Function(fn, options)
def test_init(self): impl = inspection.module(fn1) mod = collation.Module(impl) self.assertEqual(mod.name, impl.__name__) self.assertEqual(mod.impl, impl)