predicates = set([inspect.isbuiltin, inspect.isclass, inspect.iscode,

inspect.isframe, inspect.isfunction, inspect.ismethod,

inspect.ismodule, inspect.istraceback,

inspect.isgenerator, inspect.isgeneratorfunction,

inspect.iscoroutine, inspect.iscoroutinefunction,

inspect.isasyncgen, inspect.isasyncgenfunction])

def istest(self, predicate, exp):

obj = eval(exp)

self.assertTrue(predicate(obj), '%s(%s)' % (predicate.__name__, exp))

for other in self.predicates - set([predicate]):

if (predicate == inspect.isgeneratorfunction or \

predicate == inspect.isasyncgenfunction or \

predicate == inspect.iscoroutinefunction) and \

other == inspect.isfunction:

continue

def test_excluding_predicates(self):

global tb

self.istest(inspect.isbuiltin, 'sys.exit')

self.istest(inspect.isbuiltin, '[].append')

self.istest(inspect.iscode, 'mod.spam.__code__')

try:

1/0

except:

tb = sys.exc_info()[2]

self.istest(inspect.isframe, 'tb.tb_frame')

self.istest(inspect.istraceback, 'tb')

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))

finally:

# Clear traceback and all the frames and local variables hanging to it.

tb = None

self.istest(inspect.isfunction, 'mod.spam')

self.istest(inspect.isfunction, 'mod.StupidGit.abuse')

self.istest(inspect.ismethod, 'git.argue')

self.istest(inspect.ismodule, 'mod')

self.istest(inspect.isdatadescriptor, 'collections.defaultdict.default_factory')

self.istest(inspect.isgenerator, '(x for x in range(2))')

self.istest(inspect.isgeneratorfunction, 'generator_function_example')

self.istest(inspect.isasyncgen,

'async_generator_function_example(1)')

self.istest(inspect.isasyncgenfunction,

'async_generator_function_example')

with warnings.catch_warnings():

warnings.simplefilter("ignore")

self.istest(inspect.iscoroutine, 'coroutine_function_example(1)')

self.istest(inspect.iscoroutinefunction, 'coroutine_function_example')

if hasattr(types, 'MemberDescriptorType'):

self.istest(inspect.ismemberdescriptor, 'datetime.timedelta.days')

else:

self.assertFalse(inspect.ismemberdescriptor(datetime.timedelta.days))

def test_iscoroutine(self):

gen_coro = gen_coroutine_function_example(1)

coro = coroutine_function_example(1)

self.assertFalse(

inspect.iscoroutinefunction(gen_coroutine_function_example))

self.assertFalse(inspect.iscoroutine(gen_coro))

self.assertTrue(

inspect.isgeneratorfunction(gen_coroutine_function_example))

self.assertTrue(inspect.isgenerator(gen_coro))

self.assertTrue(

inspect.iscoroutinefunction(coroutine_function_example))

self.assertTrue(inspect.iscoroutine(coro))

self.assertFalse(

inspect.isgeneratorfunction(coroutine_function_example))

self.assertFalse(inspect.isgenerator(coro))

coro.close(); gen_coro.close() # silence warnings

def test_isawaitable(self):

def gen(): yield

self.assertFalse(inspect.isawaitable(gen()))

coro = coroutine_function_example(1)

gen_coro = gen_coroutine_function_example(1)

self.assertTrue(inspect.isawaitable(coro))

self.assertTrue(inspect.isawaitable(gen_coro))

class Future:

def __await__():

pass

self.assertTrue(inspect.isawaitable(Future()))

self.assertFalse(inspect.isawaitable(Future))

class NotFuture: pass

not_fut = NotFuture()

not_fut.__await__ = lambda: None

self.assertFalse(inspect.isawaitable(not_fut))

coro.close(); gen_coro.close() # silence warnings

def test_isroutine(self):

self.assertTrue(inspect.isroutine(mod.spam))

self.assertTrue(inspect.isroutine([].count))

def test_isclass(self):

