From 732532b0af9d1b5c7ae4932526c8d20d86c15507 Mon Sep 17 00:00:00 2001 From: Nikita Sobolev Date: Tue, 10 Oct 2023 23:15:11 +0300 Subject: gh-108303: Move all inspect test files to `test_inspect/` (#109607) --- Lib/test/inspect_fodder.py | 120 - Lib/test/inspect_fodder2.py | 312 -- Lib/test/inspect_stock_annotations.py | 28 - Lib/test/inspect_stringized_annotations.py | 34 - Lib/test/inspect_stringized_annotations_2.py | 3 - Lib/test/libregrtest/findtests.py | 1 + Lib/test/test_import/__init__.py | 1 - Lib/test/test_inspect.py | 4964 ------------------- Lib/test/test_inspect/__init__.py | 6 + Lib/test/test_inspect/inspect_fodder.py | 120 + Lib/test/test_inspect/inspect_fodder2.py | 312 ++ Lib/test/test_inspect/inspect_stock_annotations.py | 28 + .../test_inspect/inspect_stringized_annotations.py | 34 + .../inspect_stringized_annotations_2.py | 3 + Lib/test/test_inspect/test_inspect.py | 4965 ++++++++++++++++++++ Lib/test/test_tokenize.py | 2 +- Makefile.pre.in | 1 + 17 files changed, 5471 insertions(+), 5463 deletions(-) delete mode 100644 Lib/test/inspect_fodder.py delete mode 100644 Lib/test/inspect_fodder2.py delete mode 100644 Lib/test/inspect_stock_annotations.py delete mode 100644 Lib/test/inspect_stringized_annotations.py delete mode 100644 Lib/test/inspect_stringized_annotations_2.py delete mode 100644 Lib/test/test_inspect.py create mode 100644 Lib/test/test_inspect/__init__.py create mode 100644 Lib/test/test_inspect/inspect_fodder.py create mode 100644 Lib/test/test_inspect/inspect_fodder2.py create mode 100644 Lib/test/test_inspect/inspect_stock_annotations.py create mode 100644 Lib/test/test_inspect/inspect_stringized_annotations.py create mode 100644 Lib/test/test_inspect/inspect_stringized_annotations_2.py create mode 100644 Lib/test/test_inspect/test_inspect.py diff --git a/Lib/test/inspect_fodder.py b/Lib/test/inspect_fodder.py deleted file mode 100644 index 60ba7aa..0000000 --- a/Lib/test/inspect_fodder.py +++ /dev/null @@ -1,120 +0,0 @@ -# line 1 -'A module docstring.' - -import inspect -# line 5 - -# line 7 -def spam(a, /, b, c, d=3, e=4, f=5, *g, **h): - eggs(b + d, c + f) - -# line 11 -def eggs(x, y): - "A docstring." - global fr, st - fr = inspect.currentframe() - st = inspect.stack() - p = x - q = y / 0 - -# line 20 -class StupidGit: - """A longer, - - indented - - docstring.""" -# line 27 - - def abuse(self, a, b, c): - """Another - -\tdocstring - - containing - -\ttabs -\t - """ - self.argue(a, b, c) -# line 40 - def argue(self, a, b, c): - try: - spam(a, b, c) - except BaseException as e: - self.ex = e - self.tr = inspect.trace() - - @property - def contradiction(self): - 'The automatic gainsaying.' - pass - -# line 53 -class MalodorousPervert(StupidGit): - def abuse(self, a, b, c): - pass - - @property - def contradiction(self): - pass - -Tit = MalodorousPervert - -class ParrotDroppings: - pass - -class FesteringGob(MalodorousPervert, ParrotDroppings): - def abuse(self, a, b, c): - pass - - @property - def contradiction(self): - pass - -async def lobbest(grenade): - pass - -currentframe = inspect.currentframe() -try: - raise Exception() -except BaseException as e: - tb = e.__traceback__ - -class Callable: - def __call__(self, *args): - return args - - def as_method_of(self, obj): - from types import MethodType - return MethodType(self, obj) - -custom_method = Callable().as_method_of(42) -del Callable - -# line 95 -class WhichComments: - # line 97 - # before f - def f(self): - # line 100 - # start f - return 1 - # line 103 - # end f - # line 105 - # after f - - # before asyncf - line 108 - async def asyncf(self): - # start asyncf - return 2 - # end asyncf - # after asyncf - line 113 - # end of WhichComments - line 114 - # after WhichComments - line 115 - -# Test that getsource works on a line that includes -# a closing parenthesis with the opening paren being in another line -( -); after_closing = lambda: 1 diff --git a/Lib/test/inspect_fodder2.py b/Lib/test/inspect_fodder2.py deleted file mode 100644 index 8639cf2..0000000 --- a/Lib/test/inspect_fodder2.py +++ /dev/null @@ -1,312 +0,0 @@ -# line 1 -def wrap(foo=None): - def wrapper(func): - return func - return wrapper - -# line 7 -def replace(func): - def insteadfunc(): - print('hello') - return insteadfunc - -# line 13 -@wrap() -@wrap(wrap) -def wrapped(): - pass - -# line 19 -@replace -def gone(): - pass - -# line 24 -oll = lambda m: m - -# line 27 -tll = lambda g: g and \ -g and \ -g - -# line 32 -tlli = lambda d: d and \ - d - -# line 36 -def onelinefunc(): pass - -# line 39 -def manyargs(arg1, arg2, -arg3, arg4): pass - -# line 43 -def twolinefunc(m): return m and \ -m - -# line 47 -a = [None, - lambda x: x, - None] - -# line 52 -def setfunc(func): - globals()["anonymous"] = func -setfunc(lambda x, y: x*y) - -# line 57 -def with_comment(): # hello - world - -# line 61 -multiline_sig = [ - lambda x, \ - y: x+y, - None, - ] - -# line 68 -def func69(): - class cls70: - def func71(): - pass - return cls70 -extra74 = 74 - -# line 76 -def func77(): pass -(extra78, stuff78) = 'xy' -extra79 = 'stop' - -# line 81 -class cls82: - def func83(): pass -(extra84, stuff84) = 'xy' -extra85 = 'stop' - -# line 87 -def func88(): - # comment - return 90 - -# line 92 -def f(): - class X: - def g(): - "doc" - return 42 - return X -method_in_dynamic_class = f().g - -#line 101 -def keyworded(*arg1, arg2=1): - pass - -#line 105 -def annotated(arg1: list): - pass - -#line 109 -def keyword_only_arg(*, arg): - pass - -@wrap(lambda: None) -def func114(): - return 115 - -class ClassWithMethod: - def method(self): - pass - -from functools import wraps - -def decorator(func): - @wraps(func) - def fake(): - return 42 - return fake - -#line 129 -@decorator -def real(): - return 20 - -#line 134 -class cls135: - def func136(): - def func137(): - never_reached1 - never_reached2 - -# line 141 -class cls142: - a = """ -class cls149: - ... -""" - -# line 148 -class cls149: - - def func151(self): - pass - -''' -class cls160: - pass -''' - -# line 159 -class cls160: - - def func162(self): - pass - -# line 165 -class cls166: - a = ''' - class cls175: - ... - ''' - -# line 172 -class cls173: - - class cls175: - pass - -# line 178 -class cls179: - pass - -# line 182 -class cls183: - - class cls185: - - def func186(self): - pass - -def class_decorator(cls): - return cls - -# line 193 -@class_decorator -@class_decorator -class cls196: - - @class_decorator - @class_decorator - class cls200: - pass - -class cls203: - class cls204: - class cls205: - pass - class cls207: - class cls205: - pass - -# line 211 -def func212(): - class cls213: - pass - return cls213 - -# line 217 -class cls213: - def func219(self): - class cls220: - pass - return cls220 - -# line 224 -async def func225(): - class cls226: - pass - return cls226 - -# line 230 -class cls226: - async def func232(self): - class cls233: - pass - return cls233 - -if True: - class cls238: - class cls239: - '''if clause cls239''' -else: - class cls238: - class cls239: - '''else clause 239''' - pass - -#line 247 -def positional_only_arg(a, /): - pass - -#line 251 -def all_markers(a, b, /, c, d, *, e, f): - pass - -# line 255 -def all_markers_with_args_and_kwargs(a, b, /, c, d, *args, e, f, **kwargs): - pass - -#line 259 -def all_markers_with_defaults(a, b=1, /, c=2, d=3, *, e=4, f=5): - pass - -# line 263 -def deco_factory(**kwargs): - def deco(f): - @wraps(f) - def wrapper(*a, **kwd): - kwd.update(kwargs) - return f(*a, **kwd) - return wrapper - return deco - -@deco_factory(foo=(1 + 2), bar=lambda: 1) -def complex_decorated(foo=0, bar=lambda: 0): - return foo + bar() - -# line 276 -parenthesized_lambda = ( - lambda: ()) -parenthesized_lambda2 = [ - lambda: ()][0] -parenthesized_lambda3 = {0: - lambda: ()}[0] - -# line 285 -post_line_parenthesized_lambda1 = (lambda: () -) - -# line 289 -nested_lambda = ( - lambda right: [].map( - lambda length: ())) - -# line 294 -if True: - class cls296: - def f(): - pass -else: - class cls296: - def g(): - pass - -# line 304 -if False: - class cls310: - def f(): - pass -else: - class cls310: - def g(): - pass diff --git a/Lib/test/inspect_stock_annotations.py b/Lib/test/inspect_stock_annotations.py deleted file mode 100644 index d115a25..0000000 --- a/Lib/test/inspect_stock_annotations.py +++ /dev/null @@ -1,28 +0,0 @@ -a:int=3 -b:str="foo" - -class MyClass: - a:int=4 - b:str="bar" - def __init__(self, a, b): - self.a = a - self.b = b - def __eq__(self, other): - return isinstance(other, MyClass) and self.a == other.a and self.b == other.b - -def function(a:int, b:str) -> MyClass: - return MyClass(a, b) - - -def function2(a:int, b:"str", c:MyClass) -> MyClass: - pass - - -def function3(a:"int", b:"str", c:"MyClass"): - pass - - -class UnannotatedClass: - pass - -def unannotated_function(a, b, c): pass diff --git a/Lib/test/inspect_stringized_annotations.py b/Lib/test/inspect_stringized_annotations.py deleted file mode 100644 index a56fb05..0000000 --- a/Lib/test/inspect_stringized_annotations.py +++ /dev/null @@ -1,34 +0,0 @@ -from __future__ import annotations - -a:int=3 -b:str="foo" - -class MyClass: - a:int=4 - b:str="bar" - def __init__(self, a, b): - self.a = a - self.b = b - def __eq__(self, other): - return isinstance(other, MyClass) and self.a == other.a and self.b == other.b - -def function(a:int, b:str) -> MyClass: - return MyClass(a, b) - - -def function2(a:int, b:"str", c:MyClass) -> MyClass: - pass - - -def function3(a:"int", b:"str", c:"MyClass"): - pass - - -class UnannotatedClass: - pass - -def unannotated_function(a, b, c): pass - -class MyClassWithLocalAnnotations: - mytype = int - x: mytype diff --git a/Lib/test/inspect_stringized_annotations_2.py b/Lib/test/inspect_stringized_annotations_2.py deleted file mode 100644 index 87206d5..0000000 --- a/Lib/test/inspect_stringized_annotations_2.py +++ /dev/null @@ -1,3 +0,0 @@ -from __future__ import annotations - -def foo(a, b, c): pass diff --git a/Lib/test/libregrtest/findtests.py b/Lib/test/libregrtest/findtests.py index 96cc3e0..caf2872 100644 --- a/Lib/test/libregrtest/findtests.py +++ b/Lib/test/libregrtest/findtests.py @@ -20,6 +20,7 @@ SPLITTESTDIRS: set[TestName] = { "test_concurrent_futures", "test_future_stmt", "test_gdb", + "test_inspect", "test_multiprocessing_fork", "test_multiprocessing_forkserver", "test_multiprocessing_spawn", diff --git a/Lib/test/test_import/__init__.py b/Lib/test/test_import/__init__.py index 48553f9..aa465c7 100644 --- a/Lib/test/test_import/__init__.py +++ b/Lib/test/test_import/__init__.py @@ -1,5 +1,4 @@ import builtins -import contextlib import errno import glob import json diff --git a/Lib/test/test_inspect.py b/Lib/test/test_inspect.py deleted file mode 100644 index f9bd632..0000000 --- a/Lib/test/test_inspect.py +++ /dev/null @@ -1,4964 +0,0 @@ -import asyncio -import builtins -import collections -import copy -import datetime -import functools -import importlib -import inspect -import io -import linecache -import os -import dis -from os.path import normcase -import _pickle -import pickle -import shutil -import stat -import sys -import time -import types -import tempfile -import textwrap -import unicodedata -import unittest -import unittest.mock -import warnings - - -try: - from concurrent.futures import ThreadPoolExecutor -except ImportError: - ThreadPoolExecutor = None - -from test.support import cpython_only -from test.support import MISSING_C_DOCSTRINGS, ALWAYS_EQ -from test.support.import_helper import DirsOnSysPath, ready_to_import -from test.support.os_helper import TESTFN -from test.support.script_helper import assert_python_ok, assert_python_failure -from test import inspect_fodder as mod -from test import inspect_fodder2 as mod2 -from test import support -from test import inspect_stock_annotations -from test import inspect_stringized_annotations -from test import inspect_stringized_annotations_2 - - -# Functions tested in this suite: -# ismodule, isclass, ismethod, isfunction, istraceback, isframe, iscode, -# isbuiltin, isroutine, isgenerator, isgeneratorfunction, getmembers, -# getdoc, getfile, getmodule, getsourcefile, getcomments, getsource, -# getclasstree, getargvalues, formatargvalues, -# currentframe, stack, trace, isdatadescriptor, -# ismethodwrapper - -# NOTE: There are some additional tests relating to interaction with -# zipimport in the test_zipimport_support test module. - -modfile = mod.__file__ -if modfile.endswith(('c', 'o')): - modfile = modfile[:-1] - -# Normalize file names: on Windows, the case of file names of compiled -# modules depends on the path used to start the python executable. -modfile = normcase(modfile) - -def revise(filename, *args): - return (normcase(filename),) + args - -git = mod.StupidGit() - - -def tearDownModule(): - if support.has_socket_support: - asyncio.set_event_loop_policy(None) - - -def signatures_with_lexicographic_keyword_only_parameters(): - """ - Yields a whole bunch of functions with only keyword-only parameters, - where those parameters are always in lexicographically sorted order. - """ - 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) - yield symbols['foo'] - - -def unsorted_keyword_only_parameters_fn(*, throw, out, the, baby, with_, - the_, bathwater): - pass - -unsorted_keyword_only_parameters = 'throw out the baby with_ the_ bathwater'.split() - -class IsTestBase(unittest.TestCase): - 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): - support.check__all__(self, inspect, not_exported=("modulesbyfile",)) - -def generator_function_example(self): - for i in range(2): - yield i - -async def async_generator_function_example(self): - async for i in range(2): - yield i - -async def coroutine_function_example(self): - return 'spam' - -@types.coroutine -def gen_coroutine_function_example(self): - yield - return 'spam' - -def meth_noargs(): pass -def meth_o(object, /): pass -def meth_self_noargs(self, /): pass -def meth_self_o(self, object, /): pass -def meth_type_noargs(type, /): pass -def meth_type_o(type, object, /): pass - - -class TestPredicates(IsTestBase): - - 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)) - - async def _fn3(): - pass - - @inspect.markcoroutinefunction - def fn3(): - return _fn3() - - self.assertTrue(inspect.iscoroutinefunction(fn3)) - self.assertTrue( - inspect.iscoroutinefunction( - inspect.markcoroutinefunction(lambda: _fn3()) - ) - ) - - class Cl: - async def __call__(self): - pass - - self.assertFalse(inspect.iscoroutinefunction(Cl)) - # instances with async def __call__ are NOT recognised. - self.assertFalse(inspect.iscoroutinefunction(Cl())) - # unless explicitly marked. - self.assertTrue(inspect.iscoroutinefunction( - inspect.markcoroutinefunction(Cl()) - )) - - class Cl2: - @inspect.markcoroutinefunction - def __call__(self): - pass - - self.assertFalse(inspect.iscoroutinefunction(Cl2)) - # instances with marked __call__ are NOT recognised. - self.assertFalse(inspect.iscoroutinefunction(Cl2())) - # unless explicitly marked. - self.assertTrue(inspect.iscoroutinefunction( - inspect.markcoroutinefunction(Cl2()) - )) - - class Cl3: - @inspect.markcoroutinefunction - @classmethod - def do_something_classy(cls): - pass - - @inspect.markcoroutinefunction - @staticmethod - def do_something_static(): - pass - - self.assertTrue(inspect.iscoroutinefunction(Cl3.do_something_classy)) - self.assertTrue(inspect.iscoroutinefunction(Cl3.do_something_static)) - - 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 - self.assertEqual(isabstract_checks, [True, True, False]) - - -class TestInterpreterStack(IsTestBase): - 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.__traceback__') - 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), - '(a=7, b=8, c=9, d=3, e=4, f=5, *g=(), **h={})') - -class GetSourceBase(unittest.TestCase): - # 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), - self.sourcerange(top, bottom)) - -class SlotUser: - 'Docstrings for __slots__' - __slots__ = {'power': 'measured in kilowatts', - 'distance': 'measured in kilometers'} - -class TestRetrievingSourceCode(GetSourceBase): - 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, [('after_closing', mod.after_closing), - ('eggs', mod.eggs), - ('lobbest', mod.lobbest), - ('spam', mod.spam)]) - - @unittest.skipIf(sys.flags.optimize >= 2, - "Docstrings are omitted with -O2 and above") - 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, - "Docstrings are omitted with -O2 and above") - 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__) - - cleandoc_testdata = [ - # first line should have different margin - (' An\n indented\n docstring.', 'An\nindented\n docstring.'), - # trailing whitespace are not removed. - (' An \n \n indented \n docstring. ', - 'An \n \nindented \n docstring. '), - # NUL is not termination. - ('doc\0string\n\n second\0line\n third\0line\0', - 'doc\0string\n\nsecond\0line\nthird\0line\0'), - # first line is lstrip()-ped. other lines are kept when no margin.[w: - (' ', ''), - # compiler.cleandoc() doesn't strip leading/trailing newlines - # to keep maximum backward compatibility. - # inspect.cleandoc() removes them. - ('\n\n\n first paragraph\n\n second paragraph\n\n', - '\n\n\nfirst paragraph\n\n second paragraph\n\n'), - (' \n \n \n ', '\n \n \n '), - ] - - def test_cleandoc(self): - func = inspect.cleandoc - for i, (input, expected) in enumerate(self.cleandoc_testdata): - # only inspect.cleandoc() strip \n - expected = expected.strip('\n') - with self.subTest(i=i): - self.assertEqual(func(input), expected) - - @cpython_only - def test_c_cleandoc(self): - import _testinternalcapi - func = _testinternalcapi.compiler_cleandoc - for i, (input, expected) in enumerate(self.cleandoc_testdata): - with self.subTest(i=i): - self.assertEqual(func(input), expected) - - 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) - self.assertSourceEqual(mod.after_closing, 120, 120) - - 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('') - 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 = '', '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): - self.assertSourceEqual(mod.eggs.__code__, 12, 18) - -class TestGetsourceInteractive(unittest.TestCase): - def test_getclasses_interactive(self): - # bpo-44648: simulate a REPL session; - # there is no `__file__` in the __main__ module - code = "import sys, inspect; \ - assert not hasattr(sys.modules['__main__'], '__file__'); \ - A = type('A', (), {}); \ - inspect.getsource(A)" - _, _, stderr = assert_python_failure("-c", code, __isolated=True) - self.assertIn(b'OSError: source code not available', stderr) - -class TestGettingSourceOfToplevelFrames(GetSourceBase): - fodderModule = mod - - def test_range_toplevel_frame(self): - self.maxDiff = None - self.assertSourceEqual(mod.currentframe, 1, None) - - def test_range_traceback_toplevel_frame(self): - self.assertSourceEqual(mod.tb, 1, None) - -class TestDecorators(GetSourceBase): - 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): - self.assertSourceEqual(mod2.func114, 113, 115) - -class TestOneliners(GetSourceBase): - 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_parenthesized_multiline_lambda(self): - # Test inspect.getsource with a parenthesized multi-line lambda - # function. - self.assertSourceEqual(mod2.parenthesized_lambda, 279, 279) - self.assertSourceEqual(mod2.parenthesized_lambda2, 281, 281) - self.assertSourceEqual(mod2.parenthesized_lambda3, 283, 283) - - def test_post_line_parenthesized_lambda(self): - # Test inspect.getsource with a parenthesized multi-line lambda - # function. - self.assertSourceEqual(mod2.post_line_parenthesized_lambda1, 286, 287) - - def test_nested_lambda(self): - # Test inspect.getsource with a nested lambda function. - self.assertSourceEqual(mod2.nested_lambda, 291, 292) - - 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. - self.assertSourceEqual(mod2.anonymous, 55, 55) - -class TestBlockComments(GetSourceBase): - 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): - self.assertSourceEqual(mod.WhichComments.asyncf, 109, 112) - -class TestBuggyCases(GetSourceBase): - 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 - unicodedata.__file__.endswith('.py'), - "unicodedata is not an external binary module") - 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 ['', '']: - 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.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) - - def test_class_with_method_from_other_module(self): - with tempfile.TemporaryDirectory() as tempdir: - with open(os.path.join(tempdir, 'inspect_actual%spy' % os.extsep), - 'w', encoding='utf-8') as f: - f.write(textwrap.dedent(""" - import inspect_other - class A: - def f(self): - pass - class A: - def f(self): - pass # correct one - A.f = inspect_other.A.f - """)) - - with open(os.path.join(tempdir, 'inspect_other%spy' % os.extsep), - 'w', encoding='utf-8') as f: - f.write(textwrap.dedent(""" - class A: - def f(self): - pass - """)) - - with DirsOnSysPath(tempdir): - import inspect_actual - self.assertIn("correct", inspect.getsource(inspect_actual.A)) - # Remove the module from sys.modules to force it to be reloaded. - # This is necessary when the test is run multiple times. - sys.modules.pop("inspect_actual") - - @unittest.skipIf( - support.is_emscripten or support.is_wasi, - "socket.accept is broken" - ) - 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) - self.assertSourceEqual(asyncio.run(mod2.cls226().func232()), 233, 234) - - def test_class_definition_same_name_diff_methods(self): - self.assertSourceEqual(mod2.cls296, 296, 298) - self.assertSourceEqual(mod2.cls310, 310, 312) - -class TestNoEOL(GetSourceBase): - 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): - self.assertSourceEqual(self.fodderModule.X, 1, 2) - - -class TestComplexDecorator(GetSourceBase): - fodderModule = mod2 - - def test_parens_in_decorator(self): - self.assertSourceEqual(self.fodderModule.complex_decorated, 273, 275) - -class _BrokenDataDescriptor(object): - """ - A broken data descriptor. See bug #1785. - """ - def __get__(*args): - raise AttributeError("broken data descriptor") - - def __set__(*args): - raise RuntimeError - - def __getattr__(*args): - raise AttributeError("broken data descriptor") - - -class _BrokenMethodDescriptor(object): - """ - A broken method descriptor. See bug #1785. - """ - def __get__(*args): - raise AttributeError("broken method descriptor") - - def __getattr__(*args): - raise AttributeError("broken method descriptor") - - -# Helper for testing classify_class_attrs. -def attrs_wo_objs(cls): - return [t[:3] for t in inspect.classify_class_attrs(cls)] - - -class TestClassesAndFunctions(unittest.TestCase): - 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, - "Signature information for builtins requires docstrings") - def test_getfullargspec_builtin_methods(self): - self.assertFullArgSpecEquals(_pickle.Pickler.dump, ['self', 'obj']) - - self.assertFullArgSpecEquals(_pickle.Pickler(io.BytesIO()).dump, ['self', 'obj']) - - self.assertFullArgSpecEquals( - os.stat, - args_e=['path'], - kwonlyargs_e=['dir_fd', 'follow_symlinks'], - kwonlydefaults_e={'dir_fd': None, 'follow_symlinks': True}) - - @cpython_only - @unittest.skipIf(MISSING_C_DOCSTRINGS, - "Signature information for builtins requires docstrings") - def test_getfullargspec_builtin_func(self): - import _testcapi - builtin = _testcapi.docstring_with_signature_with_defaults - spec = inspect.getfullargspec(builtin) - self.assertEqual(spec.defaults[0], 'avocado') - - @cpython_only - @unittest.skipIf(MISSING_C_DOCSTRINGS, - "Signature information for builtins requires docstrings") - def test_getfullargspec_builtin_func_no_signature(self): - import _testcapi - builtin = _testcapi.docstring_no_signature - with self.assertRaises(TypeError): - inspect.getfullargspec(builtin) - - cls = _testcapi.DocStringNoSignatureTest - obj = _testcapi.DocStringNoSignatureTest() - tests = [ - (_testcapi.docstring_no_signature_noargs, meth_noargs), - (_testcapi.docstring_no_signature_o, meth_o), - (cls.meth_noargs, meth_self_noargs), - (cls.meth_o, meth_self_o), - (obj.meth_noargs, meth_self_noargs), - (obj.meth_o, meth_self_o), - (cls.meth_noargs_class, meth_type_noargs), - (cls.meth_o_class, meth_type_o), - (cls.meth_noargs_static, meth_noargs), - (cls.meth_o_static, meth_o), - (cls.meth_noargs_coexist, meth_self_noargs), - (cls.meth_o_coexist, meth_self_o), - - (time.time, meth_noargs), - (str.lower, meth_self_noargs), - (''.lower, meth_self_noargs), - (set.add, meth_self_o), - (set().add, meth_self_o), - (set.__contains__, meth_self_o), - (set().__contains__, meth_self_o), - (datetime.datetime.__dict__['utcnow'], meth_type_noargs), - (datetime.datetime.utcnow, meth_type_noargs), - (dict.__dict__['__class_getitem__'], meth_type_o), - (dict.__class_getitem__, meth_type_o), - ] - try: - import _stat - except ImportError: - # if the _stat extension is not available, stat.S_IMODE() is - # implemented in Python, not in C - pass - else: - tests.append((stat.S_IMODE, meth_o)) - for builtin, template in tests: - with self.subTest(builtin): - self.assertEqual(inspect.getfullargspec(builtin), - inspect.getfullargspec(template)) - - def test_getfullargspec_definition_order_preserved_on_kwonly(self): - for fn in signatures_with_lexicographic_keyword_only_parameters(): - signature = inspect.getfullargspec(fn) - l = list(signature.kwonlyargs) - sorted_l = sorted(l) - self.assertTrue(l) - self.assertEqual(l, sorted_l) - signature = inspect.getfullargspec(unsorted_keyword_only_parameters_fn) - l = list(signature.kwonlyargs) - self.assertEqual(l, unsorted_keyword_only_parameters) - - def test_classify_newstyle(self): - class A(object): - - def s(): pass - s = staticmethod(s) - - def c(cls): pass - c = classmethod(c) - - def getp(self): pass - p = property(getp) - - def m(self): pass - - def m1(self): pass - - datablob = '1' - - dd = _BrokenDataDescriptor() - md = _BrokenMethodDescriptor() - - attrs = attrs_wo_objs(A) - - self.assertIn(('__new__', 'static method', object), attrs, - 'missing __new__') - self.assertIn(('__init__', 'method', object), attrs, 'missing __init__') - - self.assertIn(('s', 'static method', A), attrs, 'missing static method') - self.assertIn(('c', 'class method', A), attrs, 'missing class method') - self.assertIn(('p', 'property', A), attrs, 'missing property') - self.assertIn(('m', 'method', A), attrs, - 'missing plain method: %r' % attrs) - self.assertIn(('m1', 'method', A), attrs, 'missing plain method') - self.assertIn(('datablob', 'data', A), attrs, 'missing data') - self.assertIn(('md', 'method', A), attrs, 'missing method descriptor') - self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor') - - class B(A): - - def m(self): pass - - attrs = attrs_wo_objs(B) - self.assertIn(('s', 'static method', A), attrs, 'missing static method') - self.assertIn(('c', 'class method', A), attrs, 'missing class method') - self.assertIn(('p', 'property', A), attrs, 'missing property') - self.assertIn(('m', 'method', B), attrs, 'missing plain method') - self.assertIn(('m1', 'method', A), attrs, 'missing plain method') - self.assertIn(('datablob', 'data', A), attrs, 'missing data') - self.assertIn(('md', 'method', A), attrs, 'missing method descriptor') - self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor') - - - class C(A): - - def m(self): pass - def c(self): pass - - attrs = attrs_wo_objs(C) - self.assertIn(('s', 'static method', A), attrs, 'missing static method') - self.assertIn(('c', 'method', C), attrs, 'missing plain method') - self.assertIn(('p', 'property', A), attrs, 'missing property') - self.assertIn(('m', 'method', C), attrs, 'missing plain method') - self.assertIn(('m1', 'method', A), attrs, 'missing plain method') - self.assertIn(('datablob', 'data', A), attrs, 'missing data') - self.assertIn(('md', 'method', A), attrs, 'missing method descriptor') - self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor') - - class D(B, C): - - def m1(self): pass - - attrs = attrs_wo_objs(D) - self.assertIn(('s', 'static method', A), attrs, 'missing static method') - self.assertIn(('c', 'method', C), attrs, 'missing plain method') - self.assertIn(('p', 'property', A), attrs, 'missing property') - self.assertIn(('m', 'method', B), attrs, 'missing plain method') - self.assertIn(('m1', 'method', D), attrs, 'missing plain method') - self.assertIn(('datablob', 'data', A), attrs, 'missing data') - self.assertIn(('md', 'method', A), attrs, 'missing method descriptor') - self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor') - - def test_classify_builtin_types(self): - # Simple sanity check that all built-in types can have their - # attributes classified. - for name in dir(__builtins__): - builtin = getattr(__builtins__, name) - if isinstance(builtin, type): - inspect.classify_class_attrs(builtin) - - attrs = attrs_wo_objs(bool) - self.assertIn(('__new__', 'static method', bool), attrs, - 'missing __new__') - self.assertIn(('from_bytes', 'class method', int), attrs, - 'missing class method') - self.assertIn(('to_bytes', 'method', int), attrs, - 'missing plain method') - self.assertIn(('__add__', 'method', int), attrs, - 'missing plain method') - self.assertIn(('__and__', 'method', bool), attrs, - 'missing plain method') - - def test_classify_DynamicClassAttribute(self): - class Meta(type): - def __getattr__(self, name): - if name == 'ham': - return 'spam' - return super().__getattr__(name) - class VA(metaclass=Meta): - @types.DynamicClassAttribute - def ham(self): - return 'eggs' - should_find_dca = inspect.Attribute('ham', 'data', VA, VA.__dict__['ham']) - self.assertIn(should_find_dca, inspect.classify_class_attrs(VA)) - should_find_ga = inspect.Attribute('ham', 'data', Meta, 'spam') - self.assertIn(should_find_ga, inspect.classify_class_attrs(VA)) - - def test_classify_overrides_bool(self): - class NoBool(object): - def __eq__(self, other): - return NoBool() - - def __bool__(self): - raise NotImplementedError( - "This object does not specify a boolean value") - - class HasNB(object): - dd = NoBool() - - should_find_attr = inspect.Attribute('dd', 'data', HasNB, HasNB.dd) - self.assertIn(should_find_attr, inspect.classify_class_attrs(HasNB)) - - def test_classify_metaclass_class_attribute(self): - class Meta(type): - fish = 'slap' - def __dir__(self): - return ['__class__', '__module__', '__name__', 'fish'] - class Class(metaclass=Meta): - pass - should_find = inspect.Attribute('fish', 'data', Meta, 'slap') - self.assertIn(should_find, inspect.classify_class_attrs(Class)) - - def test_classify_VirtualAttribute(self): - class Meta(type): - def __dir__(cls): - return ['__class__', '__module__', '__name__', 'BOOM'] - def __getattr__(self, name): - if name =='BOOM': - return 42 - return super().__getattr(name) - class Class(metaclass=Meta): - pass - should_find = inspect.Attribute('BOOM', 'data', Meta, 42) - self.assertIn(should_find, inspect.classify_class_attrs(Class)) - - def test_classify_VirtualAttribute_multi_classes(self): - class Meta1(type): - def __dir__(cls): - return ['__class__', '__module__', '__name__', 'one'] - def __getattr__(self, name): - if name =='one': - return 1 - return super().__getattr__(name) - class Meta2(type): - def __dir__(cls): - return ['__class__', '__module__', '__name__', 'two'] - def __getattr__(self, name): - if name =='two': - return 2 - return super().__getattr__(name) - class Meta3(Meta1, Meta2): - def __dir__(cls): - return list(sorted(set(['__class__', '__module__', '__name__', 'three'] + - Meta1.__dir__(cls) + Meta2.__dir__(cls)))) - def __getattr__(self, name): - if name =='three': - return 3 - return super().__getattr__(name) - class Class1(metaclass=Meta1): - pass - class Class2(Class1, metaclass=Meta3): - pass - - should_find1 = inspect.Attribute('one', 'data', Meta1, 1) - should_find2 = inspect.Attribute('two', 'data', Meta2, 2) - should_find3 = inspect.Attribute('three', 'data', Meta3, 3) - cca = inspect.classify_class_attrs(Class2) - for sf in (should_find1, should_find2, should_find3): - self.assertIn(sf, cca) - - def test_classify_class_attrs_with_buggy_dir(self): - class M(type): - def __dir__(cls): - return ['__class__', '__name__', 'missing'] - class C(metaclass=M): - pass - attrs = [a[0] for a in inspect.classify_class_attrs(C)] - self.assertNotIn('missing', attrs) - - def test_getmembers_descriptors(self): - class A(object): - dd = _BrokenDataDescriptor() - md = _BrokenMethodDescriptor() - - def pred_wrapper(pred): - # A quick'n'dirty way to discard standard attributes of new-style - # classes. - class Empty(object): - pass - def wrapped(x): - if '__name__' in dir(x) and hasattr(Empty, x.__name__): - return False - return pred(x) - return wrapped - - ismethoddescriptor = pred_wrapper(inspect.ismethoddescriptor) - isdatadescriptor = pred_wrapper(inspect.isdatadescriptor) - - self.assertEqual(inspect.getmembers(A, ismethoddescriptor), - [('md', A.__dict__['md'])]) - self.assertEqual(inspect.getmembers(A, isdatadescriptor), - [('dd', A.__dict__['dd'])]) - - class B(A): - pass - - self.assertEqual(inspect.getmembers(B, ismethoddescriptor), - [('md', A.__dict__['md'])]) - self.assertEqual(inspect.getmembers(B, isdatadescriptor), - [('dd', A.__dict__['dd'])]) - - def test_getmembers_method(self): - class B: - def f(self): - pass - - self.assertIn(('f', B.f), inspect.getmembers(B)) - self.assertNotIn(('f', B.f), inspect.getmembers(B, inspect.ismethod)) - b = B() - self.assertIn(('f', b.f), inspect.getmembers(b)) - self.assertIn(('f', b.f), inspect.getmembers(b, inspect.ismethod)) - - def test_getmembers_VirtualAttribute(self): - class M(type): - def __getattr__(cls, name): - if name == 'eggs': - return 'scrambled' - return super().__getattr__(name) - class A(metaclass=M): - @types.DynamicClassAttribute - def eggs(self): - return 'spam' - class B: - def __getattr__(self, attribute): - return None - self.assertIn(('eggs', 'scrambled'), inspect.getmembers(A)) - self.assertIn(('eggs', 'spam'), inspect.getmembers(A())) - b = B() - self.assertIn(('__getattr__', b.__getattr__), inspect.getmembers(b)) - - def test_getmembers_static(self): - class A: - @property - def name(self): - raise NotImplementedError - @types.DynamicClassAttribute - def eggs(self): - raise NotImplementedError - - a = A() - instance_members = inspect.getmembers_static(a) - class_members = inspect.getmembers_static(A) - self.assertIn(('name', inspect.getattr_static(a, 'name')), instance_members) - self.assertIn(('eggs', inspect.getattr_static(a, 'eggs')), instance_members) - self.assertIn(('name', inspect.getattr_static(A, 'name')), class_members) - self.assertIn(('eggs', inspect.getattr_static(A, 'eggs')), class_members) - - def test_getmembers_with_buggy_dir(self): - class M(type): - def __dir__(cls): - return ['__class__', '__name__', 'missing'] - class C(metaclass=M): - pass - attrs = [a[0] for a in inspect.getmembers(C)] - self.assertNotIn('missing', attrs) - - def test_get_annotations_with_stock_annotations(self): - def foo(a:int, b:str): pass - self.assertEqual(inspect.get_annotations(foo), {'a': int, 'b': str}) - - foo.__annotations__ = {'a': 'foo', 'b':'str'} - self.assertEqual(inspect.get_annotations(foo), {'a': 'foo', 'b': 'str'}) - - self.assertEqual(inspect.get_annotations(foo, eval_str=True, locals=locals()), {'a': foo, 'b': str}) - self.assertEqual(inspect.get_annotations(foo, eval_str=True, globals=locals()), {'a': foo, 'b': str}) - - isa = inspect_stock_annotations - self.assertEqual(inspect.get_annotations(isa), {'a': int, 'b': str}) - self.assertEqual(inspect.get_annotations(isa.MyClass), {'a': int, 'b': str}) - self.assertEqual(inspect.get_annotations(isa.function), {'a': int, 'b': str, 'return': isa.MyClass}) - self.assertEqual(inspect.get_annotations(isa.function2), {'a': int, 'b': 'str', 'c': isa.MyClass, 'return': isa.MyClass}) - self.assertEqual(inspect.get_annotations(isa.function3), {'a': 'int', 'b': 'str', 'c': 'MyClass'}) - self.assertEqual(inspect.get_annotations(inspect), {}) # inspect module has no annotations - self.assertEqual(inspect.get_annotations(isa.UnannotatedClass), {}) - self.assertEqual(inspect.get_annotations(isa.unannotated_function), {}) - - self.assertEqual(inspect.get_annotations(isa, eval_str=True), {'a': int, 'b': str}) - self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=True), {'a': int, 'b': str}) - self.assertEqual(inspect.get_annotations(isa.function, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass}) - self.assertEqual(inspect.get_annotations(isa.function2, eval_str=True), {'a': int, 'b': str, 'c': isa.MyClass, 'return': isa.MyClass}) - self.assertEqual(inspect.get_annotations(isa.function3, eval_str=True), {'a': int, 'b': str, 'c': isa.MyClass}) - self.assertEqual(inspect.get_annotations(inspect, eval_str=True), {}) - self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=True), {}) - self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=True), {}) - - self.assertEqual(inspect.get_annotations(isa, eval_str=False), {'a': int, 'b': str}) - self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=False), {'a': int, 'b': str}) - self.assertEqual(inspect.get_annotations(isa.function, eval_str=False), {'a': int, 'b': str, 'return': isa.MyClass}) - self.assertEqual(inspect.get_annotations(isa.function2, eval_str=False), {'a': int, 'b': 'str', 'c': isa.MyClass, 'return': isa.MyClass}) - self.assertEqual(inspect.get_annotations(isa.function3, eval_str=False), {'a': 'int', 'b': 'str', 'c': 'MyClass'}) - self.assertEqual(inspect.get_annotations(inspect, eval_str=False), {}) - self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=False), {}) - self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=False), {}) - - def times_three(fn): - @functools.wraps(fn) - def wrapper(a, b): - return fn(a*3, b*3) - return wrapper - - wrapped = times_three(isa.function) - self.assertEqual(wrapped(1, 'x'), isa.MyClass(3, 'xxx')) - self.assertIsNot(wrapped.__globals__, isa.function.__globals__) - self.assertEqual(inspect.get_annotations(wrapped), {'a': int, 'b': str, 'return': isa.MyClass}) - self.assertEqual(inspect.get_annotations(wrapped, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass}) - self.assertEqual(inspect.get_annotations(wrapped, eval_str=False), {'a': int, 'b': str, 'return': isa.MyClass}) - - def test_get_annotations_with_stringized_annotations(self): - isa = inspect_stringized_annotations - self.assertEqual(inspect.get_annotations(isa), {'a': 'int', 'b': 'str'}) - self.assertEqual(inspect.get_annotations(isa.MyClass), {'a': 'int', 'b': 'str'}) - self.assertEqual(inspect.get_annotations(isa.function), {'a': 'int', 'b': 'str', 'return': 'MyClass'}) - self.assertEqual(inspect.get_annotations(isa.function2), {'a': 'int', 'b': "'str'", 'c': 'MyClass', 'return': 'MyClass'}) - self.assertEqual(inspect.get_annotations(isa.function3), {'a': "'int'", 'b': "'str'", 'c': "'MyClass'"}) - self.assertEqual(inspect.get_annotations(isa.UnannotatedClass), {}) - self.assertEqual(inspect.get_annotations(isa.unannotated_function), {}) - - self.assertEqual(inspect.get_annotations(isa, eval_str=True), {'a': int, 'b': str}) - self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=True), {'a': int, 'b': str}) - self.assertEqual(inspect.get_annotations(isa.function, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass}) - self.assertEqual(inspect.get_annotations(isa.function2, eval_str=True), {'a': int, 'b': 'str', 'c': isa.MyClass, 'return': isa.MyClass}) - self.assertEqual(inspect.get_annotations(isa.function3, eval_str=True), {'a': 'int', 'b': 'str', 'c': 'MyClass'}) - self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=True), {}) - self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=True), {}) - - self.assertEqual(inspect.get_annotations(isa, eval_str=False), {'a': 'int', 'b': 'str'}) - self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=False), {'a': 'int', 'b': 'str'}) - self.assertEqual(inspect.get_annotations(isa.function, eval_str=False), {'a': 'int', 'b': 'str', 'return': 'MyClass'}) - self.assertEqual(inspect.get_annotations(isa.function2, eval_str=False), {'a': 'int', 'b': "'str'", 'c': 'MyClass', 'return': 'MyClass'}) - self.assertEqual(inspect.get_annotations(isa.function3, eval_str=False), {'a': "'int'", 'b': "'str'", 'c': "'MyClass'"}) - self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=False), {}) - self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=False), {}) - - isa2 = inspect_stringized_annotations_2 - self.assertEqual(inspect.get_annotations(isa2), {}) - self.assertEqual(inspect.get_annotations(isa2, eval_str=True), {}) - self.assertEqual(inspect.get_annotations(isa2, eval_str=False), {}) - - def times_three(fn): - @functools.wraps(fn) - def wrapper(a, b): - return fn(a*3, b*3) - return wrapper - - wrapped = times_three(isa.function) - self.assertEqual(wrapped(1, 'x'), isa.MyClass(3, 'xxx')) - self.assertIsNot(wrapped.__globals__, isa.function.__globals__) - self.assertEqual(inspect.get_annotations(wrapped), {'a': 'int', 'b': 'str', 'return': 'MyClass'}) - self.assertEqual(inspect.get_annotations(wrapped, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass}) - self.assertEqual(inspect.get_annotations(wrapped, eval_str=False), {'a': 'int', 'b': 'str', 'return': 'MyClass'}) - - # test that local namespace lookups work - self.assertEqual(inspect.get_annotations(isa.MyClassWithLocalAnnotations), {'x': 'mytype'}) - self.assertEqual(inspect.get_annotations(isa.MyClassWithLocalAnnotations, eval_str=True), {'x': int}) - - -class TestFormatAnnotation(unittest.TestCase): - def test_typing_replacement(self): - from test.typinganndata.ann_module9 import ann, ann1 - self.assertEqual(inspect.formatannotation(ann), 'Union[List[str], int]') - self.assertEqual(inspect.formatannotation(ann1), 'Union[List[testModule.typing.A], int]') - - -class TestIsDataDescriptor(unittest.TestCase): - - def test_custom_descriptors(self): - class NonDataDescriptor: - def __get__(self, value, type=None): pass - class DataDescriptor0: - def __set__(self, name, value): pass - class DataDescriptor1: - def __delete__(self, name): pass - class DataDescriptor2: - __set__ = None - self.assertFalse(inspect.isdatadescriptor(NonDataDescriptor()), - 'class with only __get__ not a data descriptor') - self.assertTrue(inspect.isdatadescriptor(DataDescriptor0()), - 'class with __set__ is a data descriptor') - self.assertTrue(inspect.isdatadescriptor(DataDescriptor1()), - 'class with __delete__ is a data descriptor') - self.assertTrue(inspect.isdatadescriptor(DataDescriptor2()), - 'class with __set__ = None is a data descriptor') - - def test_slot(self): - class Slotted: - __slots__ = 'foo', - self.assertTrue(inspect.isdatadescriptor(Slotted.foo), - 'a slot is a data descriptor') - - def test_property(self): - class Propertied: - @property - def a_property(self): - pass - self.assertTrue(inspect.isdatadescriptor(Propertied.a_property), - 'a property is a data descriptor') - - def test_functions(self): - class Test(object): - def instance_method(self): pass - @classmethod - def class_method(cls): pass - @staticmethod - def static_method(): pass - def function(): - pass - a_lambda = lambda: None - self.assertFalse(inspect.isdatadescriptor(Test().instance_method), - 'a instance method is not a data descriptor') - self.assertFalse(inspect.isdatadescriptor(Test().class_method), - 'a class method is not a data descriptor') - self.assertFalse(inspect.isdatadescriptor(Test().static_method), - 'a static method is not a data descriptor') - self.assertFalse(inspect.isdatadescriptor(function), - 'a function is not a data descriptor') - self.assertFalse(inspect.isdatadescriptor(a_lambda), - 'a lambda is not a data descriptor') - - -_global_ref = object() -class TestGetClosureVars(unittest.TestCase): - - def test_name_resolution(self): - # Basic test of the 4 different resolution mechanisms - def f(nonlocal_ref): - def g(local_ref): - print(local_ref, nonlocal_ref, _global_ref, unbound_ref) - return g - _arg = object() - nonlocal_vars = {"nonlocal_ref": _arg} - global_vars = {"_global_ref": _global_ref} - builtin_vars = {"print": print} - unbound_names = {"unbound_ref"} - expected = inspect.ClosureVars(nonlocal_vars, global_vars, - builtin_vars, unbound_names) - self.assertEqual(inspect.getclosurevars(f(_arg)), expected) - - def test_generator_closure(self): - def f(nonlocal_ref): - def g(local_ref): - print(local_ref, nonlocal_ref, _global_ref, unbound_ref) - yield - return g - _arg = object() - nonlocal_vars = {"nonlocal_ref": _arg} - global_vars = {"_global_ref": _global_ref} - builtin_vars = {"print": print} - unbound_names = {"unbound_ref"} - expected = inspect.ClosureVars(nonlocal_vars, global_vars, - builtin_vars, unbound_names) - self.assertEqual(inspect.getclosurevars(f(_arg)), expected) - - def test_method_closure(self): - class C: - def f(self, nonlocal_ref): - def g(local_ref): - print(local_ref, nonlocal_ref, _global_ref, unbound_ref) - return g - _arg = object() - nonlocal_vars = {"nonlocal_ref": _arg} - global_vars = {"_global_ref": _global_ref} - builtin_vars = {"print": print} - unbound_names = {"unbound_ref"} - expected = inspect.ClosureVars(nonlocal_vars, global_vars, - builtin_vars, unbound_names) - self.assertEqual(inspect.getclosurevars(C().f(_arg)), expected) - - def test_nonlocal_vars(self): - # More complex tests of nonlocal resolution - def _nonlocal_vars(f): - return inspect.getclosurevars(f).nonlocals - - def make_adder(x): - def add(y): - return x + y - return add - - def curry(func, arg1): - return lambda arg2: func(arg1, arg2) - - def less_than(a, b): - return a < b - - # The infamous Y combinator. - def Y(le): - def g(f): - return le(lambda x: f(f)(x)) - Y.g_ref = g - return g(g) - - def check_y_combinator(func): - self.assertEqual(_nonlocal_vars(func), {'f': Y.g_ref}) - - inc = make_adder(1) - add_two = make_adder(2) - greater_than_five = curry(less_than, 5) - - self.assertEqual(_nonlocal_vars(inc), {'x': 1}) - self.assertEqual(_nonlocal_vars(add_two), {'x': 2}) - self.assertEqual(_nonlocal_vars(greater_than_five), - {'arg1': 5, 'func': less_than}) - self.assertEqual(_nonlocal_vars((lambda x: lambda y: x + y)(3)), - {'x': 3}) - Y(check_y_combinator) - - def test_getclosurevars_empty(self): - def foo(): pass - _empty = inspect.ClosureVars({}, {}, {}, set()) - self.assertEqual(inspect.getclosurevars(lambda: True), _empty) - self.assertEqual(inspect.getclosurevars(foo), _empty) - - def test_getclosurevars_error(self): - class T: pass - self.assertRaises(TypeError, inspect.getclosurevars, 1) - self.assertRaises(TypeError, inspect.getclosurevars, list) - self.assertRaises(TypeError, inspect.getclosurevars, {}) - - def _private_globals(self): - code = """def f(): print(path)""" - ns = {} - exec(code, ns) - return ns["f"], ns - - def test_builtins_fallback(self): - f, ns = self._private_globals() - ns.pop("__builtins__", None) - expected = inspect.ClosureVars({}, {}, {"print":print}, {"path"}) - self.assertEqual(inspect.getclosurevars(f), expected) - - def test_builtins_as_dict(self): - f, ns = self._private_globals() - ns["__builtins__"] = {"path":1} - expected = inspect.ClosureVars({}, {}, {"path":1}, {"print"}) - self.assertEqual(inspect.getclosurevars(f), expected) - - def test_builtins_as_module(self): - f, ns = self._private_globals() - ns["__builtins__"] = os - expected = inspect.ClosureVars({}, {}, {"path":os.path}, {"print"}) - self.assertEqual(inspect.getclosurevars(f), expected) - - -class TestGetcallargsFunctions(unittest.TestCase): - - def assertEqualCallArgs(self, func, call_params_string, locs=None): - locs = dict(locs or {}, func=func) - r1 = eval('func(%s)' % call_params_string, None, locs) - r2 = eval('inspect.getcallargs(func, %s)' % call_params_string, None, - locs) - self.assertEqual(r1, r2) - - def assertEqualException(self, func, call_param_string, locs=None): - locs = dict(locs or {}, func=func) - try: - eval('func(%s)' % call_param_string, None, locs) - except Exception as e: - ex1 = e - else: - self.fail('Exception not raised') - try: - eval('inspect.getcallargs(func, %s)' % call_param_string, None, - locs) - except Exception as e: - ex2 = e - else: - self.fail('Exception not raised') - self.assertIs(type(ex1), type(ex2)) - self.assertEqual(str(ex1), str(ex2)) - del ex1, ex2 - - def makeCallable(self, signature): - """Create a function that returns its locals()""" - code = "lambda %s: locals()" - return eval(code % signature) - - def test_plain(self): - f = self.makeCallable('a, b=1') - self.assertEqualCallArgs(f, '2') - self.assertEqualCallArgs(f, '2, 3') - self.assertEqualCallArgs(f, 'a=2') - self.assertEqualCallArgs(f, 'b=3, a=2') - self.assertEqualCallArgs(f, '2, b=3') - # expand *iterable / **mapping - self.assertEqualCallArgs(f, '*(2,)') - self.assertEqualCallArgs(f, '*[2]') - self.assertEqualCallArgs(f, '*(2, 3)') - self.assertEqualCallArgs(f, '*[2, 3]') - self.assertEqualCallArgs(f, '**{"a":2}') - self.assertEqualCallArgs(f, 'b=3, **{"a":2}') - self.assertEqualCallArgs(f, '2, **{"b":3}') - self.assertEqualCallArgs(f, '**{"b":3, "a":2}') - # expand UserList / UserDict - self.assertEqualCallArgs(f, '*collections.UserList([2])') - self.assertEqualCallArgs(f, '*collections.UserList([2, 3])') - self.assertEqualCallArgs(f, '**collections.UserDict(a=2)') - self.assertEqualCallArgs(f, '2, **collections.UserDict(b=3)') - self.assertEqualCallArgs(f, 'b=2, **collections.UserDict(a=3)') - - def test_varargs(self): - f = self.makeCallable('a, b=1, *c') - self.assertEqualCallArgs(f, '2') - self.assertEqualCallArgs(f, '2, 3') - self.assertEqualCallArgs(f, '2, 3, 4') - self.assertEqualCallArgs(f, '*(2,3,4)') - self.assertEqualCallArgs(f, '2, *[3,4]') - self.assertEqualCallArgs(f, '2, 3, *collections.UserList([4])') - - def test_varkw(self): - f = self.makeCallable('a, b=1, **c') - self.assertEqualCallArgs(f, 'a=2') - self.assertEqualCallArgs(f, '2, b=3, c=4') - self.assertEqualCallArgs(f, 'b=3, a=2, c=4') - self.assertEqualCallArgs(f, 'c=4, **{"a":2, "b":3}') - self.assertEqualCallArgs(f, '2, c=4, **{"b":3}') - self.assertEqualCallArgs(f, 'b=2, **{"a":3, "c":4}') - self.assertEqualCallArgs(f, '**collections.UserDict(a=2, b=3, c=4)') - self.assertEqualCallArgs(f, '2, c=4, **collections.UserDict(b=3)') - self.assertEqualCallArgs(f, 'b=2, **collections.UserDict(a=3, c=4)') - - def test_varkw_only(self): - # issue11256: - f = self.makeCallable('**c') - self.assertEqualCallArgs(f, '') - self.assertEqualCallArgs(f, 'a=1') - self.assertEqualCallArgs(f, 'a=1, b=2') - self.assertEqualCallArgs(f, 'c=3, **{"a": 1, "b": 2}') - self.assertEqualCallArgs(f, '**collections.UserDict(a=1, b=2)') - self.assertEqualCallArgs(f, 'c=3, **collections.UserDict(a=1, b=2)') - - def test_keyword_only(self): - f = self.makeCallable('a=3, *, c, d=2') - self.assertEqualCallArgs(f, 'c=3') - self.assertEqualCallArgs(f, 'c=3, a=3') - self.assertEqualCallArgs(f, 'a=2, c=4') - self.assertEqualCallArgs(f, '4, c=4') - self.assertEqualException(f, '') - self.assertEqualException(f, '3') - self.assertEqualException(f, 'a=3') - self.assertEqualException(f, 'd=4') - - f = self.makeCallable('*, c, d=2') - self.assertEqualCallArgs(f, 'c=3') - self.assertEqualCallArgs(f, 'c=3, d=4') - self.assertEqualCallArgs(f, 'd=4, c=3') - - def test_multiple_features(self): - f = self.makeCallable('a, b=2, *f, **g') - self.assertEqualCallArgs(f, '2, 3, 7') - self.assertEqualCallArgs(f, '2, 3, x=8') - self.assertEqualCallArgs(f, '2, 3, x=8, *[(4,[5,6]), 7]') - self.assertEqualCallArgs(f, '2, x=8, *[3, (4,[5,6]), 7], y=9') - self.assertEqualCallArgs(f, 'x=8, *[2, 3, (4,[5,6])], y=9') - self.assertEqualCallArgs(f, 'x=8, *collections.UserList(' - '[2, 3, (4,[5,6])]), **{"y":9, "z":10}') - self.assertEqualCallArgs(f, '2, x=8, *collections.UserList([3, ' - '(4,[5,6])]), **collections.UserDict(' - 'y=9, z=10)') - - f = self.makeCallable('a, b=2, *f, x, y=99, **g') - self.assertEqualCallArgs(f, '2, 3, x=8') - self.assertEqualCallArgs(f, '2, 3, x=8, *[(4,[5,6]), 7]') - self.assertEqualCallArgs(f, '2, x=8, *[3, (4,[5,6]), 7], y=9, z=10') - self.assertEqualCallArgs(f, 'x=8, *[2, 3, (4,[5,6])], y=9, z=10') - self.assertEqualCallArgs(f, 'x=8, *collections.UserList(' - '[2, 3, (4,[5,6])]), q=0, **{"y":9, "z":10}') - self.assertEqualCallArgs(f, '2, x=8, *collections.UserList([3, ' - '(4,[5,6])]), q=0, **collections.UserDict(' - 'y=9, z=10)') - - def test_errors(self): - f0 = self.makeCallable('') - f1 = self.makeCallable('a, b') - f2 = self.makeCallable('a, b=1') - # f0 takes no arguments - self.assertEqualException(f0, '1') - self.assertEqualException(f0, 'x=1') - self.assertEqualException(f0, '1,x=1') - # f1 takes exactly 2 arguments - self.assertEqualException(f1, '') - self.assertEqualException(f1, '1') - self.assertEqualException(f1, 'a=2') - self.assertEqualException(f1, 'b=3') - # f2 takes at least 1 argument - self.assertEqualException(f2, '') - self.assertEqualException(f2, 'b=3') - for f in f1, f2: - # f1/f2 takes exactly/at most 2 arguments - self.assertEqualException(f, '2, 3, 4') - self.assertEqualException(f, '1, 2, 3, a=1') - self.assertEqualException(f, '2, 3, 4, c=5') - self.assertEqualException(f, '2, 3, 4, a=1, c=5') - # f got an unexpected keyword argument - self.assertEqualException(f, 'c=2') - self.assertEqualException(f, '2, c=3') - self.assertEqualException(f, '2, 3, c=4') - self.assertEqualException(f, '2, c=4, b=3') - self.assertEqualException(f, '**{u"\u03c0\u03b9": 4}') - # f got multiple values for keyword argument - self.assertEqualException(f, '1, a=2') - self.assertEqualException(f, '1, **{"a":2}') - self.assertEqualException(f, '1, 2, b=3') - self.assertEqualException(f, '1, c=3, a=2') - # issue11256: - f3 = self.makeCallable('**c') - self.assertEqualException(f3, '1, 2') - self.assertEqualException(f3, '1, 2, a=1, b=2') - f4 = self.makeCallable('*, a, b=0') - self.assertEqualException(f4, '1, 2') - self.assertEqualException(f4, '1, 2, a=1, b=2') - self.assertEqualException(f4, 'a=1, a=3') - self.assertEqualException(f4, 'a=1, c=3') - self.assertEqualException(f4, 'a=1, a=3, b=4') - self.assertEqualException(f4, 'a=1, b=2, a=3, b=4') - self.assertEqualException(f4, 'a=1, a=2, a=3, b=4') - - # issue #20816: getcallargs() fails to iterate over non-existent - # kwonlydefaults and raises a wrong TypeError - def f5(*, a): pass - with self.assertRaisesRegex(TypeError, - 'missing 1 required keyword-only'): - inspect.getcallargs(f5) - - - # issue20817: - def f6(a, b, c): - pass - with self.assertRaisesRegex(TypeError, "'a', 'b' and 'c'"): - inspect.getcallargs(f6) - - # bpo-33197 - with self.assertRaisesRegex(ValueError, - 'variadic keyword parameters cannot' - ' have default values'): - inspect.Parameter("foo", kind=inspect.Parameter.VAR_KEYWORD, - default=42) - with self.assertRaisesRegex(ValueError, - "value 5 is not a valid Parameter.kind"): - inspect.Parameter("bar", kind=5, default=42) - - with self.assertRaisesRegex(TypeError, - 'name must be a str, not a int'): - inspect.Parameter(123, kind=4) - -class TestGetcallargsMethods(TestGetcallargsFunctions): - - def setUp(self): - class Foo(object): - pass - self.cls = Foo - self.inst = Foo() - - def makeCallable(self, signature): - assert 'self' not in signature - mk = super(TestGetcallargsMethods, self).makeCallable - self.cls.method = mk('self, ' + signature) - return self.inst.method - -class TestGetcallargsUnboundMethods(TestGetcallargsMethods): - - def makeCallable(self, signature): - super(TestGetcallargsUnboundMethods, self).makeCallable(signature) - return self.cls.method - - def assertEqualCallArgs(self, func, call_params_string, locs=None): - return super(TestGetcallargsUnboundMethods, self).assertEqualCallArgs( - *self._getAssertEqualParams(func, call_params_string, locs)) - - def assertEqualException(self, func, call_params_string, locs=None): - return super(TestGetcallargsUnboundMethods, self).assertEqualException( - *self._getAssertEqualParams(func, call_params_string, locs)) - - def _getAssertEqualParams(self, func, call_params_string, locs=None): - assert 'inst' not in call_params_string - locs = dict(locs or {}, inst=self.inst) - return (func, 'inst,' + call_params_string, locs) - - -class TestGetattrStatic(unittest.TestCase): - - def test_basic(self): - class Thing(object): - x = object() - - thing = Thing() - self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x) - self.assertEqual(inspect.getattr_static(thing, 'x', None), Thing.x) - with self.assertRaises(AttributeError): - inspect.getattr_static(thing, 'y') - - self.assertEqual(inspect.getattr_static(thing, 'y', 3), 3) - - def test_inherited(self): - class Thing(object): - x = object() - class OtherThing(Thing): - pass - - something = OtherThing() - self.assertEqual(inspect.getattr_static(something, 'x'), Thing.x) - - def test_instance_attr(self): - class Thing(object): - x = 2 - def __init__(self, x): - self.x = x - thing = Thing(3) - self.assertEqual(inspect.getattr_static(thing, 'x'), 3) - del thing.x - self.assertEqual(inspect.getattr_static(thing, 'x'), 2) - - def test_property(self): - class Thing(object): - @property - def x(self): - raise AttributeError("I'm pretending not to exist") - thing = Thing() - self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x) - - def test_descriptor_raises_AttributeError(self): - class descriptor(object): - def __get__(*_): - raise AttributeError("I'm pretending not to exist") - desc = descriptor() - class Thing(object): - x = desc - thing = Thing() - self.assertEqual(inspect.getattr_static(thing, 'x'), desc) - - def test_classAttribute(self): - class Thing(object): - x = object() - - self.assertEqual(inspect.getattr_static(Thing, 'x'), Thing.x) - - def test_classVirtualAttribute(self): - class Thing(object): - @types.DynamicClassAttribute - def x(self): - return self._x - _x = object() - - self.assertEqual(inspect.getattr_static(Thing, 'x'), Thing.__dict__['x']) - - def test_inherited_classattribute(self): - class Thing(object): - x = object() - class OtherThing(Thing): - pass - - self.assertEqual(inspect.getattr_static(OtherThing, 'x'), Thing.x) - - def test_slots(self): - class Thing(object): - y = 'bar' - __slots__ = ['x'] - def __init__(self): - self.x = 'foo' - thing = Thing() - self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x) - self.assertEqual(inspect.getattr_static(thing, 'y'), 'bar') - - del thing.x - self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x) - - def test_metaclass(self): - class meta(type): - attr = 'foo' - class Thing(object, metaclass=meta): - pass - self.assertEqual(inspect.getattr_static(Thing, 'attr'), 'foo') - - class sub(meta): - pass - class OtherThing(object, metaclass=sub): - x = 3 - self.assertEqual(inspect.getattr_static(OtherThing, 'attr'), 'foo') - - class OtherOtherThing(OtherThing): - pass - # this test is odd, but it was added as it exposed a bug - self.assertEqual(inspect.getattr_static(OtherOtherThing, 'x'), 3) - - def test_no_dict_no_slots(self): - self.assertEqual(inspect.getattr_static(1, 'foo', None), None) - self.assertNotEqual(inspect.getattr_static('foo', 'lower'), None) - - def test_no_dict_no_slots_instance_member(self): - # returns descriptor - with open(__file__, encoding='utf-8') as handle: - self.assertEqual(inspect.getattr_static(handle, 'name'), type(handle).name) - - def test_inherited_slots(self): - # returns descriptor - class Thing(object): - __slots__ = ['x'] - def __init__(self): - self.x = 'foo' - - class OtherThing(Thing): - pass - # it would be nice if this worked... - # we get the descriptor instead of the instance attribute - self.assertEqual(inspect.getattr_static(OtherThing(), 'x'), Thing.x) - - def test_descriptor(self): - class descriptor(object): - def __get__(self, instance, owner): - return 3 - class Foo(object): - d = descriptor() - - foo = Foo() - - # for a non data descriptor we return the instance attribute - foo.__dict__['d'] = 1 - self.assertEqual(inspect.getattr_static(foo, 'd'), 1) - - # if the descriptor is a data-descriptor we should return the - # descriptor - descriptor.__set__ = lambda s, i, v: None - self.assertEqual(inspect.getattr_static(foo, 'd'), Foo.__dict__['d']) - - del descriptor.__set__ - descriptor.__delete__ = lambda s, i, o: None - self.assertEqual(inspect.getattr_static(foo, 'd'), Foo.__dict__['d']) - - def test_metaclass_with_descriptor(self): - class descriptor(object): - def __get__(self, instance, owner): - return 3 - class meta(type): - d = descriptor() - class Thing(object, metaclass=meta): - pass - self.assertEqual(inspect.getattr_static(Thing, 'd'), meta.__dict__['d']) - - - def test_class_as_property(self): - class Base(object): - foo = 3 - - class Something(Base): - executed = False - @property - def __class__(self): - self.executed = True - return object - - instance = Something() - self.assertEqual(inspect.getattr_static(instance, 'foo'), 3) - self.assertFalse(instance.executed) - self.assertEqual(inspect.getattr_static(Something, 'foo'), 3) - - def test_mro_as_property(self): - class Meta(type): - @property - def __mro__(self): - return (object,) - - class Base(object): - foo = 3 - - class Something(Base, metaclass=Meta): - pass - - self.assertEqual(inspect.getattr_static(Something(), 'foo'), 3) - self.assertEqual(inspect.getattr_static(Something, 'foo'), 3) - - def test_dict_as_property(self): - test = self - test.called = False - - class Foo(dict): - a = 3 - @property - def __dict__(self): - test.called = True - return {} - - foo = Foo() - foo.a = 4 - self.assertEqual(inspect.getattr_static(foo, 'a'), 3) - self.assertFalse(test.called) - - def test_mutated_mro(self): - test = self - test.called = False - - class Foo(dict): - a = 3 - @property - def __dict__(self): - test.called = True - return {} - - class Bar(dict): - a = 4 - - class Baz(Bar): pass - - baz = Baz() - self.assertEqual(inspect.getattr_static(baz, 'a'), 4) - Baz.__bases__ = (Foo,) - self.assertEqual(inspect.getattr_static(baz, 'a'), 3) - self.assertFalse(test.called) - - def test_custom_object_dict(self): - test = self - test.called = False - - class Custom(dict): - def get(self, key, default=None): - test.called = True - super().get(key, default) - - class Foo(object): - a = 3 - foo = Foo() - foo.__dict__ = Custom() - self.assertEqual(inspect.getattr_static(foo, 'a'), 3) - self.assertFalse(test.called) - - def test_metaclass_dict_as_property(self): - class Meta(type): - @property - def __dict__(self): - self.executed = True - - class Thing(metaclass=Meta): - executed = False - - def __init__(self): - self.spam = 42 - - instance = Thing() - self.assertEqual(inspect.getattr_static(instance, "spam"), 42) - self.assertFalse(Thing.executed) - - def test_module(self): - sentinel = object() - self.assertIsNot(inspect.getattr_static(sys, "version", sentinel), - sentinel) - - def test_metaclass_with_metaclass_with_dict_as_property(self): - class MetaMeta(type): - @property - def __dict__(self): - self.executed = True - return dict(spam=42) - - class Meta(type, metaclass=MetaMeta): - executed = False - - class Thing(metaclass=Meta): - pass - - with self.assertRaises(AttributeError): - inspect.getattr_static(Thing, "spam") - self.assertFalse(Thing.executed) - - def test_custom___getattr__(self): - test = self - test.called = False - - class Foo: - def __getattr__(self, attr): - test.called = True - return {} - - with self.assertRaises(AttributeError): - inspect.getattr_static(Foo(), 'whatever') - - self.assertFalse(test.called) - - def test_custom___getattribute__(self): - test = self - test.called = False - - class Foo: - def __getattribute__(self, attr): - test.called = True - return {} - - with self.assertRaises(AttributeError): - inspect.getattr_static(Foo(), 'really_could_be_anything') - - self.assertFalse(test.called) - - -class TestGetGeneratorState(unittest.TestCase): - - def setUp(self): - def number_generator(): - for number in range(5): - yield number - self.generator = number_generator() - - def _generatorstate(self): - return inspect.getgeneratorstate(self.generator) - - def test_created(self): - self.assertEqual(self._generatorstate(), inspect.GEN_CREATED) - - def test_suspended(self): - next(self.generator) - self.assertEqual(self._generatorstate(), inspect.GEN_SUSPENDED) - - def test_closed_after_exhaustion(self): - for i in self.generator: - pass - self.assertEqual(self._generatorstate(), inspect.GEN_CLOSED) - - def test_closed_after_immediate_exception(self): - with self.assertRaises(RuntimeError): - self.generator.throw(RuntimeError) - self.assertEqual(self._generatorstate(), inspect.GEN_CLOSED) - - def test_running(self): - # As mentioned on issue #10220, checking for the RUNNING state only - # makes sense inside the generator itself. - # The following generator checks for this by using the closure's - # reference to self and the generator state checking helper method - def running_check_generator(): - for number in range(5): - self.assertEqual(self._generatorstate(), inspect.GEN_RUNNING) - yield number - self.assertEqual(self._generatorstate(), inspect.GEN_RUNNING) - self.generator = running_check_generator() - # Running up to the first yield - next(self.generator) - # Running after the first yield - next(self.generator) - - def test_easy_debugging(self): - # repr() and str() of a generator state should contain the state name - names = 'GEN_CREATED GEN_RUNNING GEN_SUSPENDED GEN_CLOSED'.split() - for name in names: - state = getattr(inspect, name) - self.assertIn(name, repr(state)) - self.assertIn(name, str(state)) - - def test_getgeneratorlocals(self): - def each(lst, a=None): - b=(1, 2, 3) - for v in lst: - if v == 3: - c = 12 - yield v - - numbers = each([1, 2, 3]) - self.assertEqual(inspect.getgeneratorlocals(numbers), - {'a': None, 'lst': [1, 2, 3]}) - next(numbers) - self.assertEqual(inspect.getgeneratorlocals(numbers), - {'a': None, 'lst': [1, 2, 3], 'v': 1, - 'b': (1, 2, 3)}) - next(numbers) - self.assertEqual(inspect.getgeneratorlocals(numbers), - {'a': None, 'lst': [1, 2, 3], 'v': 2, - 'b': (1, 2, 3)}) - next(numbers) - self.assertEqual(inspect.getgeneratorlocals(numbers), - {'a': None, 'lst': [1, 2, 3], 'v': 3, - 'b': (1, 2, 3), 'c': 12}) - try: - next(numbers) - except StopIteration: - pass - self.assertEqual(inspect.getgeneratorlocals(numbers), {}) - - def test_getgeneratorlocals_empty(self): - def yield_one(): - yield 1 - one = yield_one() - self.assertEqual(inspect.getgeneratorlocals(one), {}) - try: - next(one) - except StopIteration: - pass - self.assertEqual(inspect.getgeneratorlocals(one), {}) - - def test_getgeneratorlocals_error(self): - self.assertRaises(TypeError, inspect.getgeneratorlocals, 1) - self.assertRaises(TypeError, inspect.getgeneratorlocals, lambda x: True) - self.assertRaises(TypeError, inspect.getgeneratorlocals, set) - self.assertRaises(TypeError, inspect.getgeneratorlocals, (2,3)) - - -class TestGetCoroutineState(unittest.TestCase): - - def setUp(self): - @types.coroutine - def number_coroutine(): - for number in range(5): - yield number - async def coroutine(): - await number_coroutine() - self.coroutine = coroutine() - - def tearDown(self): - self.coroutine.close() - - def _coroutinestate(self): - return inspect.getcoroutinestate(self.coroutine) - - def test_created(self): - self.assertEqual(self._coroutinestate(), inspect.CORO_CREATED) - - def test_suspended(self): - self.coroutine.send(None) - self.assertEqual(self._coroutinestate(), inspect.CORO_SUSPENDED) - - def test_closed_after_exhaustion(self): - while True: - try: - self.coroutine.send(None) - except StopIteration: - break - - self.assertEqual(self._coroutinestate(), inspect.CORO_CLOSED) - - def test_closed_after_immediate_exception(self): - with self.assertRaises(RuntimeError): - self.coroutine.throw(RuntimeError) - self.assertEqual(self._coroutinestate(), inspect.CORO_CLOSED) - - def test_easy_debugging(self): - # repr() and str() of a coroutine state should contain the state name - names = 'CORO_CREATED CORO_RUNNING CORO_SUSPENDED CORO_CLOSED'.split() - for name in names: - state = getattr(inspect, name) - self.assertIn(name, repr(state)) - self.assertIn(name, str(state)) - - def test_getcoroutinelocals(self): - @types.coroutine - def gencoro(): - yield - - gencoro = gencoro() - async def func(a=None): - b = 'spam' - await gencoro - - coro = func() - self.assertEqual(inspect.getcoroutinelocals(coro), - {'a': None, 'gencoro': gencoro}) - coro.send(None) - self.assertEqual(inspect.getcoroutinelocals(coro), - {'a': None, 'gencoro': gencoro, 'b': 'spam'}) - - -@support.requires_working_socket() -class TestGetAsyncGenState(unittest.IsolatedAsyncioTestCase): - - def setUp(self): - async def number_asyncgen(): - for number in range(5): - yield number - self.asyncgen = number_asyncgen() - - async def asyncTearDown(self): - await self.asyncgen.aclose() - - def _asyncgenstate(self): - return inspect.getasyncgenstate(self.asyncgen) - - def test_created(self): - self.assertEqual(self._asyncgenstate(), inspect.AGEN_CREATED) - - async def test_suspended(self): - value = await anext(self.asyncgen) - self.assertEqual(self._asyncgenstate(), inspect.AGEN_SUSPENDED) - self.assertEqual(value, 0) - - async def test_closed_after_exhaustion(self): - countdown = 7 - with self.assertRaises(StopAsyncIteration): - while countdown := countdown - 1: - await anext(self.asyncgen) - self.assertEqual(countdown, 1) - self.assertEqual(self._asyncgenstate(), inspect.AGEN_CLOSED) - - async def test_closed_after_immediate_exception(self): - with self.assertRaises(RuntimeError): - await self.asyncgen.athrow(RuntimeError) - self.assertEqual(self._asyncgenstate(), inspect.AGEN_CLOSED) - - async def test_running(self): - async def running_check_asyncgen(): - for number in range(5): - self.assertEqual(self._asyncgenstate(), inspect.AGEN_RUNNING) - yield number - self.assertEqual(self._asyncgenstate(), inspect.AGEN_RUNNING) - self.asyncgen = running_check_asyncgen() - # Running up to the first yield - await anext(self.asyncgen) - self.assertEqual(self._asyncgenstate(), inspect.AGEN_SUSPENDED) - # Running after the first yield - await anext(self.asyncgen) - self.assertEqual(self._asyncgenstate(), inspect.AGEN_SUSPENDED) - - def test_easy_debugging(self): - # repr() and str() of a asyncgen state should contain the state name - names = 'AGEN_CREATED AGEN_RUNNING AGEN_SUSPENDED AGEN_CLOSED'.split() - for name in names: - state = getattr(inspect, name) - self.assertIn(name, repr(state)) - self.assertIn(name, str(state)) - - async def test_getasyncgenlocals(self): - async def each(lst, a=None): - b=(1, 2, 3) - for v in lst: - if v == 3: - c = 12 - yield v - - numbers = each([1, 2, 3]) - self.assertEqual(inspect.getasyncgenlocals(numbers), - {'a': None, 'lst': [1, 2, 3]}) - await anext(numbers) - self.assertEqual(inspect.getasyncgenlocals(numbers), - {'a': None, 'lst': [1, 2, 3], 'v': 1, - 'b': (1, 2, 3)}) - await anext(numbers) - self.assertEqual(inspect.getasyncgenlocals(numbers), - {'a': None, 'lst': [1, 2, 3], 'v': 2, - 'b': (1, 2, 3)}) - await anext(numbers) - self.assertEqual(inspect.getasyncgenlocals(numbers), - {'a': None, 'lst': [1, 2, 3], 'v': 3, - 'b': (1, 2, 3), 'c': 12}) - with self.assertRaises(StopAsyncIteration): - await anext(numbers) - self.assertEqual(inspect.getasyncgenlocals(numbers), {}) - - async def test_getasyncgenlocals_empty(self): - async def yield_one(): - yield 1 - one = yield_one() - self.assertEqual(inspect.getasyncgenlocals(one), {}) - await anext(one) - self.assertEqual(inspect.getasyncgenlocals(one), {}) - with self.assertRaises(StopAsyncIteration): - await anext(one) - self.assertEqual(inspect.getasyncgenlocals(one), {}) - - def test_getasyncgenlocals_error(self): - self.assertRaises(TypeError, inspect.getasyncgenlocals, 1) - self.assertRaises(TypeError, inspect.getasyncgenlocals, lambda x: True) - self.assertRaises(TypeError, inspect.getasyncgenlocals, set) - self.assertRaises(TypeError, inspect.getasyncgenlocals, (2,3)) - - -class MySignature(inspect.Signature): - # Top-level to make it picklable; - # used in test_signature_object_pickle - pass - -class MyParameter(inspect.Parameter): - # Top-level to make it picklable; - # used in test_signature_object_pickle - pass - - - -class TestSignatureObject(unittest.TestCase): - @staticmethod - def signature(func, **kw): - sig = inspect.signature(func, **kw) - return (tuple((param.name, - (... if param.default is param.empty else param.default), - (... if param.annotation is param.empty - else param.annotation), - str(param.kind).lower()) - for param in sig.parameters.values()), - (... if sig.return_annotation is sig.empty - else sig.return_annotation)) - - def test_signature_object(self): - S = inspect.Signature - P = inspect.Parameter - - self.assertEqual(str(S()), '()') - self.assertEqual(repr(S().parameters), 'mappingproxy(OrderedDict())') - - def test(po, /, pk, pkd=100, *args, ko, kod=10, **kwargs): - pass - - sig = inspect.signature(test) - self.assertTrue(repr(sig).startswith(' {42:'ham'}: pass - foo_partial = functools.partial(foo, a=1) - - sig = inspect.signature(foo_partial) - - for ver in range(pickle.HIGHEST_PROTOCOL + 1): - with self.subTest(pickle_ver=ver, subclass=False): - sig_pickled = pickle.loads(pickle.dumps(sig, ver)) - self.assertEqual(sig, sig_pickled) - - # Test that basic sub-classing works - sig = inspect.signature(foo) - myparam = MyParameter(name='z', kind=inspect.Parameter.POSITIONAL_ONLY) - myparams = collections.OrderedDict(sig.parameters, a=myparam) - mysig = MySignature().replace(parameters=myparams.values(), - return_annotation=sig.return_annotation) - self.assertTrue(isinstance(mysig, MySignature)) - self.assertTrue(isinstance(mysig.parameters['z'], MyParameter)) - - for ver in range(pickle.HIGHEST_PROTOCOL + 1): - with self.subTest(pickle_ver=ver, subclass=True): - sig_pickled = pickle.loads(pickle.dumps(mysig, ver)) - self.assertEqual(mysig, sig_pickled) - self.assertTrue(isinstance(sig_pickled, MySignature)) - self.assertTrue(isinstance(sig_pickled.parameters['z'], - MyParameter)) - - def test_signature_immutability(self): - def test(a): - pass - sig = inspect.signature(test) - - with self.assertRaises(AttributeError): - sig.foo = 'bar' - - with self.assertRaises(TypeError): - sig.parameters['a'] = None - - def test_signature_on_noarg(self): - def test(): - pass - self.assertEqual(self.signature(test), ((), ...)) - - def test_signature_on_wargs(self): - def test(a, b:'foo') -> 123: - pass - self.assertEqual(self.signature(test), - ((('a', ..., ..., "positional_or_keyword"), - ('b', ..., 'foo', "positional_or_keyword")), - 123)) - - def test_signature_on_wkwonly(self): - def test(*, a:float, b:str) -> int: - pass - self.assertEqual(self.signature(test), - ((('a', ..., float, "keyword_only"), - ('b', ..., str, "keyword_only")), - int)) - - def test_signature_on_complex_args(self): - def test(a, b:'foo'=10, *args:'bar', spam:'baz', ham=123, **kwargs:int): - pass - self.assertEqual(self.signature(test), - ((('a', ..., ..., "positional_or_keyword"), - ('b', 10, 'foo', "positional_or_keyword"), - ('args', ..., 'bar', "var_positional"), - ('spam', ..., 'baz', "keyword_only"), - ('ham', 123, ..., "keyword_only"), - ('kwargs', ..., int, "var_keyword")), - ...)) - - def test_signature_without_self(self): - def test_args_only(*args): # NOQA - pass - - def test_args_kwargs_only(*args, **kwargs): # NOQA - pass - - class A: - @classmethod - def test_classmethod(*args): # NOQA - pass - - @staticmethod - def test_staticmethod(*args): # NOQA - pass - - f1 = functools.partialmethod((test_classmethod), 1) - f2 = functools.partialmethod((test_args_only), 1) - f3 = functools.partialmethod((test_staticmethod), 1) - f4 = functools.partialmethod((test_args_kwargs_only),1) - - self.assertEqual(self.signature(test_args_only), - ((('args', ..., ..., 'var_positional'),), ...)) - self.assertEqual(self.signature(test_args_kwargs_only), - ((('args', ..., ..., 'var_positional'), - ('kwargs', ..., ..., 'var_keyword')), ...)) - self.assertEqual(self.signature(A.f1), - ((('args', ..., ..., 'var_positional'),), ...)) - self.assertEqual(self.signature(A.f2), - ((('args', ..., ..., 'var_positional'),), ...)) - self.assertEqual(self.signature(A.f3), - ((('args', ..., ..., 'var_positional'),), ...)) - self.assertEqual(self.signature(A.f4), - ((('args', ..., ..., 'var_positional'), - ('kwargs', ..., ..., 'var_keyword')), ...)) - @cpython_only - @unittest.skipIf(MISSING_C_DOCSTRINGS, - "Signature information for builtins requires docstrings") - def test_signature_on_builtins(self): - import _testcapi - - def test_unbound_method(o): - """Use this to test unbound methods (things that should have a self)""" - signature = inspect.signature(o) - self.assertTrue(isinstance(signature, inspect.Signature)) - self.assertEqual(list(signature.parameters.values())[0].name, 'self') - return signature - - def test_callable(o): - """Use this to test bound methods or normal callables (things that don't expect self)""" - signature = inspect.signature(o) - self.assertTrue(isinstance(signature, inspect.Signature)) - if signature.parameters: - self.assertNotEqual(list(signature.parameters.values())[0].name, 'self') - return signature - - signature = test_callable(_testcapi.docstring_with_signature_with_defaults) - def p(name): return signature.parameters[name].default - self.assertEqual(p('s'), 'avocado') - self.assertEqual(p('b'), b'bytes') - self.assertEqual(p('d'), 3.14) - self.assertEqual(p('i'), 35) - self.assertEqual(p('n'), None) - self.assertEqual(p('t'), True) - self.assertEqual(p('f'), False) - self.assertEqual(p('local'), 3) - self.assertEqual(p('sys'), sys.maxsize) - self.assertEqual(p('exp'), sys.maxsize - 1) - - test_callable(object) - - # normal method - # (PyMethodDescr_Type, "method_descriptor") - test_unbound_method(_pickle.Pickler.dump) - d = _pickle.Pickler(io.StringIO()) - test_callable(d.dump) - - # static method - test_callable(bytes.maketrans) - test_callable(b'abc'.maketrans) - - # class method - test_callable(dict.fromkeys) - test_callable({}.fromkeys) - - # wrapper around slot (PyWrapperDescr_Type, "wrapper_descriptor") - test_unbound_method(type.__call__) - test_unbound_method(int.__add__) - test_callable((3).__add__) - - # _PyMethodWrapper_Type - # support for 'method-wrapper' - test_callable(min.__call__) - - # This doesn't work now. - # (We don't have a valid signature for "type" in 3.4) - with self.assertRaisesRegex(ValueError, "no signature found"): - class ThisWorksNow: - __call__ = type - test_callable(ThisWorksNow()) - - # Regression test for issue #20786 - test_unbound_method(dict.__delitem__) - test_unbound_method(property.__delete__) - - # Regression test for issue #20586 - test_callable(_testcapi.docstring_with_signature_but_no_doc) - - # Regression test for gh-104955 - method = bytearray.__release_buffer__ - sig = test_unbound_method(method) - self.assertEqual(list(sig.parameters), ['self', 'buffer']) - - @cpython_only - @unittest.skipIf(MISSING_C_DOCSTRINGS, - "Signature information for builtins requires docstrings") - def test_signature_on_decorated_builtins(self): - import _testcapi - func = _testcapi.docstring_with_signature_with_defaults - - def decorator(func): - @functools.wraps(func) - def wrapper(*args, **kwargs) -> int: - return func(*args, **kwargs) - return wrapper - - decorated_func = decorator(func) - - self.assertEqual(inspect.signature(func), - inspect.signature(decorated_func)) - - def wrapper_like(*args, **kwargs) -> int: pass - self.assertEqual(inspect.signature(decorated_func, - follow_wrapped=False), - inspect.signature(wrapper_like)) - - @cpython_only - def test_signature_on_builtins_no_signature(self): - import _testcapi - with self.assertRaisesRegex(ValueError, - 'no signature found for builtin'): - inspect.signature(_testcapi.docstring_no_signature) - - with self.assertRaisesRegex(ValueError, - 'no signature found for builtin'): - inspect.signature(str) - - cls = _testcapi.DocStringNoSignatureTest - obj = _testcapi.DocStringNoSignatureTest() - tests = [ - (_testcapi.docstring_no_signature_noargs, meth_noargs), - (_testcapi.docstring_no_signature_o, meth_o), - (cls.meth_noargs, meth_self_noargs), - (cls.meth_o, meth_self_o), - (obj.meth_noargs, meth_noargs), - (obj.meth_o, meth_o), - (cls.meth_noargs_class, meth_noargs), - (cls.meth_o_class, meth_o), - (cls.meth_noargs_static, meth_noargs), - (cls.meth_o_static, meth_o), - (cls.meth_noargs_coexist, meth_self_noargs), - (cls.meth_o_coexist, meth_self_o), - - (time.time, meth_noargs), - (str.lower, meth_self_noargs), - (''.lower, meth_noargs), - (set.add, meth_self_o), - (set().add, meth_o), - (set.__contains__, meth_self_o), - (set().__contains__, meth_o), - (datetime.datetime.__dict__['utcnow'], meth_type_noargs), - (datetime.datetime.utcnow, meth_noargs), - (dict.__dict__['__class_getitem__'], meth_type_o), - (dict.__class_getitem__, meth_o), - ] - try: - import _stat - except ImportError: - # if the _stat extension is not available, stat.S_IMODE() is - # implemented in Python, not in C - pass - else: - tests.append((stat.S_IMODE, meth_o)) - for builtin, template in tests: - with self.subTest(builtin): - self.assertEqual(inspect.signature(builtin), - inspect.signature(template)) - - def test_signature_on_non_function(self): - with self.assertRaisesRegex(TypeError, 'is not a callable object'): - inspect.signature(42) - - def test_signature_from_functionlike_object(self): - def func(a,b, *args, kwonly=True, kwonlyreq, **kwargs): - pass - - class funclike: - # Has to be callable, and have correct - # __code__, __annotations__, __defaults__, __name__, - # and __kwdefaults__ attributes - - def __init__(self, func): - self.__name__ = func.__name__ - self.__code__ = func.__code__ - self.__annotations__ = func.__annotations__ - self.__defaults__ = func.__defaults__ - self.__kwdefaults__ = func.__kwdefaults__ - self.func = func - - def __call__(self, *args, **kwargs): - return self.func(*args, **kwargs) - - sig_func = inspect.Signature.from_callable(func) - - sig_funclike = inspect.Signature.from_callable(funclike(func)) - self.assertEqual(sig_funclike, sig_func) - - sig_funclike = inspect.signature(funclike(func)) - self.assertEqual(sig_funclike, sig_func) - - # If object is not a duck type of function, then - # signature will try to get a signature for its '__call__' - # method - fl = funclike(func) - del fl.__defaults__ - self.assertEqual(self.signature(fl), - ((('args', ..., ..., "var_positional"), - ('kwargs', ..., ..., "var_keyword")), - ...)) - - # Test with cython-like builtins: - _orig_isdesc = inspect.ismethoddescriptor - def _isdesc(obj): - if hasattr(obj, '_builtinmock'): - return True - return _orig_isdesc(obj) - - with unittest.mock.patch('inspect.ismethoddescriptor', _isdesc): - builtin_func = funclike(func) - # Make sure that our mock setup is working - self.assertFalse(inspect.ismethoddescriptor(builtin_func)) - builtin_func._builtinmock = True - self.assertTrue(inspect.ismethoddescriptor(builtin_func)) - self.assertEqual(inspect.signature(builtin_func), sig_func) - - def test_signature_functionlike_class(self): - # We only want to duck type function-like objects, - # not classes. - - def func(a,b, *args, kwonly=True, kwonlyreq, **kwargs): - pass - - class funclike: - def __init__(self, marker): - pass - - __name__ = func.__name__ - __code__ = func.__code__ - __annotations__ = func.__annotations__ - __defaults__ = func.__defaults__ - __kwdefaults__ = func.__kwdefaults__ - - self.assertEqual(str(inspect.signature(funclike)), '(marker)') - - def test_signature_on_method(self): - class Test: - def __init__(*args): - pass - def m1(self, arg1, arg2=1) -> int: - pass - def m2(*args): - pass - def __call__(*, a): - pass - - self.assertEqual(self.signature(Test().m1), - ((('arg1', ..., ..., "positional_or_keyword"), - ('arg2', 1, ..., "positional_or_keyword")), - int)) - - self.assertEqual(self.signature(Test().m2), - ((('args', ..., ..., "var_positional"),), - ...)) - - self.assertEqual(self.signature(Test), - ((('args', ..., ..., "var_positional"),), - ...)) - - with self.assertRaisesRegex(ValueError, 'invalid method signature'): - self.signature(Test()) - - def test_signature_wrapped_bound_method(self): - # Issue 24298 - class Test: - def m1(self, arg1, arg2=1) -> int: - pass - @functools.wraps(Test().m1) - def m1d(*args, **kwargs): - pass - self.assertEqual(self.signature(m1d), - ((('arg1', ..., ..., "positional_or_keyword"), - ('arg2', 1, ..., "positional_or_keyword")), - int)) - - def test_signature_on_classmethod(self): - class Test: - @classmethod - def foo(cls, arg1, *, arg2=1): - pass - - meth = Test().foo - self.assertEqual(self.signature(meth), - ((('arg1', ..., ..., "positional_or_keyword"), - ('arg2', 1, ..., "keyword_only")), - ...)) - - meth = Test.foo - self.assertEqual(self.signature(meth), - ((('arg1', ..., ..., "positional_or_keyword"), - ('arg2', 1, ..., "keyword_only")), - ...)) - - def test_signature_on_staticmethod(self): - class Test: - @staticmethod - def foo(cls, *, arg): - pass - - meth = Test().foo - self.assertEqual(self.signature(meth), - ((('cls', ..., ..., "positional_or_keyword"), - ('arg', ..., ..., "keyword_only")), - ...)) - - meth = Test.foo - self.assertEqual(self.signature(meth), - ((('cls', ..., ..., "positional_or_keyword"), - ('arg', ..., ..., "keyword_only")), - ...)) - - def test_signature_on_partial(self): - from functools import partial - - def test(): - pass - - self.assertEqual(self.signature(partial(test)), ((), ...)) - - with self.assertRaisesRegex(ValueError, "has incorrect arguments"): - inspect.signature(partial(test, 1)) - - with self.assertRaisesRegex(ValueError, "has incorrect arguments"): - inspect.signature(partial(test, a=1)) - - def test(a, b, *, c, d): - pass - - self.assertEqual(self.signature(partial(test)), - ((('a', ..., ..., "positional_or_keyword"), - ('b', ..., ..., "positional_or_keyword"), - ('c', ..., ..., "keyword_only"), - ('d', ..., ..., "keyword_only")), - ...)) - - self.assertEqual(self.signature(partial(test, 1)), - ((('b', ..., ..., "positional_or_keyword"), - ('c', ..., ..., "keyword_only"), - ('d', ..., ..., "keyword_only")), - ...)) - - self.assertEqual(self.signature(partial(test, 1, c=2)), - ((('b', ..., ..., "positional_or_keyword"), - ('c', 2, ..., "keyword_only"), - ('d', ..., ..., "keyword_only")), - ...)) - - self.assertEqual(self.signature(partial(test, b=1, c=2)), - ((('a', ..., ..., "positional_or_keyword"), - ('b', 1, ..., "keyword_only"), - ('c', 2, ..., "keyword_only"), - ('d', ..., ..., "keyword_only")), - ...)) - - self.assertEqual(self.signature(partial(test, 0, b=1, c=2)), - ((('b', 1, ..., "keyword_only"), - ('c', 2, ..., "keyword_only"), - ('d', ..., ..., "keyword_only")), - ...)) - - self.assertEqual(self.signature(partial(test, a=1)), - ((('a', 1, ..., "keyword_only"), - ('b', ..., ..., "keyword_only"), - ('c', ..., ..., "keyword_only"), - ('d', ..., ..., "keyword_only")), - ...)) - - def test(a, *args, b, **kwargs): - pass - - self.assertEqual(self.signature(partial(test, 1)), - ((('args', ..., ..., "var_positional"), - ('b', ..., ..., "keyword_only"), - ('kwargs', ..., ..., "var_keyword")), - ...)) - - self.assertEqual(self.signature(partial(test, a=1)), - ((('a', 1, ..., "keyword_only"), - ('b', ..., ..., "keyword_only"), - ('kwargs', ..., ..., "var_keyword")), - ...)) - - self.assertEqual(self.signature(partial(test, 1, 2, 3)), - ((('args', ..., ..., "var_positional"), - ('b', ..., ..., "keyword_only"), - ('kwargs', ..., ..., "var_keyword")), - ...)) - - self.assertEqual(self.signature(partial(test, 1, 2, 3, test=True)), - ((('args', ..., ..., "var_positional"), - ('b', ..., ..., "keyword_only"), - ('kwargs', ..., ..., "var_keyword")), - ...)) - - self.assertEqual(self.signature(partial(test, 1, 2, 3, test=1, b=0)), - ((('args', ..., ..., "var_positional"), - ('b', 0, ..., "keyword_only"), - ('kwargs', ..., ..., "var_keyword")), - ...)) - - self.assertEqual(self.signature(partial(test, b=0)), - ((('a', ..., ..., "positional_or_keyword"), - ('args', ..., ..., "var_positional"), - ('b', 0, ..., "keyword_only"), - ('kwargs', ..., ..., "var_keyword")), - ...)) - - self.assertEqual(self.signature(partial(test, b=0, test=1)), - ((('a', ..., ..., "positional_or_keyword"), - ('args', ..., ..., "var_positional"), - ('b', 0, ..., "keyword_only"), - ('kwargs', ..., ..., "var_keyword")), - ...)) - - def test(a, b, c:int) -> 42: - pass - - sig = test.__signature__ = inspect.signature(test) - - self.assertEqual(self.signature(partial(partial(test, 1))), - ((('b', ..., ..., "positional_or_keyword"), - ('c', ..., int, "positional_or_keyword")), - 42)) - - self.assertEqual(self.signature(partial(partial(test, 1), 2)), - ((('c', ..., int, "positional_or_keyword"),), - 42)) - - def foo(a): - return a - _foo = partial(partial(foo, a=10), a=20) - self.assertEqual(self.signature(_foo), - ((('a', 20, ..., "keyword_only"),), - ...)) - # check that we don't have any side-effects in signature(), - # and the partial object is still functioning - self.assertEqual(_foo(), 20) - - def foo(a, b, c): - return a, b, c - _foo = partial(partial(foo, 1, b=20), b=30) - - self.assertEqual(self.signature(_foo), - ((('b', 30, ..., "keyword_only"), - ('c', ..., ..., "keyword_only")), - ...)) - self.assertEqual(_foo(c=10), (1, 30, 10)) - - def foo(a, b, c, *, d): - return a, b, c, d - _foo = partial(partial(foo, d=20, c=20), b=10, d=30) - self.assertEqual(self.signature(_foo), - ((('a', ..., ..., "positional_or_keyword"), - ('b', 10, ..., "keyword_only"), - ('c', 20, ..., "keyword_only"), - ('d', 30, ..., "keyword_only"), - ), - ...)) - ba = inspect.signature(_foo).bind(a=200, b=11) - self.assertEqual(_foo(*ba.args, **ba.kwargs), (200, 11, 20, 30)) - - def foo(a=1, b=2, c=3): - return a, b, c - _foo = partial(foo, c=13) # (a=1, b=2, *, c=13) - - ba = inspect.signature(_foo).bind(a=11) - self.assertEqual(_foo(*ba.args, **ba.kwargs), (11, 2, 13)) - - ba = inspect.signature(_foo).bind(11, 12) - self.assertEqual(_foo(*ba.args, **ba.kwargs), (11, 12, 13)) - - ba = inspect.signature(_foo).bind(11, b=12) - self.assertEqual(_foo(*ba.args, **ba.kwargs), (11, 12, 13)) - - ba = inspect.signature(_foo).bind(b=12) - self.assertEqual(_foo(*ba.args, **ba.kwargs), (1, 12, 13)) - - _foo = partial(_foo, b=10, c=20) - ba = inspect.signature(_foo).bind(12) - self.assertEqual(_foo(*ba.args, **ba.kwargs), (12, 10, 20)) - - - def foo(a, b, /, c, d, **kwargs): - pass - sig = inspect.signature(foo) - self.assertEqual(str(sig), '(a, b, /, c, d, **kwargs)') - - self.assertEqual(self.signature(partial(foo, 1)), - ((('b', ..., ..., 'positional_only'), - ('c', ..., ..., 'positional_or_keyword'), - ('d', ..., ..., 'positional_or_keyword'), - ('kwargs', ..., ..., 'var_keyword')), - ...)) - - self.assertEqual(self.signature(partial(foo, 1, 2)), - ((('c', ..., ..., 'positional_or_keyword'), - ('d', ..., ..., 'positional_or_keyword'), - ('kwargs', ..., ..., 'var_keyword')), - ...)) - - self.assertEqual(self.signature(partial(foo, 1, 2, 3)), - ((('d', ..., ..., 'positional_or_keyword'), - ('kwargs', ..., ..., 'var_keyword')), - ...)) - - self.assertEqual(self.signature(partial(foo, 1, 2, c=3)), - ((('c', 3, ..., 'keyword_only'), - ('d', ..., ..., 'keyword_only'), - ('kwargs', ..., ..., 'var_keyword')), - ...)) - - self.assertEqual(self.signature(partial(foo, 1, c=3)), - ((('b', ..., ..., 'positional_only'), - ('c', 3, ..., 'keyword_only'), - ('d', ..., ..., 'keyword_only'), - ('kwargs', ..., ..., 'var_keyword')), - ...)) - - def test_signature_on_partialmethod(self): - from functools import partialmethod - - class Spam: - def test(): - pass - ham = partialmethod(test) - - with self.assertRaisesRegex(ValueError, "has incorrect arguments"): - inspect.signature(Spam.ham) - - class Spam: - def test(it, a, *, c) -> 'spam': - pass - ham = partialmethod(test, c=1) - - self.assertEqual(self.signature(Spam.ham, eval_str=False), - ((('it', ..., ..., 'positional_or_keyword'), - ('a', ..., ..., 'positional_or_keyword'), - ('c', 1, ..., 'keyword_only')), - 'spam')) - - self.assertEqual(self.signature(Spam().ham, eval_str=False), - ((('a', ..., ..., 'positional_or_keyword'), - ('c', 1, ..., 'keyword_only')), - 'spam')) - - class Spam: - def test(self: 'anno', x): - pass - - g = partialmethod(test, 1) - - self.assertEqual(self.signature(Spam.g, eval_str=False), - ((('self', ..., 'anno', 'positional_or_keyword'),), - ...)) - - def test_signature_on_fake_partialmethod(self): - def foo(a): pass - foo._partialmethod = 'spam' - self.assertEqual(str(inspect.signature(foo)), '(a)') - - def test_signature_on_decorated(self): - def decorator(func): - @functools.wraps(func) - def wrapper(*args, **kwargs) -> int: - return func(*args, **kwargs) - return wrapper - - class Foo: - @decorator - def bar(self, a, b): - pass - - bar = decorator(Foo().bar) - - self.assertEqual(self.signature(Foo.bar), - ((('self', ..., ..., "positional_or_keyword"), - ('a', ..., ..., "positional_or_keyword"), - ('b', ..., ..., "positional_or_keyword")), - ...)) - - self.assertEqual(self.signature(Foo().bar), - ((('a', ..., ..., "positional_or_keyword"), - ('b', ..., ..., "positional_or_keyword")), - ...)) - - self.assertEqual(self.signature(Foo.bar, follow_wrapped=False), - ((('args', ..., ..., "var_positional"), - ('kwargs', ..., ..., "var_keyword")), - ...)) # functools.wraps will copy __annotations__ - # from "func" to "wrapper", hence no - # return_annotation - - self.assertEqual(self.signature(bar), - ((('a', ..., ..., "positional_or_keyword"), - ('b', ..., ..., "positional_or_keyword")), - ...)) - - # Test that we handle method wrappers correctly - def decorator(func): - @functools.wraps(func) - def wrapper(*args, **kwargs) -> int: - return func(42, *args, **kwargs) - sig = inspect.signature(func) - new_params = tuple(sig.parameters.values())[1:] - wrapper.__signature__ = sig.replace(parameters=new_params) - return wrapper - - class Foo: - @decorator - def __call__(self, a, b): - pass - - self.assertEqual(self.signature(Foo.__call__), - ((('a', ..., ..., "positional_or_keyword"), - ('b', ..., ..., "positional_or_keyword")), - ...)) - - self.assertEqual(self.signature(Foo().__call__), - ((('b', ..., ..., "positional_or_keyword"),), - ...)) - - # Test we handle __signature__ partway down the wrapper stack - def wrapped_foo_call(): - pass - wrapped_foo_call.__wrapped__ = Foo.__call__ - - self.assertEqual(self.signature(wrapped_foo_call), - ((('a', ..., ..., "positional_or_keyword"), - ('b', ..., ..., "positional_or_keyword")), - ...)) - - - def test_signature_on_class(self): - class C: - def __init__(self, a): - pass - - self.assertEqual(self.signature(C), - ((('a', ..., ..., "positional_or_keyword"),), - ...)) - - class CM(type): - def __call__(cls, a): - pass - class C(metaclass=CM): - def __init__(self, b): - pass - - self.assertEqual(self.signature(C), - ((('a', ..., ..., "positional_or_keyword"),), - ...)) - - class CM(type): - def __new__(mcls, name, bases, dct, *, foo=1): - return super().__new__(mcls, name, bases, dct) - class C(metaclass=CM): - def __init__(self, b): - pass - - self.assertEqual(self.signature(C), - ((('b', ..., ..., "positional_or_keyword"),), - ...)) - - self.assertEqual(self.signature(CM), - ((('name', ..., ..., "positional_or_keyword"), - ('bases', ..., ..., "positional_or_keyword"), - ('dct', ..., ..., "positional_or_keyword"), - ('foo', 1, ..., "keyword_only")), - ...)) - - class CMM(type): - def __new__(mcls, name, bases, dct, *, foo=1): - return super().__new__(mcls, name, bases, dct) - def __call__(cls, nm, bs, dt): - return type(nm, bs, dt) - class CM(type, metaclass=CMM): - def __new__(mcls, name, bases, dct, *, bar=2): - return super().__new__(mcls, name, bases, dct) - class C(metaclass=CM): - def __init__(self, b): - pass - - self.assertEqual(self.signature(CMM), - ((('name', ..., ..., "positional_or_keyword"), - ('bases', ..., ..., "positional_or_keyword"), - ('dct', ..., ..., "positional_or_keyword"), - ('foo', 1, ..., "keyword_only")), - ...)) - - self.assertEqual(self.signature(CM), - ((('nm', ..., ..., "positional_or_keyword"), - ('bs', ..., ..., "positional_or_keyword"), - ('dt', ..., ..., "positional_or_keyword")), - ...)) - - self.assertEqual(self.signature(C), - ((('b', ..., ..., "positional_or_keyword"),), - ...)) - - class CM(type): - def __init__(cls, name, bases, dct, *, bar=2): - return super().__init__(name, bases, dct) - class C(metaclass=CM): - def __init__(self, b): - pass - - self.assertEqual(self.signature(CM), - ((('name', ..., ..., "positional_or_keyword"), - ('bases', ..., ..., "positional_or_keyword"), - ('dct', ..., ..., "positional_or_keyword"), - ('bar', 2, ..., "keyword_only")), - ...)) - - def test_signature_on_subclass(self): - class A: - def __new__(cls, a=1, *args, **kwargs): - return object.__new__(cls) - class B(A): - def __init__(self, b): - pass - class C(A): - def __new__(cls, a=1, b=2, *args, **kwargs): - return object.__new__(cls) - class D(A): - pass - - self.assertEqual(self.signature(B), - ((('b', ..., ..., "positional_or_keyword"),), - ...)) - self.assertEqual(self.signature(C), - ((('a', 1, ..., 'positional_or_keyword'), - ('b', 2, ..., 'positional_or_keyword'), - ('args', ..., ..., 'var_positional'), - ('kwargs', ..., ..., 'var_keyword')), - ...)) - self.assertEqual(self.signature(D), - ((('a', 1, ..., 'positional_or_keyword'), - ('args', ..., ..., 'var_positional'), - ('kwargs', ..., ..., 'var_keyword')), - ...)) - - def test_signature_on_generic_subclass(self): - from typing import Generic, TypeVar - - T = TypeVar('T') - - class A(Generic[T]): - def __init__(self, *, a: int) -> None: - pass - - self.assertEqual(self.signature(A), - ((('a', ..., int, 'keyword_only'),), - None)) - - @unittest.skipIf(MISSING_C_DOCSTRINGS, - "Signature information for builtins requires docstrings") - def test_signature_on_class_without_init(self): - # Test classes without user-defined __init__ or __new__ - class C: pass - self.assertEqual(str(inspect.signature(C)), '()') - class D(C): pass - self.assertEqual(str(inspect.signature(D)), '()') - - # Test meta-classes without user-defined __init__ or __new__ - class C(type): pass - class D(C): pass - with self.assertRaisesRegex(ValueError, "callable.*is not supported"): - self.assertEqual(inspect.signature(C), None) - with self.assertRaisesRegex(ValueError, "callable.*is not supported"): - self.assertEqual(inspect.signature(D), None) - - @unittest.skipIf(MISSING_C_DOCSTRINGS, - "Signature information for builtins requires docstrings") - def test_signature_on_builtin_class(self): - expected = ('(file, protocol=None, fix_imports=True, ' - 'buffer_callback=None)') - self.assertEqual(str(inspect.signature(_pickle.Pickler)), expected) - - class P(_pickle.Pickler): pass - class EmptyTrait: pass - class P2(EmptyTrait, P): pass - self.assertEqual(str(inspect.signature(P)), expected) - self.assertEqual(str(inspect.signature(P2)), expected) - - class P3(P2): - def __init__(self, spam): - pass - self.assertEqual(str(inspect.signature(P3)), '(spam)') - - class MetaP(type): - def __call__(cls, foo, bar): - pass - class P4(P2, metaclass=MetaP): - pass - self.assertEqual(str(inspect.signature(P4)), '(foo, bar)') - - def test_signature_on_callable_objects(self): - class Foo: - def __call__(self, a): - pass - - self.assertEqual(self.signature(Foo()), - ((('a', ..., ..., "positional_or_keyword"),), - ...)) - - class Spam: - pass - with self.assertRaisesRegex(TypeError, "is not a callable object"): - inspect.signature(Spam()) - - class Bar(Spam, Foo): - pass - - self.assertEqual(self.signature(Bar()), - ((('a', ..., ..., "positional_or_keyword"),), - ...)) - - class Wrapped: - pass - Wrapped.__wrapped__ = lambda a: None - self.assertEqual(self.signature(Wrapped), - ((('a', ..., ..., "positional_or_keyword"),), - ...)) - # wrapper loop: - Wrapped.__wrapped__ = Wrapped - with self.assertRaisesRegex(ValueError, 'wrapper loop'): - self.signature(Wrapped) - - def test_signature_on_lambdas(self): - self.assertEqual(self.signature((lambda a=10: a)), - ((('a', 10, ..., "positional_or_keyword"),), - ...)) - - def test_signature_on_mocks(self): - # https://github.com/python/cpython/issues/96127 - for mock in ( - unittest.mock.Mock(), - unittest.mock.AsyncMock(), - unittest.mock.MagicMock(), - ): - with self.subTest(mock=mock): - self.assertEqual(str(inspect.signature(mock)), '(*args, **kwargs)') - - def test_signature_on_noncallable_mocks(self): - for mock in ( - unittest.mock.NonCallableMock(), - unittest.mock.NonCallableMagicMock(), - ): - with self.subTest(mock=mock): - with self.assertRaises(TypeError): - inspect.signature(mock) - - def test_signature_equality(self): - def foo(a, *, b:int) -> float: pass - self.assertFalse(inspect.signature(foo) == 42) - self.assertTrue(inspect.signature(foo) != 42) - self.assertTrue(inspect.signature(foo) == ALWAYS_EQ) - self.assertFalse(inspect.signature(foo) != ALWAYS_EQ) - - def bar(a, *, b:int) -> float: pass - self.assertTrue(inspect.signature(foo) == inspect.signature(bar)) - self.assertFalse(inspect.signature(foo) != inspect.signature(bar)) - self.assertEqual( - hash(inspect.signature(foo)), hash(inspect.signature(bar))) - - def bar(a, *, b:int) -> int: pass - self.assertFalse(inspect.signature(foo) == inspect.signature(bar)) - self.assertTrue(inspect.signature(foo) != inspect.signature(bar)) - self.assertNotEqual( - hash(inspect.signature(foo)), hash(inspect.signature(bar))) - - def bar(a, *, b:int): pass - self.assertFalse(inspect.signature(foo) == inspect.signature(bar)) - self.assertTrue(inspect.signature(foo) != inspect.signature(bar)) - self.assertNotEqual( - hash(inspect.signature(foo)), hash(inspect.signature(bar))) - - def bar(a, *, b:int=42) -> float: pass - self.assertFalse(inspect.signature(foo) == inspect.signature(bar)) - self.assertTrue(inspect.signature(foo) != inspect.signature(bar)) - self.assertNotEqual( - hash(inspect.signature(foo)), hash(inspect.signature(bar))) - - def bar(a, *, c) -> float: pass - self.assertFalse(inspect.signature(foo) == inspect.signature(bar)) - self.assertTrue(inspect.signature(foo) != inspect.signature(bar)) - self.assertNotEqual( - hash(inspect.signature(foo)), hash(inspect.signature(bar))) - - def bar(a, b:int) -> float: pass - self.assertFalse(inspect.signature(foo) == inspect.signature(bar)) - self.assertTrue(inspect.signature(foo) != inspect.signature(bar)) - self.assertNotEqual( - hash(inspect.signature(foo)), hash(inspect.signature(bar))) - def spam(b:int, a) -> float: pass - self.assertFalse(inspect.signature(spam) == inspect.signature(bar)) - self.assertTrue(inspect.signature(spam) != inspect.signature(bar)) - self.assertNotEqual( - hash(inspect.signature(spam)), hash(inspect.signature(bar))) - - def foo(*, a, b, c): pass - def bar(*, c, b, a): pass - self.assertTrue(inspect.signature(foo) == inspect.signature(bar)) - self.assertFalse(inspect.signature(foo) != inspect.signature(bar)) - self.assertEqual( - hash(inspect.signature(foo)), hash(inspect.signature(bar))) - - def foo(*, a=1, b, c): pass - def bar(*, c, b, a=1): pass - self.assertTrue(inspect.signature(foo) == inspect.signature(bar)) - self.assertFalse(inspect.signature(foo) != inspect.signature(bar)) - self.assertEqual( - hash(inspect.signature(foo)), hash(inspect.signature(bar))) - - def foo(pos, *, a=1, b, c): pass - def bar(pos, *, c, b, a=1): pass - self.assertTrue(inspect.signature(foo) == inspect.signature(bar)) - self.assertFalse(inspect.signature(foo) != inspect.signature(bar)) - self.assertEqual( - hash(inspect.signature(foo)), hash(inspect.signature(bar))) - - def foo(pos, *, a, b, c): pass - def bar(pos, *, c, b, a=1): pass - self.assertFalse(inspect.signature(foo) == inspect.signature(bar)) - self.assertTrue(inspect.signature(foo) != inspect.signature(bar)) - self.assertNotEqual( - hash(inspect.signature(foo)), hash(inspect.signature(bar))) - - def foo(pos, *args, a=42, b, c, **kwargs:int): pass - def bar(pos, *args, c, b, a=42, **kwargs:int): pass - self.assertTrue(inspect.signature(foo) == inspect.signature(bar)) - self.assertFalse(inspect.signature(foo) != inspect.signature(bar)) - self.assertEqual( - hash(inspect.signature(foo)), hash(inspect.signature(bar))) - - def test_signature_hashable(self): - S = inspect.Signature - P = inspect.Parameter - - def foo(a): pass - foo_sig = inspect.signature(foo) - - manual_sig = S(parameters=[P('a', P.POSITIONAL_OR_KEYWORD)]) - - self.assertEqual(hash(foo_sig), hash(manual_sig)) - self.assertNotEqual(hash(foo_sig), - hash(manual_sig.replace(return_annotation='spam'))) - - def bar(a) -> 1: pass - self.assertNotEqual(hash(foo_sig), hash(inspect.signature(bar))) - - def foo(a={}): pass - with self.assertRaisesRegex(TypeError, 'unhashable type'): - hash(inspect.signature(foo)) - - def foo(a) -> {}: pass - with self.assertRaisesRegex(TypeError, 'unhashable type'): - hash(inspect.signature(foo)) - - def test_signature_str(self): - def foo(a:int=1, *, b, c=None, **kwargs) -> 42: - pass - self.assertEqual(str(inspect.signature(foo)), - '(a: int = 1, *, b, c=None, **kwargs) -> 42') - - def foo(a:int=1, *args, b, c=None, **kwargs) -> 42: - pass - self.assertEqual(str(inspect.signature(foo)), - '(a: int = 1, *args, b, c=None, **kwargs) -> 42') - - def foo(): - pass - self.assertEqual(str(inspect.signature(foo)), '()') - - def foo(a: list[str]) -> tuple[str, float]: - pass - self.assertEqual(str(inspect.signature(foo)), - '(a: list[str]) -> tuple[str, float]') - - from typing import Tuple - def foo(a: list[str]) -> Tuple[str, float]: - pass - self.assertEqual(str(inspect.signature(foo)), - '(a: list[str]) -> Tuple[str, float]') - - def test_signature_str_positional_only(self): - P = inspect.Parameter - S = inspect.Signature - - def test(a_po, /, *, b, **kwargs): - return a_po, kwargs - - self.assertEqual(str(inspect.signature(test)), - '(a_po, /, *, b, **kwargs)') - - self.assertEqual(str(S(parameters=[P('foo', P.POSITIONAL_ONLY)])), - '(foo, /)') - - self.assertEqual(str(S(parameters=[ - P('foo', P.POSITIONAL_ONLY), - P('bar', P.VAR_KEYWORD)])), - '(foo, /, **bar)') - - self.assertEqual(str(S(parameters=[ - P('foo', P.POSITIONAL_ONLY), - P('bar', P.VAR_POSITIONAL)])), - '(foo, /, *bar)') - - def test_signature_replace_parameters(self): - def test(a, b) -> 42: - pass - - sig = inspect.signature(test) - parameters = sig.parameters - sig = sig.replace(parameters=list(parameters.values())[1:]) - self.assertEqual(list(sig.parameters), ['b']) - self.assertEqual(sig.parameters['b'], parameters['b']) - self.assertEqual(sig.return_annotation, 42) - sig = sig.replace(parameters=()) - self.assertEqual(dict(sig.parameters), {}) - - sig = inspect.signature(test) - parameters = sig.parameters - sig = copy.replace(sig, parameters=list(parameters.values())[1:]) - self.assertEqual(list(sig.parameters), ['b']) - self.assertEqual(sig.parameters['b'], parameters['b']) - self.assertEqual(sig.return_annotation, 42) - sig = copy.replace(sig, parameters=()) - self.assertEqual(dict(sig.parameters), {}) - - def test_signature_replace_anno(self): - def test() -> 42: - pass - - sig = inspect.signature(test) - sig = sig.replace(return_annotation=None) - self.assertIs(sig.return_annotation, None) - sig = sig.replace(return_annotation=sig.empty) - self.assertIs(sig.return_annotation, sig.empty) - sig = sig.replace(return_annotation=42) - self.assertEqual(sig.return_annotation, 42) - self.assertEqual(sig, inspect.signature(test)) - - sig = inspect.signature(test) - sig = copy.replace(sig, return_annotation=None) - self.assertIs(sig.return_annotation, None) - sig = copy.replace(sig, return_annotation=sig.empty) - self.assertIs(sig.return_annotation, sig.empty) - sig = copy.replace(sig, return_annotation=42) - self.assertEqual(sig.return_annotation, 42) - self.assertEqual(sig, inspect.signature(test)) - - def test_signature_replaced(self): - def test(): - pass - - spam_param = inspect.Parameter('spam', inspect.Parameter.POSITIONAL_ONLY) - sig = test.__signature__ = inspect.Signature(parameters=(spam_param,)) - self.assertEqual(sig, inspect.signature(test)) - - def test_signature_on_mangled_parameters(self): - class Spam: - def foo(self, __p1:1=2, *, __p2:2=3): - pass - class Ham(Spam): - pass - - self.assertEqual(self.signature(Spam.foo), - ((('self', ..., ..., "positional_or_keyword"), - ('_Spam__p1', 2, 1, "positional_or_keyword"), - ('_Spam__p2', 3, 2, "keyword_only")), - ...)) - - self.assertEqual(self.signature(Spam.foo), - self.signature(Ham.foo)) - - def test_signature_from_callable_python_obj(self): - class MySignature(inspect.Signature): pass - def foo(a, *, b:1): pass - foo_sig = MySignature.from_callable(foo) - self.assertIsInstance(foo_sig, MySignature) - - def test_signature_from_callable_class(self): - # A regression test for a class inheriting its signature from `object`. - class MySignature(inspect.Signature): pass - class foo: pass - foo_sig = MySignature.from_callable(foo) - self.assertIsInstance(foo_sig, MySignature) - - @unittest.skipIf(MISSING_C_DOCSTRINGS, - "Signature information for builtins requires docstrings") - def test_signature_from_callable_builtin_obj(self): - class MySignature(inspect.Signature): pass - sig = MySignature.from_callable(_pickle.Pickler) - self.assertIsInstance(sig, MySignature) - - def test_signature_definition_order_preserved_on_kwonly(self): - for fn in signatures_with_lexicographic_keyword_only_parameters(): - signature = inspect.signature(fn) - l = list(signature.parameters) - sorted_l = sorted(l) - self.assertTrue(l) - self.assertEqual(l, sorted_l) - signature = inspect.signature(unsorted_keyword_only_parameters_fn) - l = list(signature.parameters) - self.assertEqual(l, unsorted_keyword_only_parameters) - - def test_signater_parameters_is_ordered(self): - p1 = inspect.signature(lambda x, y: None).parameters - p2 = inspect.signature(lambda y, x: None).parameters - self.assertNotEqual(p1, p2) - - def test_signature_annotations_with_local_namespaces(self): - class Foo: ... - def func(foo: Foo) -> int: pass - def func2(foo: Foo, bar: 'Bar') -> int: pass - - for signature_func in (inspect.signature, inspect.Signature.from_callable): - with self.subTest(signature_func = signature_func): - sig1 = signature_func(func) - self.assertEqual(sig1.return_annotation, int) - self.assertEqual(sig1.parameters['foo'].annotation, Foo) - - sig2 = signature_func(func, locals=locals()) - self.assertEqual(sig2.return_annotation, int) - self.assertEqual(sig2.parameters['foo'].annotation, Foo) - - sig3 = signature_func(func2, globals={'Bar': int}, locals=locals()) - self.assertEqual(sig3.return_annotation, int) - self.assertEqual(sig3.parameters['foo'].annotation, Foo) - self.assertEqual(sig3.parameters['bar'].annotation, 'Bar') - - def test_signature_eval_str(self): - isa = inspect_stringized_annotations - sig = inspect.Signature - par = inspect.Parameter - PORK = inspect.Parameter.POSITIONAL_OR_KEYWORD - for signature_func in (inspect.signature, inspect.Signature.from_callable): - with self.subTest(signature_func = signature_func): - self.assertEqual( - signature_func(isa.MyClass), - sig( - parameters=( - par('a', PORK), - par('b', PORK), - ))) - self.assertEqual( - signature_func(isa.function), - sig( - return_annotation='MyClass', - parameters=( - par('a', PORK, annotation='int'), - par('b', PORK, annotation='str'), - ))) - self.assertEqual( - signature_func(isa.function2), - sig( - return_annotation='MyClass', - parameters=( - par('a', PORK, annotation='int'), - par('b', PORK, annotation="'str'"), - par('c', PORK, annotation="MyClass"), - ))) - self.assertEqual( - signature_func(isa.function3), - sig( - parameters=( - par('a', PORK, annotation="'int'"), - par('b', PORK, annotation="'str'"), - par('c', PORK, annotation="'MyClass'"), - ))) - - self.assertEqual(signature_func(isa.UnannotatedClass), sig()) - self.assertEqual(signature_func(isa.unannotated_function), - sig( - parameters=( - par('a', PORK), - par('b', PORK), - par('c', PORK), - ))) - - self.assertEqual( - signature_func(isa.MyClass, eval_str=True), - sig( - parameters=( - par('a', PORK), - par('b', PORK), - ))) - self.assertEqual( - signature_func(isa.function, eval_str=True), - sig( - return_annotation=isa.MyClass, - parameters=( - par('a', PORK, annotation=int), - par('b', PORK, annotation=str), - ))) - self.assertEqual( - signature_func(isa.function2, eval_str=True), - sig( - return_annotation=isa.MyClass, - parameters=( - par('a', PORK, annotation=int), - par('b', PORK, annotation='str'), - par('c', PORK, annotation=isa.MyClass), - ))) - self.assertEqual( - signature_func(isa.function3, eval_str=True), - sig( - parameters=( - par('a', PORK, annotation='int'), - par('b', PORK, annotation='str'), - par('c', PORK, annotation='MyClass'), - ))) - - globalns = {'int': float, 'str': complex} - localns = {'str': tuple, 'MyClass': dict} - with self.assertRaises(NameError): - signature_func(isa.function, eval_str=True, globals=globalns) - - self.assertEqual( - signature_func(isa.function, eval_str=True, locals=localns), - sig( - return_annotation=dict, - parameters=( - par('a', PORK, annotation=int), - par('b', PORK, annotation=tuple), - ))) - - self.assertEqual( - signature_func(isa.function, eval_str=True, globals=globalns, locals=localns), - sig( - return_annotation=dict, - parameters=( - par('a', PORK, annotation=float), - par('b', PORK, annotation=tuple), - ))) - - def test_signature_none_annotation(self): - class funclike: - # Has to be callable, and have correct - # __code__, __annotations__, __defaults__, __name__, - # and __kwdefaults__ attributes - - def __init__(self, func): - self.__name__ = func.__name__ - self.__code__ = func.__code__ - self.__annotations__ = func.__annotations__ - self.__defaults__ = func.__defaults__ - self.__kwdefaults__ = func.__kwdefaults__ - self.func = func - - def __call__(self, *args, **kwargs): - return self.func(*args, **kwargs) - - def foo(): pass - foo = funclike(foo) - foo.__annotations__ = None - for signature_func in (inspect.signature, inspect.Signature.from_callable): - with self.subTest(signature_func = signature_func): - self.assertEqual(signature_func(foo), inspect.Signature()) - self.assertEqual(inspect.get_annotations(foo), {}) - - def test_signature_as_str(self): - self.maxDiff = None - class S: - __signature__ = '(a, b=2)' - - self.assertEqual(self.signature(S), - ((('a', ..., ..., 'positional_or_keyword'), - ('b', 2, ..., 'positional_or_keyword')), - ...)) - - def test_signature_as_callable(self): - # __signature__ should be either a staticmethod or a bound classmethod - class S: - @classmethod - def __signature__(cls): - return '(a, b=2)' - - self.assertEqual(self.signature(S), - ((('a', ..., ..., 'positional_or_keyword'), - ('b', 2, ..., 'positional_or_keyword')), - ...)) - - class S: - @staticmethod - def __signature__(): - return '(a, b=2)' - - self.assertEqual(self.signature(S), - ((('a', ..., ..., 'positional_or_keyword'), - ('b', 2, ..., 'positional_or_keyword')), - ...)) - - def test_signature_on_derived_classes(self): - # gh-105080: Make sure that signatures are consistent on derived classes - - class B: - def __new__(self, *args, **kwargs): - return super().__new__(self) - def __init__(self, value): - self.value = value - - class D1(B): - def __init__(self, value): - super().__init__(value) - - class D2(D1): - pass - - self.assertEqual(inspect.signature(D2), inspect.signature(D1)) - - -class TestParameterObject(unittest.TestCase): - def test_signature_parameter_kinds(self): - P = inspect.Parameter - self.assertTrue(P.POSITIONAL_ONLY < P.POSITIONAL_OR_KEYWORD < \ - P.VAR_POSITIONAL < P.KEYWORD_ONLY < P.VAR_KEYWORD) - - self.assertEqual(str(P.POSITIONAL_ONLY), 'POSITIONAL_ONLY') - self.assertTrue('POSITIONAL_ONLY' in repr(P.POSITIONAL_ONLY)) - - def test_signature_parameter_object(self): - p = inspect.Parameter('foo', default=10, - kind=inspect.Parameter.POSITIONAL_ONLY) - self.assertEqual(p.name, 'foo') - self.assertEqual(p.default, 10) - self.assertIs(p.annotation, p.empty) - self.assertEqual(p.kind, inspect.Parameter.POSITIONAL_ONLY) - - with self.assertRaisesRegex(ValueError, "value '123' is " - "not a valid Parameter.kind"): - inspect.Parameter('foo', default=10, kind='123') - - with self.assertRaisesRegex(ValueError, 'not a valid parameter name'): - inspect.Parameter('1', kind=inspect.Parameter.VAR_KEYWORD) - - with self.assertRaisesRegex(ValueError, 'not a valid parameter name'): - inspect.Parameter('from', kind=inspect.Parameter.VAR_KEYWORD) - - with self.assertRaisesRegex(TypeError, 'name must be a str'): - inspect.Parameter(None, kind=inspect.Parameter.VAR_KEYWORD) - - with self.assertRaisesRegex(ValueError, - 'is not a valid parameter name'): - inspect.Parameter('$', kind=inspect.Parameter.VAR_KEYWORD) - - with self.assertRaisesRegex(ValueError, - 'is not a valid parameter name'): - inspect.Parameter('.a', kind=inspect.Parameter.VAR_KEYWORD) - - with self.assertRaisesRegex(ValueError, 'cannot have default values'): - inspect.Parameter('a', default=42, - kind=inspect.Parameter.VAR_KEYWORD) - - with self.assertRaisesRegex(ValueError, 'cannot have default values'): - inspect.Parameter('a', default=42, - kind=inspect.Parameter.VAR_POSITIONAL) - - p = inspect.Parameter('a', default=42, - kind=inspect.Parameter.POSITIONAL_OR_KEYWORD) - with self.assertRaisesRegex(ValueError, 'cannot have default values'): - p.replace(kind=inspect.Parameter.VAR_POSITIONAL) - - self.assertTrue(repr(p).startswith(' " - "is not a valid Parameter.kind"): - p2 = p2.replace(kind=p2.empty) - with self.assertRaisesRegex(ValueError, - "value " - "is not a valid Parameter.kind"): - p3 = copy.replace(p3, kind=p3.empty) - - p2 = p2.replace(kind=p2.KEYWORD_ONLY) - self.assertEqual(p2, p) - p3 = copy.replace(p3, kind=p3.KEYWORD_ONLY) - self.assertEqual(p3, p) - - def test_signature_parameter_positional_only(self): - with self.assertRaisesRegex(TypeError, 'name must be a str'): - inspect.Parameter(None, kind=inspect.Parameter.POSITIONAL_ONLY) - - @cpython_only - def test_signature_parameter_implicit(self): - with self.assertRaisesRegex(ValueError, - 'implicit arguments must be passed as ' - 'positional or keyword arguments, ' - 'not positional-only'): - inspect.Parameter('.0', kind=inspect.Parameter.POSITIONAL_ONLY) - - param = inspect.Parameter( - '.0', kind=inspect.Parameter.POSITIONAL_OR_KEYWORD) - self.assertEqual(param.kind, inspect.Parameter.POSITIONAL_ONLY) - self.assertEqual(param.name, 'implicit0') - - def test_signature_parameter_immutability(self): - p = inspect.Parameter('spam', kind=inspect.Parameter.KEYWORD_ONLY) - - with self.assertRaises(AttributeError): - p.foo = 'bar' - - with self.assertRaises(AttributeError): - p.kind = 123 - - -class TestSignatureBind(unittest.TestCase): - @staticmethod - def call(func, *args, **kwargs): - sig = inspect.signature(func) - ba = sig.bind(*args, **kwargs) - return func(*ba.args, **ba.kwargs) - - def test_signature_bind_empty(self): - def test(): - return 42 - - self.assertEqual(self.call(test), 42) - with self.assertRaisesRegex(TypeError, 'too many positional arguments'): - self.call(test, 1) - with self.assertRaisesRegex(TypeError, 'too many positional arguments'): - self.call(test, 1, spam=10) - with self.assertRaisesRegex( - TypeError, "got an unexpected keyword argument 'spam'"): - - self.call(test, spam=1) - - def test_signature_bind_var(self): - def test(*args, **kwargs): - return args, kwargs - - self.assertEqual(self.call(test), ((), {})) - self.assertEqual(self.call(test, 1), ((1,), {})) - self.assertEqual(self.call(test, 1, 2), ((1, 2), {})) - self.assertEqual(self.call(test, foo='bar'), ((), {'foo': 'bar'})) - self.assertEqual(self.call(test, 1, foo='bar'), ((1,), {'foo': 'bar'})) - self.assertEqual(self.call(test, args=10), ((), {'args': 10})) - self.assertEqual(self.call(test, 1, 2, foo='bar'), - ((1, 2), {'foo': 'bar'})) - - def test_signature_bind_just_args(self): - def test(a, b, c): - return a, b, c - - self.assertEqual(self.call(test, 1, 2, 3), (1, 2, 3)) - - with self.assertRaisesRegex(TypeError, 'too many positional arguments'): - self.call(test, 1, 2, 3, 4) - - with self.assertRaisesRegex(TypeError, - "missing a required argument: 'b'"): - self.call(test, 1) - - with self.assertRaisesRegex(TypeError, - "missing a required argument: 'a'"): - self.call(test) - - def test(a, b, c=10): - return a, b, c - self.assertEqual(self.call(test, 1, 2, 3), (1, 2, 3)) - self.assertEqual(self.call(test, 1, 2), (1, 2, 10)) - - def test(a=1, b=2, c=3): - return a, b, c - self.assertEqual(self.call(test, a=10, c=13), (10, 2, 13)) - self.assertEqual(self.call(test, a=10), (10, 2, 3)) - self.assertEqual(self.call(test, b=10), (1, 10, 3)) - - def test_signature_bind_varargs_order(self): - def test(*args): - return args - - self.assertEqual(self.call(test), ()) - self.assertEqual(self.call(test, 1, 2, 3), (1, 2, 3)) - - def test_signature_bind_args_and_varargs(self): - def test(a, b, c=3, *args): - return a, b, c, args - - self.assertEqual(self.call(test, 1, 2, 3, 4, 5), (1, 2, 3, (4, 5))) - self.assertEqual(self.call(test, 1, 2), (1, 2, 3, ())) - self.assertEqual(self.call(test, b=1, a=2), (2, 1, 3, ())) - self.assertEqual(self.call(test, 1, b=2), (1, 2, 3, ())) - - with self.assertRaisesRegex(TypeError, - "multiple values for argument 'c'"): - self.call(test, 1, 2, 3, c=4) - - def test_signature_bind_just_kwargs(self): - def test(**kwargs): - return kwargs - - self.assertEqual(self.call(test), {}) - self.assertEqual(self.call(test, foo='bar', spam='ham'), - {'foo': 'bar', 'spam': 'ham'}) - - def test_signature_bind_args_and_kwargs(self): - def test(a, b, c=3, **kwargs): - return a, b, c, kwargs - - self.assertEqual(self.call(test, 1, 2), (1, 2, 3, {})) - self.assertEqual(self.call(test, 1, 2, foo='bar', spam='ham'), - (1, 2, 3, {'foo': 'bar', 'spam': 'ham'})) - self.assertEqual(self.call(test, b=2, a=1, foo='bar', spam='ham'), - (1, 2, 3, {'foo': 'bar', 'spam': 'ham'})) - self.assertEqual(self.call(test, a=1, b=2, foo='bar', spam='ham'), - (1, 2, 3, {'foo': 'bar', 'spam': 'ham'})) - self.assertEqual(self.call(test, 1, b=2, foo='bar', spam='ham'), - (1, 2, 3, {'foo': 'bar', 'spam': 'ham'})) - self.assertEqual(self.call(test, 1, b=2, c=4, foo='bar', spam='ham'), - (1, 2, 4, {'foo': 'bar', 'spam': 'ham'})) - self.assertEqual(self.call(test, 1, 2, 4, foo='bar'), - (1, 2, 4, {'foo': 'bar'})) - self.assertEqual(self.call(test, c=5, a=4, b=3), - (4, 3, 5, {})) - - def test_signature_bind_kwonly(self): - def test(*, foo): - return foo - with self.assertRaisesRegex(TypeError, - 'too many positional arguments'): - self.call(test, 1) - self.assertEqual(self.call(test, foo=1), 1) - - def test(a, *, foo=1, bar): - return foo - with self.assertRaisesRegex(TypeError, - "missing a required argument: 'bar'"): - self.call(test, 1) - - def test(foo, *, bar): - return foo, bar - self.assertEqual(self.call(test, 1, bar=2), (1, 2)) - self.assertEqual(self.call(test, bar=2, foo=1), (1, 2)) - - with self.assertRaisesRegex( - TypeError, "got an unexpected keyword argument 'spam'"): - - self.call(test, bar=2, foo=1, spam=10) - - with self.assertRaisesRegex(TypeError, - 'too many positional arguments'): - self.call(test, 1, 2) - - with self.assertRaisesRegex(TypeError, - 'too many positional arguments'): - self.call(test, 1, 2, bar=2) - - with self.assertRaisesRegex( - TypeError, "got an unexpected keyword argument 'spam'"): - - self.call(test, 1, bar=2, spam='ham') - - with self.assertRaisesRegex(TypeError, - "missing a required keyword-only " - "argument: 'bar'"): - self.call(test, 1) - - def test(foo, *, bar, **bin): - return foo, bar, bin - self.assertEqual(self.call(test, 1, bar=2), (1, 2, {})) - self.assertEqual(self.call(test, foo=1, bar=2), (1, 2, {})) - self.assertEqual(self.call(test, 1, bar=2, spam='ham'), - (1, 2, {'spam': 'ham'})) - self.assertEqual(self.call(test, spam='ham', foo=1, bar=2), - (1, 2, {'spam': 'ham'})) - with self.assertRaisesRegex(TypeError, - "missing a required argument: 'foo'"): - self.call(test, spam='ham', bar=2) - self.assertEqual(self.call(test, 1, bar=2, bin=1, spam=10), - (1, 2, {'bin': 1, 'spam': 10})) - - def test_signature_bind_arguments(self): - def test(a, *args, b, z=100, **kwargs): - pass - sig = inspect.signature(test) - ba = sig.bind(10, 20, b=30, c=40, args=50, kwargs=60) - # we won't have 'z' argument in the bound arguments object, as we didn't - # pass it to the 'bind' - self.assertEqual(tuple(ba.arguments.items()), - (('a', 10), ('args', (20,)), ('b', 30), - ('kwargs', {'c': 40, 'args': 50, 'kwargs': 60}))) - self.assertEqual(ba.kwargs, - {'b': 30, 'c': 40, 'args': 50, 'kwargs': 60}) - self.assertEqual(ba.args, (10, 20)) - - def test_signature_bind_positional_only(self): - def test(a_po, b_po, c_po=3, /, foo=42, *, bar=50, **kwargs): - return a_po, b_po, c_po, foo, bar, kwargs - - self.assertEqual(self.call(test, 1, 2, 4, 5, bar=6), - (1, 2, 4, 5, 6, {})) - - self.assertEqual(self.call(test, 1, 2), - (1, 2, 3, 42, 50, {})) - - self.assertEqual(self.call(test, 1, 2, foo=4, bar=5), - (1, 2, 3, 4, 5, {})) - - with self.assertRaisesRegex(TypeError, "but was passed as a keyword"): - self.call(test, 1, 2, foo=4, bar=5, c_po=10) - - with self.assertRaisesRegex(TypeError, "parameter is positional only"): - self.call(test, 1, 2, c_po=4) - - with self.assertRaisesRegex(TypeError, "parameter is positional only"): - self.call(test, a_po=1, b_po=2) - - def test_signature_bind_with_self_arg(self): - # Issue #17071: one of the parameters is named "self - def test(a, self, b): - pass - sig = inspect.signature(test) - ba = sig.bind(1, 2, 3) - self.assertEqual(ba.args, (1, 2, 3)) - ba = sig.bind(1, self=2, b=3) - self.assertEqual(ba.args, (1, 2, 3)) - - def test_signature_bind_vararg_name(self): - def test(a, *args): - return a, args - sig = inspect.signature(test) - - with self.assertRaisesRegex( - TypeError, "got an unexpected keyword argument 'args'"): - - sig.bind(a=0, args=1) - - def test(*args, **kwargs): - return args, kwargs - self.assertEqual(self.call(test, args=1), ((), {'args': 1})) - - sig = inspect.signature(test) - ba = sig.bind(args=1) - self.assertEqual(ba.arguments, {'kwargs': {'args': 1}}) - - @cpython_only - def test_signature_bind_implicit_arg(self): - # Issue #19611: getcallargs should work with comprehensions - def make_set(): - return set(z * z for z in range(5)) - gencomp_code = make_set.__code__.co_consts[1] - gencomp_func = types.FunctionType(gencomp_code, {}) - - iterator = iter(range(5)) - self.assertEqual(set(self.call(gencomp_func, iterator)), {0, 1, 4, 9, 16}) - - def test_signature_bind_posonly_kwargs(self): - def foo(bar, /, **kwargs): - return bar, kwargs.get(bar) - - sig = inspect.signature(foo) - result = sig.bind("pos-only", bar="keyword") - - self.assertEqual(result.kwargs, {"bar": "keyword"}) - self.assertIn(("bar", "pos-only"), result.arguments.items()) - - -class TestBoundArguments(unittest.TestCase): - def test_signature_bound_arguments_unhashable(self): - def foo(a): pass - ba = inspect.signature(foo).bind(1) - - with self.assertRaisesRegex(TypeError, 'unhashable type'): - hash(ba) - - def test_signature_bound_arguments_equality(self): - def foo(a): pass - ba = inspect.signature(foo).bind(1) - self.assertTrue(ba == ba) - self.assertFalse(ba != ba) - self.assertTrue(ba == ALWAYS_EQ) - self.assertFalse(ba != ALWAYS_EQ) - - ba2 = inspect.signature(foo).bind(1) - self.assertTrue(ba == ba2) - self.assertFalse(ba != ba2) - - ba3 = inspect.signature(foo).bind(2) - self.assertFalse(ba == ba3) - self.assertTrue(ba != ba3) - ba3.arguments['a'] = 1 - self.assertTrue(ba == ba3) - self.assertFalse(ba != ba3) - - def bar(b): pass - ba4 = inspect.signature(bar).bind(1) - self.assertFalse(ba == ba4) - self.assertTrue(ba != ba4) - - def foo(*, a, b): pass - sig = inspect.signature(foo) - ba1 = sig.bind(a=1, b=2) - ba2 = sig.bind(b=2, a=1) - self.assertTrue(ba1 == ba2) - self.assertFalse(ba1 != ba2) - - def test_signature_bound_arguments_pickle(self): - def foo(a, b, *, c:1={}, **kw) -> {42:'ham'}: pass - sig = inspect.signature(foo) - ba = sig.bind(20, 30, z={}) - - for ver in range(pickle.HIGHEST_PROTOCOL + 1): - with self.subTest(pickle_ver=ver): - ba_pickled = pickle.loads(pickle.dumps(ba, ver)) - self.assertEqual(ba, ba_pickled) - - def test_signature_bound_arguments_repr(self): - def foo(a, b, *, c:1={}, **kw) -> {42:'ham'}: pass - sig = inspect.signature(foo) - ba = sig.bind(20, 30, z={}) - self.assertRegex(repr(ba), r'') - - def test_signature_bound_arguments_apply_defaults(self): - def foo(a, b=1, *args, c:1={}, **kw): pass - sig = inspect.signature(foo) - - ba = sig.bind(20) - ba.apply_defaults() - self.assertEqual( - list(ba.arguments.items()), - [('a', 20), ('b', 1), ('args', ()), ('c', {}), ('kw', {})]) - - # Make sure that we preserve the order: - # i.e. 'c' should be *before* 'kw'. - ba = sig.bind(10, 20, 30, d=1) - ba.apply_defaults() - self.assertEqual( - list(ba.arguments.items()), - [('a', 10), ('b', 20), ('args', (30,)), ('c', {}), ('kw', {'d':1})]) - - # Make sure that BoundArguments produced by bind_partial() - # are supported. - def foo(a, b): pass - sig = inspect.signature(foo) - ba = sig.bind_partial(20) - ba.apply_defaults() - self.assertEqual( - list(ba.arguments.items()), - [('a', 20)]) - - # Test no args - def foo(): pass - sig = inspect.signature(foo) - ba = sig.bind() - ba.apply_defaults() - self.assertEqual(list(ba.arguments.items()), []) - - # Make sure a no-args binding still acquires proper defaults. - def foo(a='spam'): pass - sig = inspect.signature(foo) - ba = sig.bind() - ba.apply_defaults() - self.assertEqual(list(ba.arguments.items()), [('a', 'spam')]) - - def test_signature_bound_arguments_arguments_type(self): - def foo(a): pass - ba = inspect.signature(foo).bind(1) - self.assertIs(type(ba.arguments), dict) - -class TestSignaturePrivateHelpers(unittest.TestCase): - def _strip_non_python_syntax(self, input, - clean_signature, self_parameter): - computed_clean_signature, \ - computed_self_parameter = \ - inspect._signature_strip_non_python_syntax(input) - self.assertEqual(computed_clean_signature, clean_signature) - self.assertEqual(computed_self_parameter, self_parameter) - - def test_signature_strip_non_python_syntax(self): - self._strip_non_python_syntax( - "($module, /, path, mode, *, dir_fd=None, " + - "effective_ids=False,\n follow_symlinks=True)", - "(module, /, path, mode, *, dir_fd=None, " + - "effective_ids=False, follow_symlinks=True)", - 0) - - self._strip_non_python_syntax( - "($module, word, salt, /)", - "(module, word, salt, /)", - 0) - - self._strip_non_python_syntax( - "(x, y=None, z=None, /)", - "(x, y=None, z=None, /)", - None) - - self._strip_non_python_syntax( - "(x, y=None, z=None)", - "(x, y=None, z=None)", - None) - - self._strip_non_python_syntax( - "(x,\n y=None,\n z = None )", - "(x, y=None, z=None)", - None) - - self._strip_non_python_syntax( - "", - "", - None) - - self._strip_non_python_syntax( - None, - None, - None) - -class TestSignatureDefinitions(unittest.TestCase): - # This test case provides a home for checking that particular APIs - # have signatures available for introspection - - @cpython_only - @unittest.skipIf(MISSING_C_DOCSTRINGS, - "Signature information for builtins requires docstrings") - def test_builtins_have_signatures(self): - # This checks all builtin callables in CPython have signatures - # A few have signatures Signature can't yet handle, so we skip those - # since they will have to wait until PEP 457 adds the required - # introspection support to the inspect module - # Some others also haven't been converted yet for various other - # reasons, so we also skip those for the time being, but design - # the test to fail in order to indicate when it needs to be - # updated. - no_signature = set() - # These need PEP 457 groups - needs_groups = {"range", "slice", "dir", "getattr", - "next", "iter", "vars"} - no_signature |= needs_groups - # These have unrepresentable parameter default values of NULL - needs_null = {"anext"} - no_signature |= needs_null - # These need PEP 457 groups or a signature change to accept None - needs_semantic_update = {"round"} - no_signature |= needs_semantic_update - # These need *args support in Argument Clinic - needs_varargs = {"breakpoint", "min", "max", "print", - "__build_class__"} - no_signature |= needs_varargs - # These simply weren't covered in the initial AC conversion - # for builtin callables - not_converted_yet = {"open", "__import__"} - no_signature |= not_converted_yet - # These builtin types are expected to provide introspection info - types_with_signatures = set() - # Check the signatures we expect to be there - ns = vars(builtins) - for name, obj in sorted(ns.items()): - if not callable(obj): - continue - # The builtin types haven't been converted to AC yet - if isinstance(obj, type) and (name not in types_with_signatures): - # Note that this also skips all the exception types - no_signature.add(name) - if (name in no_signature): - # Not yet converted - continue - with self.subTest(builtin=name): - self.assertIsNotNone(inspect.signature(obj)) - # Check callables that haven't been converted don't claim a signature - # This ensures this test will start failing as more signatures are - # added, so the affected items can be moved into the scope of the - # regression test above - for name in no_signature: - with self.subTest(builtin=name): - self.assertIsNone(obj.__text_signature__) - - def test_python_function_override_signature(self): - def func(*args, **kwargs): - pass - func.__text_signature__ = '($self, a, b=1, *args, c, d=2, **kwargs)' - sig = inspect.signature(func) - self.assertIsNotNone(sig) - self.assertEqual(str(sig), '(self, /, a, b=1, *args, c, d=2, **kwargs)') - - func.__text_signature__ = '($self, a, b=1, /, *args, c, d=2, **kwargs)' - sig = inspect.signature(func) - self.assertEqual(str(sig), '(self, a, b=1, /, *args, c, d=2, **kwargs)') - - func.__text_signature__ = '(self, a=1+2, b=4-3, c=1 | 3 | 16)' - sig = inspect.signature(func) - self.assertEqual(str(sig), '(self, a=3, b=1, c=19)') - - func.__text_signature__ = '(self, a=1,\nb=2,\n\n\n c=3)' - sig = inspect.signature(func) - self.assertEqual(str(sig), '(self, a=1, b=2, c=3)') - - func.__text_signature__ = '(self, x=does_not_exist)' - with self.assertRaises(ValueError): - inspect.signature(func) - func.__text_signature__ = '(self, x=sys, y=inspect)' - with self.assertRaises(ValueError): - inspect.signature(func) - func.__text_signature__ = '(self, 123)' - with self.assertRaises(ValueError): - inspect.signature(func) - - def test_base_class_have_text_signature(self): - # see issue 43118 - from test.typinganndata.ann_module7 import BufferedReader - class MyBufferedReader(BufferedReader): - """buffer reader class.""" - - text_signature = BufferedReader.__text_signature__ - self.assertEqual(text_signature, '(raw, buffer_size=DEFAULT_BUFFER_SIZE)') - sig = inspect.signature(MyBufferedReader) - self.assertEqual(str(sig), '(raw, buffer_size=8192)') - - -class NTimesUnwrappable: - def __init__(self, n): - self.n = n - self._next = None - - @property - def __wrapped__(self): - if self.n <= 0: - raise Exception("Unwrapped too many times") - if self._next is None: - self._next = NTimesUnwrappable(self.n - 1) - return self._next - -class TestUnwrap(unittest.TestCase): - - def test_unwrap_one(self): - def func(a, b): - return a + b - wrapper = functools.lru_cache(maxsize=20)(func) - self.assertIs(inspect.unwrap(wrapper), func) - - def test_unwrap_several(self): - def func(a, b): - return a + b - wrapper = func - for __ in range(10): - @functools.wraps(wrapper) - def wrapper(): - pass - self.assertIsNot(wrapper.__wrapped__, func) - self.assertIs(inspect.unwrap(wrapper), func) - - def test_stop(self): - def func1(a, b): - return a + b - @functools.wraps(func1) - def func2(): - pass - @functools.wraps(func2) - def wrapper(): - pass - func2.stop_here = 1 - unwrapped = inspect.unwrap(wrapper, - stop=(lambda f: hasattr(f, "stop_here"))) - self.assertIs(unwrapped, func2) - - def test_cycle(self): - def func1(): pass - func1.__wrapped__ = func1 - with self.assertRaisesRegex(ValueError, 'wrapper loop'): - inspect.unwrap(func1) - - def func2(): pass - func2.__wrapped__ = func1 - func1.__wrapped__ = func2 - with self.assertRaisesRegex(ValueError, 'wrapper loop'): - inspect.unwrap(func1) - with self.assertRaisesRegex(ValueError, 'wrapper loop'): - inspect.unwrap(func2) - - def test_unhashable(self): - def func(): pass - func.__wrapped__ = None - class C: - __hash__ = None - __wrapped__ = func - self.assertIsNone(inspect.unwrap(C())) - - def test_recursion_limit(self): - obj = NTimesUnwrappable(sys.getrecursionlimit() + 1) - with self.assertRaisesRegex(ValueError, 'wrapper loop'): - inspect.unwrap(obj) - -class TestMain(unittest.TestCase): - def test_only_source(self): - module = importlib.import_module('unittest') - rc, out, err = assert_python_ok('-m', 'inspect', - 'unittest') - lines = out.decode().splitlines() - # ignore the final newline - self.assertEqual(lines[:-1], inspect.getsource(module).splitlines()) - self.assertEqual(err, b'') - - def test_custom_getattr(self): - def foo(): - pass - foo.__signature__ = 42 - with self.assertRaises(TypeError): - inspect.signature(foo) - - @unittest.skipIf(ThreadPoolExecutor is None, - 'threads required to test __qualname__ for source files') - def test_qualname_source(self): - rc, out, err = assert_python_ok('-m', 'inspect', - 'concurrent.futures:ThreadPoolExecutor') - lines = out.decode().splitlines() - # ignore the final newline - self.assertEqual(lines[:-1], - inspect.getsource(ThreadPoolExecutor).splitlines()) - self.assertEqual(err, b'') - - def test_builtins(self): - _, out, err = assert_python_failure('-m', 'inspect', - 'sys') - lines = err.decode().splitlines() - self.assertEqual(lines, ["Can't get info for builtin modules."]) - - def test_details(self): - module = importlib.import_module('unittest') - args = support.optim_args_from_interpreter_flags() - rc, out, err = assert_python_ok(*args, '-m', 'inspect', - 'unittest', '--details') - output = out.decode() - # Just a quick sanity check on the output - self.assertIn(module.__spec__.name, output) - self.assertIn(module.__name__, output) - self.assertIn(module.__spec__.origin, output) - self.assertIn(module.__file__, output) - self.assertIn(module.__spec__.cached, output) - self.assertIn(module.__cached__, output) - self.assertEqual(err, b'') - - -class TestReload(unittest.TestCase): - - src_before = textwrap.dedent("""\ -def foo(): - print("Bla") - """) - - src_after = textwrap.dedent("""\ -def foo(): - print("Oh no!") - """) - - def assertInspectEqual(self, path, source): - inspected_src = inspect.getsource(source) - with open(path, encoding='utf-8') as src: - self.assertEqual( - src.read().splitlines(True), - inspected_src.splitlines(True) - ) - - def test_getsource_reload(self): - # see issue 1218234 - with ready_to_import('reload_bug', self.src_before) as (name, path): - module = importlib.import_module(name) - self.assertInspectEqual(path, module) - with open(path, 'w', encoding='utf-8') as src: - src.write(self.src_after) - self.assertInspectEqual(path, module) - - -if __name__ == "__main__": - unittest.main() diff --git a/Lib/test/test_inspect/__init__.py b/Lib/test/test_inspect/__init__.py new file mode 100644 index 0000000..f2a39a3 --- /dev/null +++ b/Lib/test/test_inspect/__init__.py @@ -0,0 +1,6 @@ +import os +from test import support + + +def load_tests(*args): + return support.load_package_tests(os.path.dirname(__file__), *args) diff --git a/Lib/test/test_inspect/inspect_fodder.py b/Lib/test/test_inspect/inspect_fodder.py new file mode 100644 index 0000000..60ba7aa --- /dev/null +++ b/Lib/test/test_inspect/inspect_fodder.py @@ -0,0 +1,120 @@ +# line 1 +'A module docstring.' + +import inspect +# line 5 + +# line 7 +def spam(a, /, b, c, d=3, e=4, f=5, *g, **h): + eggs(b + d, c + f) + +# line 11 +def eggs(x, y): + "A docstring." + global fr, st + fr = inspect.currentframe() + st = inspect.stack() + p = x + q = y / 0 + +# line 20 +class StupidGit: + """A longer, + + indented + + docstring.""" +# line 27 + + def abuse(self, a, b, c): + """Another + +\tdocstring + + containing + +\ttabs +\t + """ + self.argue(a, b, c) +# line 40 + def argue(self, a, b, c): + try: + spam(a, b, c) + except BaseException as e: + self.ex = e + self.tr = inspect.trace() + + @property + def contradiction(self): + 'The automatic gainsaying.' + pass + +# line 53 +class MalodorousPervert(StupidGit): + def abuse(self, a, b, c): + pass + + @property + def contradiction(self): + pass + +Tit = MalodorousPervert + +class ParrotDroppings: + pass + +class FesteringGob(MalodorousPervert, ParrotDroppings): + def abuse(self, a, b, c): + pass + + @property + def contradiction(self): + pass + +async def lobbest(grenade): + pass + +currentframe = inspect.currentframe() +try: + raise Exception() +except BaseException as e: + tb = e.__traceback__ + +class Callable: + def __call__(self, *args): + return args + + def as_method_of(self, obj): + from types import MethodType + return MethodType(self, obj) + +custom_method = Callable().as_method_of(42) +del Callable + +# line 95 +class WhichComments: + # line 97 + # before f + def f(self): + # line 100 + # start f + return 1 + # line 103 + # end f + # line 105 + # after f + + # before asyncf - line 108 + async def asyncf(self): + # start asyncf + return 2 + # end asyncf + # after asyncf - line 113 + # end of WhichComments - line 114 + # after WhichComments - line 115 + +# Test that getsource works on a line that includes +# a closing parenthesis with the opening paren being in another line +( +); after_closing = lambda: 1 diff --git a/Lib/test/test_inspect/inspect_fodder2.py b/Lib/test/test_inspect/inspect_fodder2.py new file mode 100644 index 0000000..8639cf2 --- /dev/null +++ b/Lib/test/test_inspect/inspect_fodder2.py @@ -0,0 +1,312 @@ +# line 1 +def wrap(foo=None): + def wrapper(func): + return func + return wrapper + +# line 7 +def replace(func): + def insteadfunc(): + print('hello') + return insteadfunc + +# line 13 +@wrap() +@wrap(wrap) +def wrapped(): + pass + +# line 19 +@replace +def gone(): + pass + +# line 24 +oll = lambda m: m + +# line 27 +tll = lambda g: g and \ +g and \ +g + +# line 32 +tlli = lambda d: d and \ + d + +# line 36 +def onelinefunc(): pass + +# line 39 +def manyargs(arg1, arg2, +arg3, arg4): pass + +# line 43 +def twolinefunc(m): return m and \ +m + +# line 47 +a = [None, + lambda x: x, + None] + +# line 52 +def setfunc(func): + globals()["anonymous"] = func +setfunc(lambda x, y: x*y) + +# line 57 +def with_comment(): # hello + world + +# line 61 +multiline_sig = [ + lambda x, \ + y: x+y, + None, + ] + +# line 68 +def func69(): + class cls70: + def func71(): + pass + return cls70 +extra74 = 74 + +# line 76 +def func77(): pass +(extra78, stuff78) = 'xy' +extra79 = 'stop' + +# line 81 +class cls82: + def func83(): pass +(extra84, stuff84) = 'xy' +extra85 = 'stop' + +# line 87 +def func88(): + # comment + return 90 + +# line 92 +def f(): + class X: + def g(): + "doc" + return 42 + return X +method_in_dynamic_class = f().g + +#line 101 +def keyworded(*arg1, arg2=1): + pass + +#line 105 +def annotated(arg1: list): + pass + +#line 109 +def keyword_only_arg(*, arg): + pass + +@wrap(lambda: None) +def func114(): + return 115 + +class ClassWithMethod: + def method(self): + pass + +from functools import wraps + +def decorator(func): + @wraps(func) + def fake(): + return 42 + return fake + +#line 129 +@decorator +def real(): + return 20 + +#line 134 +class cls135: + def func136(): + def func137(): + never_reached1 + never_reached2 + +# line 141 +class cls142: + a = """ +class cls149: + ... +""" + +# line 148 +class cls149: + + def func151(self): + pass + +''' +class cls160: + pass +''' + +# line 159 +class cls160: + + def func162(self): + pass + +# line 165 +class cls166: + a = ''' + class cls175: + ... + ''' + +# line 172 +class cls173: + + class cls175: + pass + +# line 178 +class cls179: + pass + +# line 182 +class cls183: + + class cls185: + + def func186(self): + pass + +def class_decorator(cls): + return cls + +# line 193 +@class_decorator +@class_decorator +class cls196: + + @class_decorator + @class_decorator + class cls200: + pass + +class cls203: + class cls204: + class cls205: + pass + class cls207: + class cls205: + pass + +# line 211 +def func212(): + class cls213: + pass + return cls213 + +# line 217 +class cls213: + def func219(self): + class cls220: + pass + return cls220 + +# line 224 +async def func225(): + class cls226: + pass + return cls226 + +# line 230 +class cls226: + async def func232(self): + class cls233: + pass + return cls233 + +if True: + class cls238: + class cls239: + '''if clause cls239''' +else: + class cls238: + class cls239: + '''else clause 239''' + pass + +#line 247 +def positional_only_arg(a, /): + pass + +#line 251 +def all_markers(a, b, /, c, d, *, e, f): + pass + +# line 255 +def all_markers_with_args_and_kwargs(a, b, /, c, d, *args, e, f, **kwargs): + pass + +#line 259 +def all_markers_with_defaults(a, b=1, /, c=2, d=3, *, e=4, f=5): + pass + +# line 263 +def deco_factory(**kwargs): + def deco(f): + @wraps(f) + def wrapper(*a, **kwd): + kwd.update(kwargs) + return f(*a, **kwd) + return wrapper + return deco + +@deco_factory(foo=(1 + 2), bar=lambda: 1) +def complex_decorated(foo=0, bar=lambda: 0): + return foo + bar() + +# line 276 +parenthesized_lambda = ( + lambda: ()) +parenthesized_lambda2 = [ + lambda: ()][0] +parenthesized_lambda3 = {0: + lambda: ()}[0] + +# line 285 +post_line_parenthesized_lambda1 = (lambda: () +) + +# line 289 +nested_lambda = ( + lambda right: [].map( + lambda length: ())) + +# line 294 +if True: + class cls296: + def f(): + pass +else: + class cls296: + def g(): + pass + +# line 304 +if False: + class cls310: + def f(): + pass +else: + class cls310: + def g(): + pass diff --git a/Lib/test/test_inspect/inspect_stock_annotations.py b/Lib/test/test_inspect/inspect_stock_annotations.py new file mode 100644 index 0000000..d115a25 --- /dev/null +++ b/Lib/test/test_inspect/inspect_stock_annotations.py @@ -0,0 +1,28 @@ +a:int=3 +b:str="foo" + +class MyClass: + a:int=4 + b:str="bar" + def __init__(self, a, b): + self.a = a + self.b = b + def __eq__(self, other): + return isinstance(other, MyClass) and self.a == other.a and self.b == other.b + +def function(a:int, b:str) -> MyClass: + return MyClass(a, b) + + +def function2(a:int, b:"str", c:MyClass) -> MyClass: + pass + + +def function3(a:"int", b:"str", c:"MyClass"): + pass + + +class UnannotatedClass: + pass + +def unannotated_function(a, b, c): pass diff --git a/Lib/test/test_inspect/inspect_stringized_annotations.py b/Lib/test/test_inspect/inspect_stringized_annotations.py new file mode 100644 index 0000000..a56fb05 --- /dev/null +++ b/Lib/test/test_inspect/inspect_stringized_annotations.py @@ -0,0 +1,34 @@ +from __future__ import annotations + +a:int=3 +b:str="foo" + +class MyClass: + a:int=4 + b:str="bar" + def __init__(self, a, b): + self.a = a + self.b = b + def __eq__(self, other): + return isinstance(other, MyClass) and self.a == other.a and self.b == other.b + +def function(a:int, b:str) -> MyClass: + return MyClass(a, b) + + +def function2(a:int, b:"str", c:MyClass) -> MyClass: + pass + + +def function3(a:"int", b:"str", c:"MyClass"): + pass + + +class UnannotatedClass: + pass + +def unannotated_function(a, b, c): pass + +class MyClassWithLocalAnnotations: + mytype = int + x: mytype diff --git a/Lib/test/test_inspect/inspect_stringized_annotations_2.py b/Lib/test/test_inspect/inspect_stringized_annotations_2.py new file mode 100644 index 0000000..87206d5 --- /dev/null +++ b/Lib/test/test_inspect/inspect_stringized_annotations_2.py @@ -0,0 +1,3 @@ +from __future__ import annotations + +def foo(a, b, c): pass diff --git a/Lib/test/test_inspect/test_inspect.py b/Lib/test/test_inspect/test_inspect.py new file mode 100644 index 0000000..31ac6b1 --- /dev/null +++ b/Lib/test/test_inspect/test_inspect.py @@ -0,0 +1,4965 @@ +import asyncio +import builtins +import collections +import copy +import datetime +import functools +import importlib +import inspect +import io +import linecache +import os +import dis +from os.path import normcase +import _pickle +import pickle +import shutil +import stat +import sys +import time +import types +import tempfile +import textwrap +import unicodedata +import unittest +import unittest.mock +import warnings + + +try: + from concurrent.futures import ThreadPoolExecutor +except ImportError: + ThreadPoolExecutor = None + +from test.support import cpython_only +from test.support import MISSING_C_DOCSTRINGS, ALWAYS_EQ +from test.support.import_helper import DirsOnSysPath, ready_to_import +from test.support.os_helper import TESTFN +from test.support.script_helper import assert_python_ok, assert_python_failure +from test import support + +from . import inspect_fodder as mod +from . import inspect_fodder2 as mod2 +from . import inspect_stock_annotations +from . import inspect_stringized_annotations +from . import inspect_stringized_annotations_2 + + +# Functions tested in this suite: +# ismodule, isclass, ismethod, isfunction, istraceback, isframe, iscode, +# isbuiltin, isroutine, isgenerator, isgeneratorfunction, getmembers, +# getdoc, getfile, getmodule, getsourcefile, getcomments, getsource, +# getclasstree, getargvalues, formatargvalues, +# currentframe, stack, trace, isdatadescriptor, +# ismethodwrapper + +# NOTE: There are some additional tests relating to interaction with +# zipimport in the test_zipimport_support test module. + +modfile = mod.__file__ +if modfile.endswith(('c', 'o')): + modfile = modfile[:-1] + +# Normalize file names: on Windows, the case of file names of compiled +# modules depends on the path used to start the python executable. +modfile = normcase(modfile) + +def revise(filename, *args): + return (normcase(filename),) + args + +git = mod.StupidGit() + + +def tearDownModule(): + if support.has_socket_support: + asyncio.set_event_loop_policy(None) + + +def signatures_with_lexicographic_keyword_only_parameters(): + """ + Yields a whole bunch of functions with only keyword-only parameters, + where those parameters are always in lexicographically sorted order. + """ + 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) + yield symbols['foo'] + + +def unsorted_keyword_only_parameters_fn(*, throw, out, the, baby, with_, + the_, bathwater): + pass + +unsorted_keyword_only_parameters = 'throw out the baby with_ the_ bathwater'.split() + +class IsTestBase(unittest.TestCase): + 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): + support.check__all__(self, inspect, not_exported=("modulesbyfile",)) + +def generator_function_example(self): + for i in range(2): + yield i + +async def async_generator_function_example(self): + async for i in range(2): + yield i + +async def coroutine_function_example(self): + return 'spam' + +@types.coroutine +def gen_coroutine_function_example(self): + yield + return 'spam' + +def meth_noargs(): pass +def meth_o(object, /): pass +def meth_self_noargs(self, /): pass +def meth_self_o(self, object, /): pass +def meth_type_noargs(type, /): pass +def meth_type_o(type, object, /): pass + + +class TestPredicates(IsTestBase): + + 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)) + + async def _fn3(): + pass + + @inspect.markcoroutinefunction + def fn3(): + return _fn3() + + self.assertTrue(inspect.iscoroutinefunction(fn3)) + self.assertTrue( + inspect.iscoroutinefunction( + inspect.markcoroutinefunction(lambda: _fn3()) + ) + ) + + class Cl: + async def __call__(self): + pass + + self.assertFalse(inspect.iscoroutinefunction(Cl)) + # instances with async def __call__ are NOT recognised. + self.assertFalse(inspect.iscoroutinefunction(Cl())) + # unless explicitly marked. + self.assertTrue(inspect.iscoroutinefunction( + inspect.markcoroutinefunction(Cl()) + )) + + class Cl2: + @inspect.markcoroutinefunction + def __call__(self): + pass + + self.assertFalse(inspect.iscoroutinefunction(Cl2)) + # instances with marked __call__ are NOT recognised. + self.assertFalse(inspect.iscoroutinefunction(Cl2())) + # unless explicitly marked. + self.assertTrue(inspect.iscoroutinefunction( + inspect.markcoroutinefunction(Cl2()) + )) + + class Cl3: + @inspect.markcoroutinefunction + @classmethod + def do_something_classy(cls): + pass + + @inspect.markcoroutinefunction + @staticmethod + def do_something_static(): + pass + + self.assertTrue(inspect.iscoroutinefunction(Cl3.do_something_classy)) + self.assertTrue(inspect.iscoroutinefunction(Cl3.do_something_static)) + + 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 + self.assertEqual(isabstract_checks, [True, True, False]) + + +class TestInterpreterStack(IsTestBase): + 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.__traceback__') + 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), + '(a=7, b=8, c=9, d=3, e=4, f=5, *g=(), **h={})') + +class GetSourceBase(unittest.TestCase): + # 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), + self.sourcerange(top, bottom)) + +class SlotUser: + 'Docstrings for __slots__' + __slots__ = {'power': 'measured in kilowatts', + 'distance': 'measured in kilometers'} + +class TestRetrievingSourceCode(GetSourceBase): + 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, [('after_closing', mod.after_closing), + ('eggs', mod.eggs), + ('lobbest', mod.lobbest), + ('spam', mod.spam)]) + + @unittest.skipIf(sys.flags.optimize >= 2, + "Docstrings are omitted with -O2 and above") + 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, + "Docstrings are omitted with -O2 and above") + 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__) + + cleandoc_testdata = [ + # first line should have different margin + (' An\n indented\n docstring.', 'An\nindented\n docstring.'), + # trailing whitespace are not removed. + (' An \n \n indented \n docstring. ', + 'An \n \nindented \n docstring. '), + # NUL is not termination. + ('doc\0string\n\n second\0line\n third\0line\0', + 'doc\0string\n\nsecond\0line\nthird\0line\0'), + # first line is lstrip()-ped. other lines are kept when no margin.[w: + (' ', ''), + # compiler.cleandoc() doesn't strip leading/trailing newlines + # to keep maximum backward compatibility. + # inspect.cleandoc() removes them. + ('\n\n\n first paragraph\n\n second paragraph\n\n', + '\n\n\nfirst paragraph\n\n second paragraph\n\n'), + (' \n \n \n ', '\n \n \n '), + ] + + def test_cleandoc(self): + func = inspect.cleandoc + for i, (input, expected) in enumerate(self.cleandoc_testdata): + # only inspect.cleandoc() strip \n + expected = expected.strip('\n') + with self.subTest(i=i): + self.assertEqual(func(input), expected) + + @cpython_only + def test_c_cleandoc(self): + import _testinternalcapi + func = _testinternalcapi.compiler_cleandoc + for i, (input, expected) in enumerate(self.cleandoc_testdata): + with self.subTest(i=i): + self.assertEqual(func(input), expected) + + 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) + self.assertSourceEqual(mod.after_closing, 120, 120) + + 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('') + 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 = '', '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): + self.assertSourceEqual(mod.eggs.__code__, 12, 18) + +class TestGetsourceInteractive(unittest.TestCase): + def test_getclasses_interactive(self): + # bpo-44648: simulate a REPL session; + # there is no `__file__` in the __main__ module + code = "import sys, inspect; \ + assert not hasattr(sys.modules['__main__'], '__file__'); \ + A = type('A', (), {}); \ + inspect.getsource(A)" + _, _, stderr = assert_python_failure("-c", code, __isolated=True) + self.assertIn(b'OSError: source code not available', stderr) + +class TestGettingSourceOfToplevelFrames(GetSourceBase): + fodderModule = mod + + def test_range_toplevel_frame(self): + self.maxDiff = None + self.assertSourceEqual(mod.currentframe, 1, None) + + def test_range_traceback_toplevel_frame(self): + self.assertSourceEqual(mod.tb, 1, None) + +class TestDecorators(GetSourceBase): + 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): + self.assertSourceEqual(mod2.func114, 113, 115) + +class TestOneliners(GetSourceBase): + 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_parenthesized_multiline_lambda(self): + # Test inspect.getsource with a parenthesized multi-line lambda + # function. + self.assertSourceEqual(mod2.parenthesized_lambda, 279, 279) + self.assertSourceEqual(mod2.parenthesized_lambda2, 281, 281) + self.assertSourceEqual(mod2.parenthesized_lambda3, 283, 283) + + def test_post_line_parenthesized_lambda(self): + # Test inspect.getsource with a parenthesized multi-line lambda + # function. + self.assertSourceEqual(mod2.post_line_parenthesized_lambda1, 286, 287) + + def test_nested_lambda(self): + # Test inspect.getsource with a nested lambda function. + self.assertSourceEqual(mod2.nested_lambda, 291, 292) + + 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. + self.assertSourceEqual(mod2.anonymous, 55, 55) + +class TestBlockComments(GetSourceBase): + 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): + self.assertSourceEqual(mod.WhichComments.asyncf, 109, 112) + +class TestBuggyCases(GetSourceBase): + 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 + unicodedata.__file__.endswith('.py'), + "unicodedata is not an external binary module") + 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 ['', '']: + 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.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) + + def test_class_with_method_from_other_module(self): + with tempfile.TemporaryDirectory() as tempdir: + with open(os.path.join(tempdir, 'inspect_actual%spy' % os.extsep), + 'w', encoding='utf-8') as f: + f.write(textwrap.dedent(""" + import inspect_other + class A: + def f(self): + pass + class A: + def f(self): + pass # correct one + A.f = inspect_other.A.f + """)) + + with open(os.path.join(tempdir, 'inspect_other%spy' % os.extsep), + 'w', encoding='utf-8') as f: + f.write(textwrap.dedent(""" + class A: + def f(self): + pass + """)) + + with DirsOnSysPath(tempdir): + import inspect_actual + self.assertIn("correct", inspect.getsource(inspect_actual.A)) + # Remove the module from sys.modules to force it to be reloaded. + # This is necessary when the test is run multiple times. + sys.modules.pop("inspect_actual") + + @unittest.skipIf( + support.is_emscripten or support.is_wasi, + "socket.accept is broken" + ) + 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) + self.assertSourceEqual(asyncio.run(mod2.cls226().func232()), 233, 234) + + def test_class_definition_same_name_diff_methods(self): + self.assertSourceEqual(mod2.cls296, 296, 298) + self.assertSourceEqual(mod2.cls310, 310, 312) + +class TestNoEOL(GetSourceBase): + 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): + self.assertSourceEqual(self.fodderModule.X, 1, 2) + + +class TestComplexDecorator(GetSourceBase): + fodderModule = mod2 + + def test_parens_in_decorator(self): + self.assertSourceEqual(self.fodderModule.complex_decorated, 273, 275) + +class _BrokenDataDescriptor(object): + """ + A broken data descriptor. See bug #1785. + """ + def __get__(*args): + raise AttributeError("broken data descriptor") + + def __set__(*args): + raise RuntimeError + + def __getattr__(*args): + raise AttributeError("broken data descriptor") + + +class _BrokenMethodDescriptor(object): + """ + A broken method descriptor. See bug #1785. + """ + def __get__(*args): + raise AttributeError("broken method descriptor") + + def __getattr__(*args): + raise AttributeError("broken method descriptor") + + +# Helper for testing classify_class_attrs. +def attrs_wo_objs(cls): + return [t[:3] for t in inspect.classify_class_attrs(cls)] + + +class TestClassesAndFunctions(unittest.TestCase): + 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, + "Signature information for builtins requires docstrings") + def test_getfullargspec_builtin_methods(self): + self.assertFullArgSpecEquals(_pickle.Pickler.dump, ['self', 'obj']) + + self.assertFullArgSpecEquals(_pickle.Pickler(io.BytesIO()).dump, ['self', 'obj']) + + self.assertFullArgSpecEquals( + os.stat, + args_e=['path'], + kwonlyargs_e=['dir_fd', 'follow_symlinks'], + kwonlydefaults_e={'dir_fd': None, 'follow_symlinks': True}) + + @cpython_only + @unittest.skipIf(MISSING_C_DOCSTRINGS, + "Signature information for builtins requires docstrings") + def test_getfullargspec_builtin_func(self): + import _testcapi + builtin = _testcapi.docstring_with_signature_with_defaults + spec = inspect.getfullargspec(builtin) + self.assertEqual(spec.defaults[0], 'avocado') + + @cpython_only + @unittest.skipIf(MISSING_C_DOCSTRINGS, + "Signature information for builtins requires docstrings") + def test_getfullargspec_builtin_func_no_signature(self): + import _testcapi + builtin = _testcapi.docstring_no_signature + with self.assertRaises(TypeError): + inspect.getfullargspec(builtin) + + cls = _testcapi.DocStringNoSignatureTest + obj = _testcapi.DocStringNoSignatureTest() + tests = [ + (_testcapi.docstring_no_signature_noargs, meth_noargs), + (_testcapi.docstring_no_signature_o, meth_o), + (cls.meth_noargs, meth_self_noargs), + (cls.meth_o, meth_self_o), + (obj.meth_noargs, meth_self_noargs), + (obj.meth_o, meth_self_o), + (cls.meth_noargs_class, meth_type_noargs), + (cls.meth_o_class, meth_type_o), + (cls.meth_noargs_static, meth_noargs), + (cls.meth_o_static, meth_o), + (cls.meth_noargs_coexist, meth_self_noargs), + (cls.meth_o_coexist, meth_self_o), + + (time.time, meth_noargs), + (str.lower, meth_self_noargs), + (''.lower, meth_self_noargs), + (set.add, meth_self_o), + (set().add, meth_self_o), + (set.__contains__, meth_self_o), + (set().__contains__, meth_self_o), + (datetime.datetime.__dict__['utcnow'], meth_type_noargs), + (datetime.datetime.utcnow, meth_type_noargs), + (dict.__dict__['__class_getitem__'], meth_type_o), + (dict.__class_getitem__, meth_type_o), + ] + try: + import _stat + except ImportError: + # if the _stat extension is not available, stat.S_IMODE() is + # implemented in Python, not in C + pass + else: + tests.append((stat.S_IMODE, meth_o)) + for builtin, template in tests: + with self.subTest(builtin): + self.assertEqual(inspect.getfullargspec(builtin), + inspect.getfullargspec(template)) + + def test_getfullargspec_definition_order_preserved_on_kwonly(self): + for fn in signatures_with_lexicographic_keyword_only_parameters(): + signature = inspect.getfullargspec(fn) + l = list(signature.kwonlyargs) + sorted_l = sorted(l) + self.assertTrue(l) + self.assertEqual(l, sorted_l) + signature = inspect.getfullargspec(unsorted_keyword_only_parameters_fn) + l = list(signature.kwonlyargs) + self.assertEqual(l, unsorted_keyword_only_parameters) + + def test_classify_newstyle(self): + class A(object): + + def s(): pass + s = staticmethod(s) + + def c(cls): pass + c = classmethod(c) + + def getp(self): pass + p = property(getp) + + def m(self): pass + + def m1(self): pass + + datablob = '1' + + dd = _BrokenDataDescriptor() + md = _BrokenMethodDescriptor() + + attrs = attrs_wo_objs(A) + + self.assertIn(('__new__', 'static method', object), attrs, + 'missing __new__') + self.assertIn(('__init__', 'method', object), attrs, 'missing __init__') + + self.assertIn(('s', 'static method', A), attrs, 'missing static method') + self.assertIn(('c', 'class method', A), attrs, 'missing class method') + self.assertIn(('p', 'property', A), attrs, 'missing property') + self.assertIn(('m', 'method', A), attrs, + 'missing plain method: %r' % attrs) + self.assertIn(('m1', 'method', A), attrs, 'missing plain method') + self.assertIn(('datablob', 'data', A), attrs, 'missing data') + self.assertIn(('md', 'method', A), attrs, 'missing method descriptor') + self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor') + + class B(A): + + def m(self): pass + + attrs = attrs_wo_objs(B) + self.assertIn(('s', 'static method', A), attrs, 'missing static method') + self.assertIn(('c', 'class method', A), attrs, 'missing class method') + self.assertIn(('p', 'property', A), attrs, 'missing property') + self.assertIn(('m', 'method', B), attrs, 'missing plain method') + self.assertIn(('m1', 'method', A), attrs, 'missing plain method') + self.assertIn(('datablob', 'data', A), attrs, 'missing data') + self.assertIn(('md', 'method', A), attrs, 'missing method descriptor') + self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor') + + + class C(A): + + def m(self): pass + def c(self): pass + + attrs = attrs_wo_objs(C) + self.assertIn(('s', 'static method', A), attrs, 'missing static method') + self.assertIn(('c', 'method', C), attrs, 'missing plain method') + self.assertIn(('p', 'property', A), attrs, 'missing property') + self.assertIn(('m', 'method', C), attrs, 'missing plain method') + self.assertIn(('m1', 'method', A), attrs, 'missing plain method') + self.assertIn(('datablob', 'data', A), attrs, 'missing data') + self.assertIn(('md', 'method', A), attrs, 'missing method descriptor') + self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor') + + class D(B, C): + + def m1(self): pass + + attrs = attrs_wo_objs(D) + self.assertIn(('s', 'static method', A), attrs, 'missing static method') + self.assertIn(('c', 'method', C), attrs, 'missing plain method') + self.assertIn(('p', 'property', A), attrs, 'missing property') + self.assertIn(('m', 'method', B), attrs, 'missing plain method') + self.assertIn(('m1', 'method', D), attrs, 'missing plain method') + self.assertIn(('datablob', 'data', A), attrs, 'missing data') + self.assertIn(('md', 'method', A), attrs, 'missing method descriptor') + self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor') + + def test_classify_builtin_types(self): + # Simple sanity check that all built-in types can have their + # attributes classified. + for name in dir(__builtins__): + builtin = getattr(__builtins__, name) + if isinstance(builtin, type): + inspect.classify_class_attrs(builtin) + + attrs = attrs_wo_objs(bool) + self.assertIn(('__new__', 'static method', bool), attrs, + 'missing __new__') + self.assertIn(('from_bytes', 'class method', int), attrs, + 'missing class method') + self.assertIn(('to_bytes', 'method', int), attrs, + 'missing plain method') + self.assertIn(('__add__', 'method', int), attrs, + 'missing plain method') + self.assertIn(('__and__', 'method', bool), attrs, + 'missing plain method') + + def test_classify_DynamicClassAttribute(self): + class Meta(type): + def __getattr__(self, name): + if name == 'ham': + return 'spam' + return super().__getattr__(name) + class VA(metaclass=Meta): + @types.DynamicClassAttribute + def ham(self): + return 'eggs' + should_find_dca = inspect.Attribute('ham', 'data', VA, VA.__dict__['ham']) + self.assertIn(should_find_dca, inspect.classify_class_attrs(VA)) + should_find_ga = inspect.Attribute('ham', 'data', Meta, 'spam') + self.assertIn(should_find_ga, inspect.classify_class_attrs(VA)) + + def test_classify_overrides_bool(self): + class NoBool(object): + def __eq__(self, other): + return NoBool() + + def __bool__(self): + raise NotImplementedError( + "This object does not specify a boolean value") + + class HasNB(object): + dd = NoBool() + + should_find_attr = inspect.Attribute('dd', 'data', HasNB, HasNB.dd) + self.assertIn(should_find_attr, inspect.classify_class_attrs(HasNB)) + + def test_classify_metaclass_class_attribute(self): + class Meta(type): + fish = 'slap' + def __dir__(self): + return ['__class__', '__module__', '__name__', 'fish'] + class Class(metaclass=Meta): + pass + should_find = inspect.Attribute('fish', 'data', Meta, 'slap') + self.assertIn(should_find, inspect.classify_class_attrs(Class)) + + def test_classify_VirtualAttribute(self): + class Meta(type): + def __dir__(cls): + return ['__class__', '__module__', '__name__', 'BOOM'] + def __getattr__(self, name): + if name =='BOOM': + return 42 + return super().__getattr(name) + class Class(metaclass=Meta): + pass + should_find = inspect.Attribute('BOOM', 'data', Meta, 42) + self.assertIn(should_find, inspect.classify_class_attrs(Class)) + + def test_classify_VirtualAttribute_multi_classes(self): + class Meta1(type): + def __dir__(cls): + return ['__class__', '__module__', '__name__', 'one'] + def __getattr__(self, name): + if name =='one': + return 1 + return super().__getattr__(name) + class Meta2(type): + def __dir__(cls): + return ['__class__', '__module__', '__name__', 'two'] + def __getattr__(self, name): + if name =='two': + return 2 + return super().__getattr__(name) + class Meta3(Meta1, Meta2): + def __dir__(cls): + return list(sorted(set(['__class__', '__module__', '__name__', 'three'] + + Meta1.__dir__(cls) + Meta2.__dir__(cls)))) + def __getattr__(self, name): + if name =='three': + return 3 + return super().__getattr__(name) + class Class1(metaclass=Meta1): + pass + class Class2(Class1, metaclass=Meta3): + pass + + should_find1 = inspect.Attribute('one', 'data', Meta1, 1) + should_find2 = inspect.Attribute('two', 'data', Meta2, 2) + should_find3 = inspect.Attribute('three', 'data', Meta3, 3) + cca = inspect.classify_class_attrs(Class2) + for sf in (should_find1, should_find2, should_find3): + self.assertIn(sf, cca) + + def test_classify_class_attrs_with_buggy_dir(self): + class M(type): + def __dir__(cls): + return ['__class__', '__name__', 'missing'] + class C(metaclass=M): + pass + attrs = [a[0] for a in inspect.classify_class_attrs(C)] + self.assertNotIn('missing', attrs) + + def test_getmembers_descriptors(self): + class A(object): + dd = _BrokenDataDescriptor() + md = _BrokenMethodDescriptor() + + def pred_wrapper(pred): + # A quick'n'dirty way to discard standard attributes of new-style + # classes. + class Empty(object): + pass + def wrapped(x): + if '__name__' in dir(x) and hasattr(Empty, x.__name__): + return False + return pred(x) + return wrapped + + ismethoddescriptor = pred_wrapper(inspect.ismethoddescriptor) + isdatadescriptor = pred_wrapper(inspect.isdatadescriptor) + + self.assertEqual(inspect.getmembers(A, ismethoddescriptor), + [('md', A.__dict__['md'])]) + self.assertEqual(inspect.getmembers(A, isdatadescriptor), + [('dd', A.__dict__['dd'])]) + + class B(A): + pass + + self.assertEqual(inspect.getmembers(B, ismethoddescriptor), + [('md', A.__dict__['md'])]) + self.assertEqual(inspect.getmembers(B, isdatadescriptor), + [('dd', A.__dict__['dd'])]) + + def test_getmembers_method(self): + class B: + def f(self): + pass + + self.assertIn(('f', B.f), inspect.getmembers(B)) + self.assertNotIn(('f', B.f), inspect.getmembers(B, inspect.ismethod)) + b = B() + self.assertIn(('f', b.f), inspect.getmembers(b)) + self.assertIn(('f', b.f), inspect.getmembers(b, inspect.ismethod)) + + def test_getmembers_VirtualAttribute(self): + class M(type): + def __getattr__(cls, name): + if name == 'eggs': + return 'scrambled' + return super().__getattr__(name) + class A(metaclass=M): + @types.DynamicClassAttribute + def eggs(self): + return 'spam' + class B: + def __getattr__(self, attribute): + return None + self.assertIn(('eggs', 'scrambled'), inspect.getmembers(A)) + self.assertIn(('eggs', 'spam'), inspect.getmembers(A())) + b = B() + self.assertIn(('__getattr__', b.__getattr__), inspect.getmembers(b)) + + def test_getmembers_static(self): + class A: + @property + def name(self): + raise NotImplementedError + @types.DynamicClassAttribute + def eggs(self): + raise NotImplementedError + + a = A() + instance_members = inspect.getmembers_static(a) + class_members = inspect.getmembers_static(A) + self.assertIn(('name', inspect.getattr_static(a, 'name')), instance_members) + self.assertIn(('eggs', inspect.getattr_static(a, 'eggs')), instance_members) + self.assertIn(('name', inspect.getattr_static(A, 'name')), class_members) + self.assertIn(('eggs', inspect.getattr_static(A, 'eggs')), class_members) + + def test_getmembers_with_buggy_dir(self): + class M(type): + def __dir__(cls): + return ['__class__', '__name__', 'missing'] + class C(metaclass=M): + pass + attrs = [a[0] for a in inspect.getmembers(C)] + self.assertNotIn('missing', attrs) + + def test_get_annotations_with_stock_annotations(self): + def foo(a:int, b:str): pass + self.assertEqual(inspect.get_annotations(foo), {'a': int, 'b': str}) + + foo.__annotations__ = {'a': 'foo', 'b':'str'} + self.assertEqual(inspect.get_annotations(foo), {'a': 'foo', 'b': 'str'}) + + self.assertEqual(inspect.get_annotations(foo, eval_str=True, locals=locals()), {'a': foo, 'b': str}) + self.assertEqual(inspect.get_annotations(foo, eval_str=True, globals=locals()), {'a': foo, 'b': str}) + + isa = inspect_stock_annotations + self.assertEqual(inspect.get_annotations(isa), {'a': int, 'b': str}) + self.assertEqual(inspect.get_annotations(isa.MyClass), {'a': int, 'b': str}) + self.assertEqual(inspect.get_annotations(isa.function), {'a': int, 'b': str, 'return': isa.MyClass}) + self.assertEqual(inspect.get_annotations(isa.function2), {'a': int, 'b': 'str', 'c': isa.MyClass, 'return': isa.MyClass}) + self.assertEqual(inspect.get_annotations(isa.function3), {'a': 'int', 'b': 'str', 'c': 'MyClass'}) + self.assertEqual(inspect.get_annotations(inspect), {}) # inspect module has no annotations + self.assertEqual(inspect.get_annotations(isa.UnannotatedClass), {}) + self.assertEqual(inspect.get_annotations(isa.unannotated_function), {}) + + self.assertEqual(inspect.get_annotations(isa, eval_str=True), {'a': int, 'b': str}) + self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=True), {'a': int, 'b': str}) + self.assertEqual(inspect.get_annotations(isa.function, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass}) + self.assertEqual(inspect.get_annotations(isa.function2, eval_str=True), {'a': int, 'b': str, 'c': isa.MyClass, 'return': isa.MyClass}) + self.assertEqual(inspect.get_annotations(isa.function3, eval_str=True), {'a': int, 'b': str, 'c': isa.MyClass}) + self.assertEqual(inspect.get_annotations(inspect, eval_str=True), {}) + self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=True), {}) + self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=True), {}) + + self.assertEqual(inspect.get_annotations(isa, eval_str=False), {'a': int, 'b': str}) + self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=False), {'a': int, 'b': str}) + self.assertEqual(inspect.get_annotations(isa.function, eval_str=False), {'a': int, 'b': str, 'return': isa.MyClass}) + self.assertEqual(inspect.get_annotations(isa.function2, eval_str=False), {'a': int, 'b': 'str', 'c': isa.MyClass, 'return': isa.MyClass}) + self.assertEqual(inspect.get_annotations(isa.function3, eval_str=False), {'a': 'int', 'b': 'str', 'c': 'MyClass'}) + self.assertEqual(inspect.get_annotations(inspect, eval_str=False), {}) + self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=False), {}) + self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=False), {}) + + def times_three(fn): + @functools.wraps(fn) + def wrapper(a, b): + return fn(a*3, b*3) + return wrapper + + wrapped = times_three(isa.function) + self.assertEqual(wrapped(1, 'x'), isa.MyClass(3, 'xxx')) + self.assertIsNot(wrapped.__globals__, isa.function.__globals__) + self.assertEqual(inspect.get_annotations(wrapped), {'a': int, 'b': str, 'return': isa.MyClass}) + self.assertEqual(inspect.get_annotations(wrapped, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass}) + self.assertEqual(inspect.get_annotations(wrapped, eval_str=False), {'a': int, 'b': str, 'return': isa.MyClass}) + + def test_get_annotations_with_stringized_annotations(self): + isa = inspect_stringized_annotations + self.assertEqual(inspect.get_annotations(isa), {'a': 'int', 'b': 'str'}) + self.assertEqual(inspect.get_annotations(isa.MyClass), {'a': 'int', 'b': 'str'}) + self.assertEqual(inspect.get_annotations(isa.function), {'a': 'int', 'b': 'str', 'return': 'MyClass'}) + self.assertEqual(inspect.get_annotations(isa.function2), {'a': 'int', 'b': "'str'", 'c': 'MyClass', 'return': 'MyClass'}) + self.assertEqual(inspect.get_annotations(isa.function3), {'a': "'int'", 'b': "'str'", 'c': "'MyClass'"}) + self.assertEqual(inspect.get_annotations(isa.UnannotatedClass), {}) + self.assertEqual(inspect.get_annotations(isa.unannotated_function), {}) + + self.assertEqual(inspect.get_annotations(isa, eval_str=True), {'a': int, 'b': str}) + self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=True), {'a': int, 'b': str}) + self.assertEqual(inspect.get_annotations(isa.function, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass}) + self.assertEqual(inspect.get_annotations(isa.function2, eval_str=True), {'a': int, 'b': 'str', 'c': isa.MyClass, 'return': isa.MyClass}) + self.assertEqual(inspect.get_annotations(isa.function3, eval_str=True), {'a': 'int', 'b': 'str', 'c': 'MyClass'}) + self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=True), {}) + self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=True), {}) + + self.assertEqual(inspect.get_annotations(isa, eval_str=False), {'a': 'int', 'b': 'str'}) + self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=False), {'a': 'int', 'b': 'str'}) + self.assertEqual(inspect.get_annotations(isa.function, eval_str=False), {'a': 'int', 'b': 'str', 'return': 'MyClass'}) + self.assertEqual(inspect.get_annotations(isa.function2, eval_str=False), {'a': 'int', 'b': "'str'", 'c': 'MyClass', 'return': 'MyClass'}) + self.assertEqual(inspect.get_annotations(isa.function3, eval_str=False), {'a': "'int'", 'b': "'str'", 'c': "'MyClass'"}) + self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=False), {}) + self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=False), {}) + + isa2 = inspect_stringized_annotations_2 + self.assertEqual(inspect.get_annotations(isa2), {}) + self.assertEqual(inspect.get_annotations(isa2, eval_str=True), {}) + self.assertEqual(inspect.get_annotations(isa2, eval_str=False), {}) + + def times_three(fn): + @functools.wraps(fn) + def wrapper(a, b): + return fn(a*3, b*3) + return wrapper + + wrapped = times_three(isa.function) + self.assertEqual(wrapped(1, 'x'), isa.MyClass(3, 'xxx')) + self.assertIsNot(wrapped.__globals__, isa.function.__globals__) + self.assertEqual(inspect.get_annotations(wrapped), {'a': 'int', 'b': 'str', 'return': 'MyClass'}) + self.assertEqual(inspect.get_annotations(wrapped, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass}) + self.assertEqual(inspect.get_annotations(wrapped, eval_str=False), {'a': 'int', 'b': 'str', 'return': 'MyClass'}) + + # test that local namespace lookups work + self.assertEqual(inspect.get_annotations(isa.MyClassWithLocalAnnotations), {'x': 'mytype'}) + self.assertEqual(inspect.get_annotations(isa.MyClassWithLocalAnnotations, eval_str=True), {'x': int}) + + +class TestFormatAnnotation(unittest.TestCase): + def test_typing_replacement(self): + from test.typinganndata.ann_module9 import ann, ann1 + self.assertEqual(inspect.formatannotation(ann), 'Union[List[str], int]') + self.assertEqual(inspect.formatannotation(ann1), 'Union[List[testModule.typing.A], int]') + + +class TestIsDataDescriptor(unittest.TestCase): + + def test_custom_descriptors(self): + class NonDataDescriptor: + def __get__(self, value, type=None): pass + class DataDescriptor0: + def __set__(self, name, value): pass + class DataDescriptor1: + def __delete__(self, name): pass + class DataDescriptor2: + __set__ = None + self.assertFalse(inspect.isdatadescriptor(NonDataDescriptor()), + 'class with only __get__ not a data descriptor') + self.assertTrue(inspect.isdatadescriptor(DataDescriptor0()), + 'class with __set__ is a data descriptor') + self.assertTrue(inspect.isdatadescriptor(DataDescriptor1()), + 'class with __delete__ is a data descriptor') + self.assertTrue(inspect.isdatadescriptor(DataDescriptor2()), + 'class with __set__ = None is a data descriptor') + + def test_slot(self): + class Slotted: + __slots__ = 'foo', + self.assertTrue(inspect.isdatadescriptor(Slotted.foo), + 'a slot is a data descriptor') + + def test_property(self): + class Propertied: + @property + def a_property(self): + pass + self.assertTrue(inspect.isdatadescriptor(Propertied.a_property), + 'a property is a data descriptor') + + def test_functions(self): + class Test(object): + def instance_method(self): pass + @classmethod + def class_method(cls): pass + @staticmethod + def static_method(): pass + def function(): + pass + a_lambda = lambda: None + self.assertFalse(inspect.isdatadescriptor(Test().instance_method), + 'a instance method is not a data descriptor') + self.assertFalse(inspect.isdatadescriptor(Test().class_method), + 'a class method is not a data descriptor') + self.assertFalse(inspect.isdatadescriptor(Test().static_method), + 'a static method is not a data descriptor') + self.assertFalse(inspect.isdatadescriptor(function), + 'a function is not a data descriptor') + self.assertFalse(inspect.isdatadescriptor(a_lambda), + 'a lambda is not a data descriptor') + + +_global_ref = object() +class TestGetClosureVars(unittest.TestCase): + + def test_name_resolution(self): + # Basic test of the 4 different resolution mechanisms + def f(nonlocal_ref): + def g(local_ref): + print(local_ref, nonlocal_ref, _global_ref, unbound_ref) + return g + _arg = object() + nonlocal_vars = {"nonlocal_ref": _arg} + global_vars = {"_global_ref": _global_ref} + builtin_vars = {"print": print} + unbound_names = {"unbound_ref"} + expected = inspect.ClosureVars(nonlocal_vars, global_vars, + builtin_vars, unbound_names) + self.assertEqual(inspect.getclosurevars(f(_arg)), expected) + + def test_generator_closure(self): + def f(nonlocal_ref): + def g(local_ref): + print(local_ref, nonlocal_ref, _global_ref, unbound_ref) + yield + return g + _arg = object() + nonlocal_vars = {"nonlocal_ref": _arg} + global_vars = {"_global_ref": _global_ref} + builtin_vars = {"print": print} + unbound_names = {"unbound_ref"} + expected = inspect.ClosureVars(nonlocal_vars, global_vars, + builtin_vars, unbound_names) + self.assertEqual(inspect.getclosurevars(f(_arg)), expected) + + def test_method_closure(self): + class C: + def f(self, nonlocal_ref): + def g(local_ref): + print(local_ref, nonlocal_ref, _global_ref, unbound_ref) + return g + _arg = object() + nonlocal_vars = {"nonlocal_ref": _arg} + global_vars = {"_global_ref": _global_ref} + builtin_vars = {"print": print} + unbound_names = {"unbound_ref"} + expected = inspect.ClosureVars(nonlocal_vars, global_vars, + builtin_vars, unbound_names) + self.assertEqual(inspect.getclosurevars(C().f(_arg)), expected) + + def test_nonlocal_vars(self): + # More complex tests of nonlocal resolution + def _nonlocal_vars(f): + return inspect.getclosurevars(f).nonlocals + + def make_adder(x): + def add(y): + return x + y + return add + + def curry(func, arg1): + return lambda arg2: func(arg1, arg2) + + def less_than(a, b): + return a < b + + # The infamous Y combinator. + def Y(le): + def g(f): + return le(lambda x: f(f)(x)) + Y.g_ref = g + return g(g) + + def check_y_combinator(func): + self.assertEqual(_nonlocal_vars(func), {'f': Y.g_ref}) + + inc = make_adder(1) + add_two = make_adder(2) + greater_than_five = curry(less_than, 5) + + self.assertEqual(_nonlocal_vars(inc), {'x': 1}) + self.assertEqual(_nonlocal_vars(add_two), {'x': 2}) + self.assertEqual(_nonlocal_vars(greater_than_five), + {'arg1': 5, 'func': less_than}) + self.assertEqual(_nonlocal_vars((lambda x: lambda y: x + y)(3)), + {'x': 3}) + Y(check_y_combinator) + + def test_getclosurevars_empty(self): + def foo(): pass + _empty = inspect.ClosureVars({}, {}, {}, set()) + self.assertEqual(inspect.getclosurevars(lambda: True), _empty) + self.assertEqual(inspect.getclosurevars(foo), _empty) + + def test_getclosurevars_error(self): + class T: pass + self.assertRaises(TypeError, inspect.getclosurevars, 1) + self.assertRaises(TypeError, inspect.getclosurevars, list) + self.assertRaises(TypeError, inspect.getclosurevars, {}) + + def _private_globals(self): + code = """def f(): print(path)""" + ns = {} + exec(code, ns) + return ns["f"], ns + + def test_builtins_fallback(self): + f, ns = self._private_globals() + ns.pop("__builtins__", None) + expected = inspect.ClosureVars({}, {}, {"print":print}, {"path"}) + self.assertEqual(inspect.getclosurevars(f), expected) + + def test_builtins_as_dict(self): + f, ns = self._private_globals() + ns["__builtins__"] = {"path":1} + expected = inspect.ClosureVars({}, {}, {"path":1}, {"print"}) + self.assertEqual(inspect.getclosurevars(f), expected) + + def test_builtins_as_module(self): + f, ns = self._private_globals() + ns["__builtins__"] = os + expected = inspect.ClosureVars({}, {}, {"path":os.path}, {"print"}) + self.assertEqual(inspect.getclosurevars(f), expected) + + +class TestGetcallargsFunctions(unittest.TestCase): + + def assertEqualCallArgs(self, func, call_params_string, locs=None): + locs = dict(locs or {}, func=func) + r1 = eval('func(%s)' % call_params_string, None, locs) + r2 = eval('inspect.getcallargs(func, %s)' % call_params_string, None, + locs) + self.assertEqual(r1, r2) + + def assertEqualException(self, func, call_param_string, locs=None): + locs = dict(locs or {}, func=func) + try: + eval('func(%s)' % call_param_string, None, locs) + except Exception as e: + ex1 = e + else: + self.fail('Exception not raised') + try: + eval('inspect.getcallargs(func, %s)' % call_param_string, None, + locs) + except Exception as e: + ex2 = e + else: + self.fail('Exception not raised') + self.assertIs(type(ex1), type(ex2)) + self.assertEqual(str(ex1), str(ex2)) + del ex1, ex2 + + def makeCallable(self, signature): + """Create a function that returns its locals()""" + code = "lambda %s: locals()" + return eval(code % signature) + + def test_plain(self): + f = self.makeCallable('a, b=1') + self.assertEqualCallArgs(f, '2') + self.assertEqualCallArgs(f, '2, 3') + self.assertEqualCallArgs(f, 'a=2') + self.assertEqualCallArgs(f, 'b=3, a=2') + self.assertEqualCallArgs(f, '2, b=3') + # expand *iterable / **mapping + self.assertEqualCallArgs(f, '*(2,)') + self.assertEqualCallArgs(f, '*[2]') + self.assertEqualCallArgs(f, '*(2, 3)') + self.assertEqualCallArgs(f, '*[2, 3]') + self.assertEqualCallArgs(f, '**{"a":2}') + self.assertEqualCallArgs(f, 'b=3, **{"a":2}') + self.assertEqualCallArgs(f, '2, **{"b":3}') + self.assertEqualCallArgs(f, '**{"b":3, "a":2}') + # expand UserList / UserDict + self.assertEqualCallArgs(f, '*collections.UserList([2])') + self.assertEqualCallArgs(f, '*collections.UserList([2, 3])') + self.assertEqualCallArgs(f, '**collections.UserDict(a=2)') + self.assertEqualCallArgs(f, '2, **collections.UserDict(b=3)') + self.assertEqualCallArgs(f, 'b=2, **collections.UserDict(a=3)') + + def test_varargs(self): + f = self.makeCallable('a, b=1, *c') + self.assertEqualCallArgs(f, '2') + self.assertEqualCallArgs(f, '2, 3') + self.assertEqualCallArgs(f, '2, 3, 4') + self.assertEqualCallArgs(f, '*(2,3,4)') + self.assertEqualCallArgs(f, '2, *[3,4]') + self.assertEqualCallArgs(f, '2, 3, *collections.UserList([4])') + + def test_varkw(self): + f = self.makeCallable('a, b=1, **c') + self.assertEqualCallArgs(f, 'a=2') + self.assertEqualCallArgs(f, '2, b=3, c=4') + self.assertEqualCallArgs(f, 'b=3, a=2, c=4') + self.assertEqualCallArgs(f, 'c=4, **{"a":2, "b":3}') + self.assertEqualCallArgs(f, '2, c=4, **{"b":3}') + self.assertEqualCallArgs(f, 'b=2, **{"a":3, "c":4}') + self.assertEqualCallArgs(f, '**collections.UserDict(a=2, b=3, c=4)') + self.assertEqualCallArgs(f, '2, c=4, **collections.UserDict(b=3)') + self.assertEqualCallArgs(f, 'b=2, **collections.UserDict(a=3, c=4)') + + def test_varkw_only(self): + # issue11256: + f = self.makeCallable('**c') + self.assertEqualCallArgs(f, '') + self.assertEqualCallArgs(f, 'a=1') + self.assertEqualCallArgs(f, 'a=1, b=2') + self.assertEqualCallArgs(f, 'c=3, **{"a": 1, "b": 2}') + self.assertEqualCallArgs(f, '**collections.UserDict(a=1, b=2)') + self.assertEqualCallArgs(f, 'c=3, **collections.UserDict(a=1, b=2)') + + def test_keyword_only(self): + f = self.makeCallable('a=3, *, c, d=2') + self.assertEqualCallArgs(f, 'c=3') + self.assertEqualCallArgs(f, 'c=3, a=3') + self.assertEqualCallArgs(f, 'a=2, c=4') + self.assertEqualCallArgs(f, '4, c=4') + self.assertEqualException(f, '') + self.assertEqualException(f, '3') + self.assertEqualException(f, 'a=3') + self.assertEqualException(f, 'd=4') + + f = self.makeCallable('*, c, d=2') + self.assertEqualCallArgs(f, 'c=3') + self.assertEqualCallArgs(f, 'c=3, d=4') + self.assertEqualCallArgs(f, 'd=4, c=3') + + def test_multiple_features(self): + f = self.makeCallable('a, b=2, *f, **g') + self.assertEqualCallArgs(f, '2, 3, 7') + self.assertEqualCallArgs(f, '2, 3, x=8') + self.assertEqualCallArgs(f, '2, 3, x=8, *[(4,[5,6]), 7]') + self.assertEqualCallArgs(f, '2, x=8, *[3, (4,[5,6]), 7], y=9') + self.assertEqualCallArgs(f, 'x=8, *[2, 3, (4,[5,6])], y=9') + self.assertEqualCallArgs(f, 'x=8, *collections.UserList(' + '[2, 3, (4,[5,6])]), **{"y":9, "z":10}') + self.assertEqualCallArgs(f, '2, x=8, *collections.UserList([3, ' + '(4,[5,6])]), **collections.UserDict(' + 'y=9, z=10)') + + f = self.makeCallable('a, b=2, *f, x, y=99, **g') + self.assertEqualCallArgs(f, '2, 3, x=8') + self.assertEqualCallArgs(f, '2, 3, x=8, *[(4,[5,6]), 7]') + self.assertEqualCallArgs(f, '2, x=8, *[3, (4,[5,6]), 7], y=9, z=10') + self.assertEqualCallArgs(f, 'x=8, *[2, 3, (4,[5,6])], y=9, z=10') + self.assertEqualCallArgs(f, 'x=8, *collections.UserList(' + '[2, 3, (4,[5,6])]), q=0, **{"y":9, "z":10}') + self.assertEqualCallArgs(f, '2, x=8, *collections.UserList([3, ' + '(4,[5,6])]), q=0, **collections.UserDict(' + 'y=9, z=10)') + + def test_errors(self): + f0 = self.makeCallable('') + f1 = self.makeCallable('a, b') + f2 = self.makeCallable('a, b=1') + # f0 takes no arguments + self.assertEqualException(f0, '1') + self.assertEqualException(f0, 'x=1') + self.assertEqualException(f0, '1,x=1') + # f1 takes exactly 2 arguments + self.assertEqualException(f1, '') + self.assertEqualException(f1, '1') + self.assertEqualException(f1, 'a=2') + self.assertEqualException(f1, 'b=3') + # f2 takes at least 1 argument + self.assertEqualException(f2, '') + self.assertEqualException(f2, 'b=3') + for f in f1, f2: + # f1/f2 takes exactly/at most 2 arguments + self.assertEqualException(f, '2, 3, 4') + self.assertEqualException(f, '1, 2, 3, a=1') + self.assertEqualException(f, '2, 3, 4, c=5') + self.assertEqualException(f, '2, 3, 4, a=1, c=5') + # f got an unexpected keyword argument + self.assertEqualException(f, 'c=2') + self.assertEqualException(f, '2, c=3') + self.assertEqualException(f, '2, 3, c=4') + self.assertEqualException(f, '2, c=4, b=3') + self.assertEqualException(f, '**{u"\u03c0\u03b9": 4}') + # f got multiple values for keyword argument + self.assertEqualException(f, '1, a=2') + self.assertEqualException(f, '1, **{"a":2}') + self.assertEqualException(f, '1, 2, b=3') + self.assertEqualException(f, '1, c=3, a=2') + # issue11256: + f3 = self.makeCallable('**c') + self.assertEqualException(f3, '1, 2') + self.assertEqualException(f3, '1, 2, a=1, b=2') + f4 = self.makeCallable('*, a, b=0') + self.assertEqualException(f4, '1, 2') + self.assertEqualException(f4, '1, 2, a=1, b=2') + self.assertEqualException(f4, 'a=1, a=3') + self.assertEqualException(f4, 'a=1, c=3') + self.assertEqualException(f4, 'a=1, a=3, b=4') + self.assertEqualException(f4, 'a=1, b=2, a=3, b=4') + self.assertEqualException(f4, 'a=1, a=2, a=3, b=4') + + # issue #20816: getcallargs() fails to iterate over non-existent + # kwonlydefaults and raises a wrong TypeError + def f5(*, a): pass + with self.assertRaisesRegex(TypeError, + 'missing 1 required keyword-only'): + inspect.getcallargs(f5) + + + # issue20817: + def f6(a, b, c): + pass + with self.assertRaisesRegex(TypeError, "'a', 'b' and 'c'"): + inspect.getcallargs(f6) + + # bpo-33197 + with self.assertRaisesRegex(ValueError, + 'variadic keyword parameters cannot' + ' have default values'): + inspect.Parameter("foo", kind=inspect.Parameter.VAR_KEYWORD, + default=42) + with self.assertRaisesRegex(ValueError, + "value 5 is not a valid Parameter.kind"): + inspect.Parameter("bar", kind=5, default=42) + + with self.assertRaisesRegex(TypeError, + 'name must be a str, not a int'): + inspect.Parameter(123, kind=4) + +class TestGetcallargsMethods(TestGetcallargsFunctions): + + def setUp(self): + class Foo(object): + pass + self.cls = Foo + self.inst = Foo() + + def makeCallable(self, signature): + assert 'self' not in signature + mk = super(TestGetcallargsMethods, self).makeCallable + self.cls.method = mk('self, ' + signature) + return self.inst.method + +class TestGetcallargsUnboundMethods(TestGetcallargsMethods): + + def makeCallable(self, signature): + super(TestGetcallargsUnboundMethods, self).makeCallable(signature) + return self.cls.method + + def assertEqualCallArgs(self, func, call_params_string, locs=None): + return super(TestGetcallargsUnboundMethods, self).assertEqualCallArgs( + *self._getAssertEqualParams(func, call_params_string, locs)) + + def assertEqualException(self, func, call_params_string, locs=None): + return super(TestGetcallargsUnboundMethods, self).assertEqualException( + *self._getAssertEqualParams(func, call_params_string, locs)) + + def _getAssertEqualParams(self, func, call_params_string, locs=None): + assert 'inst' not in call_params_string + locs = dict(locs or {}, inst=self.inst) + return (func, 'inst,' + call_params_string, locs) + + +class TestGetattrStatic(unittest.TestCase): + + def test_basic(self): + class Thing(object): + x = object() + + thing = Thing() + self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x) + self.assertEqual(inspect.getattr_static(thing, 'x', None), Thing.x) + with self.assertRaises(AttributeError): + inspect.getattr_static(thing, 'y') + + self.assertEqual(inspect.getattr_static(thing, 'y', 3), 3) + + def test_inherited(self): + class Thing(object): + x = object() + class OtherThing(Thing): + pass + + something = OtherThing() + self.assertEqual(inspect.getattr_static(something, 'x'), Thing.x) + + def test_instance_attr(self): + class Thing(object): + x = 2 + def __init__(self, x): + self.x = x + thing = Thing(3) + self.assertEqual(inspect.getattr_static(thing, 'x'), 3) + del thing.x + self.assertEqual(inspect.getattr_static(thing, 'x'), 2) + + def test_property(self): + class Thing(object): + @property + def x(self): + raise AttributeError("I'm pretending not to exist") + thing = Thing() + self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x) + + def test_descriptor_raises_AttributeError(self): + class descriptor(object): + def __get__(*_): + raise AttributeError("I'm pretending not to exist") + desc = descriptor() + class Thing(object): + x = desc + thing = Thing() + self.assertEqual(inspect.getattr_static(thing, 'x'), desc) + + def test_classAttribute(self): + class Thing(object): + x = object() + + self.assertEqual(inspect.getattr_static(Thing, 'x'), Thing.x) + + def test_classVirtualAttribute(self): + class Thing(object): + @types.DynamicClassAttribute + def x(self): + return self._x + _x = object() + + self.assertEqual(inspect.getattr_static(Thing, 'x'), Thing.__dict__['x']) + + def test_inherited_classattribute(self): + class Thing(object): + x = object() + class OtherThing(Thing): + pass + + self.assertEqual(inspect.getattr_static(OtherThing, 'x'), Thing.x) + + def test_slots(self): + class Thing(object): + y = 'bar' + __slots__ = ['x'] + def __init__(self): + self.x = 'foo' + thing = Thing() + self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x) + self.assertEqual(inspect.getattr_static(thing, 'y'), 'bar') + + del thing.x + self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x) + + def test_metaclass(self): + class meta(type): + attr = 'foo' + class Thing(object, metaclass=meta): + pass + self.assertEqual(inspect.getattr_static(Thing, 'attr'), 'foo') + + class sub(meta): + pass + class OtherThing(object, metaclass=sub): + x = 3 + self.assertEqual(inspect.getattr_static(OtherThing, 'attr'), 'foo') + + class OtherOtherThing(OtherThing): + pass + # this test is odd, but it was added as it exposed a bug + self.assertEqual(inspect.getattr_static(OtherOtherThing, 'x'), 3) + + def test_no_dict_no_slots(self): + self.assertEqual(inspect.getattr_static(1, 'foo', None), None) + self.assertNotEqual(inspect.getattr_static('foo', 'lower'), None) + + def test_no_dict_no_slots_instance_member(self): + # returns descriptor + with open(__file__, encoding='utf-8') as handle: + self.assertEqual(inspect.getattr_static(handle, 'name'), type(handle).name) + + def test_inherited_slots(self): + # returns descriptor + class Thing(object): + __slots__ = ['x'] + def __init__(self): + self.x = 'foo' + + class OtherThing(Thing): + pass + # it would be nice if this worked... + # we get the descriptor instead of the instance attribute + self.assertEqual(inspect.getattr_static(OtherThing(), 'x'), Thing.x) + + def test_descriptor(self): + class descriptor(object): + def __get__(self, instance, owner): + return 3 + class Foo(object): + d = descriptor() + + foo = Foo() + + # for a non data descriptor we return the instance attribute + foo.__dict__['d'] = 1 + self.assertEqual(inspect.getattr_static(foo, 'd'), 1) + + # if the descriptor is a data-descriptor we should return the + # descriptor + descriptor.__set__ = lambda s, i, v: None + self.assertEqual(inspect.getattr_static(foo, 'd'), Foo.__dict__['d']) + + del descriptor.__set__ + descriptor.__delete__ = lambda s, i, o: None + self.assertEqual(inspect.getattr_static(foo, 'd'), Foo.__dict__['d']) + + def test_metaclass_with_descriptor(self): + class descriptor(object): + def __get__(self, instance, owner): + return 3 + class meta(type): + d = descriptor() + class Thing(object, metaclass=meta): + pass + self.assertEqual(inspect.getattr_static(Thing, 'd'), meta.__dict__['d']) + + + def test_class_as_property(self): + class Base(object): + foo = 3 + + class Something(Base): + executed = False + @property + def __class__(self): + self.executed = True + return object + + instance = Something() + self.assertEqual(inspect.getattr_static(instance, 'foo'), 3) + self.assertFalse(instance.executed) + self.assertEqual(inspect.getattr_static(Something, 'foo'), 3) + + def test_mro_as_property(self): + class Meta(type): + @property + def __mro__(self): + return (object,) + + class Base(object): + foo = 3 + + class Something(Base, metaclass=Meta): + pass + + self.assertEqual(inspect.getattr_static(Something(), 'foo'), 3) + self.assertEqual(inspect.getattr_static(Something, 'foo'), 3) + + def test_dict_as_property(self): + test = self + test.called = False + + class Foo(dict): + a = 3 + @property + def __dict__(self): + test.called = True + return {} + + foo = Foo() + foo.a = 4 + self.assertEqual(inspect.getattr_static(foo, 'a'), 3) + self.assertFalse(test.called) + + def test_mutated_mro(self): + test = self + test.called = False + + class Foo(dict): + a = 3 + @property + def __dict__(self): + test.called = True + return {} + + class Bar(dict): + a = 4 + + class Baz(Bar): pass + + baz = Baz() + self.assertEqual(inspect.getattr_static(baz, 'a'), 4) + Baz.__bases__ = (Foo,) + self.assertEqual(inspect.getattr_static(baz, 'a'), 3) + self.assertFalse(test.called) + + def test_custom_object_dict(self): + test = self + test.called = False + + class Custom(dict): + def get(self, key, default=None): + test.called = True + super().get(key, default) + + class Foo(object): + a = 3 + foo = Foo() + foo.__dict__ = Custom() + self.assertEqual(inspect.getattr_static(foo, 'a'), 3) + self.assertFalse(test.called) + + def test_metaclass_dict_as_property(self): + class Meta(type): + @property + def __dict__(self): + self.executed = True + + class Thing(metaclass=Meta): + executed = False + + def __init__(self): + self.spam = 42 + + instance = Thing() + self.assertEqual(inspect.getattr_static(instance, "spam"), 42) + self.assertFalse(Thing.executed) + + def test_module(self): + sentinel = object() + self.assertIsNot(inspect.getattr_static(sys, "version", sentinel), + sentinel) + + def test_metaclass_with_metaclass_with_dict_as_property(self): + class MetaMeta(type): + @property + def __dict__(self): + self.executed = True + return dict(spam=42) + + class Meta(type, metaclass=MetaMeta): + executed = False + + class Thing(metaclass=Meta): + pass + + with self.assertRaises(AttributeError): + inspect.getattr_static(Thing, "spam") + self.assertFalse(Thing.executed) + + def test_custom___getattr__(self): + test = self + test.called = False + + class Foo: + def __getattr__(self, attr): + test.called = True + return {} + + with self.assertRaises(AttributeError): + inspect.getattr_static(Foo(), 'whatever') + + self.assertFalse(test.called) + + def test_custom___getattribute__(self): + test = self + test.called = False + + class Foo: + def __getattribute__(self, attr): + test.called = True + return {} + + with self.assertRaises(AttributeError): + inspect.getattr_static(Foo(), 'really_could_be_anything') + + self.assertFalse(test.called) + + +class TestGetGeneratorState(unittest.TestCase): + + def setUp(self): + def number_generator(): + for number in range(5): + yield number + self.generator = number_generator() + + def _generatorstate(self): + return inspect.getgeneratorstate(self.generator) + + def test_created(self): + self.assertEqual(self._generatorstate(), inspect.GEN_CREATED) + + def test_suspended(self): + next(self.generator) + self.assertEqual(self._generatorstate(), inspect.GEN_SUSPENDED) + + def test_closed_after_exhaustion(self): + for i in self.generator: + pass + self.assertEqual(self._generatorstate(), inspect.GEN_CLOSED) + + def test_closed_after_immediate_exception(self): + with self.assertRaises(RuntimeError): + self.generator.throw(RuntimeError) + self.assertEqual(self._generatorstate(), inspect.GEN_CLOSED) + + def test_running(self): + # As mentioned on issue #10220, checking for the RUNNING state only + # makes sense inside the generator itself. + # The following generator checks for this by using the closure's + # reference to self and the generator state checking helper method + def running_check_generator(): + for number in range(5): + self.assertEqual(self._generatorstate(), inspect.GEN_RUNNING) + yield number + self.assertEqual(self._generatorstate(), inspect.GEN_RUNNING) + self.generator = running_check_generator() + # Running up to the first yield + next(self.generator) + # Running after the first yield + next(self.generator) + + def test_easy_debugging(self): + # repr() and str() of a generator state should contain the state name + names = 'GEN_CREATED GEN_RUNNING GEN_SUSPENDED GEN_CLOSED'.split() + for name in names: + state = getattr(inspect, name) + self.assertIn(name, repr(state)) + self.assertIn(name, str(state)) + + def test_getgeneratorlocals(self): + def each(lst, a=None): + b=(1, 2, 3) + for v in lst: + if v == 3: + c = 12 + yield v + + numbers = each([1, 2, 3]) + self.assertEqual(inspect.getgeneratorlocals(numbers), + {'a': None, 'lst': [1, 2, 3]}) + next(numbers) + self.assertEqual(inspect.getgeneratorlocals(numbers), + {'a': None, 'lst': [1, 2, 3], 'v': 1, + 'b': (1, 2, 3)}) + next(numbers) + self.assertEqual(inspect.getgeneratorlocals(numbers), + {'a': None, 'lst': [1, 2, 3], 'v': 2, + 'b': (1, 2, 3)}) + next(numbers) + self.assertEqual(inspect.getgeneratorlocals(numbers), + {'a': None, 'lst': [1, 2, 3], 'v': 3, + 'b': (1, 2, 3), 'c': 12}) + try: + next(numbers) + except StopIteration: + pass + self.assertEqual(inspect.getgeneratorlocals(numbers), {}) + + def test_getgeneratorlocals_empty(self): + def yield_one(): + yield 1 + one = yield_one() + self.assertEqual(inspect.getgeneratorlocals(one), {}) + try: + next(one) + except StopIteration: + pass + self.assertEqual(inspect.getgeneratorlocals(one), {}) + + def test_getgeneratorlocals_error(self): + self.assertRaises(TypeError, inspect.getgeneratorlocals, 1) + self.assertRaises(TypeError, inspect.getgeneratorlocals, lambda x: True) + self.assertRaises(TypeError, inspect.getgeneratorlocals, set) + self.assertRaises(TypeError, inspect.getgeneratorlocals, (2,3)) + + +class TestGetCoroutineState(unittest.TestCase): + + def setUp(self): + @types.coroutine + def number_coroutine(): + for number in range(5): + yield number + async def coroutine(): + await number_coroutine() + self.coroutine = coroutine() + + def tearDown(self): + self.coroutine.close() + + def _coroutinestate(self): + return inspect.getcoroutinestate(self.coroutine) + + def test_created(self): + self.assertEqual(self._coroutinestate(), inspect.CORO_CREATED) + + def test_suspended(self): + self.coroutine.send(None) + self.assertEqual(self._coroutinestate(), inspect.CORO_SUSPENDED) + + def test_closed_after_exhaustion(self): + while True: + try: + self.coroutine.send(None) + except StopIteration: + break + + self.assertEqual(self._coroutinestate(), inspect.CORO_CLOSED) + + def test_closed_after_immediate_exception(self): + with self.assertRaises(RuntimeError): + self.coroutine.throw(RuntimeError) + self.assertEqual(self._coroutinestate(), inspect.CORO_CLOSED) + + def test_easy_debugging(self): + # repr() and str() of a coroutine state should contain the state name + names = 'CORO_CREATED CORO_RUNNING CORO_SUSPENDED CORO_CLOSED'.split() + for name in names: + state = getattr(inspect, name) + self.assertIn(name, repr(state)) + self.assertIn(name, str(state)) + + def test_getcoroutinelocals(self): + @types.coroutine + def gencoro(): + yield + + gencoro = gencoro() + async def func(a=None): + b = 'spam' + await gencoro + + coro = func() + self.assertEqual(inspect.getcoroutinelocals(coro), + {'a': None, 'gencoro': gencoro}) + coro.send(None) + self.assertEqual(inspect.getcoroutinelocals(coro), + {'a': None, 'gencoro': gencoro, 'b': 'spam'}) + + +@support.requires_working_socket() +class TestGetAsyncGenState(unittest.IsolatedAsyncioTestCase): + + def setUp(self): + async def number_asyncgen(): + for number in range(5): + yield number + self.asyncgen = number_asyncgen() + + async def asyncTearDown(self): + await self.asyncgen.aclose() + + def _asyncgenstate(self): + return inspect.getasyncgenstate(self.asyncgen) + + def test_created(self): + self.assertEqual(self._asyncgenstate(), inspect.AGEN_CREATED) + + async def test_suspended(self): + value = await anext(self.asyncgen) + self.assertEqual(self._asyncgenstate(), inspect.AGEN_SUSPENDED) + self.assertEqual(value, 0) + + async def test_closed_after_exhaustion(self): + countdown = 7 + with self.assertRaises(StopAsyncIteration): + while countdown := countdown - 1: + await anext(self.asyncgen) + self.assertEqual(countdown, 1) + self.assertEqual(self._asyncgenstate(), inspect.AGEN_CLOSED) + + async def test_closed_after_immediate_exception(self): + with self.assertRaises(RuntimeError): + await self.asyncgen.athrow(RuntimeError) + self.assertEqual(self._asyncgenstate(), inspect.AGEN_CLOSED) + + async def test_running(self): + async def running_check_asyncgen(): + for number in range(5): + self.assertEqual(self._asyncgenstate(), inspect.AGEN_RUNNING) + yield number + self.assertEqual(self._asyncgenstate(), inspect.AGEN_RUNNING) + self.asyncgen = running_check_asyncgen() + # Running up to the first yield + await anext(self.asyncgen) + self.assertEqual(self._asyncgenstate(), inspect.AGEN_SUSPENDED) + # Running after the first yield + await anext(self.asyncgen) + self.assertEqual(self._asyncgenstate(), inspect.AGEN_SUSPENDED) + + def test_easy_debugging(self): + # repr() and str() of a asyncgen state should contain the state name + names = 'AGEN_CREATED AGEN_RUNNING AGEN_SUSPENDED AGEN_CLOSED'.split() + for name in names: + state = getattr(inspect, name) + self.assertIn(name, repr(state)) + self.assertIn(name, str(state)) + + async def test_getasyncgenlocals(self): + async def each(lst, a=None): + b=(1, 2, 3) + for v in lst: + if v == 3: + c = 12 + yield v + + numbers = each([1, 2, 3]) + self.assertEqual(inspect.getasyncgenlocals(numbers), + {'a': None, 'lst': [1, 2, 3]}) + await anext(numbers) + self.assertEqual(inspect.getasyncgenlocals(numbers), + {'a': None, 'lst': [1, 2, 3], 'v': 1, + 'b': (1, 2, 3)}) + await anext(numbers) + self.assertEqual(inspect.getasyncgenlocals(numbers), + {'a': None, 'lst': [1, 2, 3], 'v': 2, + 'b': (1, 2, 3)}) + await anext(numbers) + self.assertEqual(inspect.getasyncgenlocals(numbers), + {'a': None, 'lst': [1, 2, 3], 'v': 3, + 'b': (1, 2, 3), 'c': 12}) + with self.assertRaises(StopAsyncIteration): + await anext(numbers) + self.assertEqual(inspect.getasyncgenlocals(numbers), {}) + + async def test_getasyncgenlocals_empty(self): + async def yield_one(): + yield 1 + one = yield_one() + self.assertEqual(inspect.getasyncgenlocals(one), {}) + await anext(one) + self.assertEqual(inspect.getasyncgenlocals(one), {}) + with self.assertRaises(StopAsyncIteration): + await anext(one) + self.assertEqual(inspect.getasyncgenlocals(one), {}) + + def test_getasyncgenlocals_error(self): + self.assertRaises(TypeError, inspect.getasyncgenlocals, 1) + self.assertRaises(TypeError, inspect.getasyncgenlocals, lambda x: True) + self.assertRaises(TypeError, inspect.getasyncgenlocals, set) + self.assertRaises(TypeError, inspect.getasyncgenlocals, (2,3)) + + +class MySignature(inspect.Signature): + # Top-level to make it picklable; + # used in test_signature_object_pickle + pass + +class MyParameter(inspect.Parameter): + # Top-level to make it picklable; + # used in test_signature_object_pickle + pass + + + +class TestSignatureObject(unittest.TestCase): + @staticmethod + def signature(func, **kw): + sig = inspect.signature(func, **kw) + return (tuple((param.name, + (... if param.default is param.empty else param.default), + (... if param.annotation is param.empty + else param.annotation), + str(param.kind).lower()) + for param in sig.parameters.values()), + (... if sig.return_annotation is sig.empty + else sig.return_annotation)) + + def test_signature_object(self): + S = inspect.Signature + P = inspect.Parameter + + self.assertEqual(str(S()), '()') + self.assertEqual(repr(S().parameters), 'mappingproxy(OrderedDict())') + + def test(po, /, pk, pkd=100, *args, ko, kod=10, **kwargs): + pass + + sig = inspect.signature(test) + self.assertTrue(repr(sig).startswith(' {42:'ham'}: pass + foo_partial = functools.partial(foo, a=1) + + sig = inspect.signature(foo_partial) + + for ver in range(pickle.HIGHEST_PROTOCOL + 1): + with self.subTest(pickle_ver=ver, subclass=False): + sig_pickled = pickle.loads(pickle.dumps(sig, ver)) + self.assertEqual(sig, sig_pickled) + + # Test that basic sub-classing works + sig = inspect.signature(foo) + myparam = MyParameter(name='z', kind=inspect.Parameter.POSITIONAL_ONLY) + myparams = collections.OrderedDict(sig.parameters, a=myparam) + mysig = MySignature().replace(parameters=myparams.values(), + return_annotation=sig.return_annotation) + self.assertTrue(isinstance(mysig, MySignature)) + self.assertTrue(isinstance(mysig.parameters['z'], MyParameter)) + + for ver in range(pickle.HIGHEST_PROTOCOL + 1): + with self.subTest(pickle_ver=ver, subclass=True): + sig_pickled = pickle.loads(pickle.dumps(mysig, ver)) + self.assertEqual(mysig, sig_pickled) + self.assertTrue(isinstance(sig_pickled, MySignature)) + self.assertTrue(isinstance(sig_pickled.parameters['z'], + MyParameter)) + + def test_signature_immutability(self): + def test(a): + pass + sig = inspect.signature(test) + + with self.assertRaises(AttributeError): + sig.foo = 'bar' + + with self.assertRaises(TypeError): + sig.parameters['a'] = None + + def test_signature_on_noarg(self): + def test(): + pass + self.assertEqual(self.signature(test), ((), ...)) + + def test_signature_on_wargs(self): + def test(a, b:'foo') -> 123: + pass + self.assertEqual(self.signature(test), + ((('a', ..., ..., "positional_or_keyword"), + ('b', ..., 'foo', "positional_or_keyword")), + 123)) + + def test_signature_on_wkwonly(self): + def test(*, a:float, b:str) -> int: + pass + self.assertEqual(self.signature(test), + ((('a', ..., float, "keyword_only"), + ('b', ..., str, "keyword_only")), + int)) + + def test_signature_on_complex_args(self): + def test(a, b:'foo'=10, *args:'bar', spam:'baz', ham=123, **kwargs:int): + pass + self.assertEqual(self.signature(test), + ((('a', ..., ..., "positional_or_keyword"), + ('b', 10, 'foo', "positional_or_keyword"), + ('args', ..., 'bar', "var_positional"), + ('spam', ..., 'baz', "keyword_only"), + ('ham', 123, ..., "keyword_only"), + ('kwargs', ..., int, "var_keyword")), + ...)) + + def test_signature_without_self(self): + def test_args_only(*args): # NOQA + pass + + def test_args_kwargs_only(*args, **kwargs): # NOQA + pass + + class A: + @classmethod + def test_classmethod(*args): # NOQA + pass + + @staticmethod + def test_staticmethod(*args): # NOQA + pass + + f1 = functools.partialmethod((test_classmethod), 1) + f2 = functools.partialmethod((test_args_only), 1) + f3 = functools.partialmethod((test_staticmethod), 1) + f4 = functools.partialmethod((test_args_kwargs_only),1) + + self.assertEqual(self.signature(test_args_only), + ((('args', ..., ..., 'var_positional'),), ...)) + self.assertEqual(self.signature(test_args_kwargs_only), + ((('args', ..., ..., 'var_positional'), + ('kwargs', ..., ..., 'var_keyword')), ...)) + self.assertEqual(self.signature(A.f1), + ((('args', ..., ..., 'var_positional'),), ...)) + self.assertEqual(self.signature(A.f2), + ((('args', ..., ..., 'var_positional'),), ...)) + self.assertEqual(self.signature(A.f3), + ((('args', ..., ..., 'var_positional'),), ...)) + self.assertEqual(self.signature(A.f4), + ((('args', ..., ..., 'var_positional'), + ('kwargs', ..., ..., 'var_keyword')), ...)) + @cpython_only + @unittest.skipIf(MISSING_C_DOCSTRINGS, + "Signature information for builtins requires docstrings") + def test_signature_on_builtins(self): + import _testcapi + + def test_unbound_method(o): + """Use this to test unbound methods (things that should have a self)""" + signature = inspect.signature(o) + self.assertTrue(isinstance(signature, inspect.Signature)) + self.assertEqual(list(signature.parameters.values())[0].name, 'self') + return signature + + def test_callable(o): + """Use this to test bound methods or normal callables (things that don't expect self)""" + signature = inspect.signature(o) + self.assertTrue(isinstance(signature, inspect.Signature)) + if signature.parameters: + self.assertNotEqual(list(signature.parameters.values())[0].name, 'self') + return signature + + signature = test_callable(_testcapi.docstring_with_signature_with_defaults) + def p(name): return signature.parameters[name].default + self.assertEqual(p('s'), 'avocado') + self.assertEqual(p('b'), b'bytes') + self.assertEqual(p('d'), 3.14) + self.assertEqual(p('i'), 35) + self.assertEqual(p('n'), None) + self.assertEqual(p('t'), True) + self.assertEqual(p('f'), False) + self.assertEqual(p('local'), 3) + self.assertEqual(p('sys'), sys.maxsize) + self.assertEqual(p('exp'), sys.maxsize - 1) + + test_callable(object) + + # normal method + # (PyMethodDescr_Type, "method_descriptor") + test_unbound_method(_pickle.Pickler.dump) + d = _pickle.Pickler(io.StringIO()) + test_callable(d.dump) + + # static method + test_callable(bytes.maketrans) + test_callable(b'abc'.maketrans) + + # class method + test_callable(dict.fromkeys) + test_callable({}.fromkeys) + + # wrapper around slot (PyWrapperDescr_Type, "wrapper_descriptor") + test_unbound_method(type.__call__) + test_unbound_method(int.__add__) + test_callable((3).__add__) + + # _PyMethodWrapper_Type + # support for 'method-wrapper' + test_callable(min.__call__) + + # This doesn't work now. + # (We don't have a valid signature for "type" in 3.4) + with self.assertRaisesRegex(ValueError, "no signature found"): + class ThisWorksNow: + __call__ = type + test_callable(ThisWorksNow()) + + # Regression test for issue #20786 + test_unbound_method(dict.__delitem__) + test_unbound_method(property.__delete__) + + # Regression test for issue #20586 + test_callable(_testcapi.docstring_with_signature_but_no_doc) + + # Regression test for gh-104955 + method = bytearray.__release_buffer__ + sig = test_unbound_method(method) + self.assertEqual(list(sig.parameters), ['self', 'buffer']) + + @cpython_only + @unittest.skipIf(MISSING_C_DOCSTRINGS, + "Signature information for builtins requires docstrings") + def test_signature_on_decorated_builtins(self): + import _testcapi + func = _testcapi.docstring_with_signature_with_defaults + + def decorator(func): + @functools.wraps(func) + def wrapper(*args, **kwargs) -> int: + return func(*args, **kwargs) + return wrapper + + decorated_func = decorator(func) + + self.assertEqual(inspect.signature(func), + inspect.signature(decorated_func)) + + def wrapper_like(*args, **kwargs) -> int: pass + self.assertEqual(inspect.signature(decorated_func, + follow_wrapped=False), + inspect.signature(wrapper_like)) + + @cpython_only + def test_signature_on_builtins_no_signature(self): + import _testcapi + with self.assertRaisesRegex(ValueError, + 'no signature found for builtin'): + inspect.signature(_testcapi.docstring_no_signature) + + with self.assertRaisesRegex(ValueError, + 'no signature found for builtin'): + inspect.signature(str) + + cls = _testcapi.DocStringNoSignatureTest + obj = _testcapi.DocStringNoSignatureTest() + tests = [ + (_testcapi.docstring_no_signature_noargs, meth_noargs), + (_testcapi.docstring_no_signature_o, meth_o), + (cls.meth_noargs, meth_self_noargs), + (cls.meth_o, meth_self_o), + (obj.meth_noargs, meth_noargs), + (obj.meth_o, meth_o), + (cls.meth_noargs_class, meth_noargs), + (cls.meth_o_class, meth_o), + (cls.meth_noargs_static, meth_noargs), + (cls.meth_o_static, meth_o), + (cls.meth_noargs_coexist, meth_self_noargs), + (cls.meth_o_coexist, meth_self_o), + + (time.time, meth_noargs), + (str.lower, meth_self_noargs), + (''.lower, meth_noargs), + (set.add, meth_self_o), + (set().add, meth_o), + (set.__contains__, meth_self_o), + (set().__contains__, meth_o), + (datetime.datetime.__dict__['utcnow'], meth_type_noargs), + (datetime.datetime.utcnow, meth_noargs), + (dict.__dict__['__class_getitem__'], meth_type_o), + (dict.__class_getitem__, meth_o), + ] + try: + import _stat + except ImportError: + # if the _stat extension is not available, stat.S_IMODE() is + # implemented in Python, not in C + pass + else: + tests.append((stat.S_IMODE, meth_o)) + for builtin, template in tests: + with self.subTest(builtin): + self.assertEqual(inspect.signature(builtin), + inspect.signature(template)) + + def test_signature_on_non_function(self): + with self.assertRaisesRegex(TypeError, 'is not a callable object'): + inspect.signature(42) + + def test_signature_from_functionlike_object(self): + def func(a,b, *args, kwonly=True, kwonlyreq, **kwargs): + pass + + class funclike: + # Has to be callable, and have correct + # __code__, __annotations__, __defaults__, __name__, + # and __kwdefaults__ attributes + + def __init__(self, func): + self.__name__ = func.__name__ + self.__code__ = func.__code__ + self.__annotations__ = func.__annotations__ + self.__defaults__ = func.__defaults__ + self.__kwdefaults__ = func.__kwdefaults__ + self.func = func + + def __call__(self, *args, **kwargs): + return self.func(*args, **kwargs) + + sig_func = inspect.Signature.from_callable(func) + + sig_funclike = inspect.Signature.from_callable(funclike(func)) + self.assertEqual(sig_funclike, sig_func) + + sig_funclike = inspect.signature(funclike(func)) + self.assertEqual(sig_funclike, sig_func) + + # If object is not a duck type of function, then + # signature will try to get a signature for its '__call__' + # method + fl = funclike(func) + del fl.__defaults__ + self.assertEqual(self.signature(fl), + ((('args', ..., ..., "var_positional"), + ('kwargs', ..., ..., "var_keyword")), + ...)) + + # Test with cython-like builtins: + _orig_isdesc = inspect.ismethoddescriptor + def _isdesc(obj): + if hasattr(obj, '_builtinmock'): + return True + return _orig_isdesc(obj) + + with unittest.mock.patch('inspect.ismethoddescriptor', _isdesc): + builtin_func = funclike(func) + # Make sure that our mock setup is working + self.assertFalse(inspect.ismethoddescriptor(builtin_func)) + builtin_func._builtinmock = True + self.assertTrue(inspect.ismethoddescriptor(builtin_func)) + self.assertEqual(inspect.signature(builtin_func), sig_func) + + def test_signature_functionlike_class(self): + # We only want to duck type function-like objects, + # not classes. + + def func(a,b, *args, kwonly=True, kwonlyreq, **kwargs): + pass + + class funclike: + def __init__(self, marker): + pass + + __name__ = func.__name__ + __code__ = func.__code__ + __annotations__ = func.__annotations__ + __defaults__ = func.__defaults__ + __kwdefaults__ = func.__kwdefaults__ + + self.assertEqual(str(inspect.signature(funclike)), '(marker)') + + def test_signature_on_method(self): + class Test: + def __init__(*args): + pass + def m1(self, arg1, arg2=1) -> int: + pass + def m2(*args): + pass + def __call__(*, a): + pass + + self.assertEqual(self.signature(Test().m1), + ((('arg1', ..., ..., "positional_or_keyword"), + ('arg2', 1, ..., "positional_or_keyword")), + int)) + + self.assertEqual(self.signature(Test().m2), + ((('args', ..., ..., "var_positional"),), + ...)) + + self.assertEqual(self.signature(Test), + ((('args', ..., ..., "var_positional"),), + ...)) + + with self.assertRaisesRegex(ValueError, 'invalid method signature'): + self.signature(Test()) + + def test_signature_wrapped_bound_method(self): + # Issue 24298 + class Test: + def m1(self, arg1, arg2=1) -> int: + pass + @functools.wraps(Test().m1) + def m1d(*args, **kwargs): + pass + self.assertEqual(self.signature(m1d), + ((('arg1', ..., ..., "positional_or_keyword"), + ('arg2', 1, ..., "positional_or_keyword")), + int)) + + def test_signature_on_classmethod(self): + class Test: + @classmethod + def foo(cls, arg1, *, arg2=1): + pass + + meth = Test().foo + self.assertEqual(self.signature(meth), + ((('arg1', ..., ..., "positional_or_keyword"), + ('arg2', 1, ..., "keyword_only")), + ...)) + + meth = Test.foo + self.assertEqual(self.signature(meth), + ((('arg1', ..., ..., "positional_or_keyword"), + ('arg2', 1, ..., "keyword_only")), + ...)) + + def test_signature_on_staticmethod(self): + class Test: + @staticmethod + def foo(cls, *, arg): + pass + + meth = Test().foo + self.assertEqual(self.signature(meth), + ((('cls', ..., ..., "positional_or_keyword"), + ('arg', ..., ..., "keyword_only")), + ...)) + + meth = Test.foo + self.assertEqual(self.signature(meth), + ((('cls', ..., ..., "positional_or_keyword"), + ('arg', ..., ..., "keyword_only")), + ...)) + + def test_signature_on_partial(self): + from functools import partial + + def test(): + pass + + self.assertEqual(self.signature(partial(test)), ((), ...)) + + with self.assertRaisesRegex(ValueError, "has incorrect arguments"): + inspect.signature(partial(test, 1)) + + with self.assertRaisesRegex(ValueError, "has incorrect arguments"): + inspect.signature(partial(test, a=1)) + + def test(a, b, *, c, d): + pass + + self.assertEqual(self.signature(partial(test)), + ((('a', ..., ..., "positional_or_keyword"), + ('b', ..., ..., "positional_or_keyword"), + ('c', ..., ..., "keyword_only"), + ('d', ..., ..., "keyword_only")), + ...)) + + self.assertEqual(self.signature(partial(test, 1)), + ((('b', ..., ..., "positional_or_keyword"), + ('c', ..., ..., "keyword_only"), + ('d', ..., ..., "keyword_only")), + ...)) + + self.assertEqual(self.signature(partial(test, 1, c=2)), + ((('b', ..., ..., "positional_or_keyword"), + ('c', 2, ..., "keyword_only"), + ('d', ..., ..., "keyword_only")), + ...)) + + self.assertEqual(self.signature(partial(test, b=1, c=2)), + ((('a', ..., ..., "positional_or_keyword"), + ('b', 1, ..., "keyword_only"), + ('c', 2, ..., "keyword_only"), + ('d', ..., ..., "keyword_only")), + ...)) + + self.assertEqual(self.signature(partial(test, 0, b=1, c=2)), + ((('b', 1, ..., "keyword_only"), + ('c', 2, ..., "keyword_only"), + ('d', ..., ..., "keyword_only")), + ...)) + + self.assertEqual(self.signature(partial(test, a=1)), + ((('a', 1, ..., "keyword_only"), + ('b', ..., ..., "keyword_only"), + ('c', ..., ..., "keyword_only"), + ('d', ..., ..., "keyword_only")), + ...)) + + def test(a, *args, b, **kwargs): + pass + + self.assertEqual(self.signature(partial(test, 1)), + ((('args', ..., ..., "var_positional"), + ('b', ..., ..., "keyword_only"), + ('kwargs', ..., ..., "var_keyword")), + ...)) + + self.assertEqual(self.signature(partial(test, a=1)), + ((('a', 1, ..., "keyword_only"), + ('b', ..., ..., "keyword_only"), + ('kwargs', ..., ..., "var_keyword")), + ...)) + + self.assertEqual(self.signature(partial(test, 1, 2, 3)), + ((('args', ..., ..., "var_positional"), + ('b', ..., ..., "keyword_only"), + ('kwargs', ..., ..., "var_keyword")), + ...)) + + self.assertEqual(self.signature(partial(test, 1, 2, 3, test=True)), + ((('args', ..., ..., "var_positional"), + ('b', ..., ..., "keyword_only"), + ('kwargs', ..., ..., "var_keyword")), + ...)) + + self.assertEqual(self.signature(partial(test, 1, 2, 3, test=1, b=0)), + ((('args', ..., ..., "var_positional"), + ('b', 0, ..., "keyword_only"), + ('kwargs', ..., ..., "var_keyword")), + ...)) + + self.assertEqual(self.signature(partial(test, b=0)), + ((('a', ..., ..., "positional_or_keyword"), + ('args', ..., ..., "var_positional"), + ('b', 0, ..., "keyword_only"), + ('kwargs', ..., ..., "var_keyword")), + ...)) + + self.assertEqual(self.signature(partial(test, b=0, test=1)), + ((('a', ..., ..., "positional_or_keyword"), + ('args', ..., ..., "var_positional"), + ('b', 0, ..., "keyword_only"), + ('kwargs', ..., ..., "var_keyword")), + ...)) + + def test(a, b, c:int) -> 42: + pass + + sig = test.__signature__ = inspect.signature(test) + + self.assertEqual(self.signature(partial(partial(test, 1))), + ((('b', ..., ..., "positional_or_keyword"), + ('c', ..., int, "positional_or_keyword")), + 42)) + + self.assertEqual(self.signature(partial(partial(test, 1), 2)), + ((('c', ..., int, "positional_or_keyword"),), + 42)) + + def foo(a): + return a + _foo = partial(partial(foo, a=10), a=20) + self.assertEqual(self.signature(_foo), + ((('a', 20, ..., "keyword_only"),), + ...)) + # check that we don't have any side-effects in signature(), + # and the partial object is still functioning + self.assertEqual(_foo(), 20) + + def foo(a, b, c): + return a, b, c + _foo = partial(partial(foo, 1, b=20), b=30) + + self.assertEqual(self.signature(_foo), + ((('b', 30, ..., "keyword_only"), + ('c', ..., ..., "keyword_only")), + ...)) + self.assertEqual(_foo(c=10), (1, 30, 10)) + + def foo(a, b, c, *, d): + return a, b, c, d + _foo = partial(partial(foo, d=20, c=20), b=10, d=30) + self.assertEqual(self.signature(_foo), + ((('a', ..., ..., "positional_or_keyword"), + ('b', 10, ..., "keyword_only"), + ('c', 20, ..., "keyword_only"), + ('d', 30, ..., "keyword_only"), + ), + ...)) + ba = inspect.signature(_foo).bind(a=200, b=11) + self.assertEqual(_foo(*ba.args, **ba.kwargs), (200, 11, 20, 30)) + + def foo(a=1, b=2, c=3): + return a, b, c + _foo = partial(foo, c=13) # (a=1, b=2, *, c=13) + + ba = inspect.signature(_foo).bind(a=11) + self.assertEqual(_foo(*ba.args, **ba.kwargs), (11, 2, 13)) + + ba = inspect.signature(_foo).bind(11, 12) + self.assertEqual(_foo(*ba.args, **ba.kwargs), (11, 12, 13)) + + ba = inspect.signature(_foo).bind(11, b=12) + self.assertEqual(_foo(*ba.args, **ba.kwargs), (11, 12, 13)) + + ba = inspect.signature(_foo).bind(b=12) + self.assertEqual(_foo(*ba.args, **ba.kwargs), (1, 12, 13)) + + _foo = partial(_foo, b=10, c=20) + ba = inspect.signature(_foo).bind(12) + self.assertEqual(_foo(*ba.args, **ba.kwargs), (12, 10, 20)) + + + def foo(a, b, /, c, d, **kwargs): + pass + sig = inspect.signature(foo) + self.assertEqual(str(sig), '(a, b, /, c, d, **kwargs)') + + self.assertEqual(self.signature(partial(foo, 1)), + ((('b', ..., ..., 'positional_only'), + ('c', ..., ..., 'positional_or_keyword'), + ('d', ..., ..., 'positional_or_keyword'), + ('kwargs', ..., ..., 'var_keyword')), + ...)) + + self.assertEqual(self.signature(partial(foo, 1, 2)), + ((('c', ..., ..., 'positional_or_keyword'), + ('d', ..., ..., 'positional_or_keyword'), + ('kwargs', ..., ..., 'var_keyword')), + ...)) + + self.assertEqual(self.signature(partial(foo, 1, 2, 3)), + ((('d', ..., ..., 'positional_or_keyword'), + ('kwargs', ..., ..., 'var_keyword')), + ...)) + + self.assertEqual(self.signature(partial(foo, 1, 2, c=3)), + ((('c', 3, ..., 'keyword_only'), + ('d', ..., ..., 'keyword_only'), + ('kwargs', ..., ..., 'var_keyword')), + ...)) + + self.assertEqual(self.signature(partial(foo, 1, c=3)), + ((('b', ..., ..., 'positional_only'), + ('c', 3, ..., 'keyword_only'), + ('d', ..., ..., 'keyword_only'), + ('kwargs', ..., ..., 'var_keyword')), + ...)) + + def test_signature_on_partialmethod(self): + from functools import partialmethod + + class Spam: + def test(): + pass + ham = partialmethod(test) + + with self.assertRaisesRegex(ValueError, "has incorrect arguments"): + inspect.signature(Spam.ham) + + class Spam: + def test(it, a, *, c) -> 'spam': + pass + ham = partialmethod(test, c=1) + + self.assertEqual(self.signature(Spam.ham, eval_str=False), + ((('it', ..., ..., 'positional_or_keyword'), + ('a', ..., ..., 'positional_or_keyword'), + ('c', 1, ..., 'keyword_only')), + 'spam')) + + self.assertEqual(self.signature(Spam().ham, eval_str=False), + ((('a', ..., ..., 'positional_or_keyword'), + ('c', 1, ..., 'keyword_only')), + 'spam')) + + class Spam: + def test(self: 'anno', x): + pass + + g = partialmethod(test, 1) + + self.assertEqual(self.signature(Spam.g, eval_str=False), + ((('self', ..., 'anno', 'positional_or_keyword'),), + ...)) + + def test_signature_on_fake_partialmethod(self): + def foo(a): pass + foo._partialmethod = 'spam' + self.assertEqual(str(inspect.signature(foo)), '(a)') + + def test_signature_on_decorated(self): + def decorator(func): + @functools.wraps(func) + def wrapper(*args, **kwargs) -> int: + return func(*args, **kwargs) + return wrapper + + class Foo: + @decorator + def bar(self, a, b): + pass + + bar = decorator(Foo().bar) + + self.assertEqual(self.signature(Foo.bar), + ((('self', ..., ..., "positional_or_keyword"), + ('a', ..., ..., "positional_or_keyword"), + ('b', ..., ..., "positional_or_keyword")), + ...)) + + self.assertEqual(self.signature(Foo().bar), + ((('a', ..., ..., "positional_or_keyword"), + ('b', ..., ..., "positional_or_keyword")), + ...)) + + self.assertEqual(self.signature(Foo.bar, follow_wrapped=False), + ((('args', ..., ..., "var_positional"), + ('kwargs', ..., ..., "var_keyword")), + ...)) # functools.wraps will copy __annotations__ + # from "func" to "wrapper", hence no + # return_annotation + + self.assertEqual(self.signature(bar), + ((('a', ..., ..., "positional_or_keyword"), + ('b', ..., ..., "positional_or_keyword")), + ...)) + + # Test that we handle method wrappers correctly + def decorator(func): + @functools.wraps(func) + def wrapper(*args, **kwargs) -> int: + return func(42, *args, **kwargs) + sig = inspect.signature(func) + new_params = tuple(sig.parameters.values())[1:] + wrapper.__signature__ = sig.replace(parameters=new_params) + return wrapper + + class Foo: + @decorator + def __call__(self, a, b): + pass + + self.assertEqual(self.signature(Foo.__call__), + ((('a', ..., ..., "positional_or_keyword"), + ('b', ..., ..., "positional_or_keyword")), + ...)) + + self.assertEqual(self.signature(Foo().__call__), + ((('b', ..., ..., "positional_or_keyword"),), + ...)) + + # Test we handle __signature__ partway down the wrapper stack + def wrapped_foo_call(): + pass + wrapped_foo_call.__wrapped__ = Foo.__call__ + + self.assertEqual(self.signature(wrapped_foo_call), + ((('a', ..., ..., "positional_or_keyword"), + ('b', ..., ..., "positional_or_keyword")), + ...)) + + + def test_signature_on_class(self): + class C: + def __init__(self, a): + pass + + self.assertEqual(self.signature(C), + ((('a', ..., ..., "positional_or_keyword"),), + ...)) + + class CM(type): + def __call__(cls, a): + pass + class C(metaclass=CM): + def __init__(self, b): + pass + + self.assertEqual(self.signature(C), + ((('a', ..., ..., "positional_or_keyword"),), + ...)) + + class CM(type): + def __new__(mcls, name, bases, dct, *, foo=1): + return super().__new__(mcls, name, bases, dct) + class C(metaclass=CM): + def __init__(self, b): + pass + + self.assertEqual(self.signature(C), + ((('b', ..., ..., "positional_or_keyword"),), + ...)) + + self.assertEqual(self.signature(CM), + ((('name', ..., ..., "positional_or_keyword"), + ('bases', ..., ..., "positional_or_keyword"), + ('dct', ..., ..., "positional_or_keyword"), + ('foo', 1, ..., "keyword_only")), + ...)) + + class CMM(type): + def __new__(mcls, name, bases, dct, *, foo=1): + return super().__new__(mcls, name, bases, dct) + def __call__(cls, nm, bs, dt): + return type(nm, bs, dt) + class CM(type, metaclass=CMM): + def __new__(mcls, name, bases, dct, *, bar=2): + return super().__new__(mcls, name, bases, dct) + class C(metaclass=CM): + def __init__(self, b): + pass + + self.assertEqual(self.signature(CMM), + ((('name', ..., ..., "positional_or_keyword"), + ('bases', ..., ..., "positional_or_keyword"), + ('dct', ..., ..., "positional_or_keyword"), + ('foo', 1, ..., "keyword_only")), + ...)) + + self.assertEqual(self.signature(CM), + ((('nm', ..., ..., "positional_or_keyword"), + ('bs', ..., ..., "positional_or_keyword"), + ('dt', ..., ..., "positional_or_keyword")), + ...)) + + self.assertEqual(self.signature(C), + ((('b', ..., ..., "positional_or_keyword"),), + ...)) + + class CM(type): + def __init__(cls, name, bases, dct, *, bar=2): + return super().__init__(name, bases, dct) + class C(metaclass=CM): + def __init__(self, b): + pass + + self.assertEqual(self.signature(CM), + ((('name', ..., ..., "positional_or_keyword"), + ('bases', ..., ..., "positional_or_keyword"), + ('dct', ..., ..., "positional_or_keyword"), + ('bar', 2, ..., "keyword_only")), + ...)) + + def test_signature_on_subclass(self): + class A: + def __new__(cls, a=1, *args, **kwargs): + return object.__new__(cls) + class B(A): + def __init__(self, b): + pass + class C(A): + def __new__(cls, a=1, b=2, *args, **kwargs): + return object.__new__(cls) + class D(A): + pass + + self.assertEqual(self.signature(B), + ((('b', ..., ..., "positional_or_keyword"),), + ...)) + self.assertEqual(self.signature(C), + ((('a', 1, ..., 'positional_or_keyword'), + ('b', 2, ..., 'positional_or_keyword'), + ('args', ..., ..., 'var_positional'), + ('kwargs', ..., ..., 'var_keyword')), + ...)) + self.assertEqual(self.signature(D), + ((('a', 1, ..., 'positional_or_keyword'), + ('args', ..., ..., 'var_positional'), + ('kwargs', ..., ..., 'var_keyword')), + ...)) + + def test_signature_on_generic_subclass(self): + from typing import Generic, TypeVar + + T = TypeVar('T') + + class A(Generic[T]): + def __init__(self, *, a: int) -> None: + pass + + self.assertEqual(self.signature(A), + ((('a', ..., int, 'keyword_only'),), + None)) + + @unittest.skipIf(MISSING_C_DOCSTRINGS, + "Signature information for builtins requires docstrings") + def test_signature_on_class_without_init(self): + # Test classes without user-defined __init__ or __new__ + class C: pass + self.assertEqual(str(inspect.signature(C)), '()') + class D(C): pass + self.assertEqual(str(inspect.signature(D)), '()') + + # Test meta-classes without user-defined __init__ or __new__ + class C(type): pass + class D(C): pass + with self.assertRaisesRegex(ValueError, "callable.*is not supported"): + self.assertEqual(inspect.signature(C), None) + with self.assertRaisesRegex(ValueError, "callable.*is not supported"): + self.assertEqual(inspect.signature(D), None) + + @unittest.skipIf(MISSING_C_DOCSTRINGS, + "Signature information for builtins requires docstrings") + def test_signature_on_builtin_class(self): + expected = ('(file, protocol=None, fix_imports=True, ' + 'buffer_callback=None)') + self.assertEqual(str(inspect.signature(_pickle.Pickler)), expected) + + class P(_pickle.Pickler): pass + class EmptyTrait: pass + class P2(EmptyTrait, P): pass + self.assertEqual(str(inspect.signature(P)), expected) + self.assertEqual(str(inspect.signature(P2)), expected) + + class P3(P2): + def __init__(self, spam): + pass + self.assertEqual(str(inspect.signature(P3)), '(spam)') + + class MetaP(type): + def __call__(cls, foo, bar): + pass + class P4(P2, metaclass=MetaP): + pass + self.assertEqual(str(inspect.signature(P4)), '(foo, bar)') + + def test_signature_on_callable_objects(self): + class Foo: + def __call__(self, a): + pass + + self.assertEqual(self.signature(Foo()), + ((('a', ..., ..., "positional_or_keyword"),), + ...)) + + class Spam: + pass + with self.assertRaisesRegex(TypeError, "is not a callable object"): + inspect.signature(Spam()) + + class Bar(Spam, Foo): + pass + + self.assertEqual(self.signature(Bar()), + ((('a', ..., ..., "positional_or_keyword"),), + ...)) + + class Wrapped: + pass + Wrapped.__wrapped__ = lambda a: None + self.assertEqual(self.signature(Wrapped), + ((('a', ..., ..., "positional_or_keyword"),), + ...)) + # wrapper loop: + Wrapped.__wrapped__ = Wrapped + with self.assertRaisesRegex(ValueError, 'wrapper loop'): + self.signature(Wrapped) + + def test_signature_on_lambdas(self): + self.assertEqual(self.signature((lambda a=10: a)), + ((('a', 10, ..., "positional_or_keyword"),), + ...)) + + def test_signature_on_mocks(self): + # https://github.com/python/cpython/issues/96127 + for mock in ( + unittest.mock.Mock(), + unittest.mock.AsyncMock(), + unittest.mock.MagicMock(), + ): + with self.subTest(mock=mock): + self.assertEqual(str(inspect.signature(mock)), '(*args, **kwargs)') + + def test_signature_on_noncallable_mocks(self): + for mock in ( + unittest.mock.NonCallableMock(), + unittest.mock.NonCallableMagicMock(), + ): + with self.subTest(mock=mock): + with self.assertRaises(TypeError): + inspect.signature(mock) + + def test_signature_equality(self): + def foo(a, *, b:int) -> float: pass + self.assertFalse(inspect.signature(foo) == 42) + self.assertTrue(inspect.signature(foo) != 42) + self.assertTrue(inspect.signature(foo) == ALWAYS_EQ) + self.assertFalse(inspect.signature(foo) != ALWAYS_EQ) + + def bar(a, *, b:int) -> float: pass + self.assertTrue(inspect.signature(foo) == inspect.signature(bar)) + self.assertFalse(inspect.signature(foo) != inspect.signature(bar)) + self.assertEqual( + hash(inspect.signature(foo)), hash(inspect.signature(bar))) + + def bar(a, *, b:int) -> int: pass + self.assertFalse(inspect.signature(foo) == inspect.signature(bar)) + self.assertTrue(inspect.signature(foo) != inspect.signature(bar)) + self.assertNotEqual( + hash(inspect.signature(foo)), hash(inspect.signature(bar))) + + def bar(a, *, b:int): pass + self.assertFalse(inspect.signature(foo) == inspect.signature(bar)) + self.assertTrue(inspect.signature(foo) != inspect.signature(bar)) + self.assertNotEqual( + hash(inspect.signature(foo)), hash(inspect.signature(bar))) + + def bar(a, *, b:int=42) -> float: pass + self.assertFalse(inspect.signature(foo) == inspect.signature(bar)) + self.assertTrue(inspect.signature(foo) != inspect.signature(bar)) + self.assertNotEqual( + hash(inspect.signature(foo)), hash(inspect.signature(bar))) + + def bar(a, *, c) -> float: pass + self.assertFalse(inspect.signature(foo) == inspect.signature(bar)) + self.assertTrue(inspect.signature(foo) != inspect.signature(bar)) + self.assertNotEqual( + hash(inspect.signature(foo)), hash(inspect.signature(bar))) + + def bar(a, b:int) -> float: pass + self.assertFalse(inspect.signature(foo) == inspect.signature(bar)) + self.assertTrue(inspect.signature(foo) != inspect.signature(bar)) + self.assertNotEqual( + hash(inspect.signature(foo)), hash(inspect.signature(bar))) + def spam(b:int, a) -> float: pass + self.assertFalse(inspect.signature(spam) == inspect.signature(bar)) + self.assertTrue(inspect.signature(spam) != inspect.signature(bar)) + self.assertNotEqual( + hash(inspect.signature(spam)), hash(inspect.signature(bar))) + + def foo(*, a, b, c): pass + def bar(*, c, b, a): pass + self.assertTrue(inspect.signature(foo) == inspect.signature(bar)) + self.assertFalse(inspect.signature(foo) != inspect.signature(bar)) + self.assertEqual( + hash(inspect.signature(foo)), hash(inspect.signature(bar))) + + def foo(*, a=1, b, c): pass + def bar(*, c, b, a=1): pass + self.assertTrue(inspect.signature(foo) == inspect.signature(bar)) + self.assertFalse(inspect.signature(foo) != inspect.signature(bar)) + self.assertEqual( + hash(inspect.signature(foo)), hash(inspect.signature(bar))) + + def foo(pos, *, a=1, b, c): pass + def bar(pos, *, c, b, a=1): pass + self.assertTrue(inspect.signature(foo) == inspect.signature(bar)) + self.assertFalse(inspect.signature(foo) != inspect.signature(bar)) + self.assertEqual( + hash(inspect.signature(foo)), hash(inspect.signature(bar))) + + def foo(pos, *, a, b, c): pass + def bar(pos, *, c, b, a=1): pass + self.assertFalse(inspect.signature(foo) == inspect.signature(bar)) + self.assertTrue(inspect.signature(foo) != inspect.signature(bar)) + self.assertNotEqual( + hash(inspect.signature(foo)), hash(inspect.signature(bar))) + + def foo(pos, *args, a=42, b, c, **kwargs:int): pass + def bar(pos, *args, c, b, a=42, **kwargs:int): pass + self.assertTrue(inspect.signature(foo) == inspect.signature(bar)) + self.assertFalse(inspect.signature(foo) != inspect.signature(bar)) + self.assertEqual( + hash(inspect.signature(foo)), hash(inspect.signature(bar))) + + def test_signature_hashable(self): + S = inspect.Signature + P = inspect.Parameter + + def foo(a): pass + foo_sig = inspect.signature(foo) + + manual_sig = S(parameters=[P('a', P.POSITIONAL_OR_KEYWORD)]) + + self.assertEqual(hash(foo_sig), hash(manual_sig)) + self.assertNotEqual(hash(foo_sig), + hash(manual_sig.replace(return_annotation='spam'))) + + def bar(a) -> 1: pass + self.assertNotEqual(hash(foo_sig), hash(inspect.signature(bar))) + + def foo(a={}): pass + with self.assertRaisesRegex(TypeError, 'unhashable type'): + hash(inspect.signature(foo)) + + def foo(a) -> {}: pass + with self.assertRaisesRegex(TypeError, 'unhashable type'): + hash(inspect.signature(foo)) + + def test_signature_str(self): + def foo(a:int=1, *, b, c=None, **kwargs) -> 42: + pass + self.assertEqual(str(inspect.signature(foo)), + '(a: int = 1, *, b, c=None, **kwargs) -> 42') + + def foo(a:int=1, *args, b, c=None, **kwargs) -> 42: + pass + self.assertEqual(str(inspect.signature(foo)), + '(a: int = 1, *args, b, c=None, **kwargs) -> 42') + + def foo(): + pass + self.assertEqual(str(inspect.signature(foo)), '()') + + def foo(a: list[str]) -> tuple[str, float]: + pass + self.assertEqual(str(inspect.signature(foo)), + '(a: list[str]) -> tuple[str, float]') + + from typing import Tuple + def foo(a: list[str]) -> Tuple[str, float]: + pass + self.assertEqual(str(inspect.signature(foo)), + '(a: list[str]) -> Tuple[str, float]') + + def test_signature_str_positional_only(self): + P = inspect.Parameter + S = inspect.Signature + + def test(a_po, /, *, b, **kwargs): + return a_po, kwargs + + self.assertEqual(str(inspect.signature(test)), + '(a_po, /, *, b, **kwargs)') + + self.assertEqual(str(S(parameters=[P('foo', P.POSITIONAL_ONLY)])), + '(foo, /)') + + self.assertEqual(str(S(parameters=[ + P('foo', P.POSITIONAL_ONLY), + P('bar', P.VAR_KEYWORD)])), + '(foo, /, **bar)') + + self.assertEqual(str(S(parameters=[ + P('foo', P.POSITIONAL_ONLY), + P('bar', P.VAR_POSITIONAL)])), + '(foo, /, *bar)') + + def test_signature_replace_parameters(self): + def test(a, b) -> 42: + pass + + sig = inspect.signature(test) + parameters = sig.parameters + sig = sig.replace(parameters=list(parameters.values())[1:]) + self.assertEqual(list(sig.parameters), ['b']) + self.assertEqual(sig.parameters['b'], parameters['b']) + self.assertEqual(sig.return_annotation, 42) + sig = sig.replace(parameters=()) + self.assertEqual(dict(sig.parameters), {}) + + sig = inspect.signature(test) + parameters = sig.parameters + sig = copy.replace(sig, parameters=list(parameters.values())[1:]) + self.assertEqual(list(sig.parameters), ['b']) + self.assertEqual(sig.parameters['b'], parameters['b']) + self.assertEqual(sig.return_annotation, 42) + sig = copy.replace(sig, parameters=()) + self.assertEqual(dict(sig.parameters), {}) + + def test_signature_replace_anno(self): + def test() -> 42: + pass + + sig = inspect.signature(test) + sig = sig.replace(return_annotation=None) + self.assertIs(sig.return_annotation, None) + sig = sig.replace(return_annotation=sig.empty) + self.assertIs(sig.return_annotation, sig.empty) + sig = sig.replace(return_annotation=42) + self.assertEqual(sig.return_annotation, 42) + self.assertEqual(sig, inspect.signature(test)) + + sig = inspect.signature(test) + sig = copy.replace(sig, return_annotation=None) + self.assertIs(sig.return_annotation, None) + sig = copy.replace(sig, return_annotation=sig.empty) + self.assertIs(sig.return_annotation, sig.empty) + sig = copy.replace(sig, return_annotation=42) + self.assertEqual(sig.return_annotation, 42) + self.assertEqual(sig, inspect.signature(test)) + + def test_signature_replaced(self): + def test(): + pass + + spam_param = inspect.Parameter('spam', inspect.Parameter.POSITIONAL_ONLY) + sig = test.__signature__ = inspect.Signature(parameters=(spam_param,)) + self.assertEqual(sig, inspect.signature(test)) + + def test_signature_on_mangled_parameters(self): + class Spam: + def foo(self, __p1:1=2, *, __p2:2=3): + pass + class Ham(Spam): + pass + + self.assertEqual(self.signature(Spam.foo), + ((('self', ..., ..., "positional_or_keyword"), + ('_Spam__p1', 2, 1, "positional_or_keyword"), + ('_Spam__p2', 3, 2, "keyword_only")), + ...)) + + self.assertEqual(self.signature(Spam.foo), + self.signature(Ham.foo)) + + def test_signature_from_callable_python_obj(self): + class MySignature(inspect.Signature): pass + def foo(a, *, b:1): pass + foo_sig = MySignature.from_callable(foo) + self.assertIsInstance(foo_sig, MySignature) + + def test_signature_from_callable_class(self): + # A regression test for a class inheriting its signature from `object`. + class MySignature(inspect.Signature): pass + class foo: pass + foo_sig = MySignature.from_callable(foo) + self.assertIsInstance(foo_sig, MySignature) + + @unittest.skipIf(MISSING_C_DOCSTRINGS, + "Signature information for builtins requires docstrings") + def test_signature_from_callable_builtin_obj(self): + class MySignature(inspect.Signature): pass + sig = MySignature.from_callable(_pickle.Pickler) + self.assertIsInstance(sig, MySignature) + + def test_signature_definition_order_preserved_on_kwonly(self): + for fn in signatures_with_lexicographic_keyword_only_parameters(): + signature = inspect.signature(fn) + l = list(signature.parameters) + sorted_l = sorted(l) + self.assertTrue(l) + self.assertEqual(l, sorted_l) + signature = inspect.signature(unsorted_keyword_only_parameters_fn) + l = list(signature.parameters) + self.assertEqual(l, unsorted_keyword_only_parameters) + + def test_signater_parameters_is_ordered(self): + p1 = inspect.signature(lambda x, y: None).parameters + p2 = inspect.signature(lambda y, x: None).parameters + self.assertNotEqual(p1, p2) + + def test_signature_annotations_with_local_namespaces(self): + class Foo: ... + def func(foo: Foo) -> int: pass + def func2(foo: Foo, bar: 'Bar') -> int: pass + + for signature_func in (inspect.signature, inspect.Signature.from_callable): + with self.subTest(signature_func = signature_func): + sig1 = signature_func(func) + self.assertEqual(sig1.return_annotation, int) + self.assertEqual(sig1.parameters['foo'].annotation, Foo) + + sig2 = signature_func(func, locals=locals()) + self.assertEqual(sig2.return_annotation, int) + self.assertEqual(sig2.parameters['foo'].annotation, Foo) + + sig3 = signature_func(func2, globals={'Bar': int}, locals=locals()) + self.assertEqual(sig3.return_annotation, int) + self.assertEqual(sig3.parameters['foo'].annotation, Foo) + self.assertEqual(sig3.parameters['bar'].annotation, 'Bar') + + def test_signature_eval_str(self): + isa = inspect_stringized_annotations + sig = inspect.Signature + par = inspect.Parameter + PORK = inspect.Parameter.POSITIONAL_OR_KEYWORD + for signature_func in (inspect.signature, inspect.Signature.from_callable): + with self.subTest(signature_func = signature_func): + self.assertEqual( + signature_func(isa.MyClass), + sig( + parameters=( + par('a', PORK), + par('b', PORK), + ))) + self.assertEqual( + signature_func(isa.function), + sig( + return_annotation='MyClass', + parameters=( + par('a', PORK, annotation='int'), + par('b', PORK, annotation='str'), + ))) + self.assertEqual( + signature_func(isa.function2), + sig( + return_annotation='MyClass', + parameters=( + par('a', PORK, annotation='int'), + par('b', PORK, annotation="'str'"), + par('c', PORK, annotation="MyClass"), + ))) + self.assertEqual( + signature_func(isa.function3), + sig( + parameters=( + par('a', PORK, annotation="'int'"), + par('b', PORK, annotation="'str'"), + par('c', PORK, annotation="'MyClass'"), + ))) + + self.assertEqual(signature_func(isa.UnannotatedClass), sig()) + self.assertEqual(signature_func(isa.unannotated_function), + sig( + parameters=( + par('a', PORK), + par('b', PORK), + par('c', PORK), + ))) + + self.assertEqual( + signature_func(isa.MyClass, eval_str=True), + sig( + parameters=( + par('a', PORK), + par('b', PORK), + ))) + self.assertEqual( + signature_func(isa.function, eval_str=True), + sig( + return_annotation=isa.MyClass, + parameters=( + par('a', PORK, annotation=int), + par('b', PORK, annotation=str), + ))) + self.assertEqual( + signature_func(isa.function2, eval_str=True), + sig( + return_annotation=isa.MyClass, + parameters=( + par('a', PORK, annotation=int), + par('b', PORK, annotation='str'), + par('c', PORK, annotation=isa.MyClass), + ))) + self.assertEqual( + signature_func(isa.function3, eval_str=True), + sig( + parameters=( + par('a', PORK, annotation='int'), + par('b', PORK, annotation='str'), + par('c', PORK, annotation='MyClass'), + ))) + + globalns = {'int': float, 'str': complex} + localns = {'str': tuple, 'MyClass': dict} + with self.assertRaises(NameError): + signature_func(isa.function, eval_str=True, globals=globalns) + + self.assertEqual( + signature_func(isa.function, eval_str=True, locals=localns), + sig( + return_annotation=dict, + parameters=( + par('a', PORK, annotation=int), + par('b', PORK, annotation=tuple), + ))) + + self.assertEqual( + signature_func(isa.function, eval_str=True, globals=globalns, locals=localns), + sig( + return_annotation=dict, + parameters=( + par('a', PORK, annotation=float), + par('b', PORK, annotation=tuple), + ))) + + def test_signature_none_annotation(self): + class funclike: + # Has to be callable, and have correct + # __code__, __annotations__, __defaults__, __name__, + # and __kwdefaults__ attributes + + def __init__(self, func): + self.__name__ = func.__name__ + self.__code__ = func.__code__ + self.__annotations__ = func.__annotations__ + self.__defaults__ = func.__defaults__ + self.__kwdefaults__ = func.__kwdefaults__ + self.func = func + + def __call__(self, *args, **kwargs): + return self.func(*args, **kwargs) + + def foo(): pass + foo = funclike(foo) + foo.__annotations__ = None + for signature_func in (inspect.signature, inspect.Signature.from_callable): + with self.subTest(signature_func = signature_func): + self.assertEqual(signature_func(foo), inspect.Signature()) + self.assertEqual(inspect.get_annotations(foo), {}) + + def test_signature_as_str(self): + self.maxDiff = None + class S: + __signature__ = '(a, b=2)' + + self.assertEqual(self.signature(S), + ((('a', ..., ..., 'positional_or_keyword'), + ('b', 2, ..., 'positional_or_keyword')), + ...)) + + def test_signature_as_callable(self): + # __signature__ should be either a staticmethod or a bound classmethod + class S: + @classmethod + def __signature__(cls): + return '(a, b=2)' + + self.assertEqual(self.signature(S), + ((('a', ..., ..., 'positional_or_keyword'), + ('b', 2, ..., 'positional_or_keyword')), + ...)) + + class S: + @staticmethod + def __signature__(): + return '(a, b=2)' + + self.assertEqual(self.signature(S), + ((('a', ..., ..., 'positional_or_keyword'), + ('b', 2, ..., 'positional_or_keyword')), + ...)) + + def test_signature_on_derived_classes(self): + # gh-105080: Make sure that signatures are consistent on derived classes + + class B: + def __new__(self, *args, **kwargs): + return super().__new__(self) + def __init__(self, value): + self.value = value + + class D1(B): + def __init__(self, value): + super().__init__(value) + + class D2(D1): + pass + + self.assertEqual(inspect.signature(D2), inspect.signature(D1)) + + +class TestParameterObject(unittest.TestCase): + def test_signature_parameter_kinds(self): + P = inspect.Parameter + self.assertTrue(P.POSITIONAL_ONLY < P.POSITIONAL_OR_KEYWORD < \ + P.VAR_POSITIONAL < P.KEYWORD_ONLY < P.VAR_KEYWORD) + + self.assertEqual(str(P.POSITIONAL_ONLY), 'POSITIONAL_ONLY') + self.assertTrue('POSITIONAL_ONLY' in repr(P.POSITIONAL_ONLY)) + + def test_signature_parameter_object(self): + p = inspect.Parameter('foo', default=10, + kind=inspect.Parameter.POSITIONAL_ONLY) + self.assertEqual(p.name, 'foo') + self.assertEqual(p.default, 10) + self.assertIs(p.annotation, p.empty) + self.assertEqual(p.kind, inspect.Parameter.POSITIONAL_ONLY) + + with self.assertRaisesRegex(ValueError, "value '123' is " + "not a valid Parameter.kind"): + inspect.Parameter('foo', default=10, kind='123') + + with self.assertRaisesRegex(ValueError, 'not a valid parameter name'): + inspect.Parameter('1', kind=inspect.Parameter.VAR_KEYWORD) + + with self.assertRaisesRegex(ValueError, 'not a valid parameter name'): + inspect.Parameter('from', kind=inspect.Parameter.VAR_KEYWORD) + + with self.assertRaisesRegex(TypeError, 'name must be a str'): + inspect.Parameter(None, kind=inspect.Parameter.VAR_KEYWORD) + + with self.assertRaisesRegex(ValueError, + 'is not a valid parameter name'): + inspect.Parameter('$', kind=inspect.Parameter.VAR_KEYWORD) + + with self.assertRaisesRegex(ValueError, + 'is not a valid parameter name'): + inspect.Parameter('.a', kind=inspect.Parameter.VAR_KEYWORD) + + with self.assertRaisesRegex(ValueError, 'cannot have default values'): + inspect.Parameter('a', default=42, + kind=inspect.Parameter.VAR_KEYWORD) + + with self.assertRaisesRegex(ValueError, 'cannot have default values'): + inspect.Parameter('a', default=42, + kind=inspect.Parameter.VAR_POSITIONAL) + + p = inspect.Parameter('a', default=42, + kind=inspect.Parameter.POSITIONAL_OR_KEYWORD) + with self.assertRaisesRegex(ValueError, 'cannot have default values'): + p.replace(kind=inspect.Parameter.VAR_POSITIONAL) + + self.assertTrue(repr(p).startswith(' " + "is not a valid Parameter.kind"): + p2 = p2.replace(kind=p2.empty) + with self.assertRaisesRegex(ValueError, + "value " + "is not a valid Parameter.kind"): + p3 = copy.replace(p3, kind=p3.empty) + + p2 = p2.replace(kind=p2.KEYWORD_ONLY) + self.assertEqual(p2, p) + p3 = copy.replace(p3, kind=p3.KEYWORD_ONLY) + self.assertEqual(p3, p) + + def test_signature_parameter_positional_only(self): + with self.assertRaisesRegex(TypeError, 'name must be a str'): + inspect.Parameter(None, kind=inspect.Parameter.POSITIONAL_ONLY) + + @cpython_only + def test_signature_parameter_implicit(self): + with self.assertRaisesRegex(ValueError, + 'implicit arguments must be passed as ' + 'positional or keyword arguments, ' + 'not positional-only'): + inspect.Parameter('.0', kind=inspect.Parameter.POSITIONAL_ONLY) + + param = inspect.Parameter( + '.0', kind=inspect.Parameter.POSITIONAL_OR_KEYWORD) + self.assertEqual(param.kind, inspect.Parameter.POSITIONAL_ONLY) + self.assertEqual(param.name, 'implicit0') + + def test_signature_parameter_immutability(self): + p = inspect.Parameter('spam', kind=inspect.Parameter.KEYWORD_ONLY) + + with self.assertRaises(AttributeError): + p.foo = 'bar' + + with self.assertRaises(AttributeError): + p.kind = 123 + + +class TestSignatureBind(unittest.TestCase): + @staticmethod + def call(func, *args, **kwargs): + sig = inspect.signature(func) + ba = sig.bind(*args, **kwargs) + return func(*ba.args, **ba.kwargs) + + def test_signature_bind_empty(self): + def test(): + return 42 + + self.assertEqual(self.call(test), 42) + with self.assertRaisesRegex(TypeError, 'too many positional arguments'): + self.call(test, 1) + with self.assertRaisesRegex(TypeError, 'too many positional arguments'): + self.call(test, 1, spam=10) + with self.assertRaisesRegex( + TypeError, "got an unexpected keyword argument 'spam'"): + + self.call(test, spam=1) + + def test_signature_bind_var(self): + def test(*args, **kwargs): + return args, kwargs + + self.assertEqual(self.call(test), ((), {})) + self.assertEqual(self.call(test, 1), ((1,), {})) + self.assertEqual(self.call(test, 1, 2), ((1, 2), {})) + self.assertEqual(self.call(test, foo='bar'), ((), {'foo': 'bar'})) + self.assertEqual(self.call(test, 1, foo='bar'), ((1,), {'foo': 'bar'})) + self.assertEqual(self.call(test, args=10), ((), {'args': 10})) + self.assertEqual(self.call(test, 1, 2, foo='bar'), + ((1, 2), {'foo': 'bar'})) + + def test_signature_bind_just_args(self): + def test(a, b, c): + return a, b, c + + self.assertEqual(self.call(test, 1, 2, 3), (1, 2, 3)) + + with self.assertRaisesRegex(TypeError, 'too many positional arguments'): + self.call(test, 1, 2, 3, 4) + + with self.assertRaisesRegex(TypeError, + "missing a required argument: 'b'"): + self.call(test, 1) + + with self.assertRaisesRegex(TypeError, + "missing a required argument: 'a'"): + self.call(test) + + def test(a, b, c=10): + return a, b, c + self.assertEqual(self.call(test, 1, 2, 3), (1, 2, 3)) + self.assertEqual(self.call(test, 1, 2), (1, 2, 10)) + + def test(a=1, b=2, c=3): + return a, b, c + self.assertEqual(self.call(test, a=10, c=13), (10, 2, 13)) + self.assertEqual(self.call(test, a=10), (10, 2, 3)) + self.assertEqual(self.call(test, b=10), (1, 10, 3)) + + def test_signature_bind_varargs_order(self): + def test(*args): + return args + + self.assertEqual(self.call(test), ()) + self.assertEqual(self.call(test, 1, 2, 3), (1, 2, 3)) + + def test_signature_bind_args_and_varargs(self): + def test(a, b, c=3, *args): + return a, b, c, args + + self.assertEqual(self.call(test, 1, 2, 3, 4, 5), (1, 2, 3, (4, 5))) + self.assertEqual(self.call(test, 1, 2), (1, 2, 3, ())) + self.assertEqual(self.call(test, b=1, a=2), (2, 1, 3, ())) + self.assertEqual(self.call(test, 1, b=2), (1, 2, 3, ())) + + with self.assertRaisesRegex(TypeError, + "multiple values for argument 'c'"): + self.call(test, 1, 2, 3, c=4) + + def test_signature_bind_just_kwargs(self): + def test(**kwargs): + return kwargs + + self.assertEqual(self.call(test), {}) + self.assertEqual(self.call(test, foo='bar', spam='ham'), + {'foo': 'bar', 'spam': 'ham'}) + + def test_signature_bind_args_and_kwargs(self): + def test(a, b, c=3, **kwargs): + return a, b, c, kwargs + + self.assertEqual(self.call(test, 1, 2), (1, 2, 3, {})) + self.assertEqual(self.call(test, 1, 2, foo='bar', spam='ham'), + (1, 2, 3, {'foo': 'bar', 'spam': 'ham'})) + self.assertEqual(self.call(test, b=2, a=1, foo='bar', spam='ham'), + (1, 2, 3, {'foo': 'bar', 'spam': 'ham'})) + self.assertEqual(self.call(test, a=1, b=2, foo='bar', spam='ham'), + (1, 2, 3, {'foo': 'bar', 'spam': 'ham'})) + self.assertEqual(self.call(test, 1, b=2, foo='bar', spam='ham'), + (1, 2, 3, {'foo': 'bar', 'spam': 'ham'})) + self.assertEqual(self.call(test, 1, b=2, c=4, foo='bar', spam='ham'), + (1, 2, 4, {'foo': 'bar', 'spam': 'ham'})) + self.assertEqual(self.call(test, 1, 2, 4, foo='bar'), + (1, 2, 4, {'foo': 'bar'})) + self.assertEqual(self.call(test, c=5, a=4, b=3), + (4, 3, 5, {})) + + def test_signature_bind_kwonly(self): + def test(*, foo): + return foo + with self.assertRaisesRegex(TypeError, + 'too many positional arguments'): + self.call(test, 1) + self.assertEqual(self.call(test, foo=1), 1) + + def test(a, *, foo=1, bar): + return foo + with self.assertRaisesRegex(TypeError, + "missing a required argument: 'bar'"): + self.call(test, 1) + + def test(foo, *, bar): + return foo, bar + self.assertEqual(self.call(test, 1, bar=2), (1, 2)) + self.assertEqual(self.call(test, bar=2, foo=1), (1, 2)) + + with self.assertRaisesRegex( + TypeError, "got an unexpected keyword argument 'spam'"): + + self.call(test, bar=2, foo=1, spam=10) + + with self.assertRaisesRegex(TypeError, + 'too many positional arguments'): + self.call(test, 1, 2) + + with self.assertRaisesRegex(TypeError, + 'too many positional arguments'): + self.call(test, 1, 2, bar=2) + + with self.assertRaisesRegex( + TypeError, "got an unexpected keyword argument 'spam'"): + + self.call(test, 1, bar=2, spam='ham') + + with self.assertRaisesRegex(TypeError, + "missing a required keyword-only " + "argument: 'bar'"): + self.call(test, 1) + + def test(foo, *, bar, **bin): + return foo, bar, bin + self.assertEqual(self.call(test, 1, bar=2), (1, 2, {})) + self.assertEqual(self.call(test, foo=1, bar=2), (1, 2, {})) + self.assertEqual(self.call(test, 1, bar=2, spam='ham'), + (1, 2, {'spam': 'ham'})) + self.assertEqual(self.call(test, spam='ham', foo=1, bar=2), + (1, 2, {'spam': 'ham'})) + with self.assertRaisesRegex(TypeError, + "missing a required argument: 'foo'"): + self.call(test, spam='ham', bar=2) + self.assertEqual(self.call(test, 1, bar=2, bin=1, spam=10), + (1, 2, {'bin': 1, 'spam': 10})) + + def test_signature_bind_arguments(self): + def test(a, *args, b, z=100, **kwargs): + pass + sig = inspect.signature(test) + ba = sig.bind(10, 20, b=30, c=40, args=50, kwargs=60) + # we won't have 'z' argument in the bound arguments object, as we didn't + # pass it to the 'bind' + self.assertEqual(tuple(ba.arguments.items()), + (('a', 10), ('args', (20,)), ('b', 30), + ('kwargs', {'c': 40, 'args': 50, 'kwargs': 60}))) + self.assertEqual(ba.kwargs, + {'b': 30, 'c': 40, 'args': 50, 'kwargs': 60}) + self.assertEqual(ba.args, (10, 20)) + + def test_signature_bind_positional_only(self): + def test(a_po, b_po, c_po=3, /, foo=42, *, bar=50, **kwargs): + return a_po, b_po, c_po, foo, bar, kwargs + + self.assertEqual(self.call(test, 1, 2, 4, 5, bar=6), + (1, 2, 4, 5, 6, {})) + + self.assertEqual(self.call(test, 1, 2), + (1, 2, 3, 42, 50, {})) + + self.assertEqual(self.call(test, 1, 2, foo=4, bar=5), + (1, 2, 3, 4, 5, {})) + + with self.assertRaisesRegex(TypeError, "but was passed as a keyword"): + self.call(test, 1, 2, foo=4, bar=5, c_po=10) + + with self.assertRaisesRegex(TypeError, "parameter is positional only"): + self.call(test, 1, 2, c_po=4) + + with self.assertRaisesRegex(TypeError, "parameter is positional only"): + self.call(test, a_po=1, b_po=2) + + def test_signature_bind_with_self_arg(self): + # Issue #17071: one of the parameters is named "self + def test(a, self, b): + pass + sig = inspect.signature(test) + ba = sig.bind(1, 2, 3) + self.assertEqual(ba.args, (1, 2, 3)) + ba = sig.bind(1, self=2, b=3) + self.assertEqual(ba.args, (1, 2, 3)) + + def test_signature_bind_vararg_name(self): + def test(a, *args): + return a, args + sig = inspect.signature(test) + + with self.assertRaisesRegex( + TypeError, "got an unexpected keyword argument 'args'"): + + sig.bind(a=0, args=1) + + def test(*args, **kwargs): + return args, kwargs + self.assertEqual(self.call(test, args=1), ((), {'args': 1})) + + sig = inspect.signature(test) + ba = sig.bind(args=1) + self.assertEqual(ba.arguments, {'kwargs': {'args': 1}}) + + @cpython_only + def test_signature_bind_implicit_arg(self): + # Issue #19611: getcallargs should work with comprehensions + def make_set(): + return set(z * z for z in range(5)) + gencomp_code = make_set.__code__.co_consts[1] + gencomp_func = types.FunctionType(gencomp_code, {}) + + iterator = iter(range(5)) + self.assertEqual(set(self.call(gencomp_func, iterator)), {0, 1, 4, 9, 16}) + + def test_signature_bind_posonly_kwargs(self): + def foo(bar, /, **kwargs): + return bar, kwargs.get(bar) + + sig = inspect.signature(foo) + result = sig.bind("pos-only", bar="keyword") + + self.assertEqual(result.kwargs, {"bar": "keyword"}) + self.assertIn(("bar", "pos-only"), result.arguments.items()) + + +class TestBoundArguments(unittest.TestCase): + def test_signature_bound_arguments_unhashable(self): + def foo(a): pass + ba = inspect.signature(foo).bind(1) + + with self.assertRaisesRegex(TypeError, 'unhashable type'): + hash(ba) + + def test_signature_bound_arguments_equality(self): + def foo(a): pass + ba = inspect.signature(foo).bind(1) + self.assertTrue(ba == ba) + self.assertFalse(ba != ba) + self.assertTrue(ba == ALWAYS_EQ) + self.assertFalse(ba != ALWAYS_EQ) + + ba2 = inspect.signature(foo).bind(1) + self.assertTrue(ba == ba2) + self.assertFalse(ba != ba2) + + ba3 = inspect.signature(foo).bind(2) + self.assertFalse(ba == ba3) + self.assertTrue(ba != ba3) + ba3.arguments['a'] = 1 + self.assertTrue(ba == ba3) + self.assertFalse(ba != ba3) + + def bar(b): pass + ba4 = inspect.signature(bar).bind(1) + self.assertFalse(ba == ba4) + self.assertTrue(ba != ba4) + + def foo(*, a, b): pass + sig = inspect.signature(foo) + ba1 = sig.bind(a=1, b=2) + ba2 = sig.bind(b=2, a=1) + self.assertTrue(ba1 == ba2) + self.assertFalse(ba1 != ba2) + + def test_signature_bound_arguments_pickle(self): + def foo(a, b, *, c:1={}, **kw) -> {42:'ham'}: pass + sig = inspect.signature(foo) + ba = sig.bind(20, 30, z={}) + + for ver in range(pickle.HIGHEST_PROTOCOL + 1): + with self.subTest(pickle_ver=ver): + ba_pickled = pickle.loads(pickle.dumps(ba, ver)) + self.assertEqual(ba, ba_pickled) + + def test_signature_bound_arguments_repr(self): + def foo(a, b, *, c:1={}, **kw) -> {42:'ham'}: pass + sig = inspect.signature(foo) + ba = sig.bind(20, 30, z={}) + self.assertRegex(repr(ba), r'') + + def test_signature_bound_arguments_apply_defaults(self): + def foo(a, b=1, *args, c:1={}, **kw): pass + sig = inspect.signature(foo) + + ba = sig.bind(20) + ba.apply_defaults() + self.assertEqual( + list(ba.arguments.items()), + [('a', 20), ('b', 1), ('args', ()), ('c', {}), ('kw', {})]) + + # Make sure that we preserve the order: + # i.e. 'c' should be *before* 'kw'. + ba = sig.bind(10, 20, 30, d=1) + ba.apply_defaults() + self.assertEqual( + list(ba.arguments.items()), + [('a', 10), ('b', 20), ('args', (30,)), ('c', {}), ('kw', {'d':1})]) + + # Make sure that BoundArguments produced by bind_partial() + # are supported. + def foo(a, b): pass + sig = inspect.signature(foo) + ba = sig.bind_partial(20) + ba.apply_defaults() + self.assertEqual( + list(ba.arguments.items()), + [('a', 20)]) + + # Test no args + def foo(): pass + sig = inspect.signature(foo) + ba = sig.bind() + ba.apply_defaults() + self.assertEqual(list(ba.arguments.items()), []) + + # Make sure a no-args binding still acquires proper defaults. + def foo(a='spam'): pass + sig = inspect.signature(foo) + ba = sig.bind() + ba.apply_defaults() + self.assertEqual(list(ba.arguments.items()), [('a', 'spam')]) + + def test_signature_bound_arguments_arguments_type(self): + def foo(a): pass + ba = inspect.signature(foo).bind(1) + self.assertIs(type(ba.arguments), dict) + +class TestSignaturePrivateHelpers(unittest.TestCase): + def _strip_non_python_syntax(self, input, + clean_signature, self_parameter): + computed_clean_signature, \ + computed_self_parameter = \ + inspect._signature_strip_non_python_syntax(input) + self.assertEqual(computed_clean_signature, clean_signature) + self.assertEqual(computed_self_parameter, self_parameter) + + def test_signature_strip_non_python_syntax(self): + self._strip_non_python_syntax( + "($module, /, path, mode, *, dir_fd=None, " + + "effective_ids=False,\n follow_symlinks=True)", + "(module, /, path, mode, *, dir_fd=None, " + + "effective_ids=False, follow_symlinks=True)", + 0) + + self._strip_non_python_syntax( + "($module, word, salt, /)", + "(module, word, salt, /)", + 0) + + self._strip_non_python_syntax( + "(x, y=None, z=None, /)", + "(x, y=None, z=None, /)", + None) + + self._strip_non_python_syntax( + "(x, y=None, z=None)", + "(x, y=None, z=None)", + None) + + self._strip_non_python_syntax( + "(x,\n y=None,\n z = None )", + "(x, y=None, z=None)", + None) + + self._strip_non_python_syntax( + "", + "", + None) + + self._strip_non_python_syntax( + None, + None, + None) + +class TestSignatureDefinitions(unittest.TestCase): + # This test case provides a home for checking that particular APIs + # have signatures available for introspection + + @cpython_only + @unittest.skipIf(MISSING_C_DOCSTRINGS, + "Signature information for builtins requires docstrings") + def test_builtins_have_signatures(self): + # This checks all builtin callables in CPython have signatures + # A few have signatures Signature can't yet handle, so we skip those + # since they will have to wait until PEP 457 adds the required + # introspection support to the inspect module + # Some others also haven't been converted yet for various other + # reasons, so we also skip those for the time being, but design + # the test to fail in order to indicate when it needs to be + # updated. + no_signature = set() + # These need PEP 457 groups + needs_groups = {"range", "slice", "dir", "getattr", + "next", "iter", "vars"} + no_signature |= needs_groups + # These have unrepresentable parameter default values of NULL + needs_null = {"anext"} + no_signature |= needs_null + # These need PEP 457 groups or a signature change to accept None + needs_semantic_update = {"round"} + no_signature |= needs_semantic_update + # These need *args support in Argument Clinic + needs_varargs = {"breakpoint", "min", "max", "print", + "__build_class__"} + no_signature |= needs_varargs + # These simply weren't covered in the initial AC conversion + # for builtin callables + not_converted_yet = {"open", "__import__"} + no_signature |= not_converted_yet + # These builtin types are expected to provide introspection info + types_with_signatures = set() + # Check the signatures we expect to be there + ns = vars(builtins) + for name, obj in sorted(ns.items()): + if not callable(obj): + continue + # The builtin types haven't been converted to AC yet + if isinstance(obj, type) and (name not in types_with_signatures): + # Note that this also skips all the exception types + no_signature.add(name) + if (name in no_signature): + # Not yet converted + continue + with self.subTest(builtin=name): + self.assertIsNotNone(inspect.signature(obj)) + # Check callables that haven't been converted don't claim a signature + # This ensures this test will start failing as more signatures are + # added, so the affected items can be moved into the scope of the + # regression test above + for name in no_signature: + with self.subTest(builtin=name): + self.assertIsNone(obj.__text_signature__) + + def test_python_function_override_signature(self): + def func(*args, **kwargs): + pass + func.__text_signature__ = '($self, a, b=1, *args, c, d=2, **kwargs)' + sig = inspect.signature(func) + self.assertIsNotNone(sig) + self.assertEqual(str(sig), '(self, /, a, b=1, *args, c, d=2, **kwargs)') + + func.__text_signature__ = '($self, a, b=1, /, *args, c, d=2, **kwargs)' + sig = inspect.signature(func) + self.assertEqual(str(sig), '(self, a, b=1, /, *args, c, d=2, **kwargs)') + + func.__text_signature__ = '(self, a=1+2, b=4-3, c=1 | 3 | 16)' + sig = inspect.signature(func) + self.assertEqual(str(sig), '(self, a=3, b=1, c=19)') + + func.__text_signature__ = '(self, a=1,\nb=2,\n\n\n c=3)' + sig = inspect.signature(func) + self.assertEqual(str(sig), '(self, a=1, b=2, c=3)') + + func.__text_signature__ = '(self, x=does_not_exist)' + with self.assertRaises(ValueError): + inspect.signature(func) + func.__text_signature__ = '(self, x=sys, y=inspect)' + with self.assertRaises(ValueError): + inspect.signature(func) + func.__text_signature__ = '(self, 123)' + with self.assertRaises(ValueError): + inspect.signature(func) + + def test_base_class_have_text_signature(self): + # see issue 43118 + from test.typinganndata.ann_module7 import BufferedReader + class MyBufferedReader(BufferedReader): + """buffer reader class.""" + + text_signature = BufferedReader.__text_signature__ + self.assertEqual(text_signature, '(raw, buffer_size=DEFAULT_BUFFER_SIZE)') + sig = inspect.signature(MyBufferedReader) + self.assertEqual(str(sig), '(raw, buffer_size=8192)') + + +class NTimesUnwrappable: + def __init__(self, n): + self.n = n + self._next = None + + @property + def __wrapped__(self): + if self.n <= 0: + raise Exception("Unwrapped too many times") + if self._next is None: + self._next = NTimesUnwrappable(self.n - 1) + return self._next + +class TestUnwrap(unittest.TestCase): + + def test_unwrap_one(self): + def func(a, b): + return a + b + wrapper = functools.lru_cache(maxsize=20)(func) + self.assertIs(inspect.unwrap(wrapper), func) + + def test_unwrap_several(self): + def func(a, b): + return a + b + wrapper = func + for __ in range(10): + @functools.wraps(wrapper) + def wrapper(): + pass + self.assertIsNot(wrapper.__wrapped__, func) + self.assertIs(inspect.unwrap(wrapper), func) + + def test_stop(self): + def func1(a, b): + return a + b + @functools.wraps(func1) + def func2(): + pass + @functools.wraps(func2) + def wrapper(): + pass + func2.stop_here = 1 + unwrapped = inspect.unwrap(wrapper, + stop=(lambda f: hasattr(f, "stop_here"))) + self.assertIs(unwrapped, func2) + + def test_cycle(self): + def func1(): pass + func1.__wrapped__ = func1 + with self.assertRaisesRegex(ValueError, 'wrapper loop'): + inspect.unwrap(func1) + + def func2(): pass + func2.__wrapped__ = func1 + func1.__wrapped__ = func2 + with self.assertRaisesRegex(ValueError, 'wrapper loop'): + inspect.unwrap(func1) + with self.assertRaisesRegex(ValueError, 'wrapper loop'): + inspect.unwrap(func2) + + def test_unhashable(self): + def func(): pass + func.__wrapped__ = None + class C: + __hash__ = None + __wrapped__ = func + self.assertIsNone(inspect.unwrap(C())) + + def test_recursion_limit(self): + obj = NTimesUnwrappable(sys.getrecursionlimit() + 1) + with self.assertRaisesRegex(ValueError, 'wrapper loop'): + inspect.unwrap(obj) + +class TestMain(unittest.TestCase): + def test_only_source(self): + module = importlib.import_module('unittest') + rc, out, err = assert_python_ok('-m', 'inspect', + 'unittest') + lines = out.decode().splitlines() + # ignore the final newline + self.assertEqual(lines[:-1], inspect.getsource(module).splitlines()) + self.assertEqual(err, b'') + + def test_custom_getattr(self): + def foo(): + pass + foo.__signature__ = 42 + with self.assertRaises(TypeError): + inspect.signature(foo) + + @unittest.skipIf(ThreadPoolExecutor is None, + 'threads required to test __qualname__ for source files') + def test_qualname_source(self): + rc, out, err = assert_python_ok('-m', 'inspect', + 'concurrent.futures:ThreadPoolExecutor') + lines = out.decode().splitlines() + # ignore the final newline + self.assertEqual(lines[:-1], + inspect.getsource(ThreadPoolExecutor).splitlines()) + self.assertEqual(err, b'') + + def test_builtins(self): + _, out, err = assert_python_failure('-m', 'inspect', + 'sys') + lines = err.decode().splitlines() + self.assertEqual(lines, ["Can't get info for builtin modules."]) + + def test_details(self): + module = importlib.import_module('unittest') + args = support.optim_args_from_interpreter_flags() + rc, out, err = assert_python_ok(*args, '-m', 'inspect', + 'unittest', '--details') + output = out.decode() + # Just a quick sanity check on the output + self.assertIn(module.__spec__.name, output) + self.assertIn(module.__name__, output) + self.assertIn(module.__spec__.origin, output) + self.assertIn(module.__file__, output) + self.assertIn(module.__spec__.cached, output) + self.assertIn(module.__cached__, output) + self.assertEqual(err, b'') + + +class TestReload(unittest.TestCase): + + src_before = textwrap.dedent("""\ +def foo(): + print("Bla") + """) + + src_after = textwrap.dedent("""\ +def foo(): + print("Oh no!") + """) + + def assertInspectEqual(self, path, source): + inspected_src = inspect.getsource(source) + with open(path, encoding='utf-8') as src: + self.assertEqual( + src.read().splitlines(True), + inspected_src.splitlines(True) + ) + + def test_getsource_reload(self): + # see issue 1218234 + with ready_to_import('reload_bug', self.src_before) as (name, path): + module = importlib.import_module(name) + self.assertInspectEqual(path, module) + with open(path, 'w', encoding='utf-8') as src: + src.write(self.src_after) + self.assertInspectEqual(path, module) + + +if __name__ == "__main__": + unittest.main() diff --git a/Lib/test/test_tokenize.py b/Lib/test/test_tokenize.py index 9369560..06517ac 100644 --- a/Lib/test/test_tokenize.py +++ b/Lib/test/test_tokenize.py @@ -1911,7 +1911,7 @@ class TestRoundtrip(TestCase): # TODO: Remove this once we can untokenize PEP 701 syntax testfiles.remove(os.path.join(tempdir, "test_fstring.py")) - for f in ('buffer', 'builtin', 'fileio', 'inspect', 'os', 'platform', 'sys'): + for f in ('buffer', 'builtin', 'fileio', 'os', 'platform', 'sys'): testfiles.remove(os.path.join(tempdir, "test_%s.py") % f) if not support.is_resource_enabled("cpu"): diff --git a/Makefile.pre.in b/Makefile.pre.in index 043000c..f612f07 100644 --- a/Makefile.pre.in +++ b/Makefile.pre.in @@ -2147,6 +2147,7 @@ TESTSUBDIRS= idlelib/idle_test \ test/test_email/data \ test/test_future_stmt \ test/test_gdb \ + test/test_inspect \ test/test_import \ test/test_import/data \ test/test_import/data/circular_imports \ -- cgit v0.12