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)