self.istest(inspect.isclass, 'mod.StupidGit')

self.assertTrue(inspect.isclass(list))

class CustomGetattr(object):

def __getattr__(self, attr):

return None

self.assertFalse(inspect.isclass(CustomGetattr()))

def test_get_slot_members(self):

class C(object):

__slots__ = ("a", "b")

x = C()

x.a = 42

members = dict(inspect.getmembers(x))

self.assertIn('a', members)

self.assertNotIn('b', members)

def test_isabstract(self):

from abc import ABCMeta, abstractmethod

class AbstractClassExample(metaclass=ABCMeta):

@abstractmethod

def foo(self):

pass

class ClassExample(AbstractClassExample):

def foo(self):

pass

a = ClassExample()

# Test general behaviour.

self.assertTrue(inspect.isabstract(AbstractClassExample))

self.assertFalse(inspect.isabstract(ClassExample))

self.assertFalse(inspect.isabstract(a))

self.assertFalse(inspect.isabstract(int))

self.assertFalse(inspect.isabstract(5))

def test_isabstract_during_init_subclass(self):

from abc import ABCMeta, abstractmethod

isabstract_checks = []

class AbstractChecker(metaclass=ABCMeta):

def __init_subclass__(cls):

isabstract_checks.append(inspect.isabstract(cls))

class AbstractClassExample(AbstractChecker):

@abstractmethod

def foo(self):

pass

class ClassExample(AbstractClassExample):

def foo(self):

pass

self.assertEqual(isabstract_checks, [True, False])

isabstract_checks.clear()

class AbstractChild(AbstractClassExample):

pass

class AbstractGrandchild(AbstractChild):

pass

class ConcreteGrandchild(ClassExample):

pass

def __init__(self, *args, **kwargs):

unittest.TestCase.__init__(self, *args, **kwargs)

git.abuse(7, 8, 9)

def test_abuse_done(self):

self.istest(inspect.istraceback, 'git.ex[2]')

self.istest(inspect.isframe, 'mod.fr')

def test_stack(self):

self.assertTrue(len(mod.st) >= 5)

self.assertEqual(revise(*mod.st[0][1:]),

(modfile, 16, 'eggs', [' st = inspect.stack()\n'], 0))

self.assertEqual(revise(*mod.st[1][1:]),

(modfile, 9, 'spam', [' eggs(b + d, c + f)\n'], 0))

self.assertEqual(revise(*mod.st[2][1:]),

(modfile, 43, 'argue', [' spam(a, b, c)\n'], 0))

self.assertEqual(revise(*mod.st[3][1:]),

(modfile, 39, 'abuse', [' self.argue(a, b, c)\n'], 0))

# Test named tuple fields

record = mod.st[0]

self.assertIs(record.frame, mod.fr)

self.assertEqual(record.lineno, 16)

self.assertEqual(record.filename, mod.__file__)

self.assertEqual(record.function, 'eggs')

self.assertIn('inspect.stack()', record.code_context[0])

self.assertEqual(record.index, 0)

def test_trace(self):

self.assertEqual(len(git.tr), 3)

self.assertEqual(revise(*git.tr[0][1:]),

(modfile, 43, 'argue', [' spam(a, b, c)\n'], 0))

self.assertEqual(revise(*git.tr[1][1:]),

(modfile, 9, 'spam', [' eggs(b + d, c + f)\n'], 0))

self.assertEqual(revise(*git.tr[2][1:]),

(modfile, 18, 'eggs', [' q = y / 0\n'], 0))

def test_frame(self):

args, varargs, varkw, locals = inspect.getargvalues(mod.fr)

self.assertEqual(args, ['x', 'y'])

self.assertEqual(varargs, None)

self.assertEqual(varkw, None)

self.assertEqual(locals, {'x': 11, 'p': 11, 'y': 14})

self.assertEqual(inspect.formatargvalues(args, varargs, varkw, locals),

'(x=11, y=14)')

def test_previous_frame(self):

