Update inspect module and related tests

Author: pablogsal

Lib/inspect.py

@@ -272,6 +272,7 @@ def iscode(object):
                             | 16=nested | 32=generator | 64=nofree | 128=coroutine
                             | 256=iterable_coroutine | 512=async_generator
         co_freevars         tuple of names of free variables
+        co_posonlyargcount  number of positional only arguments
         co_kwonlyargcount   number of keyword only arguments (not including ** arg)
         co_lnotab           encoded mapping of line numbers to bytecode indices
         co_name             name with which this code object was defined
@@ -1031,8 +1032,8 @@ def getargs(co):
     'args' is the list of argument names. Keyword-only arguments are
     appended. 'varargs' and 'varkw' are the names of the * and **
     arguments or None."""
-    args, varargs, kwonlyargs, varkw = _getfullargs(co)
-    return Arguments(args + kwonlyargs, varargs, varkw)
+    args, varargs, posonlyargs, kwonlyargs, varkw = _getfullargs(co)
+    return Arguments(posonlyargs + args + kwonlyargs, varargs, varkw)
 
 def _getfullargs(co):
     """Get information about the arguments accepted by a code object.
@@ -1044,13 +1045,17 @@ def _getfullargs(co):
     if not iscode(co):
         raise TypeError('{!r} is not a code object'.format(co))
 
-    nargs = co.co_argcount
     names = co.co_varnames
+    nargs = co.co_argcount
+    nposonlyargs = co.co_posonlyargcount
     nkwargs = co.co_kwonlyargcount
-    args = list(names[:nargs])
-    kwonlyargs = list(names[nargs:nargs+nkwargs])
+    nposargs = nargs + nposonlyargs
+    posonlyargs = list(names[:nposonlyargs])
+    args = list(names[nposonlyargs:nposonlyargs+nargs])
+    kwonlyargs = list(names[nposargs:nposargs+nkwargs])
     step = 0
 
+    nargs += nposonlyargs
     nargs += nkwargs
     varargs = None
     if co.co_flags & CO_VARARGS:
@@ -1059,7 +1064,7 @@ def _getfullargs(co):
     varkw = None
     if co.co_flags & CO_VARKEYWORDS:
         varkw = co.co_varnames[nargs]
-    return args, varargs, kwonlyargs, varkw
+    return args, varargs, posonlyargs, kwonlyargs, varkw
 
 
 ArgSpec = namedtuple('ArgSpec', 'args varargs keywords defaults')
@@ -1087,15 +1092,16 @@ def getargspec(func):
     warnings.warn("inspect.getargspec() is deprecated since Python 3.0, "
                   "use inspect.signature() or inspect.getfullargspec()",
                   DeprecationWarning, stacklevel=2)
