"""

parameters = ['a', 'bar', 'c', 'delta', 'ephraim', 'magical', 'yoyo', 'z']

for i in range(1, 2**len(parameters)):

p = []

bit = 1

for j in range(len(parameters)):

if i & (bit << j):

p.append(parameters[j])

fn_text = "def foo(*, " + ", ".join(p) + "): pass"

symbols = {}

exec(fn_text, symbols, symbols)

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,

inspect.ismethodwrapper])

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

self.assertFalse(other(obj), 'not %s(%s)' % (other.__name__, exp))

def test__all__(self):

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 Exception as e:

tb = e.__traceback__

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.ismethod, 'mod.custom_method')

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

self.istest(inspect.ismethodwrapper, "object().__str__")

self.istest(inspect.ismethodwrapper, "object().__eq__")

self.istest(inspect.ismethodwrapper, "object().__repr__")

self.assertFalse(inspect.ismethodwrapper(type))

self.assertFalse(inspect.ismethodwrapper(int))

self.assertFalse(inspect.ismethodwrapper(type("AnyClass", (), {})))

def test_iscoroutine(self):

async_gen_coro = async_generator_function_example(1)

gen_coro = gen_coroutine_function_example(1)

coro = coroutine_function_example(1)

self.assertFalse(

inspect.iscoroutinefunction(gen_coroutine_function_example))

self.assertFalse(

inspect.iscoroutinefunction(

functools.partial(functools.partial(

gen_coroutine_function_example))))

self.assertFalse(inspect.iscoroutine(gen_coro))

self.assertTrue(

inspect.isgeneratorfunction(gen_coroutine_function_example))

self.assertTrue(

inspect.isgeneratorfunction(

functools.partial(functools.partial(

gen_coroutine_function_example))))

self.assertTrue(inspect.isgenerator(gen_coro))

self.assertFalse(

inspect.iscoroutinefunction(unittest.mock.Mock()))

self.assertTrue(

inspect.iscoroutinefunction(unittest.mock.AsyncMock()))

self.assertTrue(

inspect.iscoroutinefunction(coroutine_function_example))

self.assertTrue(

inspect.iscoroutinefunction(

functools.partial(functools.partial(

coroutine_function_example))))

self.assertTrue(inspect.iscoroutine(coro))

self.assertFalse(

inspect.isgeneratorfunction(unittest.mock.Mock()))

self.assertFalse(

inspect.isgeneratorfunction(unittest.mock.AsyncMock()))

self.assertFalse(

inspect.isgeneratorfunction(coroutine_function_example))

self.assertFalse(

inspect.isgeneratorfunction(

functools.partial(functools.partial(

coroutine_function_example))))

self.assertFalse(inspect.isgenerator(coro))

self.assertFalse(

inspect.isasyncgenfunction(unittest.mock.Mock()))

self.assertFalse(

inspect.isasyncgenfunction(unittest.mock.AsyncMock()))

self.assertFalse(

inspect.isasyncgenfunction(coroutine_function_example))

self.assertTrue(

inspect.isasyncgenfunction(async_generator_function_example))

self.assertTrue(

inspect.isasyncgenfunction(

functools.partial(functools.partial(

async_generator_function_example))))

self.assertTrue(inspect.isasyncgen(async_gen_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):

# method

self.assertTrue(inspect.isroutine(git.argue))

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

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

# function

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

self.assertTrue(inspect.isroutine(mod.StupidGit.abuse))

# slot-wrapper

self.assertTrue(inspect.isroutine(object.__init__))

self.assertTrue(inspect.isroutine(object.__str__))

self.assertTrue(inspect.isroutine(object.__lt__))

self.assertTrue(inspect.isroutine(int.__lt__))

# method-wrapper

self.assertTrue(inspect.isroutine(object().__init__))

self.assertTrue(inspect.isroutine(object().__str__))

self.assertTrue(inspect.isroutine(object().__lt__))

self.assertTrue(inspect.isroutine((42).__lt__))

# method-descriptor

self.assertTrue(inspect.isroutine(str.join))

self.assertTrue(inspect.isroutine(list.append))

self.assertTrue(inspect.isroutine(''.join))

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

# object

self.assertFalse(inspect.isroutine(object))

self.assertFalse(inspect.isroutine(object()))

self.assertFalse(inspect.isroutine(str()))

# module

self.assertFalse(inspect.isroutine(mod))

# type

self.assertFalse(inspect.isroutine(type))

self.assertFalse(inspect.isroutine(int))

self.assertFalse(inspect.isroutine(type('some_class', (), {})))

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)

frame1, frame2, frame3, frame4, *_ = mod.st

frameinfo = revise(*frame1[1:])

self.assertEqual(frameinfo,

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

self.assertEqual(frame1.positions, dis.Positions(16, 16, 9, 24))

frameinfo = revise(*frame2[1:])

self.assertEqual(frameinfo,

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

self.assertEqual(frame2.positions, dis.Positions(9, 9, 4, 22))

frameinfo = revise(*frame3[1:])

self.assertEqual(frameinfo,

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

self.assertEqual(frame3.positions, dis.Positions(43, 43, 12, 25))

frameinfo = revise(*frame4[1:])

self.assertEqual(frameinfo,

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

self.assertEqual(frame4.positions, dis.Positions(39, 39, 8, 27))

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

frame1, frame2, frame3, = git.tr

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

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

self.assertEqual(frame1.positions, dis.Positions(43, 43, 12, 25))

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

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

self.assertEqual(frame2.positions, dis.Positions(9, 9, 4, 22))

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

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

self.assertEqual(frame3.positions, dis.Positions(18, 18, 8, 13))

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), encoding="utf-8") 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),

('WhichComments', mod.WhichComments),

])

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

]

],

(mod.WhichComments, (object,),)

]

])

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

]

],

(mod.WhichComments, (object,),)

]

])

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

self.assertEqual(inspect.getdoc(SlotUser.power),

'measured in kilowatts')

self.assertEqual(inspect.getdoc(SlotUser.distance),

'measured in kilometers')

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

self.assertEqual(inspect.getcomments(mod2.cls160), '# line 159\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_getmodule_file_not_found(self):

# See bpo-45406

def _getabsfile(obj, _filename):

raise FileNotFoundError('bad file')

with unittest.mock.patch('inspect.getabsfile', _getabsfile):

f = inspect.currentframe()

self.assertIsNone(inspect.getmodule(f))

inspect.getouterframes(f) # smoke test

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_builtin_module(self):

with self.assertRaises(TypeError) as e:

inspect.getfile(sys)

self.assertTrue(str(e.exception).startswith('<module'))

def test_getfile_builtin_class(self):

with self.assertRaises(TypeError) as e:

inspect.getfile(int)

self.assertTrue(str(e.exception).startswith('<class'))

def test_getfile_builtin_function_or_method(self):

with self.assertRaises(TypeError) as e_abs:

inspect.getfile(abs)

self.assertIn('expected, got', str(e_abs.exception))

with self.assertRaises(TypeError) as e_append:

inspect.getfile(list.append)

self.assertIn('expected, got', str(e_append.exception))

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_getfile_broken_repr(self):

class ErrorRepr:

def __repr__(self):

raise Exception('xyz')

er = ErrorRepr()

with self.assertRaises(TypeError):

inspect.getfile(er)

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

def test_getclasses_interactive(self):

# bpo-44648: simulate a REPL session;

# there is no `__file__` in the __main__ module

code = "import sys, inspect; \

_, _, stderr = assert_python_failure("-c", code, __isolated=True)

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 = mod

def test_toplevel_class(self):

self.assertSourceEqual(mod.WhichComments, 96, 114)

def test_class_method(self):

self.assertSourceEqual(mod.WhichComments.f, 99, 104)

def test_class_async_method(self):

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_findsource_with_out_of_bounds_lineno(self):

mod_len = len(inspect.getsource(mod))

src = '\n' * 2* mod_len + "def f(): pass"

co = compile(src, mod.__file__, "exec")

g, l = {}, {}

eval(co, g, l)

func = l['f']

self.assertEqual(func.__code__.co_firstlineno, 1+2*mod_len)

with self.assertRaisesRegex(IOError, "lineno is out of bounds"):

inspect.findsource(func)

def test_getsource_on_method(self):

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

def test_nested_func(self):

self.assertSourceEqual(mod2.cls135.func136, 136, 139)

def test_class_definition_in_multiline_string_definition(self):

self.assertSourceEqual(mod2.cls149, 149, 152)

def test_class_definition_in_multiline_comment(self):

self.assertSourceEqual(mod2.cls160, 160, 163)

def test_nested_class_definition_indented_string(self):

self.assertSourceEqual(mod2.cls173.cls175, 175, 176)

def test_nested_class_definition(self):

self.assertSourceEqual(mod2.cls183, 183, 188)

self.assertSourceEqual(mod2.cls183.cls185, 185, 188)

def test_class_decorator(self):

self.assertSourceEqual(mod2.cls196, 194, 201)

self.assertSourceEqual(mod2.cls196.cls200, 198, 201)

def test_class_inside_conditional(self):

self.assertSourceEqual(mod2.cls238, 238, 240)

self.assertSourceEqual(mod2.cls238.cls239, 239, 240)

def test_multiple_children_classes(self):

self.assertSourceEqual(mod2.cls203, 203, 209)

self.assertSourceEqual(mod2.cls203.cls204, 204, 206)

self.assertSourceEqual(mod2.cls203.cls204.cls205, 205, 206)

self.assertSourceEqual(mod2.cls203.cls207, 207, 209)

self.assertSourceEqual(mod2.cls203.cls207.cls205, 208, 209)

def test_nested_class_definition_inside_function(self):

self.assertSourceEqual(mod2.func212(), 213, 214)

self.assertSourceEqual(mod2.cls213, 218, 222)

self.assertSourceEqual(mod2.cls213().func219(), 220, 221)

@unittest.skipIf(

def test_nested_class_definition_inside_async_function(self):

import asyncio

self.addCleanup(asyncio.set_event_loop_policy, None)

self.assertSourceEqual(asyncio.run(mod2.func225()), 226, 227)

self.assertSourceEqual(mod2.cls226, 231, 235)

def setUp(self):

self.tempdir = TESTFN + '_dir'

os.mkdir(self.tempdir)

with open(os.path.join(self.tempdir, 'inspect_fodder3%spy' % os.extsep),

'w', encoding='utf-8') 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 assertFullArgSpecEquals(self, routine, args_e, varargs_e=None,

varkw_e=None, defaults_e=None,

posonlyargs_e=[], kwonlyargs_e=[],

kwonlydefaults_e=None,

ann_e={}):

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)

def test_getfullargspec(self):

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

kwonlyargs_e=['arg2'],

kwonlydefaults_e={'arg2':1})

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

ann_e={'arg1' : list})

self.assertFullArgSpecEquals(mod2.keyword_only_arg, [],

kwonlyargs_e=['arg'])

self.assertFullArgSpecEquals(mod2.all_markers, ['a', 'b', 'c', 'd'],

kwonlyargs_e=['e', 'f'])

self.assertFullArgSpecEquals(mod2.all_markers_with_args_and_kwargs,

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

varargs_e='args',

varkw_e='kwargs',

kwonlyargs_e=['e', 'f'])

self.assertFullArgSpecEquals(mod2.all_markers_with_defaults, ['a', 'b', 'c', 'd'],

defaults_e=(1,2,3),

kwonlyargs_e=['e', 'f'],

kwonlydefaults_e={'e': 4, 'f': 5})

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.assertFullArgSpecEquals(ham, ['x', 'y'])

self.assertFullArgSpecEquals(functools.partial(ham),

['x', 'y'])

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, ['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, ['self', 'obj'])