Lines Matching refs:self

101     def istest(self, predicate, exp):
103 self.assertTrue(predicate(obj), '%s(%s)' % (predicate.__name__, exp))
105 for other in self.predicates - set([predicate]):
111 self.assertFalse(other(obj), 'not %s(%s)' % (other.__name__, exp))
113 def test__all__(self):
114 support.check__all__(self, inspect, not_exported=("modulesbyfile",))
116 def generator_function_example(self):
120 async def async_generator_function_example(self):
124 async def coroutine_function_example(self):
128 def gen_coroutine_function_example(self):
134 def test_excluding_predicates(self):
136 self.istest(inspect.isbuiltin, 'sys.exit')
137 self.istest(inspect.isbuiltin, '[].append')
138 self.istest(inspect.iscode, 'mod.spam.__code__')
143 self.istest(inspect.isframe, 'tb.tb_frame')
144 self.istest(inspect.istraceback, 'tb')
146 self.istest(inspect.isgetsetdescriptor,
149 self.assertFalse(inspect.isgetsetdescriptor(type(tb.tb_frame).f_locals))
153 self.istest(inspect.isfunction, 'mod.spam')
154 self.istest(inspect.isfunction, 'mod.StupidGit.abuse')
155 self.istest(inspect.ismethod, 'git.argue')
156 self.istest(inspect.ismethod, 'mod.custom_method')
157 self.istest(inspect.ismodule, 'mod')
158 self.istest(inspect.isdatadescriptor, 'collections.defaultdict.default_factory')
159 self.istest(inspect.isgenerator, '(x for x in range(2))')
160 self.istest(inspect.isgeneratorfunction, 'generator_function_example')
161 self.istest(inspect.isasyncgen,
163 self.istest(inspect.isasyncgenfunction,
168 self.istest(inspect.iscoroutine, 'coroutine_function_example(1)')
169 self.istest(inspect.iscoroutinefunction, 'coroutine_function_example')
172 self.istest(inspect.ismemberdescriptor, 'datetime.timedelta.days')
174 self.assertFalse(inspect.ismemberdescriptor(datetime.timedelta.days))
175 self.istest(inspect.ismethodwrapper, "object().__str__")
176 self.istest(inspect.ismethodwrapper, "object().__eq__")
177 self.istest(inspect.ismethodwrapper, "object().__repr__")
178 self.assertFalse(inspect.ismethodwrapper(type))
179 self.assertFalse(inspect.ismethodwrapper(int))
180 self.assertFalse(inspect.ismethodwrapper(type("AnyClass", (), {})))
184 def test_iscoroutine(self):
189 self.assertFalse(
191 self.assertFalse(
195 self.assertFalse(inspect.iscoroutine(gen_coro))
197 self.assertTrue(
199 self.assertTrue(
203 self.assertTrue(inspect.isgenerator(gen_coro))
205 self.assertFalse(
207 self.assertTrue(
209 self.assertTrue(
211 self.assertTrue(
215 self.assertTrue(inspect.iscoroutine(coro))
217 self.assertFalse(
219 self.assertFalse(
221 self.assertFalse(
223 self.assertFalse(
227 self.assertFalse(inspect.isgenerator(coro))
229 self.assertFalse(
231 self.assertFalse(
233 self.assertFalse(
235 self.assertTrue(
237 self.assertTrue(
241 self.assertTrue(inspect.isasyncgen(async_gen_coro))
245 def test_isawaitable(self):
247 self.assertFalse(inspect.isawaitable(gen()))
252 self.assertTrue(inspect.isawaitable(coro))
253 self.assertTrue(inspect.isawaitable(gen_coro))
258 self.assertTrue(inspect.isawaitable(Future()))
259 self.assertFalse(inspect.isawaitable(Future))
264 self.assertFalse(inspect.isawaitable(not_fut))
268 def test_isroutine(self):
270 self.assertTrue(inspect.isroutine(git.argue))
271 self.assertTrue(inspect.isroutine(mod.custom_method))
272 self.assertTrue(inspect.isroutine([].count))
274 self.assertTrue(inspect.isroutine(mod.spam))
275 self.assertTrue(inspect.isroutine(mod.StupidGit.abuse))
277 self.assertTrue(inspect.isroutine(object.__init__))
278 self.assertTrue(inspect.isroutine(object.__str__))
279 self.assertTrue(inspect.isroutine(object.__lt__))
280 self.assertTrue(inspect.isroutine(int.__lt__))
282 self.assertTrue(inspect.isroutine(object().__init__))
283 self.assertTrue(inspect.isroutine(object().__str__))
284 self.assertTrue(inspect.isroutine(object().__lt__))
285 self.assertTrue(inspect.isroutine((42).__lt__))
287 self.assertTrue(inspect.isroutine(str.join))
288 self.assertTrue(inspect.isroutine(list.append))
289 self.assertTrue(inspect.isroutine(''.join))
290 self.assertTrue(inspect.isroutine([].append))
292 self.assertFalse(inspect.isroutine(object))
293 self.assertFalse(inspect.isroutine(object()))
294 self.assertFalse(inspect.isroutine(str()))
296 self.assertFalse(inspect.isroutine(mod))
298 self.assertFalse(inspect.isroutine(type))
299 self.assertFalse(inspect.isroutine(int))
300 self.assertFalse(inspect.isroutine(type('some_class', (), {})))
302 def test_isclass(self):
303 self.istest(inspect.isclass, 'mod.StupidGit')
304 self.assertTrue(inspect.isclass(list))
307 def __getattr__(self, attr):
309 self.assertFalse(inspect.isclass(CustomGetattr()))
311 def test_get_slot_members(self):
317 self.assertIn('a', members)
318 self.assertNotIn('b', members)
320 def test_isabstract(self):
326 def foo(self):
330 def foo(self):
336 self.assertTrue(inspect.isabstract(AbstractClassExample))
337 self.assertFalse(inspect.isabstract(ClassExample))
338 self.assertFalse(inspect.isabstract(a))
339 self.assertFalse(inspect.isabstract(int))
340 self.assertFalse(inspect.isabstract(5))
342 def test_isabstract_during_init_subclass(self):
350 def foo(self):
353 def foo(self):
355 self.assertEqual(isabstract_checks, [True, False])
364 self.assertEqual(isabstract_checks, [True, True, False])
368 def __init__(self, *args, **kwargs):
369 unittest.TestCase.__init__(self, *args, **kwargs)
373 def test_abuse_done(self):
374 self.istest(inspect.istraceback, 'git.ex[2]')
375 self.istest(inspect.isframe, 'mod.fr')
377 def test_stack(self):
378 self.assertTrue(len(mod.st) >= 5)
381 self.assertEqual(frameinfo,
383 self.assertEqual(frame1.positions, dis.Positions(16, 16, 9, 24))
385 self.assertEqual(frameinfo,
387 self.assertEqual(frame2.positions, dis.Positions(9, 9, 4, 22))
389 self.assertEqual(frameinfo,
391 self.assertEqual(frame3.positions, dis.Positions(43, 43, 12, 25))
393 self.assertEqual(frameinfo,
394 (modfile, 39, 'abuse', [' self.argue(a, b, c)\n'], 0))
395 self.assertEqual(frame4.positions, dis.Positions(39, 39, 8, 27))
398 self.assertIs(record.frame, mod.fr)
399 self.assertEqual(record.lineno, 16)
400 self.assertEqual(record.filename, mod.__file__)
401 self.assertEqual(record.function, 'eggs')
402 self.assertIn('inspect.stack()', record.code_context[0])
403 self.assertEqual(record.index, 0)
405 def test_trace(self):
406 self.assertEqual(len(git.tr), 3)
408 self.assertEqual(revise(*frame1[1:]),
410 self.assertEqual(frame1.positions, dis.Positions(43, 43, 12, 25))
411 self.assertEqual(revise(*frame2[1:]),
413 self.assertEqual(frame2.positions, dis.Positions(9, 9, 4, 22))
414 self.assertEqual(revise(*frame3[1:]),
416 self.assertEqual(frame3.positions, dis.Positions(18, 18, 8, 13))
418 def test_frame(self):
420 self.assertEqual(args, ['x', 'y'])
421 self.assertEqual(varargs, None)
422 self.assertEqual(varkw, None)
423 self.assertEqual(locals, {'x': 11, 'p': 11, 'y': 14})
424 self.assertEqual(inspect.formatargvalues(args, varargs, varkw, locals),
427 def test_previous_frame(self):
429 self.assertEqual(args, ['a', 'b', 'c', 'd', 'e', 'f'])
430 self.assertEqual(varargs, 'g')
431 self.assertEqual(varkw, 'h')
432 self.assertEqual(inspect.formatargvalues(args, varargs, varkw, locals),
439 def setUp(self):
440 with open(inspect.getsourcefile(self.fodderModule), encoding="utf-8") as fp:
441 self.source = fp.read()
443 def sourcerange(self, top, bottom):
444 lines = self.source.split("\n")
447 def assertSourceEqual(self, obj, top, bottom):
448 self.assertEqual(inspect.getsource(obj),
449 self.sourcerange(top, bottom))
459 def test_getclasses(self):
461 self.assertEqual(classes,
470 self.assertEqual(tree,
486 self.assertEqual(tree,
499 def test_getfunctions(self):
501 self.assertEqual(functions, [('eggs', mod.eggs),
507 def test_getdoc(self):
508 self.assertEqual(inspect.getdoc(mod), 'A module docstring.')
509 self.assertEqual(inspect.getdoc(mod.StupidGit),
511 self.assertEqual(inspect.getdoc(git.abuse),
513 self.assertEqual(inspect.getdoc(SlotUser.power),
515 self.assertEqual(inspect.getdoc(SlotUser.distance),
520 def test_getdoc_inherited(self):
521 self.assertEqual(inspect.getdoc(mod.FesteringGob),
523 self.assertEqual(inspect.getdoc(mod.FesteringGob.abuse),
525 self.assertEqual(inspect.getdoc(mod.FesteringGob().abuse),
527 self.assertEqual(inspect.getdoc(mod.FesteringGob.contradiction),
531 def test_finddoc(self):
533 self.assertEqual(finddoc(int), int.__doc__)
534 self.assertEqual(finddoc(int.to_bytes), int.to_bytes.__doc__)
535 self.assertEqual(finddoc(int().to_bytes), int.to_bytes.__doc__)
536 self.assertEqual(finddoc(int.from_bytes), int.from_bytes.__doc__)
537 self.assertEqual(finddoc(int.real), int.real.__doc__)
539 def test_cleandoc(self):
540 self.assertEqual(inspect.cleandoc('An\n indented\n docstring.'),
543 def test_getcomments(self):
544 self.assertEqual(inspect.getcomments(mod), '# line 1\n')
545 self.assertEqual(inspect.getcomments(mod.StupidGit), '# line 20\n')
546 self.assertEqual(inspect.getcomments(mod2.cls160), '# line 159\n')
549 self.assertIsNone(inspect.getcomments(co))
551 self.assertIsNone(inspect.getcomments(list))
553 def test_getmodule(self):
555 self.assertEqual(inspect.getmodule(mod), mod)
557 self.assertEqual(inspect.getmodule(mod.StupidGit), mod)
559 self.assertEqual(inspect.getmodule(mod.StupidGit.abuse), mod)
561 self.assertEqual(inspect.getmodule(mod.StupidGit.abuse), mod)
563 self.assertEqual(inspect.getmodule(str), sys.modules["builtins"])
565 self.assertEqual(inspect.getmodule(None, modfile), mod)
567 def test_getmodule_file_not_found(self):
573 self.assertIsNone(inspect.getmodule(f))
576 def test_getframeinfo_get_first_line(self):
577 frame_info = inspect.getframeinfo(self.fodderModule.fr, 50)
578 self.assertEqual(frame_info.code_context[0], "# line 1\n")
579 self.assertEqual(frame_info.code_context[1], "'A module docstring.'\n")
581 def test_getsource(self):
582 self.assertSourceEqual(git.abuse, 29, 39)
583 self.assertSourceEqual(mod.StupidGit, 21, 51)
584 self.assertSourceEqual(mod.lobbest, 75, 76)
586 def test_getsourcefile(self):
587 self.assertEqual(normcase(inspect.getsourcefile(mod.spam)), modfile)
588 self.assertEqual(normcase(inspect.getsourcefile(git.abuse)), modfile)
591 self.assertEqual(inspect.getsourcefile(co), None)
594 self.assertEqual(normcase(inspect.getsourcefile(co)), fn)
598 def test_getfile(self):
599 self.assertEqual(inspect.getfile(mod.StupidGit), mod.__file__)
601 def test_getfile_builtin_module(self):
602 with self.assertRaises(TypeError) as e:
604 self.assertTrue(str(e.exception).startswith('<module'))
606 def test_getfile_builtin_class(self):
607 with self.assertRaises(TypeError) as e:
609 self.assertTrue(str(e.exception).startswith('<class'))
611 def test_getfile_builtin_function_or_method(self):
612 with self.assertRaises(TypeError) as e_abs:
614 self.assertIn('expected, got', str(e_abs.exception))
615 with self.assertRaises(TypeError) as e_append:
617 self.assertIn('expected, got', str(e_append.exception))
619 def test_getfile_class_without_module(self):
626 with self.assertRaises(TypeError):
629 def test_getfile_broken_repr(self):
631 def __repr__(self):
634 with self.assertRaises(TypeError):
637 def test_getmodule_recursion(self):
644 self.assertEqual(inspect.getsourcefile(m.x.__code__), '<string>')
648 def test_proceed_with_fake_filename(self):
665 def test_getsource_on_code_object(self):
666 self.assertSourceEqual(mod.eggs.__code__, 12, 18)
669 def test_getclasses_interactive(self):
677 self.assertIn(b'OSError: source code not available', stderr)
682 def test_range_toplevel_frame(self):
683 self.maxDiff = None
684 self.assertSourceEqual(mod.currentframe, 1, None)
686 def test_range_traceback_toplevel_frame(self):
687 self.assertSourceEqual(mod.tb, 1, None)
692 def test_wrapped_decorator(self):
693 self.assertSourceEqual(mod2.wrapped, 14, 17)
695 def test_replacing_decorator(self):
696 self.assertSourceEqual(mod2.gone, 9, 10)
698 def test_getsource_unwrap(self):
699 self.assertSourceEqual(mod2.real, 130, 132)
701 def test_decorator_with_lambda(self):
702 self.assertSourceEqual(mod2.func114, 113, 115)
706 def test_oneline_lambda(self):
708 self.assertSourceEqual(mod2.oll, 25, 25)
710 def test_threeline_lambda(self):
713 self.assertSourceEqual(mod2.tll, 28, 30)
715 def test_twoline_indented_lambda(self):
718 self.assertSourceEqual(mod2.tlli, 33, 34)
720 def test_onelinefunc(self):
722 self.assertSourceEqual(mod2.onelinefunc, 37, 37)
724 def test_manyargs(self):
728 self.assertSourceEqual(mod2.manyargs, 40, 41)
730 def test_twolinefunc(self):
734 self.assertSourceEqual(mod2.twolinefunc, 44, 45)
736 def test_lambda_in_list(self):
739 self.assertSourceEqual(mod2.a[1], 49, 49)
741 def test_anonymous(self):
744 self.assertSourceEqual(mod2.anonymous, 55, 55)
749 def test_toplevel_class(self):
750 self.assertSourceEqual(mod.WhichComments, 96, 114)
752 def test_class_method(self):
753 self.assertSourceEqual(mod.WhichComments.f, 99, 104)
755 def test_class_async_method(self):
756 self.assertSourceEqual(mod.WhichComments.asyncf, 109, 112)
761 def test_with_comment(self):
762 self.assertSourceEqual(mod2.with_comment, 58, 59)
764 def test_multiline_sig(self):
765 self.assertSourceEqual(mod2.multiline_sig[0], 63, 64)
767 def test_nested_class(self):
768 self.assertSourceEqual(mod2.func69().func71, 71, 72)
770 def test_one_liner_followed_by_non_name(self):
771 self.assertSourceEqual(mod2.func77, 77, 77)
773 def test_one_liner_dedent_non_name(self):
774 self.assertSourceEqual(mod2.cls82.func83, 83, 83)
776 def test_with_comment_instead_of_docstring(self):
777 self.assertSourceEqual(mod2.func88, 88, 90)
779 def test_method_in_dynamic_class(self):
780 self.assertSourceEqual(mod2.method_in_dynamic_class, 95, 97)
787 def test_findsource_binary(self):
788 self.assertRaises(OSError, inspect.getsource, unicodedata)
789 self.assertRaises(OSError, inspect.findsource, unicodedata)
791 def test_findsource_code_in_linecache(self):
794 self.assertRaises(OSError, inspect.findsource, co)
795 self.assertRaises(OSError, inspect.getsource, co)
798 self.assertEqual(inspect.findsource(co), (lines,0))
799 self.assertEqual(inspect.getsource(co), lines[0])
803 def test_findsource_without_filename(self):
806 self.assertRaises(IOError, inspect.findsource, co)
807 self.assertRaises(IOError, inspect.getsource, co)
809 def test_findsource_with_out_of_bounds_lineno(self):
816 self.assertEqual(func.__code__.co_firstlineno, 1+2*mod_len)
817 with self.assertRaisesRegex(IOError, "lineno is out of bounds"):
820 def test_getsource_on_method(self):
821 self.assertSourceEqual(mod2.ClassWithMethod.method, 118, 119)
823 def test_nested_func(self):
824 self.assertSourceEqual(mod2.cls135.func136, 136, 139)
826 def test_class_definition_in_multiline_string_definition(self):
827 self.assertSourceEqual(mod2.cls149, 149, 152)
829 def test_class_definition_in_multiline_comment(self):
830 self.assertSourceEqual(mod2.cls160, 160, 163)
832 def test_nested_class_definition_indented_string(self):
833 self.assertSourceEqual(mod2.cls173.cls175, 175, 176)
835 def test_nested_class_definition(self):
836 self.assertSourceEqual(mod2.cls183, 183, 188)
837 self.assertSourceEqual(mod2.cls183.cls185, 185, 188)
839 def test_class_decorator(self):
840 self.assertSourceEqual(mod2.cls196, 194, 201)
841 self.assertSourceEqual(mod2.cls196.cls200, 198, 201)
843 def test_class_inside_conditional(self):
844 self.assertSourceEqual(mod2.cls238, 238, 240)
845 self.assertSourceEqual(mod2.cls238.cls239, 239, 240)
847 def test_multiple_children_classes(self):
848 self.assertSourceEqual(mod2.cls203, 203, 209)
849 self.assertSourceEqual(mod2.cls203.cls204, 204, 206)
850 self.assertSourceEqual(mod2.cls203.cls204.cls205, 205, 206)
851 self.assertSourceEqual(mod2.cls203.cls207, 207, 209)
852 self.assertSourceEqual(mod2.cls203.cls207.cls205, 208, 209)
854 def test_nested_class_definition_inside_function(self):
855 self.assertSourceEqual(mod2.func212(), 213, 214)
856 self.assertSourceEqual(mod2.cls213, 218, 222)
857 self.assertSourceEqual(mod2.cls213().func219(), 220, 221)
863 def test_nested_class_definition_inside_async_function(self):
865 self.addCleanup(asyncio.set_event_loop_policy, None)
866 self.assertSourceEqual(asyncio.run(mod2.func225()), 226, 227)
867 self.assertSourceEqual(mod2.cls226, 231, 235)
868 self.assertSourceEqual(asyncio.run(mod2.cls226().func232()), 233, 234)
871 def setUp(self):
872 self.tempdir = TESTFN + '_dir'
873 os.mkdir(self.tempdir)
874 with open(os.path.join(self.tempdir, 'inspect_fodder3%spy' % os.extsep),
877 with DirsOnSysPath(self.tempdir):
879 self.fodderModule = mod3
882 def tearDown(self):
883 shutil.rmtree(self.tempdir)
885 def test_class(self):
886 self.assertSourceEqual(self.fodderModule.X, 1, 2)
892 def test_parens_in_decorator(self):
893 self.assertSourceEqual(self.fodderModule.complex_decorated, 273, 275)
926 def test_newstyle_mro(self):
935 self.assertEqual(expected, got)
937 def assertFullArgSpecEquals(self, routine, args_e, varargs_e=None,
944 self.assertEqual(args, args_e)
945 self.assertEqual(varargs, varargs_e)
946 self.assertEqual(varkw, varkw_e)
947 self.assertEqual(defaults, defaults_e)
948 self.assertEqual(kwonlyargs, kwonlyargs_e)
949 self.assertEqual(kwonlydefaults, kwonlydefaults_e)
950 self.assertEqual(ann, ann_e)
952 def test_getfullargspec(self):
953 self.assertFullArgSpecEquals(mod2.keyworded, [], varargs_e='arg1',
957 self.assertFullArgSpecEquals(mod2.annotated, ['arg1'],
959 self.assertFullArgSpecEquals(mod2.keyword_only_arg, [],
962 self.assertFullArgSpecEquals(mod2.all_markers, ['a', 'b', 'c', 'd'],
965 self.assertFullArgSpecEquals(mod2.all_markers_with_args_and_kwargs,
971 self.assertFullArgSpecEquals(mod2.all_markers_with_defaults, ['a', 'b', 'c', 'd'],
976 def test_argspec_api_ignores_wrapped(self):
982 self.assertFullArgSpecEquals(ham, ['x', 'y'])
983 self.assertFullArgSpecEquals(functools.partial(ham),
986 def test_getfullargspec_signature_attr(self):
992 self.assertFullArgSpecEquals(test, ['spam'])
994 def test_getfullargspec_signature_annos(self):
997 self.assertEqual(test.__annotations__, spec.annotations)
1001 self.assertEqual(test.__annotations__, spec.annotations)
1005 def test_getfullargspec_builtin_methods(self):
1006 self.assertFullArgSpecEquals(_pickle.Pickler.dump, ['self', 'obj'])
1008 self.assertFullArgSpecEquals(_pickle.Pickler(io.BytesIO()).dump, ['self', 'obj'])
1010 self.assertFullArgSpecEquals(
1019 def test_getfullargspec_builtin_func(self):
1023 self.assertEqual(spec.defaults[0], 'avocado')
1028 def test_getfullargspec_builtin_func_no_signature(self):
1031 with self.assertRaises(TypeError):
1034 def test_getfullargspec_definition_order_preserved_on_kwonly(self):
1039 self.assertTrue(l)
1040 self.assertEqual(l, sorted_l)
1043 self.assertEqual(l, unsorted_keyword_only_parameters)
1045 def test_classify_newstyle(self):
1054 def getp(self): pass
1057 def m(self): pass
1059 def m1(self): pass
1068 self.assertIn(('__new__', 'static method', object), attrs,
1070 self.assertIn(('__init__', 'method', object), attrs, 'missing __init__')
1072 self.assertIn(('s', 'static method', A), attrs, 'missing static method')
1073 self.assertIn(('c', 'class method', A), attrs, 'missing class method')
1074 self.assertIn(('p', 'property', A), attrs, 'missing property')
1075 self.assertIn(('m', 'method', A), attrs,
1077 self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
1078 self.assertIn(('datablob', 'data', A), attrs, 'missing data')
1079 self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')
1080 self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')
1084 def m(self): pass
1087 self.assertIn(('s', 'static method', A), attrs, 'missing static method')
1088 self.assertIn(('c', 'class method', A), attrs, 'missing class method')
1089 self.assertIn(('p', 'property', A), attrs, 'missing property')
1090 self.assertIn(('m', 'method', B), attrs, 'missing plain method')
1091 self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
1092 self.assertIn(('datablob', 'data', A), attrs, 'missing data')
1093 self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')
1094 self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')
1099 def m(self): pass
1100 def c(self): pass
1103 self.assertIn(('s', 'static method', A), attrs, 'missing static method')
1104 self.assertIn(('c', 'method', C), attrs, 'missing plain method')
1105 self.assertIn(('p', 'property', A), attrs, 'missing property')
1106 self.assertIn(('m', 'method', C), attrs, 'missing plain method')
1107 self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
1108 self.assertIn(('datablob', 'data', A), attrs, 'missing data')
1109 self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')
1110 self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')
1114 def m1(self): pass
1117 self.assertIn(('s', 'static method', A), attrs, 'missing static method')
1118 self.assertIn(('c', 'method', C), attrs, 'missing plain method')
1119 self.assertIn(('p', 'property', A), attrs, 'missing property')
1120 self.assertIn(('m', 'method', B), attrs, 'missing plain method')
1121 self.assertIn(('m1', 'method', D), attrs, 'missing plain method')
1122 self.assertIn(('datablob', 'data', A), attrs, 'missing data')
1123 self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')
1124 self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')
1126 def test_classify_builtin_types(self):
1135 self.assertIn(('__new__', 'static method', bool), attrs,
1137 self.assertIn(('from_bytes', 'class method', int), attrs,
1139 self.assertIn(('to_bytes', 'method', int), attrs,
1141 self.assertIn(('__add__', 'method', int), attrs,
1143 self.assertIn(('__and__', 'method', bool), attrs,
1146 def test_classify_DynamicClassAttribute(self):
1148 def __getattr__(self, name):
1154 def ham(self):
1157 self.assertIn(should_find_dca, inspect.classify_class_attrs(VA))
1159 self.assertIn(should_find_ga, inspect.classify_class_attrs(VA))
1161 def test_classify_overrides_bool(self):
1163 def __eq__(self, other):
1166 def __bool__(self):
1174 self.assertIn(should_find_attr, inspect.classify_class_attrs(HasNB))
1176 def test_classify_metaclass_class_attribute(self):
1179 def __dir__(self):
1184 self.assertIn(should_find, inspect.classify_class_attrs(Class))
1186 def test_classify_VirtualAttribute(self):
1190 def __getattr__(self, name):
1197 self.assertIn(should_find, inspect.classify_class_attrs(Class))
1199 def test_classify_VirtualAttribute_multi_classes(self):
1203 def __getattr__(self, name):
1210 def __getattr__(self, name):
1218 def __getattr__(self, name):
1232 self.assertIn(sf, cca)
1234 def test_classify_class_attrs_with_buggy_dir(self):
1241 self.assertNotIn('missing', attrs)
1243 def test_getmembers_descriptors(self):
1262 self.assertEqual(inspect.getmembers(A, ismethoddescriptor),
1264 self.assertEqual(inspect.getmembers(A, isdatadescriptor),
1270 self.assertEqual(inspect.getmembers(B, ismethoddescriptor),
1272 self.assertEqual(inspect.getmembers(B, isdatadescriptor),
1275 def test_getmembers_method(self):
1277 def f(self):
1280 self.assertIn(('f', B.f), inspect.getmembers(B))
1281 self.assertNotIn(('f', B.f), inspect.getmembers(B, inspect.ismethod))
1283 self.assertIn(('f', b.f), inspect.getmembers(b))
1284 self.assertIn(('f', b.f), inspect.getmembers(b, inspect.ismethod))
1286 def test_getmembers_VirtualAttribute(self):
1294 def eggs(self):
1297 def __getattr__(self, attribute):
1299 self.assertIn(('eggs', 'scrambled'), inspect.getmembers(A))
1300 self.assertIn(('eggs', 'spam'), inspect.getmembers(A()))
1302 self.assertIn(('__getattr__', b.__getattr__), inspect.getmembers(b))
1304 def test_getmembers_static(self):
1307 def name(self):
1310 def eggs(self):
1316 self.assertIn(('name', inspect.getattr_static(a, 'name')), instance_members)
1317 self.assertIn(('eggs', inspect.getattr_static(a, 'eggs')), instance_members)
1318 self.assertIn(('name', inspect.getattr_static(A, 'name')), class_members)
1319 self.assertIn(('eggs', inspect.getattr_static(A, 'eggs')), class_members)
1321 def test_getmembers_with_buggy_dir(self):
1328 self.assertNotIn('missing', attrs)
1330 def test_get_annotations_with_stock_annotations(self):
1332 self.assertEqual(inspect.get_annotations(foo), {'a': int, 'b': str})
1335 self.assertEqual(inspect.get_annotations(foo), {'a': 'foo', 'b': 'str'})
1337 self.assertEqual(inspect.get_annotations(foo, eval_str=True, locals=locals()), {'a': foo, 'b': str})
1338 self.assertEqual(inspect.get_annotations(foo, eval_str=True, globals=locals()), {'a': foo, 'b': str})
1341 self.assertEqual(inspect.get_annotations(isa), {'a': int, 'b': str})
1342 self.assertEqual(inspect.get_annotations(isa.MyClass), {'a': int, 'b': str})
1343 self.assertEqual(inspect.get_annotations(isa.function), {'a': int, 'b': str, 'return': isa.MyClass})
1344 self.assertEqual(inspect.get_annotations(isa.function2), {'a': int, 'b': 'str', 'c': isa.MyClass, 'return': isa.MyClass})
1345 self.assertEqual(inspect.get_annotations(isa.function3), {'a': 'int', 'b': 'str', 'c': 'MyClass'})
1346 self.assertEqual(inspect.get_annotations(inspect), {}) # inspect module has no annotations
1347 self.assertEqual(inspect.get_annotations(isa.UnannotatedClass), {})
1348 self.assertEqual(inspect.get_annotations(isa.unannotated_function), {})
1350 self.assertEqual(inspect.get_annotations(isa, eval_str=True), {'a': int, 'b': str})
1351 self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=True), {'a': int, 'b': str})
1352 self.assertEqual(inspect.get_annotations(isa.function, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass})
1353 self.assertEqual(inspect.get_annotations(isa.function2, eval_str=True), {'a': int, 'b': str, 'c': isa.MyClass, 'return': isa.MyClass})
1354 self.assertEqual(inspect.get_annotations(isa.function3, eval_str=True), {'a': int, 'b': str, 'c': isa.MyClass})
1355 self.assertEqual(inspect.get_annotations(inspect, eval_str=True), {})
1356 self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=True), {})
1357 self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=True), {})
1359 self.assertEqual(inspect.get_annotations(isa, eval_str=False), {'a': int, 'b': str})
1360 self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=False), {'a': int, 'b': str})
1361 self.assertEqual(inspect.get_annotations(isa.function, eval_str=False), {'a': int, 'b': str, 'return': isa.MyClass})
1362 self.assertEqual(inspect.get_annotations(isa.function2, eval_str=False), {'a': int, 'b': 'str', 'c': isa.MyClass, 'return': isa.MyClass})
1363 self.assertEqual(inspect.get_annotations(isa.function3, eval_str=False), {'a': 'int', 'b': 'str', 'c': 'MyClass'})
1364 self.assertEqual(inspect.get_annotations(inspect, eval_str=False), {})
1365 self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=False), {})
1366 self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=False), {})
1375 self.assertEqual(wrapped(1, 'x'), isa.MyClass(3, 'xxx'))
1376 self.assertIsNot(wrapped.__globals__, isa.function.__globals__)
1377 self.assertEqual(inspect.get_annotations(wrapped), {'a': int, 'b': str, 'return': isa.MyClass})
1378 self.assertEqual(inspect.get_annotations(wrapped, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass})
1379 self.assertEqual(inspect.get_annotations(wrapped, eval_str=False), {'a': int, 'b': str, 'return': isa.MyClass})
1381 def test_get_annotations_with_stringized_annotations(self):
1383 self.assertEqual(inspect.get_annotations(isa), {'a': 'int', 'b': 'str'})
1384 self.assertEqual(inspect.get_annotations(isa.MyClass), {'a': 'int', 'b': 'str'})
1385 self.assertEqual(inspect.get_annotations(isa.function), {'a': 'int', 'b': 'str', 'return': 'MyClass'})
1386 self.assertEqual(inspect.get_annotations(isa.function2), {'a': 'int', 'b': "'str'", 'c': 'MyClass', 'return': 'MyClass'})
1387 self.assertEqual(inspect.get_annotations(isa.function3), {'a': "'int'", 'b': "'str'", 'c': "'MyClass'"})
1388 self.assertEqual(inspect.get_annotations(isa.UnannotatedClass), {})
1389 self.assertEqual(inspect.get_annotations(isa.unannotated_function), {})
1391 self.assertEqual(inspect.get_annotations(isa, eval_str=True), {'a': int, 'b': str})
1392 self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=True), {'a': int, 'b': str})
1393 self.assertEqual(inspect.get_annotations(isa.function, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass})
1394 self.assertEqual(inspect.get_annotations(isa.function2, eval_str=True), {'a': int, 'b': 'str', 'c': isa.MyClass, 'return': isa.MyClass})
1395 self.assertEqual(inspect.get_annotations(isa.function3, eval_str=True), {'a': 'int', 'b': 'str', 'c': 'MyClass'})
1396 self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=True), {})
1397 self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=True), {})
1399 self.assertEqual(inspect.get_annotations(isa, eval_str=False), {'a': 'int', 'b': 'str'})
1400 self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=False), {'a': 'int', 'b': 'str'})
1401 self.assertEqual(inspect.get_annotations(isa.function, eval_str=False), {'a': 'int', 'b': 'str', 'return': 'MyClass'})
1402 self.assertEqual(inspect.get_annotations(isa.function2, eval_str=False), {'a': 'int', 'b': "'str'", 'c': 'MyClass', 'return': 'MyClass'})
1403 self.assertEqual(inspect.get_annotations(isa.function3, eval_str=False), {'a': "'int'", 'b': "'str'", 'c': "'MyClass'"})
1404 self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=False), {})
1405 self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=False), {})
1408 self.assertEqual(inspect.get_annotations(isa2), {})
1409 self.assertEqual(inspect.get_annotations(isa2, eval_str=True), {})
1410 self.assertEqual(inspect.get_annotations(isa2, eval_str=False), {})
1419 self.assertEqual(wrapped(1, 'x'), isa.MyClass(3, 'xxx'))
1420 self.assertIsNot(wrapped.__globals__, isa.function.__globals__)
1421 self.assertEqual(inspect.get_annotations(wrapped), {'a': 'int', 'b': 'str', 'return': 'MyClass'})
1422 self.assertEqual(inspect.get_annotations(wrapped, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass})
1423 self.assertEqual(inspect.get_annotations(wrapped, eval_str=False), {'a': 'int', 'b': 'str', 'return': 'MyClass'})
1426 self.assertEqual(inspect.get_annotations(isa.MyClassWithLocalAnnotations), {'x': 'mytype'})
1427 self.assertEqual(inspect.get_annotations(isa.MyClassWithLocalAnnotations, eval_str=True), {'x': int})
1431 def test_typing_replacement(self):
1433 self.assertEqual(inspect.formatannotation(ann), 'Union[List[str], int]')
1434 self.assertEqual(inspect.formatannotation(ann1), 'Union[List[testModule.typing.A], int]')
1439 def test_custom_descriptors(self):
1441 def __get__(self, value, type=None): pass
1443 def __set__(self, name, value): pass
1445 def __delete__(self, name): pass
1448 self.assertFalse(inspect.isdatadescriptor(NonDataDescriptor()),
1450 self.assertTrue(inspect.isdatadescriptor(DataDescriptor0()),
1452 self.assertTrue(inspect.isdatadescriptor(DataDescriptor1()),
1454 self.assertTrue(inspect.isdatadescriptor(DataDescriptor2()),
1457 def test_slot(self):
1460 self.assertTrue(inspect.isdatadescriptor(Slotted.foo),
1463 def test_property(self):
1466 def a_property(self):
1468 self.assertTrue(inspect.isdatadescriptor(Propertied.a_property),
1471 def test_functions(self):
1473 def instance_method(self): pass
1481 self.assertFalse(inspect.isdatadescriptor(Test().instance_method),
1483 self.assertFalse(inspect.isdatadescriptor(Test().class_method),
1485 self.assertFalse(inspect.isdatadescriptor(Test().static_method),
1487 self.assertFalse(inspect.isdatadescriptor(function),
1489 self.assertFalse(inspect.isdatadescriptor(a_lambda),
1496 def test_name_resolution(self):
1509 self.assertEqual(inspect.getclosurevars(f(_arg)), expected)
1511 def test_generator_closure(self):
1524 self.assertEqual(inspect.getclosurevars(f(_arg)), expected)
1526 def test_method_closure(self):
1528 def f(self, nonlocal_ref):
1539 self.assertEqual(inspect.getclosurevars(C().f(_arg)), expected)
1541 def test_nonlocal_vars(self):
1565 self.assertEqual(_nonlocal_vars(func), {'f': Y.g_ref})
1571 self.assertEqual(_nonlocal_vars(inc), {'x': 1})
1572 self.assertEqual(_nonlocal_vars(add_two), {'x': 2})
1573 self.assertEqual(_nonlocal_vars(greater_than_five),
1575 self.assertEqual(_nonlocal_vars((lambda x: lambda y: x + y)(3)),
1579 def test_getclosurevars_empty(self):
1582 self.assertEqual(inspect.getclosurevars(lambda: True), _empty)
1583 self.assertEqual(inspect.getclosurevars(foo), _empty)
1585 def test_getclosurevars_error(self):
1587 self.assertRaises(TypeError, inspect.getclosurevars, 1)
1588 self.assertRaises(TypeError, inspect.getclosurevars, list)
1589 self.assertRaises(TypeError, inspect.getclosurevars, {})
1591 def _private_globals(self):
1597 def test_builtins_fallback(self):
1598 f, ns = self._private_globals()
1601 self.assertEqual(inspect.getclosurevars(f), expected)
1603 def test_builtins_as_dict(self):
1604 f, ns = self._private_globals()
1607 self.assertEqual(inspect.getclosurevars(f), expected)
1609 def test_builtins_as_module(self):
1610 f, ns = self._private_globals()
1613 self.assertEqual(inspect.getclosurevars(f), expected)
1618 def assertEqualCallArgs(self, func, call_params_string, locs=None):
1623 self.assertEqual(r1, r2)
1625 def assertEqualException(self, func, call_param_string, locs=None):
1632 self.fail('Exception not raised')
1639 self.fail('Exception not raised')
1640 self.assertIs(type(ex1), type(ex2))
1641 self.assertEqual(str(ex1), str(ex2))
1644 def makeCallable(self, signature):
1649 def test_plain(self):
1650 f = self.makeCallable('a, b=1')
1651 self.assertEqualCallArgs(f, '2')
1652 self.assertEqualCallArgs(f, '2, 3')
1653 self.assertEqualCallArgs(f, 'a=2')
1654 self.assertEqualCallArgs(f, 'b=3, a=2')
1655 self.assertEqualCallArgs(f, '2, b=3')
1657 self.assertEqualCallArgs(f, '*(2,)')
1658 self.assertEqualCallArgs(f, '*[2]')
1659 self.assertEqualCallArgs(f, '*(2, 3)')
1660 self.assertEqualCallArgs(f, '*[2, 3]')
1661 self.assertEqualCallArgs(f, '**{"a":2}')
1662 self.assertEqualCallArgs(f, 'b=3, **{"a":2}')
1663 self.assertEqualCallArgs(f, '2, **{"b":3}')
1664 self.assertEqualCallArgs(f, '**{"b":3, "a":2}')
1666 self.assertEqualCallArgs(f, '*collections.UserList([2])')
1667 self.assertEqualCallArgs(f, '*collections.UserList([2, 3])')
1668 self.assertEqualCallArgs(f, '**collections.UserDict(a=2)')
1669 self.assertEqualCallArgs(f, '2, **collections.UserDict(b=3)')
1670 self.assertEqualCallArgs(f, 'b=2, **collections.UserDict(a=3)')
1672 def test_varargs(self):
1673 f = self.makeCallable('a, b=1, *c')
1674 self.assertEqualCallArgs(f, '2')
1675 self.assertEqualCallArgs(f, '2, 3')
1676 self.assertEqualCallArgs(f, '2, 3, 4')
1677 self.assertEqualCallArgs(f, '*(2,3,4)')
1678 self.assertEqualCallArgs(f, '2, *[3,4]')
1679 self.assertEqualCallArgs(f, '2, 3, *collections.UserList([4])')
1681 def test_varkw(self):
1682 f = self.makeCallable('a, b=1, **c')
1683 self.assertEqualCallArgs(f, 'a=2')
1684 self.assertEqualCallArgs(f, '2, b=3, c=4')
1685 self.assertEqualCallArgs(f, 'b=3, a=2, c=4')
1686 self.assertEqualCallArgs(f, 'c=4, **{"a":2, "b":3}')
1687 self.assertEqualCallArgs(f, '2, c=4, **{"b":3}')
1688 self.assertEqualCallArgs(f, 'b=2, **{"a":3, "c":4}')
1689 self.assertEqualCallArgs(f, '**collections.UserDict(a=2, b=3, c=4)')
1690 self.assertEqualCallArgs(f, '2, c=4, **collections.UserDict(b=3)')
1691 self.assertEqualCallArgs(f, 'b=2, **collections.UserDict(a=3, c=4)')
1693 def test_varkw_only(self):
1695 f = self.makeCallable('**c')
1696 self.assertEqualCallArgs(f, '')
1697 self.assertEqualCallArgs(f, 'a=1')
1698 self.assertEqualCallArgs(f, 'a=1, b=2')
1699 self.assertEqualCallArgs(f, 'c=3, **{"a": 1, "b": 2}')
1700 self.assertEqualCallArgs(f, '**collections.UserDict(a=1, b=2)')
1701 self.assertEqualCallArgs(f, 'c=3, **collections.UserDict(a=1, b=2)')
1703 def test_keyword_only(self):
1704 f = self.makeCallable('a=3, *, c, d=2')
1705 self.assertEqualCallArgs(f, 'c=3')
1706 self.assertEqualCallArgs(f, 'c=3, a=3')
1707 self.assertEqualCallArgs(f, 'a=2, c=4')
1708 self.assertEqualCallArgs(f, '4, c=4')
1709 self.assertEqualException(f, '')
1710 self.assertEqualException(f, '3')
1711 self.assertEqualException(f, 'a=3')
1712 self.assertEqualException(f, 'd=4')
1714 f = self.makeCallable('*, c, d=2')
1715 self.assertEqualCallArgs(f, 'c=3')
1716 self.assertEqualCallArgs(f, 'c=3, d=4')
1717 self.assertEqualCallArgs(f, 'd=4, c=3')
1719 def test_multiple_features(self):
1720 f = self.makeCallable('a, b=2, *f, **g')
1721 self.assertEqualCallArgs(f, '2, 3, 7')
1722 self.assertEqualCallArgs(f, '2, 3, x=8')
1723 self.assertEqualCallArgs(f, '2, 3, x=8, *[(4,[5,6]), 7]')
1724 self.assertEqualCallArgs(f, '2, x=8, *[3, (4,[5,6]), 7], y=9')
1725 self.assertEqualCallArgs(f, 'x=8, *[2, 3, (4,[5,6])], y=9')
1726 self.assertEqualCallArgs(f, 'x=8, *collections.UserList('
1728 self.assertEqualCallArgs(f, '2, x=8, *collections.UserList([3, '
1732 f = self.makeCallable('a, b=2, *f, x, y=99, **g')
1733 self.assertEqualCallArgs(f, '2, 3, x=8')
1734 self.assertEqualCallArgs(f, '2, 3, x=8, *[(4,[5,6]), 7]')
1735 self.assertEqualCallArgs(f, '2, x=8, *[3, (4,[5,6]), 7], y=9, z=10')
1736 self.assertEqualCallArgs(f, 'x=8, *[2, 3, (4,[5,6])], y=9, z=10')
1737 self.assertEqualCallArgs(f, 'x=8, *collections.UserList('
1739 self.assertEqualCallArgs(f, '2, x=8, *collections.UserList([3, '
1743 def test_errors(self):
1744 f0 = self.makeCallable('')
1745 f1 = self.makeCallable('a, b')
1746 f2 = self.makeCallable('a, b=1')
1748 self.assertEqualException(f0, '1')
1749 self.assertEqualException(f0, 'x=1')
1750 self.assertEqualException(f0, '1,x=1')
1752 self.assertEqualException(f1, '')
1753 self.assertEqualException(f1, '1')
1754 self.assertEqualException(f1, 'a=2')
1755 self.assertEqualException(f1, 'b=3')
1757 self.assertEqualException(f2, '')
1758 self.assertEqualException(f2, 'b=3')
1761 self.assertEqualException(f, '2, 3, 4')
1762 self.assertEqualException(f, '1, 2, 3, a=1')
1763 self.assertEqualException(f, '2, 3, 4, c=5')
1764 self.assertEqualException(f, '2, 3, 4, a=1, c=5')
1766 self.assertEqualException(f, 'c=2')
1767 self.assertEqualException(f, '2, c=3')
1768 self.assertEqualException(f, '2, 3, c=4')
1769 self.assertEqualException(f, '2, c=4, b=3')
1770 self.assertEqualException(f, '**{u"\u03c0\u03b9": 4}')
1772 self.assertEqualException(f, '1, a=2')
1773 self.assertEqualException(f, '1, **{"a":2}')
1774 self.assertEqualException(f, '1, 2, b=3')
1775 self.assertEqualException(f, '1, c=3, a=2')
1777 f3 = self.makeCallable('**c')
1778 self.assertEqualException(f3, '1, 2')
1779 self.assertEqualException(f3, '1, 2, a=1, b=2')
1780 f4 = self.makeCallable('*, a, b=0')
1781 self.assertEqualException(f4, '1, 2')
1782 self.assertEqualException(f4, '1, 2, a=1, b=2')
1783 self.assertEqualException(f4, 'a=1, a=3')
1784 self.assertEqualException(f4, 'a=1, c=3')
1785 self.assertEqualException(f4, 'a=1, a=3, b=4')
1786 self.assertEqualException(f4, 'a=1, b=2, a=3, b=4')
1787 self.assertEqualException(f4, 'a=1, a=2, a=3, b=4')
1792 with self.assertRaisesRegex(TypeError,
1800 with self.assertRaisesRegex(TypeError, "'a', 'b' and 'c'"):
1804 with self.assertRaisesRegex(ValueError,
1809 with self.assertRaisesRegex(ValueError,
1813 with self.assertRaisesRegex(TypeError,
1819 def setUp(self):
1822 self.cls = Foo
1823 self.inst = Foo()
1825 def makeCallable(self, signature):
1826 assert 'self' not in signature
1827 mk = super(TestGetcallargsMethods, self).makeCallable
1828 self.cls.method = mk('self, ' + signature)
1829 return self.inst.method
1833 def makeCallable(self, signature):
1834 super(TestGetcallargsUnboundMethods, self).makeCallable(signature)
1835 return self.cls.method
1837 def assertEqualCallArgs(self, func, call_params_string, locs=None):
1838 return super(TestGetcallargsUnboundMethods, self).assertEqualCallArgs(
1839 *self._getAssertEqualParams(func, call_params_string, locs))
1841 def assertEqualException(self, func, call_params_string, locs=None):
1842 return super(TestGetcallargsUnboundMethods, self).assertEqualException(
1843 *self._getAssertEqualParams(func, call_params_string, locs))
1845 def _getAssertEqualParams(self, func, call_params_string, locs=None):
1847 locs = dict(locs or {}, inst=self.inst)
1853 def test_basic(self):
1858 self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x)
1859 self.assertEqual(inspect.getattr_static(thing, 'x', None), Thing.x)
1860 with self.assertRaises(AttributeError):
1863 self.assertEqual(inspect.getattr_static(thing, 'y', 3), 3)
1865 def test_inherited(self):
1872 self.assertEqual(inspect.getattr_static(something, 'x'), Thing.x)
1874 def test_instance_attr(self):
1877 def __init__(self, x):
1878 self.x = x
1880 self.assertEqual(inspect.getattr_static(thing, 'x'), 3)
1882 self.assertEqual(inspect.getattr_static(thing, 'x'), 2)
1884 def test_property(self):
1887 def x(self):
1890 self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x)
1892 def test_descriptor_raises_AttributeError(self):
1900 self.assertEqual(inspect.getattr_static(thing, 'x'), desc)
1902 def test_classAttribute(self):
1906 self.assertEqual(inspect.getattr_static(Thing, 'x'), Thing.x)
1908 def test_classVirtualAttribute(self):
1911 def x(self):
1912 return self._x
1915 self.assertEqual(inspect.getattr_static(Thing, 'x'), Thing.__dict__['x'])
1917 def test_inherited_classattribute(self):
1923 self.assertEqual(inspect.getattr_static(OtherThing, 'x'), Thing.x)
1925 def test_slots(self):
1929 def __init__(self):
1930 self.x = 'foo'
1932 self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x)
1933 self.assertEqual(inspect.getattr_static(thing, 'y'), 'bar')
1936 self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x)
1938 def test_metaclass(self):
1943 self.assertEqual(inspect.getattr_static(Thing, 'attr'), 'foo')
1949 self.assertEqual(inspect.getattr_static(OtherThing, 'attr'), 'foo')
1954 self.assertEqual(inspect.getattr_static(OtherOtherThing, 'x'), 3)
1956 def test_no_dict_no_slots(self):
1957 self.assertEqual(inspect.getattr_static(1, 'foo', None), None)
1958 self.assertNotEqual(inspect.getattr_static('foo', 'lower'), None)
1960 def test_no_dict_no_slots_instance_member(self):
1963 self.assertEqual(inspect.getattr_static(handle, 'name'), type(handle).name)
1965 def test_inherited_slots(self):
1969 def __init__(self):
1970 self.x = 'foo'
1976 self.assertEqual(inspect.getattr_static(OtherThing(), 'x'), Thing.x)
1978 def test_descriptor(self):
1980 def __get__(self, instance, owner):
1989 self.assertEqual(inspect.getattr_static(foo, 'd'), 1)
1994 self.assertEqual(inspect.getattr_static(foo, 'd'), Foo.__dict__['d'])
1998 self.assertEqual(inspect.getattr_static(foo, 'd'), Foo.__dict__['d'])
2000 def test_metaclass_with_descriptor(self):
2002 def __get__(self, instance, owner):
2008 self.assertEqual(inspect.getattr_static(Thing, 'd'), meta.__dict__['d'])
2011 def test_class_as_property(self):
2018 def __class__(self):
2019 self.executed = True
2023 self.assertEqual(inspect.getattr_static(instance, 'foo'), 3)
2024 self.assertFalse(instance.executed)
2025 self.assertEqual(inspect.getattr_static(Something, 'foo'), 3)
2027 def test_mro_as_property(self):
2030 def __mro__(self):
2039 self.assertEqual(inspect.getattr_static(Something(), 'foo'), 3)
2040 self.assertEqual(inspect.getattr_static(Something, 'foo'), 3)
2042 def test_dict_as_property(self):
2043 test = self
2049 def __dict__(self):
2055 self.assertEqual(inspect.getattr_static(foo, 'a'), 3)
2056 self.assertFalse(test.called)
2058 def test_custom_object_dict(self):
2059 test = self
2063 def get(self, key, default=None):
2071 self.assertEqual(inspect.getattr_static(foo, 'a'), 3)
2072 self.assertFalse(test.called)
2074 def test_metaclass_dict_as_property(self):
2077 def __dict__(self):
2078 self.executed = True
2083 def __init__(self):
2084 self.spam = 42
2087 self.assertEqual(inspect.getattr_static(instance, "spam"), 42)
2088 self.assertFalse(Thing.executed)
2090 def test_module(self):
2092 self.assertIsNot(inspect.getattr_static(sys, "version", sentinel),
2095 def test_metaclass_with_metaclass_with_dict_as_property(self):
2098 def __dict__(self):
2099 self.executed = True
2108 with self.assertRaises(AttributeError):
2110 self.assertFalse(Thing.executed)
2112 def test_custom___getattr__(self):
2113 test = self
2117 def __getattr__(self, attr):
2121 with self.assertRaises(AttributeError):
2124 self.assertFalse(test.called)
2126 def test_custom___getattribute__(self):
2127 test = self
2131 def __getattribute__(self, attr):
2135 with self.assertRaises(AttributeError):
2138 self.assertFalse(test.called)
2143 def setUp(self):
2147 self.generator = number_generator()
2149 def _generatorstate(self):
2150 return inspect.getgeneratorstate(self.generator)
2152 def test_created(self):
2153 self.assertEqual(self._generatorstate(), inspect.GEN_CREATED)
2155 def test_suspended(self):
2156 next(self.generator)
2157 self.assertEqual(self._generatorstate(), inspect.GEN_SUSPENDED)
2159 def test_closed_after_exhaustion(self):
2160 for i in self.generator:
2162 self.assertEqual(self._generatorstate(), inspect.GEN_CLOSED)
2164 def test_closed_after_immediate_exception(self):
2165 with self.assertRaises(RuntimeError):
2166 self.generator.throw(RuntimeError)
2167 self.assertEqual(self._generatorstate(), inspect.GEN_CLOSED)
2169 def test_running(self):
2173 # reference to self and the generator state checking helper method
2176 self.assertEqual(self._generatorstate(), inspect.GEN_RUNNING)
2178 self.assertEqual(self._generatorstate(), inspect.GEN_RUNNING)
2179 self.generator = running_check_generator()
2181 next(self.generator)
2183 next(self.generator)
2185 def test_easy_debugging(self):
2190 self.assertIn(name, repr(state))
2191 self.assertIn(name, str(state))
2193 def test_getgeneratorlocals(self):
2202 self.assertEqual(inspect.getgeneratorlocals(numbers),
2205 self.assertEqual(inspect.getgeneratorlocals(numbers),
2209 self.assertEqual(inspect.getgeneratorlocals(numbers),
2213 self.assertEqual(inspect.getgeneratorlocals(numbers),
2220 self.assertEqual(inspect.getgeneratorlocals(numbers), {})
2222 def test_getgeneratorlocals_empty(self):
2226 self.assertEqual(inspect.getgeneratorlocals(one), {})
2231 self.assertEqual(inspect.getgeneratorlocals(one), {})
2233 def test_getgeneratorlocals_error(self):
2234 self.assertRaises(TypeError, inspect.getgeneratorlocals, 1)
2235 self.assertRaises(TypeError, inspect.getgeneratorlocals, lambda x: True)
2236 self.assertRaises(TypeError, inspect.getgeneratorlocals, set)
2237 self.assertRaises(TypeError, inspect.getgeneratorlocals, (2,3))
2242 def setUp(self):
2249 self.coroutine = coroutine()
2251 def tearDown(self):
2252 self.coroutine.close()
2254 def _coroutinestate(self):
2255 return inspect.getcoroutinestate(self.coroutine)
2257 def test_created(self):
2258 self.assertEqual(self._coroutinestate(), inspect.CORO_CREATED)
2260 def test_suspended(self):
2261 self.coroutine.send(None)
2262 self.assertEqual(self._coroutinestate(), inspect.CORO_SUSPENDED)
2264 def test_closed_after_exhaustion(self):
2267 self.coroutine.send(None)
2271 self.assertEqual(self._coroutinestate(), inspect.CORO_CLOSED)
2273 def test_closed_after_immediate_exception(self):
2274 with self.assertRaises(RuntimeError):
2275 self.coroutine.throw(RuntimeError)
2276 self.assertEqual(self._coroutinestate(), inspect.CORO_CLOSED)
2278 def test_easy_debugging(self):
2283 self.assertIn(name, repr(state))
2284 self.assertIn(name, str(state))
2286 def test_getcoroutinelocals(self):
2297 self.assertEqual(inspect.getcoroutinelocals(coro),
2300 self.assertEqual(inspect.getcoroutinelocals(coro),
2329 def test_signature_object(self):
2333 self.assertEqual(str(S()), '()')
2334 self.assertEqual(repr(S().parameters), 'mappingproxy(OrderedDict())')
2340 self.assertTrue(repr(sig).startswith('<Signature'))
2341 self.assertTrue('(po, /, pk' in repr(sig))
2349 self.assertTrue(repr(sig2).startswith('<Signature'))
2350 self.assertTrue('(pod=42, /)' in repr(sig2))
2374 with self.assertRaisesRegex(ValueError, 'wrong parameter order'):
2377 with self.assertRaisesRegex(ValueError, 'wrong parameter order'):
2380 with self.assertRaisesRegex(ValueError, 'wrong parameter order'):
2383 with self.assertRaisesRegex(ValueError, 'wrong parameter order'):
2387 with self.assertRaisesRegex(ValueError, 'duplicate parameter name'):
2390 with self.assertRaisesRegex(ValueError, 'follows default argument'):
2393 with self.assertRaisesRegex(ValueError, 'follows default argument'):
2396 with self.assertRaisesRegex(ValueError, 'follows default argument'):
2399 with self.assertRaisesRegex(ValueError, 'follows default argument'):
2402 with self.assertRaisesRegex(ValueError, 'follows default argument'):
2405 def test_signature_object_pickle(self):
2412 with self.subTest(pickle_ver=ver, subclass=False):
2414 self.assertEqual(sig, sig_pickled)
2422 self.assertTrue(isinstance(mysig, MySignature))
2423 self.assertTrue(isinstance(mysig.parameters['z'], MyParameter))
2426 with self.subTest(pickle_ver=ver, subclass=True):
2428 self.assertEqual(mysig, sig_pickled)
2429 self.assertTrue(isinstance(sig_pickled, MySignature))
2430 self.assertTrue(isinstance(sig_pickled.parameters['z'],
2433 def test_signature_immutability(self):
2438 with self.assertRaises(AttributeError):
2441 with self.assertRaises(TypeError):
2444 def test_signature_on_noarg(self):
2447 self.assertEqual(self.signature(test), ((), ...))
2449 def test_signature_on_wargs(self):
2452 self.assertEqual(self.signature(test),
2457 def test_signature_on_wkwonly(self):
2460 self.assertEqual(self.signature(test),
2465 def test_signature_on_complex_args(self):
2468 self.assertEqual(self.signature(test),
2477 def test_signature_without_self(self):
2498 self.assertEqual(self.signature(test_args_only),
2500 self.assertEqual(self.signature(test_args_kwargs_only),
2503 self.assertEqual(self.signature(A.f1),
2505 self.assertEqual(self.signature(A.f2),
2507 self.assertEqual(self.signature(A.f3),
2509 self.assertEqual(self.signature(A.f4),
2515 def test_signature_on_builtins(self):
2519 """Use this to test unbound methods (things that should have a self)"""
2521 self.assertTrue(isinstance(signature, inspect.Signature))
2522 self.assertEqual(list(signature.parameters.values())[0].name, 'self')
2526 """Use this to test bound methods or normal callables (things that don't expect self)"""
2528 self.assertTrue(isinstance(signature, inspect.Signature))
2530 self.assertNotEqual(list(signature.parameters.values())[0].name, 'self')
2535 self.assertEqual(p('s'), 'avocado')
2536 self.assertEqual(p('b'), b'bytes')
2537 self.assertEqual(p('d'), 3.14)
2538 self.assertEqual(p('i'), 35)
2539 self.assertEqual(p('n'), None)
2540 self.assertEqual(p('t'), True)
2541 self.assertEqual(p('f'), False)
2542 self.assertEqual(p('local'), 3)
2543 self.assertEqual(p('sys'), sys.maxsize)
2544 self.assertEqual(p('exp'), sys.maxsize - 1)
2573 with self.assertRaisesRegex(ValueError, "no signature found"):
2588 def test_signature_on_decorated_builtins(self):
2600 self.assertEqual(inspect.signature(func),
2604 self.assertEqual(inspect.signature(decorated_func,
2609 def test_signature_on_builtins_no_signature(self):
2611 with self.assertRaisesRegex(ValueError,
2615 with self.assertRaisesRegex(ValueError,
2619 def test_signature_on_non_function(self):
2620 with self.assertRaisesRegex(TypeError, 'is not a callable object'):
2623 def test_signature_from_functionlike_object(self):
2632 def __init__(self, func):
2633 self.__name__ = func.__name__
2634 self.__code__ = func.__code__
2635 self.__annotations__ = func.__annotations__
2636 self.__defaults__ = func.__defaults__
2637 self.__kwdefaults__ = func.__kwdefaults__
2638 self.func = func
2640 def __call__(self, *args, **kwargs):
2641 return self.func(*args, **kwargs)
2646 self.assertEqual(sig_funclike, sig_func)
2649 self.assertEqual(sig_funclike, sig_func)
2656 self.assertEqual(self.signature(fl),
2671 self.assertFalse(inspect.ismethoddescriptor(builtin_func))
2673 self.assertTrue(inspect.ismethoddescriptor(builtin_func))
2674 self.assertEqual(inspect.signature(builtin_func), sig_func)
2676 def test_signature_functionlike_class(self):
2684 def __init__(self, marker):
2693 self.assertEqual(str(inspect.signature(funclike)), '(marker)')
2695 def test_signature_on_method(self):
2699 def m1(self, arg1, arg2=1) -> int:
2706 self.assertEqual(self.signature(Test().m1),
2711 self.assertEqual(self.signature(Test().m2),
2715 self.assertEqual(self.signature(Test),
2719 with self.assertRaisesRegex(ValueError, 'invalid method signature'):
2720 self.signature(Test())
2722 def test_signature_wrapped_bound_method(self):
2725 def m1(self, arg1, arg2=1) -> int:
2730 self.assertEqual(self.signature(m1d),
2735 def test_signature_on_classmethod(self):
2742 self.assertEqual(self.signature(meth),
2748 self.assertEqual(self.signature(meth),
2753 def test_signature_on_staticmethod(self):
2760 self.assertEqual(self.signature(meth),
2766 self.assertEqual(self.signature(meth),
2771 def test_signature_on_partial(self):
2777 self.assertEqual(self.signature(partial(test)), ((), ...))
2779 with self.assertRaisesRegex(ValueError, "has incorrect arguments"):
2782 with self.assertRaisesRegex(ValueError, "has incorrect arguments"):
2788 self.assertEqual(self.signature(partial(test)),
2795 self.assertEqual(self.signature(partial(test, 1)),
2801 self.assertEqual(self.signature(partial(test, 1, c=2)),
2807 self.assertEqual(self.signature(partial(test, b=1, c=2)),
2814 self.assertEqual(self.signature(partial(test, 0, b=1, c=2)),
2820 self.assertEqual(self.signature(partial(test, a=1)),
2830 self.assertEqual(self.signature(partial(test, 1)),
2836 self.assertEqual(self.signature(partial(test, a=1)),
2842 self.assertEqual(self.signature(partial(test, 1, 2, 3)),
2848 self.assertEqual(self.signature(partial(test, 1, 2, 3, test=True)),
2854 self.assertEqual(self.signature(partial(test, 1, 2, 3, test=1, b=0)),
2860 self.assertEqual(self.signature(partial(test, b=0)),
2867 self.assertEqual(self.signature(partial(test, b=0, test=1)),
2879 self.assertEqual(self.signature(partial(partial(test, 1))),
2884 self.assertEqual(self.signature(partial(partial(test, 1), 2)),
2891 self.assertEqual(self.signature(_foo),
2896 self.assertEqual(_foo(), 20)
2902 self.assertEqual(self.signature(_foo),
2906 self.assertEqual(_foo(c=10), (1, 30, 10))
2911 self.assertEqual(self.signature(_foo),
2919 self.assertEqual(_foo(*ba.args, **ba.kwargs), (200, 11, 20, 30))
2926 self.assertEqual(_foo(*ba.args, **ba.kwargs), (11, 2, 13))
2929 self.assertEqual(_foo(*ba.args, **ba.kwargs), (11, 12, 13))
2932 self.assertEqual(_foo(*ba.args, **ba.kwargs), (11, 12, 13))
2935 self.assertEqual(_foo(*ba.args, **ba.kwargs), (1, 12, 13))
2939 self.assertEqual(_foo(*ba.args, **ba.kwargs), (12, 10, 20))
2945 self.assertEqual(str(sig), '(a, b, /, c, d, **kwargs)')
2947 self.assertEqual(self.signature(partial(foo, 1)),
2954 self.assertEqual(self.signature(partial(foo, 1, 2)),
2960 self.assertEqual(self.signature(partial(foo, 1, 2, 3)),
2965 self.assertEqual(self.signature(partial(foo, 1, 2, c=3)),
2971 self.assertEqual(self.signature(partial(foo, 1, c=3)),
2978 def test_signature_on_partialmethod(self):
2986 with self.assertRaisesRegex(ValueError, "has incorrect arguments"):
2994 self.assertEqual(self.signature(Spam.ham, eval_str=False),
3000 self.assertEqual(self.signature(Spam().ham, eval_str=False),
3006 def test(self: 'anno', x):
3011 self.assertEqual(self.signature(Spam.g, eval_str=False),
3012 ((('self', ..., 'anno', 'positional_or_keyword'),),
3015 def test_signature_on_fake_partialmethod(self):
3018 self.assertEqual(str(inspect.signature(foo)), '(a)')
3020 def test_signature_on_decorated(self):
3029 def bar(self, a, b):
3034 self.assertEqual(self.signature(Foo.bar),
3035 ((('self', ..., ..., "positional_or_keyword"),
3040 self.assertEqual(self.signature(Foo().bar),
3045 self.assertEqual(self.signature(Foo.bar, follow_wrapped=False),
3052 self.assertEqual(self.signature(bar),
3069 def __call__(self, a, b):
3072 self.assertEqual(self.signature(Foo.__call__),
3077 self.assertEqual(self.signature(Foo().__call__),
3086 self.assertEqual(self.signature(wrapped_foo_call),
3092 def test_signature_on_class(self):
3094 def __init__(self, a):
3097 self.assertEqual(self.signature(C),
3105 def __init__(self, b):
3108 self.assertEqual(self.signature(C),
3116 def __init__(self, b):
3119 self.assertEqual(self.signature(C),
3123 self.assertEqual(self.signature(CM),
3139 def __init__(self, b):
3142 self.assertEqual(self.signature(CMM),
3149 self.assertEqual(self.signature(CM),
3155 self.assertEqual(self.signature(C),
3163 def __init__(self, b):
3166 self.assertEqual(self.signature(CM),
3173 def test_signature_on_subclass(self):
3178 def __init__(self, b):
3186 self.assertEqual(self.signature(B),
3189 self.assertEqual(self.signature(C),
3195 self.assertEqual(self.signature(D),
3201 def test_signature_on_generic_subclass(self):
3207 def __init__(self, *, a: int) -> None:
3210 self.assertEqual(self.signature(A),
3216 def test_signature_on_class_without_init(self):
3219 self.assertEqual(str(inspect.signature(C)), '()')
3221 self.assertEqual(str(inspect.signature(D)), '()')
3226 with self.assertRaisesRegex(ValueError, "callable.*is not supported"):
3227 self.assertEqual(inspect.signature(C), None)
3228 with self.assertRaisesRegex(ValueError, "callable.*is not supported"):
3229 self.assertEqual(inspect.signature(D), None)
3233 def test_signature_on_builtin_class(self):
3236 self.assertEqual(str(inspect.signature(_pickle.Pickler)), expected)
3241 self.assertEqual(str(inspect.signature(P)), expected)
3242 self.assertEqual(str(inspect.signature(P2)), expected)
3245 def __init__(self, spam):
3247 self.assertEqual(str(inspect.signature(P3)), '(spam)')
3254 self.assertEqual(str(inspect.signature(P4)), '(foo, bar)')
3256 def test_signature_on_callable_objects(self):
3258 def __call__(self, a):
3261 self.assertEqual(self.signature(Foo()),
3267 with self.assertRaisesRegex(TypeError, "is not a callable object"):
3273 self.assertEqual(self.signature(Bar()),
3280 self.assertEqual(self.signature(Wrapped),
3285 with self.assertRaisesRegex(ValueError, 'wrapper loop'):
3286 self.signature(Wrapped)
3288 def test_signature_on_lambdas(self):
3289 self.assertEqual(self.signature((lambda a=10: a)),
3293 def test_signature_on_mocks(self):
3300 with self.subTest(mock=mock):
3301 self.assertEqual(str(inspect.signature(mock)), '(*args, **kwargs)')
3303 def test_signature_on_noncallable_mocks(self):
3308 with self.subTest(mock=mock):
3309 with self.assertRaises(TypeError):
3312 def test_signature_equality(self):
3314 self.assertFalse(inspect.signature(foo) == 42)
3315 self.assertTrue(inspect.signature(foo) != 42)
3316 self.assertTrue(inspect.signature(foo) == ALWAYS_EQ)
3317 self.assertFalse(inspect.signature(foo) != ALWAYS_EQ)
3320 self.assertTrue(inspect.signature(foo) == inspect.signature(bar))
3321 self.assertFalse(inspect.signature(foo) != inspect.signature(bar))
3322 self.assertEqual(
3326 self.assertFalse(inspect.signature(foo) == inspect.signature(bar))
3327 self.assertTrue(inspect.signature(foo) != inspect.signature(bar))
3328 self.assertNotEqual(
3332 self.assertFalse(inspect.signature(foo) == inspect.signature(bar))
3333 self.assertTrue(inspect.signature(foo) != inspect.signature(bar))
3334 self.assertNotEqual(
3338 self.assertFalse(inspect.signature(foo) == inspect.signature(bar))
3339 self.assertTrue(inspect.signature(foo) != inspect.signature(bar))
3340 self.assertNotEqual(
3344 self.assertFalse(inspect.signature(foo) == inspect.signature(bar))
3345 self.assertTrue(inspect.signature(foo) != inspect.signature(bar))
3346 self.assertNotEqual(
3350 self.assertFalse(inspect.signature(foo) == inspect.signature(bar))
3351 self.assertTrue(inspect.signature(foo) != inspect.signature(bar))
3352 self.assertNotEqual(
3355 self.assertFalse(inspect.signature(spam) == inspect.signature(bar))
3356 self.assertTrue(inspect.signature(spam) != inspect.signature(bar))
3357 self.assertNotEqual(
3362 self.assertTrue(inspect.signature(foo) == inspect.signature(bar))
3363 self.assertFalse(inspect.signature(foo) != inspect.signature(bar))
3364 self.assertEqual(
3369 self.assertTrue(inspect.signature(foo) == inspect.signature(bar))
3370 self.assertFalse(inspect.signature(foo) != inspect.signature(bar))
3371 self.assertEqual(
3376 self.assertTrue(inspect.signature(foo) == inspect.signature(bar))
3377 self.assertFalse(inspect.signature(foo) != inspect.signature(bar))
3378 self.assertEqual(
3383 self.assertFalse(inspect.signature(foo) == inspect.signature(bar))
3384 self.assertTrue(inspect.signature(foo) != inspect.signature(bar))
3385 self.assertNotEqual(
3390 self.assertTrue(inspect.signature(foo) == inspect.signature(bar))
3391 self.assertFalse(inspect.signature(foo) != inspect.signature(bar))
3392 self.assertEqual(
3395 def test_signature_hashable(self):
3404 self.assertEqual(hash(foo_sig), hash(manual_sig))
3405 self.assertNotEqual(hash(foo_sig),
3409 self.assertNotEqual(hash(foo_sig), hash(inspect.signature(bar)))
3412 with self.assertRaisesRegex(TypeError, 'unhashable type'):
3416 with self.assertRaisesRegex(TypeError, 'unhashable type'):
3419 def test_signature_str(self):
3422 self.assertEqual(str(inspect.signature(foo)),
3427 self.assertEqual(str(inspect.signature(foo)),
3432 self.assertEqual(str(inspect.signature(foo)), '()')
3436 self.assertEqual(str(inspect.signature(foo)),
3442 self.assertEqual(str(inspect.signature(foo)),
3445 def test_signature_str_positional_only(self):
3452 self.assertEqual(str(inspect.signature(test)),
3455 self.assertEqual(str(S(parameters=[P('foo', P.POSITIONAL_ONLY)])),
3458 self.assertEqual(str(S(parameters=[
3463 self.assertEqual(str(S(parameters=[
3468 def test_signature_replace_anno(self):
3474 self.assertIs(sig.return_annotation, None)
3476 self.assertIs(sig.return_annotation, sig.empty)
3478 self.assertEqual(sig.return_annotation, 42)
3479 self.assertEqual(sig, inspect.signature(test))
3481 def test_signature_replaced(self):
3487 self.assertEqual(sig, inspect.signature(test))
3489 def test_signature_on_mangled_parameters(self):
3491 def foo(self, __p1:1=2, *, __p2:2=3):
3496 self.assertEqual(self.signature(Spam.foo),
3497 ((('self', ..., ..., "positional_or_keyword"),
3502 self.assertEqual(self.signature(Spam.foo),
3503 self.signature(Ham.foo))
3505 def test_signature_from_callable_python_obj(self):
3509 self.assertIsInstance(foo_sig, MySignature)
3511 def test_signature_from_callable_class(self):
3516 self.assertIsInstance(foo_sig, MySignature)
3520 def test_signature_from_callable_builtin_obj(self):
3523 self.assertIsInstance(sig, MySignature)
3525 def test_signature_definition_order_preserved_on_kwonly(self):
3530 self.assertTrue(l)
3531 self.assertEqual(l, sorted_l)
3534 self.assertEqual(l, unsorted_keyword_only_parameters)
3536 def test_signater_parameters_is_ordered(self):
3539 self.assertNotEqual(p1, p2)
3541 def test_signature_annotations_with_local_namespaces(self):
3547 with self.subTest(signature_func = signature_func):
3549 self.assertEqual(sig1.return_annotation, int)
3550 self.assertEqual(sig1.parameters['foo'].annotation, Foo)
3553 self.assertEqual(sig2.return_annotation, int)
3554 self.assertEqual(sig2.parameters['foo'].annotation, Foo)
3557 self.assertEqual(sig3.return_annotation, int)
3558 self.assertEqual(sig3.parameters['foo'].annotation, Foo)
3559 self.assertEqual(sig3.parameters['bar'].annotation, 'Bar')
3561 def test_signature_eval_str(self):
3567 with self.subTest(signature_func = signature_func):
3568 self.assertEqual(
3575 self.assertEqual(
3583 self.assertEqual(
3592 self.assertEqual(
3601 self.assertEqual(signature_func(isa.UnannotatedClass), sig())
3602 self.assertEqual(signature_func(isa.unannotated_function),
3610 self.assertEqual(
3617 self.assertEqual(
3625 self.assertEqual(
3634 self.assertEqual(
3645 with self.assertRaises(NameError):
3648 self.assertEqual(
3657 self.assertEqual(
3666 def test_signature_none_annotation(self):
3672 def __init__(self, func):
3673 self.__name__ = func.__name__
3674 self.__code__ = func.__code__
3675 self.__annotations__ = func.__annotations__
3676 self.__defaults__ = func.__defaults__
3677 self.__kwdefaults__ = func.__kwdefaults__
3678 self.func = func
3680 def __call__(self, *args, **kwargs):
3681 return self.func(*args, **kwargs)
3687 with self.subTest(signature_func = signature_func):
3688 self.assertEqual(signature_func(foo), inspect.Signature())
3689 self.assertEqual(inspect.get_annotations(foo), {})
3691 def test_signature_on_derived_classes(self):
3695 def __new__(self, *args, **kwargs):
3696 return super().__new__(self)
3697 def __init__(self, value):
3698 self.value = value
3701 def __init__(self, value):
3707 self.assertEqual(inspect.signature(D2), inspect.signature(D1))
3711 def test_signature_parameter_kinds(self):
3713 self.assertTrue(P.POSITIONAL_ONLY < P.POSITIONAL_OR_KEYWORD < \
3716 self.assertEqual(str(P.POSITIONAL_ONLY), 'POSITIONAL_ONLY')
3717 self.assertTrue('POSITIONAL_ONLY' in repr(P.POSITIONAL_ONLY))
3719 def test_signature_parameter_object(self):
3722 self.assertEqual(p.name, 'foo')
3723 self.assertEqual(p.default, 10)
3724 self.assertIs(p.annotation, p.empty)
3725 self.assertEqual(p.kind, inspect.Parameter.POSITIONAL_ONLY)
3727 with self.assertRaisesRegex(ValueError, "value '123' is "
3731 with self.assertRaisesRegex(ValueError, 'not a valid parameter name'):
3734 with self.assertRaisesRegex(ValueError, 'not a valid parameter name'):
3737 with self.assertRaisesRegex(TypeError, 'name must be a str'):
3740 with self.assertRaisesRegex(ValueError,
3744 with self.assertRaisesRegex(ValueError,
3748 with self.assertRaisesRegex(ValueError, 'cannot have default values'):
3752 with self.assertRaisesRegex(ValueError, 'cannot have default values'):
3758 with self.assertRaisesRegex(ValueError, 'cannot have default values'):
3761 self.assertTrue(repr(p).startswith('<Parameter'))
3762 self.assertTrue('"a=42"' in repr(p))
3764 def test_signature_parameter_hashable(self):
3767 self.assertEqual(hash(foo), hash(P('foo', kind=P.POSITIONAL_ONLY)))
3768 self.assertNotEqual(hash(foo), hash(P('foo', kind=P.POSITIONAL_ONLY,
3770 self.assertNotEqual(hash(foo),
3773 def test_signature_parameter_equality(self):
3777 self.assertTrue(p == p)
3778 self.assertFalse(p != p)
3779 self.assertFalse(p == 42)
3780 self.assertTrue(p != 42)
3781 self.assertTrue(p == ALWAYS_EQ)
3782 self.assertFalse(p != ALWAYS_EQ)
3784 self.assertTrue(p == P('foo', default=42,
3786 self.assertFalse(p != P('foo', default=42,
3789 def test_signature_parameter_replace(self):
3793 self.assertIsNot(p, p.replace())
3794 self.assertEqual(p, p.replace())
3797 self.assertEqual(p2.annotation, 1)
3799 self.assertEqual(p, p2)
3802 self.assertEqual(p2.name, 'bar')
3803 self.assertNotEqual(p2, p)
3805 with self.assertRaisesRegex(ValueError,
3810 self.assertIs(p2.default, None)
3811 self.assertNotEqual(p2, p)
3814 self.assertIs(p2.default, p2.empty)
3818 self.assertEqual(p2.kind, p2.POSITIONAL_OR_KEYWORD)
3819 self.assertNotEqual(p2, p)
3821 with self.assertRaisesRegex(ValueError,
3827 self.assertEqual(p2, p)
3829 def test_signature_parameter_positional_only(self):
3830 with self.assertRaisesRegex(TypeError, 'name must be a str'):
3834 def test_signature_parameter_implicit(self):
3835 with self.assertRaisesRegex(ValueError,
3843 self.assertEqual(param.kind, inspect.Parameter.POSITIONAL_ONLY)
3844 self.assertEqual(param.name, 'implicit0')
3846 def test_signature_parameter_immutability(self):
3849 with self.assertRaises(AttributeError):
3852 with self.assertRaises(AttributeError):
3863 def test_signature_bind_empty(self):
3867 self.assertEqual(self.call(test), 42)
3868 with self.assertRaisesRegex(TypeError, 'too many positional arguments'):
3869 self.call(test, 1)
3870 with self.assertRaisesRegex(TypeError, 'too many positional arguments'):
3871 self.call(test, 1, spam=10)
3872 with self.assertRaisesRegex(
3875 self.call(test, spam=1)
3877 def test_signature_bind_var(self):
3881 self.assertEqual(self.call(test), ((), {}))
3882 self.assertEqual(self.call(test, 1), ((1,), {}))
3883 self.assertEqual(self.call(test, 1, 2), ((1, 2), {}))
3884 self.assertEqual(self.call(test, foo='bar'), ((), {'foo': 'bar'}))
3885 self.assertEqual(self.call(test, 1, foo='bar'), ((1,), {'foo': 'bar'}))
3886 self.assertEqual(self.call(test, args=10), ((), {'args': 10}))
3887 self.assertEqual(self.call(test, 1, 2, foo='bar'),
3890 def test_signature_bind_just_args(self):
3894 self.assertEqual(self.call(test, 1, 2, 3), (1, 2, 3))
3896 with self.assertRaisesRegex(TypeError, 'too many positional arguments'):
3897 self.call(test, 1, 2, 3, 4)
3899 with self.assertRaisesRegex(TypeError,
3901 self.call(test, 1)
3903 with self.assertRaisesRegex(TypeError,
3905 self.call(test)
3909 self.assertEqual(self.call(test, 1, 2, 3), (1, 2, 3))
3910 self.assertEqual(self.call(test, 1, 2), (1, 2, 10))
3914 self.assertEqual(self.call(test, a=10, c=13), (10, 2, 13))
3915 self.assertEqual(self.call(test, a=10), (10, 2, 3))
3916 self.assertEqual(self.call(test, b=10), (1, 10, 3))
3918 def test_signature_bind_varargs_order(self):
3922 self.assertEqual(self.call(test), ())
3923 self.assertEqual(self.call(test, 1, 2, 3), (1, 2, 3))
3925 def test_signature_bind_args_and_varargs(self):
3929 self.assertEqual(self.call(test, 1, 2, 3, 4, 5), (1, 2, 3, (4, 5)))
3930 self.assertEqual(self.call(test, 1, 2), (1, 2, 3, ()))
3931 self.assertEqual(self.call(test, b=1, a=2), (2, 1, 3, ()))
3932 self.assertEqual(self.call(test, 1, b=2), (1, 2, 3, ()))
3934 with self.assertRaisesRegex(TypeError,
3936 self.call(test, 1, 2, 3, c=4)
3938 def test_signature_bind_just_kwargs(self):
3942 self.assertEqual(self.call(test), {})
3943 self.assertEqual(self.call(test, foo='bar', spam='ham'),
3946 def test_signature_bind_args_and_kwargs(self):
3950 self.assertEqual(self.call(test, 1, 2), (1, 2, 3, {}))
3951 self.assertEqual(self.call(test, 1, 2, foo='bar', spam='ham'),
3953 self.assertEqual(self.call(test, b=2, a=1, foo='bar', spam='ham'),
3955 self.assertEqual(self.call(test, a=1, b=2, foo='bar', spam='ham'),
3957 self.assertEqual(self.call(test, 1, b=2, foo='bar', spam='ham'),
3959 self.assertEqual(self.call(test, 1, b=2, c=4, foo='bar', spam='ham'),
3961 self.assertEqual(self.call(test, 1, 2, 4, foo='bar'),
3963 self.assertEqual(self.call(test, c=5, a=4, b=3),
3966 def test_signature_bind_kwonly(self):
3969 with self.assertRaisesRegex(TypeError,
3971 self.call(test, 1)
3972 self.assertEqual(self.call(test, foo=1), 1)
3976 with self.assertRaisesRegex(TypeError,
3978 self.call(test, 1)
3982 self.assertEqual(self.call(test, 1, bar=2), (1, 2))
3983 self.assertEqual(self.call(test, bar=2, foo=1), (1, 2))
3985 with self.assertRaisesRegex(
3988 self.call(test, bar=2, foo=1, spam=10)
3990 with self.assertRaisesRegex(TypeError,
3992 self.call(test, 1, 2)
3994 with self.assertRaisesRegex(TypeError,
3996 self.call(test, 1, 2, bar=2)
3998 with self.assertRaisesRegex(
4001 self.call(test, 1, bar=2, spam='ham')
4003 with self.assertRaisesRegex(TypeError,
4005 self.call(test, 1)
4009 self.assertEqual(self.call(test, 1, bar=2), (1, 2, {}))
4010 self.assertEqual(self.call(test, foo=1, bar=2), (1, 2, {}))
4011 self.assertEqual(self.call(test, 1, bar=2, spam='ham'),
4013 self.assertEqual(self.call(test, spam='ham', foo=1, bar=2),
4015 with self.assertRaisesRegex(TypeError,
4017 self.call(test, spam='ham', bar=2)
4018 self.assertEqual(self.call(test, 1, bar=2, bin=1, spam=10),
4021 def test_signature_bind_arguments(self):
4028 self.assertEqual(tuple(ba.arguments.items()),
4031 self.assertEqual(ba.kwargs,
4033 self.assertEqual(ba.args, (10, 20))
4035 def test_signature_bind_positional_only(self):
4039 self.assertEqual(self.call(test, 1, 2, 4, 5, bar=6),
4042 self.assertEqual(self.call(test, 1, 2),
4045 self.assertEqual(self.call(test, 1, 2, foo=4, bar=5),
4048 with self.assertRaisesRegex(TypeError, "but was passed as a keyword"):
4049 self.call(test, 1, 2, foo=4, bar=5, c_po=10)
4051 with self.assertRaisesRegex(TypeError, "parameter is positional only"):
4052 self.call(test, 1, 2, c_po=4)
4054 with self.assertRaisesRegex(TypeError, "parameter is positional only"):
4055 self.call(test, a_po=1, b_po=2)
4057 def test_signature_bind_with_self_arg(self):
4058 # Issue #17071: one of the parameters is named "self
4059 def test(a, self, b):
4063 self.assertEqual(ba.args, (1, 2, 3))
4064 ba = sig.bind(1, self=2, b=3)
4065 self.assertEqual(ba.args, (1, 2, 3))
4067 def test_signature_bind_vararg_name(self):
4072 with self.assertRaisesRegex(
4079 self.assertEqual(self.call(test, args=1), ((), {'args': 1}))
4083 self.assertEqual(ba.arguments, {'kwargs': {'args': 1}})
4086 def test_signature_bind_implicit_arg(self):
4094 self.assertEqual(self.call(setcomp_func, iterator), {0, 1, 4, 9, 16})
4096 def test_signature_bind_posonly_kwargs(self):
4103 self.assertEqual(result.kwargs, {"bar": "keyword"})
4104 self.assertIn(("bar", "pos-only"), result.arguments.items())
4108 def test_signature_bound_arguments_unhashable(self):
4112 with self.assertRaisesRegex(TypeError, 'unhashable type'):
4115 def test_signature_bound_arguments_equality(self):
4118 self.assertTrue(ba == ba)
4119 self.assertFalse(ba != ba)
4120 self.assertTrue(ba == ALWAYS_EQ)
4121 self.assertFalse(ba != ALWAYS_EQ)
4124 self.assertTrue(ba == ba2)
4125 self.assertFalse(ba != ba2)
4128 self.assertFalse(ba == ba3)
4129 self.assertTrue(ba != ba3)
4131 self.assertTrue(ba == ba3)
4132 self.assertFalse(ba != ba3)
4136 self.assertFalse(ba == ba4)
4137 self.assertTrue(ba != ba4)
4143 self.assertTrue(ba1 == ba2)
4144 self.assertFalse(ba1 != ba2)
4146 def test_signature_bound_arguments_pickle(self):
4152 with self.subTest(pickle_ver=ver):
4154 self.assertEqual(ba, ba_pickled)
4156 def test_signature_bound_arguments_repr(self):
4160 self.assertRegex(repr(ba), r'<BoundArguments \(a=20,.*\}\}\)>')
4162 def test_signature_bound_arguments_apply_defaults(self):
4168 self.assertEqual(
4176 self.assertEqual(
4186 self.assertEqual(
4195 self.assertEqual(list(ba.arguments.items()), [])
4202 self.assertEqual(list(ba.arguments.items()), [('a', 'spam')])
4204 def test_signature_bound_arguments_arguments_type(self):
4207 self.assertIs(type(ba.arguments), dict)
4210 def _strip_non_python_syntax(self, input,
4216 self.assertEqual(computed_clean_signature, clean_signature)
4217 self.assertEqual(computed_self_parameter, self_parameter)
4218 self.assertEqual(computed_last_positional_only, last_positional_only)
4220 def test_signature_strip_non_python_syntax(self):
4221 self._strip_non_python_syntax(
4229 self._strip_non_python_syntax(
4235 self._strip_non_python_syntax(
4241 self._strip_non_python_syntax(
4247 self._strip_non_python_syntax(
4253 self._strip_non_python_syntax(
4259 self._strip_non_python_syntax(
4272 def test_builtins_have_signatures(self):
4314 with self.subTest(builtin=name):
4315 self.assertIsNotNone(inspect.signature(obj))
4321 with self.subTest(builtin=name):
4322 self.assertIsNone(obj.__text_signature__)
4324 def test_python_function_override_signature(self):
4327 func.__text_signature__ = '($self, a, b=1, *args, c, d=2, **kwargs)'
4329 self.assertIsNotNone(sig)
4330 self.assertEqual(str(sig), '(self, /, a, b=1, *args, c, d=2, **kwargs)')
4332 func.__text_signature__ = '($self, a, b=1, /, *args, c, d=2, **kwargs)'
4334 self.assertEqual(str(sig), '(self, a, b=1, /, *args, c, d=2, **kwargs)')
4336 func.__text_signature__ = '(self, a=1+2, b=4-3, c=1 | 3 | 16)'
4338 self.assertEqual(str(sig), '(self, a=3, b=1, c=19)')
4340 func.__text_signature__ = '(self, a=1,\nb=2,\n\n\n c=3)'
4342 self.assertEqual(str(sig), '(self, a=1, b=2, c=3)')
4344 func.__text_signature__ = '(self, x=does_not_exist)'
4345 with self.assertRaises(ValueError):
4347 func.__text_signature__ = '(self, x=sys, y=inspect)'
4348 with self.assertRaises(ValueError):
4350 func.__text_signature__ = '(self, 123)'
4351 with self.assertRaises(ValueError):
4354 def test_base_class_have_text_signature(self):
4361 self.assertEqual(text_signature, '(raw, buffer_size=DEFAULT_BUFFER_SIZE)')
4363 self.assertEqual(str(sig), '(raw, buffer_size=8192)')
4367 def __init__(self, n):
4368 self.n = n
4369 self._next = None
4372 def __wrapped__(self):
4373 if self.n <= 0:
4375 if self._next is None:
4376 self._next = NTimesUnwrappable(self.n - 1)
4377 return self._next
4381 def test_unwrap_one(self):
4385 self.assertIs(inspect.unwrap(wrapper), func)
4387 def test_unwrap_several(self):
4395 self.assertIsNot(wrapper.__wrapped__, func)
4396 self.assertIs(inspect.unwrap(wrapper), func)
4398 def test_stop(self):
4410 self.assertIs(unwrapped, func2)
4412 def test_cycle(self):
4415 with self.assertRaisesRegex(ValueError, 'wrapper loop'):
4421 with self.assertRaisesRegex(ValueError, 'wrapper loop'):
4423 with self.assertRaisesRegex(ValueError, 'wrapper loop'):
4426 def test_unhashable(self):
4432 self.assertIsNone(inspect.unwrap(C()))
4434 def test_recursion_limit(self):
4436 with self.assertRaisesRegex(ValueError, 'wrapper loop'):
4440 def test_only_source(self):
4446 self.assertEqual(lines[:-1], inspect.getsource(module).splitlines())
4447 self.assertEqual(err, b'')
4449 def test_custom_getattr(self):
4453 with self.assertRaises(TypeError):
4458 def test_qualname_source(self):
4463 self.assertEqual(lines[:-1],
4465 self.assertEqual(err, b'')
4467 def test_builtins(self):
4471 self.assertEqual(lines, ["Can't get info for builtin modules."])
4473 def test_details(self):
4480 self.assertIn(module.__name__, output)
4481 self.assertIn(module.__file__, output)
4482 self.assertIn(module.__cached__, output)
4483 self.assertEqual(err, b'')
4498 def assertInspectEqual(self, path, source):
4501 self.assertEqual(
4506 def test_getsource_reload(self):
4508 with _ready_to_import('reload_bug', self.src_before) as (name, path):
4510 self.assertInspectEqual(path, module)
4512 src.write(self.src_after)
4513 self.assertInspectEqual(path, module)