Further cleanup of CMakeLists

Remove some remains of Python2 and Qt 5 and some
unused options.

Task-number: PYSIDE-1339
Task-number: PYSIDE-904
Change-Id: Ic9c7d4048b6be0cdeb0f5cc9b23d13b1702f1bdc
Reviewed-by: Christian Tismer <tismer@stackless.com>

1 files changed, 0 insertions, 900 deletions

diff --git a/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/backport_inspect.py b/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/backport_inspect.py
deleted file mode 100644
index 0f9598c64..000000000
--- a/sources/shiboken2/shibokenmodule/files.dir/shibokensupport/backport_inspect.py
+++ /dev/null
@@ -1,900 +0,0 @@
-# This Python file uses the following encoding: utf-8
-# It has been edited by fix-complaints.py .
-
-#############################################################################
-##
-## Copyright (C) 2019 The Qt Company Ltd.
-## Contact: https://www.qt.io/licensing/
-##
-## This file is part of Qt for Python.
-##
-## $QT_BEGIN_LICENSE:LGPL$
-## Commercial License Usage
-## Licensees holding valid commercial Qt licenses may use this file in
-## accordance with the commercial license agreement provided with the
-## Software or, alternatively, in accordance with the terms contained in
-## a written agreement between you and The Qt Company. For licensing terms
-## and conditions see https://www.qt.io/terms-conditions. For further
-## information use the contact form at https://www.qt.io/contact-us.
-##
-## GNU Lesser General Public License Usage
-## Alternatively, this file may be used under the terms of the GNU Lesser
-## General Public License version 3 as published by the Free Software
-## Foundation and appearing in the file LICENSE.LGPL3 included in the
-## packaging of this file. Please review the following information to
-## ensure the GNU Lesser General Public License version 3 requirements
-## will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-##
-## GNU General Public License Usage
-## Alternatively, this file may be used under the terms of the GNU
-## General Public License version 2.0 or (at your option) the GNU General
-## Public license version 3 or any later version approved by the KDE Free
-## Qt Foundation. The licenses are as published by the Free Software
-## Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-## included in the packaging of this file. Please review the following
-## information to ensure the GNU General Public License requirements will
-## be met: https://www.gnu.org/licenses/gpl-2.0.html and
-## https://www.gnu.org/licenses/gpl-3.0.html.
-##
-## $QT_END_LICENSE$
-##
-#############################################################################
-
-from __future__ import print_function
-
-"""
-PSF LICENSE AGREEMENT FOR PYTHON 3.7.0
-
-1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and
-   the Individual or Organization ("Licensee") accessing and otherwise using Python
-   3.7.0 software in source or binary form and its associated documentation.
-
-2. Subject to the terms and conditions of this License Agreement, PSF hereby
-   grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
-   analyze, test, perform and/or display publicly, prepare derivative works,
-   distribute, and otherwise use Python 3.7.0 alone or in any derivative
-   version, provided, however, that PSF's License Agreement and PSF's notice of
-   copyright, i.e., "Copyright © 2001-2018 Python Software Foundation; All Rights
-   Reserved" are retained in Python 3.7.0 alone or in any derivative version
-   prepared by Licensee.
-
-3. In the event Licensee prepares a derivative work that is based on or
-   incorporates Python 3.7.0 or any part thereof, and wants to make the
-   derivative work available to others as provided herein, then Licensee hereby
-   agrees to include in any such work a brief summary of the changes made to Python
-   3.7.0.
-
-4. PSF is making Python 3.7.0 available to Licensee on an "AS IS" basis.
-   PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED.  BY WAY OF
-   EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR
-   WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE
-   USE OF PYTHON 3.7.0 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
-
-5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 3.7.0
-   FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF
-   MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 3.7.0, OR ANY DERIVATIVE
-   THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
-
-6. This License Agreement will automatically terminate upon a material breach of
-   its terms and conditions.
-
-7. Nothing in this License Agreement shall be deemed to create any relationship
-   of agency, partnership, or joint venture between PSF and Licensee.  This License
-   Agreement does not grant permission to use PSF trademarks or trade name in a
-   trademark sense to endorse or promote products or services of Licensee, or any
-   third party.
-
-8. By copying, installing or otherwise using Python 3.7.0, Licensee agrees
-   to be bound by the terms and conditions of this License Agreement.
-"""
-
-__doc__ = """
-    signature() - get a Signature object for the callable
-"""
-
-import sys
-from collections import OrderedDict
-
-CO_OPTIMIZED    = 0x0001
-CO_NEWLOCALS    = 0x0002
-CO_VARARGS      = 0x0004
-CO_VARKEYWORDS  = 0x0008
-CO_NESTED       = 0x0010
-CO_GENERATOR    = 0x0020
-CO_NOFREE       = 0x0040
-
-
-###############################################################################
-### Function Signature Object (PEP 362)
-###############################################################################
-
-
-
-# PYSIDE-1286: We now use the added __qualname__ for classes.
-def _get_class_name(cls):
-    return getattr(cls, "__qualname__", cls.__name__)
-
-# This function was changed: 'builtins' and 'qualname' don't exist.
-# We use '__builtin__' and '__(qual)?name__' instead.
-def formatannotation(annotation, base_module=None):
-    if getattr(annotation, '__module__', None) == 'typing':
-        # The replace must not be done on Python 2.7 because it
-        # already happens somewhere else.
-        return repr(annotation) ##.replace('typing.', '')
-    if isinstance(annotation, type):
-        if annotation.__module__ in ('__builtin__', base_module):
-            return _get_class_name(annotation)
-        return annotation.__module__ + '.' + _get_class_name(annotation)
-    return repr(annotation)
-
-
-def _signature_is_functionlike(obj):
-    """Private helper to test if `obj` is a duck type of FunctionType.
-    A good example of such objects are functions compiled with
-    Cython, which have all attributes that a pure Python function
-    would have, but have their code statically compiled.
-    """
-
-    if not callable(obj) or isclass(obj):
-        # All function-like objects are obviously callables,
-        # and not classes.
-        return False
-
-    name = getattr(obj, '__name__', None)
-    code = getattr(obj, '__code__', None)
-    defaults = getattr(obj, '__defaults__', _void) # Important to use _void ...
-    kwdefaults = getattr(obj, '__kwdefaults__', _void) # ... and not None here
-    annotations = getattr(obj, '__annotations__', None)
-
-    return (isinstance(code, types.CodeType) and
-            isinstance(name, str) and
-            (defaults is None or isinstance(defaults, tuple)) and
-            (kwdefaults is None or isinstance(kwdefaults, dict)) and
-            isinstance(annotations, dict))
-
-
-
-def _signature_from_function(cls, func):
-    """Private helper: constructs Signature for the given python function."""
-
-    is_duck_function = False
-    if not isfunction(func):
-        if _signature_is_functionlike(func):
-            is_duck_function = True
-        else:
-            # If it's not a pure Python function, and not a duck type
-            # of pure function:
-            raise TypeError('{!r} is not a Python function'.format(func))
-
-    Parameter = cls._parameter_cls
-
-    # Parameter information.
-    func_code = func.__code__
-    pos_count = func_code.co_argcount
-    arg_names = func_code.co_varnames
-    positional = tuple(arg_names[:pos_count])
-    keyword_only_count = 0 # func_code.co_kwonlyargcount
-    keyword_only = arg_names[pos_count:(pos_count + keyword_only_count)]
-    annotations = func.__annotations__
-    defaults = func.__defaults__
-    kwdefaults = func.__kwdefaults__
-
-    if defaults:
-        pos_default_count = len(defaults)
-    else:
-        pos_default_count = 0
-
-    parameters = []
-
-    # Non-keyword-only parameters w/o defaults.
-    non_default_count = pos_count - pos_default_count
-    for name in positional[:non_default_count]:
-        annotation = annotations.get(name, _empty)
-        parameters.append(Parameter(name, annotation=annotation,
-                                    kind=_POSITIONAL_OR_KEYWORD))
-
-    # ... w/ defaults.
-    for offset, name in enumerate(positional[non_default_count:]):
-        annotation = annotations.get(name, _empty)
-        parameters.append(Parameter(name, annotation=annotation,
-                                    kind=_POSITIONAL_OR_KEYWORD,
-                                    default=defaults[offset]))
-
-    # *args
-    if func_code.co_flags & CO_VARARGS:
-        name = arg_names[pos_count + keyword_only_count]
-        annotation = annotations.get(name, _empty)
-        parameters.append(Parameter(name, annotation=annotation,
-                                    kind=_VAR_POSITIONAL))
-
-    # Keyword-only parameters.
-    for name in keyword_only:
-        default = _empty
-        if kwdefaults is not None:
-            default = kwdefaults.get(name, _empty)
-
-        annotation = annotations.get(name, _empty)
-        parameters.append(Parameter(name, annotation=annotation,
-                                    kind=_KEYWORD_ONLY,
-                                    default=default))
-    # **kwargs
-    if func_code.co_flags & CO_VARKEYWORDS:
-        index = pos_count + keyword_only_count
-        if func_code.co_flags & CO_VARARGS:
-            index += 1
-
-        name = arg_names[index]
-        annotation = annotations.get(name, _empty)
-        parameters.append(Parameter(name, annotation=annotation,
-                                    kind=_VAR_KEYWORD))
-
-    # Is 'func' is a pure Python function - don't validate the
-    # parameters list (for correct order and defaults), it should be OK.
-    return cls(parameters,
-               return_annotation=annotations.get('return', _empty),
-               __validate_parameters__=is_duck_function)
-
-
-
-
-class _void(object):
-    """A private marker - used in Parameter & Signature."""
-
-
-class _empty(object):
-    """Marker object for Signature.empty and Parameter.empty."""
-
-
-class _ParameterKind(object): # (enum.IntEnum):
-    POSITIONAL_ONLY = 0
-    POSITIONAL_OR_KEYWORD = 1
-    VAR_POSITIONAL = 2
-    KEYWORD_ONLY = 3
-    VAR_KEYWORD = 4
-
-    def __str__(self):
-        return self._name_
-
-
-_POSITIONAL_ONLY         = _ParameterKind.POSITIONAL_ONLY
-_POSITIONAL_OR_KEYWORD   = _ParameterKind.POSITIONAL_OR_KEYWORD
-_VAR_POSITIONAL          = _ParameterKind.VAR_POSITIONAL
-_KEYWORD_ONLY            = _ParameterKind.KEYWORD_ONLY
-_VAR_KEYWORD             = _ParameterKind.VAR_KEYWORD
-
-
-class Parameter(object):
-    """Represents a parameter in a function signature.
-
-    Has the following public attributes:
-
-    * name : str
-        The name of the parameter as a string.
-    * default : object
-        The default value for the parameter if specified.  If the
-        parameter has no default value, this attribute is set to
-        `Parameter.empty`.
-    * annotation
-        The annotation for the parameter if specified.  If the
-        parameter has no annotation, this attribute is set to
-        `Parameter.empty`.
-    * kind : str
-        Describes how argument values are bound to the parameter.
-        Possible values: `Parameter.POSITIONAL_ONLY`,
-        `Parameter.POSITIONAL_OR_KEYWORD`, `Parameter.VAR_POSITIONAL`,
-        `Parameter.KEYWORD_ONLY`, `Parameter.VAR_KEYWORD`.
-    """
-
-    __slots__ = ('_name', '_kind', '_default', '_annotation')
-
-    POSITIONAL_ONLY         = _POSITIONAL_ONLY
-    POSITIONAL_OR_KEYWORD   = _POSITIONAL_OR_KEYWORD
-    VAR_POSITIONAL          = _VAR_POSITIONAL
-    KEYWORD_ONLY            = _KEYWORD_ONLY
-    VAR_KEYWORD             = _VAR_KEYWORD
-
-    empty = _empty
-
-    def __init__(self, name, kind, default=_empty, annotation=_empty):
-
-        if kind not in (_POSITIONAL_ONLY, _POSITIONAL_OR_KEYWORD,
-                        _VAR_POSITIONAL, _KEYWORD_ONLY, _VAR_KEYWORD):
-            raise ValueError("invalid value for 'Parameter.kind' attribute")
-        self._kind = kind
-
-        if default is not _empty:
-            if kind in (_VAR_POSITIONAL, _VAR_KEYWORD):
-                msg = '{} parameters cannot have default values'.format(kind)
-                raise ValueError(msg)
-        self._default = default
-        self._annotation = annotation
-
-        if name is _empty:
-            raise ValueError('name is a required attribute for Parameter')
-
-        if not isinstance(name, str):
-            raise TypeError("name must be a str, not a {!r}".format(name))
-
-        if name[0] == '.' and name[1:].isdigit():
-            # These are implicit arguments generated by comprehensions. In
-            # order to provide a friendlier interface to users, we recast
-            # their name as "implicitN" and treat them as positional-only.
-            # See issue 19611.
-            if kind != _POSITIONAL_OR_KEYWORD:
-                raise ValueError(
-                    'implicit arguments must be passed in as {}'.format(
-                        _POSITIONAL_OR_KEYWORD
-                    )
-                )
-            self._kind = _POSITIONAL_ONLY
-            name = 'implicit{}'.format(name[1:])
-
-        if not True: # name.isidentifier():
-            raise ValueError('{!r} is not a valid parameter name'.format(name))
-
-        self._name = name
-
-    def __reduce__(self):
-        return (type(self),
-                (self._name, self._kind),
-                {'_default': self._default,
-                 '_annotation': self._annotation})
-
-    def __setstate__(self, state):
-        self._default = state['_default']
-        self._annotation = state['_annotation']
-
-    @property
-    def name(self):
-        return self._name
-
-    @property
-    def default(self):
-        return self._default
-
-    @property
-    def annotation(self):
-        return self._annotation
-
-    @property
-    def kind(self):
-        return self._kind
-
-    def replace(self, name=_void, kind=_void,
-                annotation=_void, default=_void):
-        """Creates a customized copy of the Parameter."""
-
-        if name is _void:
-            name = self._name
-
-        if kind is _void:
-            kind = self._kind
-
-        if annotation is _void:
-            annotation = self._annotation
-
-        if default is _void:
-            default = self._default
-
-        return type(self)(name, kind, default=default, annotation=annotation)
-
-    def __str__(self):
-        kind = self.kind
-        formatted = self._name
-
-        # Add annotation and default value
-        if self._annotation is not _empty:
-            formatted = '{}: {}'.format(formatted,
-                                       formatannotation(self._annotation))
-
-        if self._default is not _empty:
-            formatted = '{}={}'.format(formatted, repr(self._default))
-
-        if kind == _VAR_POSITIONAL:
-            formatted = '*' + formatted
-        elif kind == _VAR_KEYWORD:
-            formatted = '**' + formatted
-
-        return formatted
-
-    def __repr__(self):
-        return '<{} "{}">'.format(_get_class_name(self.__class__), self)
-
-    def __hash__(self):
-        return hash((self.name, self.kind, self.annotation, self.default))
-
-    def __eq__(self, other):
-        if self is other:
-            return True
-        if not isinstance(other, Parameter):
-            return NotImplemented
-        return (self._name == other._name and
-                self._kind == other._kind and
-                self._default == other._default and
-                self._annotation == other._annotation)
-
-
-class BoundArguments(object):
-    """Result of `Signature.bind` call.  Holds the mapping of arguments
-    to the function's parameters.
-
-    Has the following public attributes:
-
-    * arguments : OrderedDict
-        An ordered mutable mapping of parameters' names to arguments' values.
-        Does not contain arguments' default values.
-    * signature : Signature
-        The Signature object that created this instance.
-    * args : tuple
-        Tuple of positional arguments values.
-    * kwargs : dict
-        Dict of keyword arguments values.
-    """
-
-    __slots__ = ('arguments', '_signature', '__weakref__')
-
-    def __init__(self, signature, arguments):
-        self.arguments = arguments
-        self._signature = signature
-
-    @property
-    def signature(self):
-        return self._signature
-
-    @property
-    def args(self):
-        args = []
-        for param_name, param in self._signature.parameters.items():
-            if param.kind in (_VAR_KEYWORD, _KEYWORD_ONLY):
-                break
-
-            try:
-                arg = self.arguments[param_name]
-            except KeyError:
-                # We're done here. Other arguments
-                # will be mapped in 'BoundArguments.kwargs'
-                break
-            else:
-                if param.kind == _VAR_POSITIONAL:
-                    # *args
-                    args.extend(arg)
-                else:
-                    # plain argument
-                    args.append(arg)
-
-        return tuple(args)
-
-    @property
-    def kwargs(self):
-        kwargs = {}
-        kwargs_started = False
-        for param_name, param in self._signature.parameters.items():
-            if not kwargs_started:
-                if param.kind in (_VAR_KEYWORD, _KEYWORD_ONLY):
-                    kwargs_started = True
-                else:
-                    if param_name not in self.arguments:
-                        kwargs_started = True
-                        continue
-
-            if not kwargs_started:
-                continue
-
-            try:
-                arg = self.arguments[param_name]
-            except KeyError:
-                pass
-            else:
-                if param.kind == _VAR_KEYWORD:
-                    # **kwargs
-                    kwargs.update(arg)
-                else:
-                    # plain keyword argument
-                    kwargs[param_name] = arg
-
-        return kwargs
-
-    def apply_defaults(self):
-        """Set default values for missing arguments.
-
-        For variable-positional arguments (*args) the default is an
-        empty tuple.
-
-        For variable-keyword arguments (**kwargs) the default is an
-        empty dict.
-        """
-        arguments = self.arguments
-        new_arguments = []
-        for name, param in self._signature.parameters.items():
-            try:
-                new_arguments.append((name, arguments[name]))
-            except KeyError:
-                if param.default is not _empty:
-                    val = param.default
-                elif param.kind is _VAR_POSITIONAL:
-                    val = ()
-                elif param.kind is _VAR_KEYWORD:
-                    val = {}
-                else:
-                    # This BoundArguments was likely produced by
-                    # Signature.bind_partial().
-                    continue
-                new_arguments.append((name, val))
-        self.arguments = OrderedDict(new_arguments)
-
-    def __eq__(self, other):
-        if self is other:
-            return True
-        if not isinstance(other, BoundArguments):
-            return NotImplemented
-        return (self.signature == other.signature and
-                self.arguments == other.arguments)
-
-    def __setstate__(self, state):
-        self._signature = state['_signature']
-        self.arguments = state['arguments']
-
-    def __getstate__(self):
-        return {'_signature': self._signature, 'arguments': self.arguments}
-
-    def __repr__(self):
-        args = []
-        for arg, value in self.arguments.items():
-            args.append('{}={!r}'.format(arg, value))
-        return '<{} ({})>'.format(_get_class_name(self.__class__), ', '.join(args))
-
-
-class Signature(object):
-    """A Signature object represents the overall signature of a function.
-    It stores a Parameter object for each parameter accepted by the
-    function, as well as information specific to the function itself.
-
-    A Signature object has the following public attributes and methods:
-
-    * parameters : OrderedDict
-        An ordered mapping of parameters' names to the corresponding
-        Parameter objects (keyword-only arguments are in the same order
-        as listed in `code.co_varnames`).
-    * return_annotation : object
-        The annotation for the return type of the function if specified.
-        If the function has no annotation for its return type, this
-        attribute is set to `Signature.empty`.
-    * bind(*args, **kwargs) -> BoundArguments
-        Creates a mapping from positional and keyword arguments to
-        parameters.
-    * bind_partial(*args, **kwargs) -> BoundArguments
-        Creates a partial mapping from positional and keyword arguments
-        to parameters (simulating 'functools.partial' behavior.)
-    """
-
-    __slots__ = ('_return_annotation', '_parameters')
-
-    _parameter_cls = Parameter
-    _bound_arguments_cls = BoundArguments
-
-    empty = _empty
-
-    def __init__(self, parameters=None, return_annotation=_empty,
-                 __validate_parameters__=True):
-        """Constructs Signature from the given list of Parameter
-        objects and 'return_annotation'.  All arguments are optional.
-        """
-
-        if parameters is None:
-            params = OrderedDict()
-        else:
-            if __validate_parameters__:
-                params = OrderedDict()
-                top_kind = _POSITIONAL_ONLY
-                kind_defaults = False
-
-                for idx, param in enumerate(parameters):
-                    kind = param.kind
-                    name = param.name
-
-                    if kind < top_kind:
-                        msg = 'wrong parameter order: {!r} before {!r}'
-                        msg = msg.format(top_kind, kind)
-                        raise ValueError(msg)
-                    elif kind > top_kind:
-                        kind_defaults = False
-                        top_kind = kind
-
-                    if kind in (_POSITIONAL_ONLY, _POSITIONAL_OR_KEYWORD):
-                        if param.default is _empty:
-                            if kind_defaults:
-                                # No default for this parameter, but the
-                                # previous parameter of the same kind had
-                                # a default
-                                msg = 'non-default argument follows default ' \
-                                      'argument'
-                                raise ValueError(msg)
-                        else:
-                            # There is a default for this parameter.
-                            kind_defaults = True
-
-                    if name in params:
-                        msg = 'duplicate parameter name: {!r}'.format(name)
-                        raise ValueError(msg)
-
-                    params[name] = param
-            else:
-                params = OrderedDict(((param.name, param)
-                                                for param in parameters))
-
-        self._parameters = params # types.MappingProxyType(params)
-        self._return_annotation = return_annotation
-
-    @classmethod
-    def from_function(cls, func):
-        """Constructs Signature for the given python function."""
-
-        warnings.warn("inspect.Signature.from_function() is deprecated, "
-                      "use Signature.from_callable()",
-                      DeprecationWarning, stacklevel=2)
-        return _signature_from_function(cls, func)
-
-    @classmethod
-    def from_builtin(cls, func):
-        """Constructs Signature for the given builtin function."""
-
-        warnings.warn("inspect.Signature.from_builtin() is deprecated, "
-                      "use Signature.from_callable()",
-                      DeprecationWarning, stacklevel=2)
-        return _signature_from_builtin(cls, func)
-
-    @classmethod
-    def from_callable(cls, obj, follow_wrapped=True):
-        """Constructs Signature for the given callable object."""
-        return _signature_from_callable(obj, sigcls=cls,
-                                        follow_wrapper_chains=follow_wrapped)
-
-    @property
-    def parameters(self):
-        return self._parameters
-
-    @property
-    def return_annotation(self):
-        return self._return_annotation
-
-    def replace(self, parameters=_void, return_annotation=_void):
-        """Creates a customized copy of the Signature.
-        Pass 'parameters' and/or 'return_annotation' arguments
-        to override them in the new copy.
-        """
-
-        if parameters is _void:
-            parameters = self.parameters.values()
-
-        if return_annotation is _void:
-            return_annotation = self._return_annotation
-
-        return type(self)(parameters,
-                          return_annotation=return_annotation)
-
-    def _hash_basis(self):
-        params = tuple(param for param in self.parameters.values()
-                             if param.kind != _KEYWORD_ONLY)
-
-        kwo_params = {param.name: param for param in self.parameters.values()
-                                        if param.kind == _KEYWORD_ONLY}
-
-        return params, kwo_params, self.return_annotation
-
-    def __hash__(self):
-        params, kwo_params, return_annotation = self._hash_basis()
-        kwo_params = frozenset(kwo_params.values())
-        return hash((params, kwo_params, return_annotation))
-
-    def __eq__(self, other):
-        if self is other:
-            return True
-        if not isinstance(other, Signature):
-            return NotImplemented
-        return self._hash_basis() == other._hash_basis()
-
-    def _bind(self, args, kwargs, partial=False):
-        """Private method. Don't use directly."""
-
-        arguments = OrderedDict()
-
-        parameters = iter(self.parameters.values())
-        parameters_ex = ()
-        arg_vals = iter(args)
-
-        while True:
-            # Let's iterate through the positional arguments and corresponding
-            # parameters
-            try:
-                arg_val = next(arg_vals)
-            except StopIteration:
-                # No more positional arguments
-                try:
-                    param = next(parameters)
-                except StopIteration:
-                    # No more parameters. That's it. Just need to check that
-                    # we have no `kwargs` after this while loop
-                    break
-                else:
-                    if param.kind == _VAR_POSITIONAL:
-                        # That's OK, just empty *args.  Let's start parsing
-                        # kwargs
-                        break
-                    elif param.name in kwargs:
-                        if param.kind == _POSITIONAL_ONLY:
-                            msg = '{arg!r} parameter is positional only, ' \
-                                  'but was passed as a keyword'
-                            msg = msg.format(arg=param.name)
-                            raise TypeError(msg)# from None
-                        parameters_ex = (param,)
-                        break
-                    elif (param.kind == _VAR_KEYWORD or
-                                                param.default is not _empty):
-                        # That's fine too - we have a default value for this
-                        # parameter.  So, lets start parsing `kwargs`, starting
-                        # with the current parameter
-                        parameters_ex = (param,)
-                        break
-                    else:
-                        # No default, not VAR_KEYWORD, not VAR_POSITIONAL,
-                        # not in `kwargs`
-                        if partial:
-                            parameters_ex = (param,)
-                            break
-                        else:
-                            msg = 'missing a required argument: {arg!r}'
-                            msg = msg.format(arg=param.name)
-                            raise TypeError(msg)# from None
-            else:
-                # We have a positional argument to process
-                try:
-                    param = next(parameters)
-                except StopIteration:
-                    raise TypeError('too many positional arguments')# from None
-                else:
-                    if param.kind in (_VAR_KEYWORD, _KEYWORD_ONLY):
-                        # Looks like we have no parameter for this positional
-                        # argument
-                        raise TypeError(
-                            'too many positional arguments')# from None
-
-                    if param.kind == _VAR_POSITIONAL:
-                        # We have an '*args'-like argument, let's fill it with
-                        # all positional arguments we have left and move on to
-                        # the next phase
-                        values = [arg_val]
-                        values.extend(arg_vals)
-                        arguments[param.name] = tuple(values)
-                        break
-
-                    if param.name in kwargs:
-                        raise TypeError(
-                            'multiple values for argument {arg!r}'.format(
-                                arg=param.name))# from None
-
-                    arguments[param.name] = arg_val
-
-        # Now, we iterate through the remaining parameters to process
-        # keyword arguments
-        kwargs_param = None
-        for param in itertools.chain(parameters_ex, parameters):
-            if param.kind == _VAR_KEYWORD:
-                # Memorize that we have a '**kwargs'-like parameter
-                kwargs_param = param
-                continue
-
-            if param.kind == _VAR_POSITIONAL:
-                # Named arguments don't refer to '*args'-like parameters.
-                # We only arrive here if the positional arguments ended
-                # before reaching the last parameter before *args.
-                continue
-
-            param_name = param.name
-            try:
-                arg_val = kwargs.pop(param_name)
-            except KeyError:
-                # We have no value for this parameter.  It's fine though,
-                # if it has a default value, or it is an '*args'-like
-                # parameter, left alone by the processing of positional
-                # arguments.
-                if (not partial and param.kind != _VAR_POSITIONAL and
-                                                    param.default is _empty):
-                    raise TypeError('missing a required argument: {arg!r}'. \
-                                    format(arg=param_name))# from None
-
-            else:
-                if param.kind == _POSITIONAL_ONLY:
-                    # This should never happen in case of a properly built
-                    # Signature object (but let's have this check here
-                    # to ensure correct behavior just in case)
-                    raise TypeError('{arg!r} parameter is positional only, '
-                                    'but was passed as a keyword'. \
-                                    format(arg=param.name))
-
-                arguments[param_name] = arg_val
-
-        if kwargs:
-            if kwargs_param is not None:
-                # Process our '**kwargs'-like parameter
-                arguments[kwargs_param.name] = kwargs
-            else:
-                raise TypeError(
-                    'got an unexpected keyword argument {arg!r}'.format(
-                        arg=next(iter(kwargs))))
-
-        return self._bound_arguments_cls(self, arguments)
-
-    def bind(*args, **kwargs):
-        """Get a BoundArguments object, that maps the passed `args`
-        and `kwargs` to the function's signature.  Raises `TypeError`
-        if the passed arguments can not be bound.
-        """
-        return args[0]._bind(args[1:], kwargs)
-
-    def bind_partial(*args, **kwargs):
-        """Get a BoundArguments object, that partially maps the
-        passed `args` and `kwargs` to the function's signature.
-        Raises `TypeError` if the passed arguments can not be bound.
-        """
-        return args[0]._bind(args[1:], kwargs, partial=True)
-
-    def __reduce__(self):
-        return (type(self),
-                (tuple(self._parameters.values()),),
-                {'_return_annotation': self._return_annotation})
-
-    def __setstate__(self, state):
-        self._return_annotation = state['_return_annotation']
-
-    def __repr__(self):
-        return '<{} {}>'.format(_get_class_name(self.__class__), self)
-
-    def __str__(self):
-        result = []
-        render_pos_only_separator = False
-        render_kw_only_separator = True
-        for param in self.parameters.values():
-            formatted = str(param)
-
-            kind = param.kind
-
-            if kind == _POSITIONAL_ONLY:
-                render_pos_only_separator = True
-            elif render_pos_only_separator:
-                # It's not a positional-only parameter, and the flag
-                # is set to 'True' (there were pos-only params before.)
-                result.append('/')
-                render_pos_only_separator = False
-
-            if kind == _VAR_POSITIONAL:
-                # OK, we have an '*args'-like parameter, so we won't need
-                # a '*' to separate keyword-only arguments
-                render_kw_only_separator = False
-            elif kind == _KEYWORD_ONLY and render_kw_only_separator:
-                # We have a keyword-only parameter to render and we haven't
-                # rendered an '*args'-like parameter before, so add a '*'
-                # separator to the parameters list ("foo(arg1, *, arg2)" case)
-                result.append('*')
-                # This condition should be only triggered once, so
-                # reset the flag
-                render_kw_only_separator = False
-
-            result.append(formatted)
-
-        if render_pos_only_separator:
-            # There were only positional-only parameters, hence the
-            # flag was not reset to 'False'
-            result.append('/')
-
-        rendered = '({})'.format(', '.join(result))
-
-        if self.return_annotation is not _empty:
-            anno = formatannotation(self.return_annotation)
-            rendered += ' -> {}'.format(anno)
-
-        return rendered
-
-
-def signature(obj, follow_wrapped=True):
-    """Get a signature object for the passed callable."""
-    return Signature.from_callable(obj, follow_wrapped=follow_wrapped)