args, varargs, varkw, locals = inspect.getargvalues(mod.fr.f_back)

self.assertEqual(args, ['a', 'b', 'c', 'd', 'e', 'f'])

self.assertEqual(varargs, 'g')

self.assertEqual(varkw, 'h')

self.assertEqual(inspect.formatargvalues(args, varargs, varkw, locals),

# Subclasses must override.

fodderModule = None

def setUp(self):

with open(inspect.getsourcefile(self.fodderModule)) as fp:

self.source = fp.read()

def sourcerange(self, top, bottom):

lines = self.source.split("\n")

return "\n".join(lines[top-1:bottom]) + ("\n" if bottom else "")

def assertSourceEqual(self, obj, top, bottom):

self.assertEqual(inspect.getsource(obj),

fodderModule = mod

def test_getclasses(self):

classes = inspect.getmembers(mod, inspect.isclass)

self.assertEqual(classes,

[('FesteringGob', mod.FesteringGob),

('MalodorousPervert', mod.MalodorousPervert),

('ParrotDroppings', mod.ParrotDroppings),

('StupidGit', mod.StupidGit),

('Tit', mod.MalodorousPervert),

])

tree = inspect.getclasstree([cls[1] for cls in classes])

self.assertEqual(tree,

[(object, ()),

[(mod.ParrotDroppings, (object,)),

[(mod.FesteringGob, (mod.MalodorousPervert,

mod.ParrotDroppings))

],

(mod.StupidGit, (object,)),

[(mod.MalodorousPervert, (mod.StupidGit,)),

[(mod.FesteringGob, (mod.MalodorousPervert,

mod.ParrotDroppings))

]

]

]

])

tree = inspect.getclasstree([cls[1] for cls in classes], True)

self.assertEqual(tree,

[(object, ()),

[(mod.ParrotDroppings, (object,)),

(mod.StupidGit, (object,)),

[(mod.MalodorousPervert, (mod.StupidGit,)),

[(mod.FesteringGob, (mod.MalodorousPervert,

mod.ParrotDroppings))

]

]

]

])

def test_getfunctions(self):

functions = inspect.getmembers(mod, inspect.isfunction)

self.assertEqual(functions, [('eggs', mod.eggs),

('lobbest', mod.lobbest),

('spam', mod.spam)])

@unittest.skipIf(sys.flags.optimize >= 2,

def test_getdoc(self):

self.assertEqual(inspect.getdoc(mod), 'A module docstring.')

self.assertEqual(inspect.getdoc(mod.StupidGit),

'A longer,\n\nindented\n\ndocstring.')

self.assertEqual(inspect.getdoc(git.abuse),

'Another\n\ndocstring\n\ncontaining\n\ntabs')

@unittest.skipIf(sys.flags.optimize >= 2,

def test_getdoc_inherited(self):

self.assertEqual(inspect.getdoc(mod.FesteringGob),

'A longer,\n\nindented\n\ndocstring.')

self.assertEqual(inspect.getdoc(mod.FesteringGob.abuse),

'Another\n\ndocstring\n\ncontaining\n\ntabs')

self.assertEqual(inspect.getdoc(mod.FesteringGob().abuse),

'Another\n\ndocstring\n\ncontaining\n\ntabs')

self.assertEqual(inspect.getdoc(mod.FesteringGob.contradiction),

'The automatic gainsaying.')

@unittest.skipIf(MISSING_C_DOCSTRINGS, "test requires docstrings")

def test_finddoc(self):

finddoc = inspect._finddoc

self.assertEqual(finddoc(int), int.__doc__)

self.assertEqual(finddoc(int.to_bytes), int.to_bytes.__doc__)

self.assertEqual(finddoc(int().to_bytes), int.to_bytes.__doc__)

self.assertEqual(finddoc(int.from_bytes), int.from_bytes.__doc__)

self.assertEqual(finddoc(int.real), int.real.__doc__)

def test_cleandoc(self):

self.assertEqual(inspect.cleandoc('An\n indented\n docstring.'),

'An\nindented\ndocstring.')

def test_getcomments(self):

self.assertEqual(inspect.getcomments(mod), '# line 1\n')

self.assertEqual(inspect.getcomments(mod.StupidGit), '# line 20\n')

# If the object source file is not available, return None.

co = compile('x=1', '_non_existing_filename.py', 'exec')

self.assertIsNone(inspect.getcomments(co))

# If the object has been defined in C, return None.

self.assertIsNone(inspect.getcomments(list))

def test_getmodule(self):

# Check actual module

self.assertEqual(inspect.getmodule(mod), mod)

# Check class (uses __module__ attribute)

self.assertEqual(inspect.getmodule(mod.StupidGit), mod)

# Check a method (no __module__ attribute, falls back to filename)

self.assertEqual(inspect.getmodule(mod.StupidGit.abuse), mod)

# Do it again (check the caching isn't broken)

self.assertEqual(inspect.getmodule(mod.StupidGit.abuse), mod)

# Check a builtin

self.assertEqual(inspect.getmodule(str), sys.modules["builtins"])

# Check filename override

self.assertEqual(inspect.getmodule(None, modfile), mod)

def test_getframeinfo_get_first_line(self):

frame_info = inspect.getframeinfo(self.fodderModule.fr, 50)

self.assertEqual(frame_info.code_context[0], "# line 1\n")

self.assertEqual(frame_info.code_context[1], "'A module docstring.'\n")

def test_getsource(self):

self.assertSourceEqual(git.abuse, 29, 39)

self.assertSourceEqual(mod.StupidGit, 21, 51)

self.assertSourceEqual(mod.lobbest, 75, 76)

def test_getsourcefile(self):

self.assertEqual(normcase(inspect.getsourcefile(mod.spam)), modfile)

self.assertEqual(normcase(inspect.getsourcefile(git.abuse)), modfile)

fn = "_non_existing_filename_used_for_sourcefile_test.py"

co = compile("x=1", fn, "exec")

self.assertEqual(inspect.getsourcefile(co), None)

linecache.cache[co.co_filename] = (1, None, "None", co.co_filename)

try:

self.assertEqual(normcase(inspect.getsourcefile(co)), fn)

finally:

del linecache.cache[co.co_filename]

def test_getfile(self):

self.assertEqual(inspect.getfile(mod.StupidGit), mod.__file__)

def test_getfile_class_without_module(self):

class CM(type):

@property

def __module__(cls):

raise AttributeError

class C(metaclass=CM):

pass

with self.assertRaises(TypeError):

inspect.getfile(C)

def test_getmodule_recursion(self):

from types import ModuleType

name = '__inspect_dummy'

m = sys.modules[name] = ModuleType(name)

m.__file__ = "<string>" # hopefully not a real filename...

m.__loader__ = "dummy" # pretend the filename is understood by a loader

exec("def x(): pass", m.__dict__)

self.assertEqual(inspect.getsourcefile(m.x.__code__), '<string>')

del sys.modules[name]

inspect.getmodule(compile('a=10','','single'))

def test_proceed_with_fake_filename(self):

'''doctest monkeypatches linecache to enable inspection'''

fn, source = '<test>', 'def x(): pass\n'

getlines = linecache.getlines

def monkey(filename, module_globals=None):

if filename == fn:

return source.splitlines(keepends=True)

else:

return getlines(filename, module_globals)

linecache.getlines = monkey

try:

ns = {}

exec(compile(source, fn, 'single'), ns)

inspect.getsource(ns["x"])

finally:

linecache.getlines = getlines

def test_getsource_on_code_object(self):

fodderModule = mod

def test_range_toplevel_frame(self):

self.maxDiff = None

self.assertSourceEqual(mod.currentframe, 1, None)

def test_range_traceback_toplevel_frame(self):

fodderModule = mod2

def test_wrapped_decorator(self):

self.assertSourceEqual(mod2.wrapped, 14, 17)

def test_replacing_decorator(self):

self.assertSourceEqual(mod2.gone, 9, 10)

def test_getsource_unwrap(self):

self.assertSourceEqual(mod2.real, 130, 132)

def test_decorator_with_lambda(self):

fodderModule = mod2

def test_oneline_lambda(self):

# Test inspect.getsource with a one-line lambda function.

self.assertSourceEqual(mod2.oll, 25, 25)

def test_threeline_lambda(self):

# Test inspect.getsource with a three-line lambda function,

# where the second and third lines are _not_ indented.

self.assertSourceEqual(mod2.tll, 28, 30)

def test_twoline_indented_lambda(self):

# Test inspect.getsource with a two-line lambda function,

# where the second line _is_ indented.

self.assertSourceEqual(mod2.tlli, 33, 34)

def test_onelinefunc(self):

# Test inspect.getsource with a regular one-line function.

self.assertSourceEqual(mod2.onelinefunc, 37, 37)

def test_manyargs(self):

# Test inspect.getsource with a regular function where

# the arguments are on two lines and _not_ indented and

# the body on the second line with the last arguments.

self.assertSourceEqual(mod2.manyargs, 40, 41)

def test_twolinefunc(self):

# Test inspect.getsource with a regular function where

# the body is on two lines, following the argument list and

# continued on the next line by a \\.

self.assertSourceEqual(mod2.twolinefunc, 44, 45)

def test_lambda_in_list(self):

# Test inspect.getsource with a one-line lambda function

# defined in a list, indented.

self.assertSourceEqual(mod2.a[1], 49, 49)

def test_anonymous(self):

# Test inspect.getsource with a lambda function defined

# as argument to another function.

fodderModule = mod2

def test_with_comment(self):

self.assertSourceEqual(mod2.with_comment, 58, 59)

def test_multiline_sig(self):

self.assertSourceEqual(mod2.multiline_sig[0], 63, 64)

def test_nested_class(self):

self.assertSourceEqual(mod2.func69().func71, 71, 72)

def test_one_liner_followed_by_non_name(self):

self.assertSourceEqual(mod2.func77, 77, 77)

def test_one_liner_dedent_non_name(self):

self.assertSourceEqual(mod2.cls82.func83, 83, 83)

def test_with_comment_instead_of_docstring(self):

self.assertSourceEqual(mod2.func88, 88, 90)

def test_method_in_dynamic_class(self):

self.assertSourceEqual(mod2.method_in_dynamic_class, 95, 97)

# This should not skip for CPython, but might on a repackaged python where

# unicodedata is not an external module, or on pypy.

@unittest.skipIf(not hasattr(unicodedata, '__file__') or

def test_findsource_binary(self):

self.assertRaises(OSError, inspect.getsource, unicodedata)

self.assertRaises(OSError, inspect.findsource, unicodedata)

def test_findsource_code_in_linecache(self):

lines = ["x=1"]

co = compile(lines[0], "_dynamically_created_file", "exec")

self.assertRaises(OSError, inspect.findsource, co)

self.assertRaises(OSError, inspect.getsource, co)

linecache.cache[co.co_filename] = (1, None, lines, co.co_filename)

try:

self.assertEqual(inspect.findsource(co), (lines,0))

self.assertEqual(inspect.getsource(co), lines[0])

finally:

del linecache.cache[co.co_filename]

def test_findsource_without_filename(self):

for fname in ['', '<string>']:

co = compile('x=1', fname, "exec")

self.assertRaises(IOError, inspect.findsource, co)

self.assertRaises(IOError, inspect.getsource, co)

def test_getsource_on_method(self):

self.assertSourceEqual(mod2.ClassWithMethod.method, 118, 119)

def test_nested_func(self):

def setUp(self):

self.tempdir = TESTFN + '_dir'

os.mkdir(self.tempdir)

with open(os.path.join(self.tempdir,

'inspect_fodder3%spy' % os.extsep), 'w') as f:

f.write("class X:\n pass # No EOL")

with DirsOnSysPath(self.tempdir):

import inspect_fodder3 as mod3

self.fodderModule = mod3

super().setUp()

def tearDown(self):

shutil.rmtree(self.tempdir)

def test_class(self):

"""

def __get__(*args):

raise AttributeError("broken data descriptor")

def __set__(*args):

raise RuntimeError

def __getattr__(*args):

"""

def __get__(*args):

raise AttributeError("broken method descriptor")

def __getattr__(*args):

def test_newstyle_mro(self):

# The same w/ new-class MRO.

class A(object): pass

class B(A): pass

class C(A): pass

class D(B, C): pass

expected = (D, B, C, A, object)

got = inspect.getmro(D)

self.assertEqual(expected, got)

def assertArgSpecEquals(self, routine, args_e, varargs_e=None,

varkw_e=None, defaults_e=None, formatted=None):

with self.assertWarns(DeprecationWarning):

args, varargs, varkw, defaults = inspect.getargspec(routine)

self.assertEqual(args, args_e)

self.assertEqual(varargs, varargs_e)

self.assertEqual(varkw, varkw_e)

self.assertEqual(defaults, defaults_e)

if formatted is not None:

self.assertEqual(inspect.formatargspec(args, varargs, varkw, defaults),

formatted)

def assertFullArgSpecEquals(self, routine, args_e, varargs_e=None,

varkw_e=None, defaults_e=None,

kwonlyargs_e=[], kwonlydefaults_e=None,

ann_e={}, formatted=None):

args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, ann = \

inspect.getfullargspec(routine)

self.assertEqual(args, args_e)

self.assertEqual(varargs, varargs_e)

self.assertEqual(varkw, varkw_e)

self.assertEqual(defaults, defaults_e)

self.assertEqual(kwonlyargs, kwonlyargs_e)

self.assertEqual(kwonlydefaults, kwonlydefaults_e)

self.assertEqual(ann, ann_e)

if formatted is not None:

self.assertEqual(inspect.formatargspec(args, varargs, varkw, defaults,

kwonlyargs, kwonlydefaults, ann),

formatted)

def test_getargspec(self):

self.assertArgSpecEquals(mod.eggs, ['x', 'y'], formatted='(x, y)')

self.assertArgSpecEquals(mod.spam,

['a', 'b', 'c', 'd', 'e', 'f'],

'g', 'h', (3, 4, 5),

'(a, b, c, d=3, e=4, f=5, *g, **h)')

self.assertRaises(ValueError, self.assertArgSpecEquals,

mod2.keyworded, [])

self.assertRaises(ValueError, self.assertArgSpecEquals,

mod2.annotated, [])

self.assertRaises(ValueError, self.assertArgSpecEquals,

mod2.keyword_only_arg, [])

def test_getfullargspec(self):

self.assertFullArgSpecEquals(mod2.keyworded, [], varargs_e='arg1',

kwonlyargs_e=['arg2'],

kwonlydefaults_e={'arg2':1},

formatted='(*arg1, arg2=1)')

self.assertFullArgSpecEquals(mod2.annotated, ['arg1'],

ann_e={'arg1' : list},

formatted='(arg1: list)')

self.assertFullArgSpecEquals(mod2.keyword_only_arg, [],

kwonlyargs_e=['arg'],

formatted='(*, arg)')

def test_argspec_api_ignores_wrapped(self):

# Issue 20684: low level introspection API must ignore __wrapped__

@functools.wraps(mod.spam)

def ham(x, y):

pass

# Basic check

self.assertArgSpecEquals(ham, ['x', 'y'], formatted='(x, y)')

self.assertFullArgSpecEquals(ham, ['x', 'y'], formatted='(x, y)')

self.assertFullArgSpecEquals(functools.partial(ham),

['x', 'y'], formatted='(x, y)')

# Other variants

def check_method(f):

self.assertArgSpecEquals(f, ['self', 'x', 'y'],

formatted='(self, x, y)')

class C:

@functools.wraps(mod.spam)

def ham(self, x, y):

pass

pham = functools.partialmethod(ham)

@functools.wraps(mod.spam)

def __call__(self, x, y):

pass

check_method(C())

check_method(C.ham)

check_method(C().ham)

check_method(C.pham)

check_method(C().pham)

class C_new:

@functools.wraps(mod.spam)

def __new__(self, x, y):

pass

check_method(C_new)

class C_init:

@functools.wraps(mod.spam)

def __init__(self, x, y):

pass

check_method(C_init)

def test_getfullargspec_signature_attr(self):

def test():

pass

spam_param = inspect.Parameter('spam', inspect.Parameter.POSITIONAL_ONLY)

test.__signature__ = inspect.Signature(parameters=(spam_param,))

self.assertFullArgSpecEquals(test, args_e=['spam'], formatted='(spam)')

def test_getfullargspec_signature_annos(self):

def test(a:'spam') -> 'ham': pass

spec = inspect.getfullargspec(test)

self.assertEqual(test.__annotations__, spec.annotations)

def test(): pass

spec = inspect.getfullargspec(test)

self.assertEqual(test.__annotations__, spec.annotations)

@unittest.skipIf(MISSING_C_DOCSTRINGS,

def test_getfullargspec_builtin_methods(self):

self.assertFullArgSpecEquals(_pickle.Pickler.dump,

args_e=['self', 'obj'], formatted='(self, obj)')

self.assertFullArgSpecEquals(_pickle.Pickler(io.BytesIO()).dump,

args_e=['self', 'obj'], formatted='(self, obj)')

self.assertFullArgSpecEquals(

os.stat,

args_e=['path'],

kwonlyargs_e=['dir_fd', 'follow_symlinks'],

kwonlydefaults_e={'dir_fd': None, 'follow_symlinks': True},

formatted='(path, *, dir_fd=None, follow_symlinks=True)')

@cpython_only

@unittest.skipIf(MISSING_C_DOCSTRINGS,

def test_getfullagrspec_builtin_func(self):

import _testcapi

builtin = _testcapi.docstring_with_signature_with_defaults

spec = inspect.getfullargspec(builtin)

self.assertEqual(spec.defaults[0], 'avocado')

@cpython_only

@unittest.skipIf(MISSING_C_DOCSTRINGS,

def test_getfullagrspec_builtin_func_no_signature(self):

import _testcapi

builtin = _testcapi.docstring_no_signature

with self.assertRaises(TypeError):

inspect.getfullargspec(builtin)

def test_getargspec_method(self):

class A(object):

def m(self):

pass

self.assertArgSpecEquals(A.m, ['self'])

def test_classify_newstyle(self):

class A(object):

def s(): pass

s = staticmethod(s)

def c(cls): pass

c = classmethod(c)

def getp(self): pass

p = property(getp)

def m(self): pass

def m1(self): pass

datablob = '1'

dd = _BrokenDataDescriptor()

md = _BrokenMethodDescriptor()

attrs = attrs_wo_objs(A)

self.assertIn(('__new__', 'method', object), attrs, 'missing __new__')

self.assertIn(('__init__', 'method', object), attrs, 'missing __init__')

self.assertIn(('s', 'static method', A), attrs, 'missing static method')

self.assertIn(('c', 'class method', A), attrs, 'missing class method')

self.assertIn(('p', 'property', A), attrs, 'missing property')

self.assertIn(('m', 'method', A), attrs,

'missing plain method: %r' % attrs)

self.assertIn(('m1', 'method', A), attrs, 'missing plain method')

self.assertIn(('datablob', 'data', A), attrs, 'missing data')

self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')

self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')

class B(A):

def m(self): pass

attrs = attrs_wo_objs(B)

self.assertIn(('s', 'static method', A), attrs, 'missing static method')

self.assertIn(('c', 'class method', A), attrs, 'missing class method')

self.assertIn(('p', 'property', A), attrs, 'missing property')

self.assertIn(('m', 'method', B), attrs, 'missing plain method')

self.assertIn(('m1', 'method', A), attrs, 'missing plain method')

self.assertIn(('datablob', 'data', A), attrs, 'missing data')

self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')

self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')

class C(A):

def m(self): pass

def c(self): pass

attrs = attrs_wo_objs(C)

self.assertIn(('s', 'static method', A), attrs, 'missing static method')

self.assertIn(('c', 'method', C), attrs, 'missing plain method')

self.assertIn(('p', 'property', A), attrs, 'missing property')

self.assertIn(('m', 'method', C), attrs, 'missing plain method')

self.assertIn(('m1', 'method', A), attrs, 'missing plain method')

self.assertIn(('datablob', 'data', A), attrs, 'missing data')

self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')

self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')

class D(B, C):

def m1(self): pass

attrs = attrs_wo_objs(D)

self.assertIn(('s', 'static method', A), attrs, 'missing static method')

self.assertIn(('c', 'method', C), attrs, 'missing plain method')

self.assertIn(('p', 'property', A), attrs, 'missing property')

self.assertIn(('m', 'method', B), attrs, 'missing plain method')

self.assertIn(('m1', 'method', D), attrs, 'missing plain method')

self.assertIn(('datablob', 'data', A), attrs, 'missing data')

self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')

self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')

def test_classify_builtin_types(self):

# Simple sanity check that all built-in types can have their

# attributes classified.

for name in dir(__builtins__):

builtin = getattr(__builtins__, name)

if isinstance(builtin, type):

inspect.classify_class_attrs(builtin)

def test_classify_DynamicClassAttribute(self):

class Meta(type):

def __getattr__(self, name):

if name == 'ham':

return 'spam'

return super().__getattr__(name)

class VA(metaclass=Meta):

@types.DynamicClassAttribute

def ham(self):

return 'eggs'

should_find_dca = inspect.Attribute('ham', 'data', VA, VA.__dict__['ham'])

self.assertIn(should_find_dca, inspect.classify_class_attrs(VA))

should_find_ga = inspect.Attribute('ham', 'data', Meta, 'spam')

self.assertIn(should_find_ga, inspect.classify_class_attrs(VA))

def test_classify_overrides_bool(self):

class NoBool(object):

def __eq__(self, other):

return NoBool()

def __bool__(self):

raise NotImplementedError(

"This object does not specify a boolean value")

class HasNB(object):

dd = NoBool()

should_find_attr = inspect.Attribute('dd', 'data', HasNB, HasNB.dd)

self.assertIn(should_find_attr, inspect.classify_class_attrs(HasNB))

def test_classify_metaclass_class_attribute(self):

class Meta(type):

fish = 'slap'

def __dir__(self):

return ['__class__', '__module__', '__name__', 'fish']

class Class(metaclass=Meta):

pass

should_find = inspect.Attribute('fish', 'data', Meta, 'slap')

self.assertIn(should_find, inspect.classify_class_attrs(Class))

def test_classify_VirtualAttribute(self):

class Meta(type):

def __dir__(cls):

return ['__class__', '__module__', '__name__', 'BOOM']

def __getattr__(self, name):

if name =='BOOM':

return 42

return super().__getattr(name)

class Class(metaclass=Meta):

pass

should_find = inspect.Attribute('BOOM', 'data', Meta, 42)

self.assertIn(should_find, inspect.classify_class_attrs(Class))

def test_classify_VirtualAttribute_multi_classes(self):

class Meta1(type):

def __dir__(cls):

return ['__class__', '__module__', '__name__', 'one']

def __getattr__(self, name):

if name =='one':

return 1

return super().__getattr__(name)

class Meta2(type):

def __dir__(cls):

return ['__class__', '__module__', '__name__', 'two']

def __getattr__(self, name):

if name =='two':

return 2

return super().__getattr__(name)

class Meta3(Meta1, Meta2):

def __dir__(cls):