-    args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, ann = \
-        getfullargspec(func)
-    if kwonlyargs or ann:
-        raise ValueError("Function has keyword-only parameters or annotations"
-                         ", use getfullargspec() API which can support them")
+    args, varargs, varkw, defaults, posonlyargs, kwonlyargs, \
+    kwonlydefaults, ann = getfullargspec(func)
+    if posonlyargs or kwonlyargs or ann:
+        raise ValueError("Function has positional-only, keyword-only parameters"
+                         " or annotations, use getfullargspec() API which can"
+                         " support them")
     return ArgSpec(args, varargs, varkw, defaults)
 
 FullArgSpec = namedtuple('FullArgSpec',
-    'args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations')
+    'args, varargs, varkw, defaults, posonlyargs, kwonlyargs, kwonlydefaults, annotations')
 
 def getfullargspec(func):
     """Get the names and default values of a callable object's parameters.
@@ -1145,6 +1151,7 @@ def getfullargspec(func):
     args = []
     varargs = None
     varkw = None
+    posonlyargs = []
     kwonlyargs = []
     defaults = ()
     annotations = {}
@@ -1159,7 +1166,9 @@ def getfullargspec(func):
         name = param.name
 
         if kind is _POSITIONAL_ONLY:
-            args.append(name)
+            posonlyargs.append(name)
+            if param.default is not param.empty:
+                defaults += (param.default,)
         elif kind is _POSITIONAL_OR_KEYWORD:
             args.append(name)
             if param.default is not param.empty:
@@ -1185,7 +1194,7 @@ def getfullargspec(func):
         defaults = None
 
     return FullArgSpec(args, varargs, varkw, defaults,
-                       kwonlyargs, kwdefaults, annotations)
+                       posonlyargs, kwonlyargs, kwdefaults, annotations)
 
 
 ArgInfo = namedtuple('ArgInfo', 'args varargs keywords locals')
@@ -1216,7 +1225,8 @@ def _formatannotation(annotation):
     return _formatannotation
 
 def formatargspec(args, varargs=None, varkw=None, defaults=None,
-                  kwonlyargs=(), kwonlydefaults={}, annotations={},
+                  posonlyargs=(), kwonlyargs=(), kwonlydefaults={},
+                  annotations={},
                   formatarg=str,
                   formatvarargs=lambda name: '*' + name,
                   formatvarkw=lambda name: '**' + name,
@@ -1249,12 +1259,17 @@ def formatargandannotation(arg):
         return result
     specs = []
     if defaults:
-        firstdefault = len(args) - len(defaults)
-    for i, arg in enumerate(args):
+        firstdefault = len(posonlyargs) + len(args) - len(defaults)
+    posonly_left = len(posonlyargs)
+    for i, arg in enumerate(list(posonlyargs) + list(args)):
         spec = formatargandannotation(arg)
         if defaults and i >= firstdefault:
             spec = spec + formatvalue(defaults[i - firstdefault])
         specs.append(spec)
+        posonly_left -= 1
+        if posonlyargs and posonly_left == 0:
+            specs.append('/')
+
     if varargs is not None:
         specs.append(formatvarargs(formatargandannotation(varargs)))
     else:
@@ -1342,7 +1357,8 @@ def getcallargs(*func_and_positional, **named):
     func = func_and_positional[0]
     positional = func_and_positional[1:]
     spec = getfullargspec(func)
-    args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, ann = spec
+    (args, varargs, varkw, defaults, posonlyargs,
+     kwonlyargs, kwonlydefaults, ann) = spec
     f_name = func.__name__
     arg2value = {}
 
@@ -1351,12 +1367,16 @@ def getcallargs(*func_and_positional, **named):
         # implicit 'self' (or 'cls' for classmethods) argument
         positional = (func.__self__,) + positional
     num_pos = len(positional)
+    num_posonlyargs = len(posonlyargs)
     num_args = len(args)
     num_defaults = len(defaults) if defaults else 0
 
+    n = min(num_pos, num_posonlyargs)
+    for i in range(num_posonlyargs):
+        arg2value[posonlyargs[i]] = positional[i]
     n = min(num_pos, num_args)
     for i in range(n):
-        arg2value[args[i]] = positional[i]
+        arg2value[args[i]] = positional[num_posonlyargs+i]
     if varargs:
         arg2value[varargs] = tuple(positional[n:])
     possible_kwargs = set(args + kwonlyargs)
@@ -2137,9 +2157,12 @@ def _signature_from_function(cls, func):
     func_code = func.__code__
     pos_count = func_code.co_argcount
     arg_names = func_code.co_varnames
-    positional = tuple(arg_names[:pos_count])
+    posonly_count = func_code.co_posonlyargcount
+    positional_count = posonly_count + pos_count
+    positional_only = tuple(arg_names[:posonly_count])
+    positional = tuple(arg_names[posonly_count:positional_count])
     keyword_only_count = func_code.co_kwonlyargcount
-    keyword_only = arg_names[pos_count:(pos_count + keyword_only_count)]
+    keyword_only = arg_names[positional_count:(positional_count + keyword_only_count)]
     annotations = func.__annotations__
     defaults = func.__defaults__
     kwdefaults = func.__kwdefaults__
@@ -2151,23 +2174,33 @@ def _signature_from_function(cls, func):
 
     parameters = []
 
+    non_default_count = positional_count - pos_default_count
+    all_positional = positional_only + positional
+
+    posonly_left = posonly_count
+
     # Non-keyword-only parameters w/o defaults.
-    non_default_count = pos_count - pos_default_count
-    for name in positional[:non_default_count]:
+    for name in all_positional[:non_default_count]:
+        kind = _POSITIONAL_ONLY if posonly_left else _POSITIONAL_OR_KEYWORD
         annotation = annotations.get(name, _empty)
         parameters.append(Parameter(name, annotation=annotation,
-                                    kind=_POSITIONAL_OR_KEYWORD))
+                                    kind=kind))
+        if posonly_left:
+            posonly_left -= 1
 
     # ... w/ defaults.
-    for offset, name in enumerate(positional[non_default_count:]):
+    for offset, name in enumerate(all_positional[non_default_count:]):
+        kind = _POSITIONAL_ONLY if posonly_left else _POSITIONAL_OR_KEYWORD
         annotation = annotations.get(name, _empty)
         parameters.append(Parameter(name, annotation=annotation,
-                                    kind=_POSITIONAL_OR_KEYWORD,
+                                    kind=kind,
                                     default=defaults[offset]))
+        if posonly_left:
+            posonly_left -= 1
 
     # *args
     if func_code.co_flags & CO_VARARGS:
-        name = arg_names[pos_count + keyword_only_count]
+        name = arg_names[positional_count + keyword_only_count]
         annotation = annotations.get(name, _empty)
         parameters.append(Parameter(name, annotation=annotation,
                                     kind=_VAR_POSITIONAL))
@@ -2184,7 +2217,7 @@ def _signature_from_function(cls, func):
                                     default=default))
     # **kwargs
     if func_code.co_flags & CO_VARKEYWORDS:
-        index = pos_count + keyword_only_count
+        index = positional_count + keyword_only_count
         if func_code.co_flags & CO_VARARGS:
             index += 1
 

Lib/test/inspect_fodder.py

@@ -5,7 +5,7 @@
 # line 5
 
 # line 7
-def spam(a, b, c, d=3, e=4, f=5, *g, **h):
+def spam(a, /, b, c, d=3, e=4, f=5, *g, **h):
     eggs(b + d, c + f)
 
 # line 11

Lib/test/inspect_fodder2.py

@@ -137,3 +137,19 @@ def func136():
         def func137():
             never_reached1
             never_reached2
+
+#line 141
+def positional_only_arg(a,/):
+    pass
+
+#line 145
+def all_markers(a,b,/,c,d,*,e,f):
+    pass
+
+# line 149
+def all_markers_with_args_and_kwargs(a,b,/,c,d,*args,e,f,**kwargs):
+    pass
+
+#line 153
+def all_markers_with_defaults(a,b=1,/,c=2,d=3,*,e=4,f=5):
+    pass

Lib/test/test_inspect.py

@@ -763,30 +763,31 @@ def assertArgSpecEquals(self, routine, args_e, varargs_e=None,
 
     def assertFullArgSpecEquals(self, routine, args_e, varargs_e=None,
                                     varkw_e=None, defaults_e=None,
-                                    kwonlyargs_e=[], kwonlydefaults_e=None,
+                                    posonlyargs_e=[], kwonlyargs_e=[],
+                                    kwonlydefaults_e=None,
                                     ann_e={}, formatted=None):
-        args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, ann = \
+        args, varargs, varkw, defaults, posonlyargs, 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(posonlyargs, posonlyargs_e)
         self.assertEqual(kwonlyargs, kwonlyargs_e)
         self.assertEqual(kwonlydefaults, kwonlydefaults_e)
         self.assertEqual(ann, ann_e)
         if formatted is not None:
             with self.assertWarns(DeprecationWarning):
                 self.assertEqual(inspect.formatargspec(args, varargs, varkw, defaults,
-                                                       kwonlyargs, kwonlydefaults, ann),
+                                                       posonlyargs, kwonlyargs,
+                                                       kwonlydefaults, ann),
                              formatted)
 
     def test_getargspec(self):
-        self.assertArgSpecEquals(mod.eggs, ['x', 'y'], formatted='(x, y)')
+        # self.assertArgSpecEquals(mod.eggs, ['x', 'y'], formatted='(x, y)')
 
-        self.assertArgSpecEquals(mod.spam,
-                                 ['a', 'b', 'c', 'd', 'e', 'f'],
-                                 'g', 'h', (3, 4, 5),
-                                 '(a, b, c, d=3, e=4, f=5, *g, **h)')
+        self.assertRaises(ValueError, self.assertArgSpecEquals,
+                          mod.spam, [])
 
         self.assertRaises(ValueError, self.assertArgSpecEquals,
                           mod2.keyworded, [])
@@ -810,6 +811,26 @@ def test_getfullargspec(self):
                                      kwonlyargs_e=['arg'],
                                      formatted='(*, arg)')
 
+        self.assertFullArgSpecEquals(mod2.all_markers, ['c', 'd'],
+                                     posonlyargs_e=['a', 'b'],
+                                     kwonlyargs_e=['e', 'f'],
+                                     formatted='(a, b, /, c, d, *, e, f)')
+
+        self.assertFullArgSpecEquals(mod2.all_markers_with_args_and_kwargs,
+                                     ['c', 'd'],
+                                     posonlyargs_e=['a', 'b'],
+                                     varargs_e='args',
+                                     varkw_e='kwargs',
+                                     kwonlyargs_e=['e', 'f'],
+                                     formatted='(a, b, /, c, d, *args, e, f, **kwargs)')
+
+        self.assertFullArgSpecEquals(mod2.all_markers_with_defaults, ['c', 'd'],
+                                     defaults_e=(1,2,3),
+                                     posonlyargs_e=['a', 'b'],
+                                     kwonlyargs_e=['e', 'f'],
+                                     kwonlydefaults_e={'e': 4, 'f': 5},
+                                     formatted='(a, b=1, /, c=2, d=3, *, e=4, f=5)')
+
     def test_argspec_api_ignores_wrapped(self):
         # Issue 20684: low level introspection API must ignore __wrapped__
         @functools.wraps(mod.spam)
@@ -856,7 +877,7 @@ def test():
         spam_param = inspect.Parameter('spam', inspect.Parameter.POSITIONAL_ONLY)
         test.__signature__ = inspect.Signature(parameters=(spam_param,))
 
-        self.assertFullArgSpecEquals(test, args_e=['spam'], formatted='(spam)')
+        self.assertFullArgSpecEquals(test, [], posonlyargs_e=['spam'], formatted='(spam, /)')
 
     def test_getfullargspec_signature_annos(self):
         def test(a:'spam') -> 'ham': pass
@@ -870,11 +891,11 @@ def test(): pass
     @unittest.skipIf(MISSING_C_DOCSTRINGS,
                      "Signature information for builtins requires docstrings")
     def test_getfullargspec_builtin_methods(self):
-        self.assertFullArgSpecEquals(_pickle.Pickler.dump,
-                                     args_e=['self', 'obj'], formatted='(self, obj)')
+        self.assertFullArgSpecEquals(_pickle.Pickler.dump, [],
+                                     posonlyargs_e=['self', 'obj'], formatted='(self, obj, /)')
 
-        self.assertFullArgSpecEquals(_pickle.Pickler(io.BytesIO()).dump,
-                                     args_e=['self', 'obj'], formatted='(self, obj)')
+        self.assertFullArgSpecEquals(_pickle.Pickler(io.BytesIO()).dump, [],
+                                     posonlyargs_e=['self', 'obj'], formatted='(self, obj, /)')
 
         self.assertFullArgSpecEquals(
              os.stat,

Lib/test/test_positional_only_arg.py

@@ -22,6 +22,7 @@ def assertRaisesSyntaxError(self, codestr, regex="invalid syntax"):
     def test_invalid_syntax_errors(self):
         self.assertRaisesSyntaxError("def f(a, b = 5, /, c): pass", "non-default argument follows default argument")
         self.assertRaisesSyntaxError("def f(a = 5, b, /, c): pass", "non-default argument follows default argument")
+        self.assertRaisesSyntaxError("def f(a = 5, b=1, /, c, *, d=2): pass", "non-default argument follows default argument")
         self.assertRaisesSyntaxError("def f(a = 5, b, /): pass", "non-default argument follows default argument")
         self.assertRaisesSyntaxError("def f(*args, /): pass")
         self.assertRaisesSyntaxError("def f(*args, a, /): pass")
@@ -38,6 +39,7 @@ def test_invalid_syntax_errors(self):
     def test_invalid_syntax_errors_async(self):
         self.assertRaisesSyntaxError("async def f(a, b = 5, /, c): pass", "non-default argument follows default argument")
         self.assertRaisesSyntaxError("async def f(a = 5, b, /, c): pass", "non-default argument follows default argument")
+        self.assertRaisesSyntaxError("async def f(a = 5, b=1, /, c, d=2): pass", "non-default argument follows default argument")
         self.assertRaisesSyntaxError("async def f(a = 5, b, /): pass", "non-default argument follows default argument")
         self.assertRaisesSyntaxError("async def f(*args, /): pass")
         self.assertRaisesSyntaxError("async def f(*args, a, /): pass")
@@ -146,6 +148,26 @@ def f(a, b, /, c=3):
         with self.assertRaisesRegex(TypeError, r"f\(\) takes from 2 to 3 positional arguments but 4 were given"):
             f(1, 2, 3, 4)
 
+    def test_positional_only_and_kwonlyargs_invalid_calls(self):
+        def f(a, b, /, c, *, d, e):
+            pass
+        f(1, 2, 3, d=1, e=2)  # does not raise
+        with self.assertRaisesRegex(TypeError, r"missing 1 required keyword-only argument: 'd'"):
+            f(1, 2, 3, e=2)
+        with self.assertRaisesRegex(TypeError, r"missing 2 required keyword-only arguments: 'd' and 'e'"):
+            f(1, 2, 3)
+        with self.assertRaisesRegex(TypeError, r"f\(\) missing 1 required positional argument: 'c'"):
+            f(1, 2)
+        with self.assertRaisesRegex(TypeError, r"f\(\) missing 2 required positional arguments: 'b' and 'c'"):
+            f(1)
+        with self.assertRaisesRegex(TypeError, r" missing 3 required positional arguments: 'a', 'b', and 'c'"):
+            f()
+        with self.assertRaisesRegex(TypeError, r"f\(\) takes 3 positional arguments but 6 positional arguments "
+                                               r"\(and 2 keyword-only arguments\) were given"):
+            f(1, 2, 3, 4, 5, 6, d=7, e=8)
+        with self.assertRaisesRegex(TypeError, r"f\(\) got an unexpected keyword argument 'f'"):
+            f(1, 2, 3, d=1, e=4, f=56)
+
     def test_positional_only_invalid_calls(self):
         def f(a, b, /):
             pass