
    `                         d dl mZmZmZ d dlZd dlZd dlZd dlZd dl	Z
 G d dej                        Z G d dej                        Z G d dej                        Z G d	 d
ej                        Zy)    )absolute_importdivisionprint_functionNc                       e Zd Zed        Zej                  d   dkD  r ed       d Zd Z	ej                  d   dkD  r ed       ej                  d   dkD  r ed       ej                  d   dkD  r ed	       d
 Z
d Zej                  d   dkD  r ed       ej                  d   dkD  r ed       ej                  d   dkD  r ed       ej                  d   dkD  r ed       ej                  d   dkD  r ed       ej                  d   dkD  r ed       d Zd Zej                  d   dkD  r ed       d Zej                  d   dkD  r ed       ej                  d   dkD  r ed       ej                  d   dkD  r	 ed       yy)TestSignatureObjectc                     t        j                  |       }t        d |j                  j	                         D              |j
                  |j                  u rt        fS |j
                  fS )Nc              3     K   | ]  }|j                   |j                  |j                  u rt        n|j                  |j                  |j                  u rt        n|j                  t        |j                        j                         f  y wN)namedefaultemptyEllipsis
annotationstrkindlower).0params     :platform/gsutil/third_party/funcsigs/tests/test_inspect.py	<genexpr>z0TestSignatureObject.signature.<locals>.<genexpr>   sq      J
 2I zz$)MMU[[$@emm$)$4$4$C=B=M=M5::,,.	0
 2Is   BB)inspect	signaturetuple
parametersvaluesreturn_annotationr   r   )funcsigs     r   r   zTestSignatureObject.signature   sr    % J
 251F1F1HJ J !22cii?I 	I 251F1FI 	I    r      a  
def test_signature_object(self):
    S = inspect.Signature
    P = inspect.Parameter

    self.assertEqual(str(S()), '()')

    def test(po, pk, *args, ko, **kwargs):
        pass
    sig = inspect.signature(test)
    po = sig.parameters['po'].replace(kind=P.POSITIONAL_ONLY)
    pk = sig.parameters['pk']
    args = sig.parameters['args']
    ko = sig.parameters['ko']
    kwargs = sig.parameters['kwargs']

    S((po, pk, args, ko, kwargs))

    with self.assertRaisesRegex(ValueError, 'wrong parameter order'):
        S((pk, po, args, ko, kwargs))

    with self.assertRaisesRegex(ValueError, 'wrong parameter order'):
        S((po, args, pk, ko, kwargs))

    with self.assertRaisesRegex(ValueError, 'wrong parameter order'):
        S((args, po, pk, ko, kwargs))

    with self.assertRaisesRegex(ValueError, 'wrong parameter order'):
        S((po, pk, args, kwargs, ko))

    kwargs2 = kwargs.replace(name='args')
    with self.assertRaisesRegex(ValueError, 'duplicate parameter name'):
        S((po, pk, args, kwargs2, ko))
c                 6   d }t        j                  |      }| j                  t              5  d|_        d d d        t
        j                  d d dk  ry | j                  t              5  d |j                  d<   d d d        y # 1 sw Y   NxY w# 1 sw Y   y xY w)Nc                      y r
    as    r   testz=TestSignatureObject.test_signature_immutability.<locals>.test>       r   barr    )   r)   r%   )	r   r   assertRaisesAttributeErrorfoosysversion_info	TypeErrorr   )selfr&   r   s      r   test_signature_immutabilityz/TestSignatureObject.test_signature_immutability=   s    	%~.CG / BQ&(y)"&CNN3 *) /. *)s   B*BBBc                 X    d }| j                  | j                  |      dt        f       y )Nc                       y r
   r#   r#   r   r   r&   z9TestSignatureObject.test_signature_on_noarg.<locals>.testM   r'   r   r#   assertEqualr   r   r0   r&   s     r   test_signature_on_noargz+TestSignatureObject.test_signature_on_noargL   s$    	-H~>r   a-  
def test_signature_on_wargs(self):
    def test(a, b:'foo') -> 123:
        pass
    self.assertEqual(self.signature(test),
                     ((('a', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('b', Ellipsis, 'foo', "positional_or_keyword")),
                      123))
a   
def test_signature_on_wkwonly(self):
    def test(*, a:float, b:str) -> int:
        pass
    self.assertEqual(self.signature(test),
                     ((('a', Ellipsis, float, "keyword_only"),
                       ('b', Ellipsis, str, "keyword_only")),
                       int))
ae  
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', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('b', 10, 'foo', "positional_or_keyword"),
                       ('args', Ellipsis, 'bar', "var_positional"),
                       ('spam', Ellipsis, 'baz', "keyword_only"),
                       ('ham', 123, Ellipsis, "keyword_only"),
                       ('kwargs', Ellipsis, int, "var_keyword")),
                      Ellipsis))
c                    | j                  t        d      5  t        j                  t               d d d        | j                  t        d      5  t        j                  t        j
                         t        t        d      rt        d      	 d d d        | j                  t        d      5  t        j                  t        j
                         t        t        d      rt        d      	 d d d        | j                  t        d      5  t        j                  t               d d d        y # 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   ZxY w# 1 sw Y   y xY w)Nnot supported by signaturepypy_version_infoz'no signature found for builtin function)	assertRaisesRegex
ValueErrorr   r   type__call__hasattrr-   minr0   s    r   "test_signature_on_builtin_functionz6TestSignatureObject.test_signature_on_builtin_functionv   s   ##J0LMd# N##J0LMdmm,s/0 !=>> 1 N
 ##J0LMcll+s/0 !=>> 1 N
 ##J%NP c"P P NMMM
 NM
P Ps/   D.?D:-?EE.D7:EEEc                    | j                  t        d      5  t        j                  d       d d d        | j                  t        d      5  t        j                  j                  d       d d d        y # 1 sw Y   HxY w# 1 sw Y   y xY w)Nis not a callable object*   zis not a Python function)r;   r/   r   r   	Signaturefrom_functionrA   s    r   test_signature_on_non_functionz2TestSignatureObject.test_signature_on_non_function   sk    ##I/IJb! K ##I/IJ++B/ KJ KJ KJs   A4 B 4A= B	ag  
def test_signature_on_method(self):
    class Test:
        def foo(self, arg1, arg2=1) -> int:
            pass

    meth = Test().foo

    self.assertEqual(self.signature(meth),
                     ((('arg1', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('arg2', 1, Ellipsis, "positional_or_keyword")),
                      int))
ae  
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', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('arg2', 1, Ellipsis, "keyword_only")),
                      Ellipsis))

    meth = Test.foo
    self.assertEqual(self.signature(meth),
                     ((('arg1', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('arg2', 1, Ellipsis, "keyword_only")),
                      Ellipsis))
ah  
def test_signature_on_staticmethod(self):
    class Test:
        @staticmethod
        def foo(cls, *, arg):
            pass

    meth = Test().foo
    self.assertEqual(self.signature(meth),
                     ((('cls', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('arg', Ellipsis, Ellipsis, "keyword_only")),
                      Ellipsis))

    meth = Test.foo
    self.assertEqual(self.signature(meth),
                     ((('cls', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('arg', Ellipsis, Ellipsis, "keyword_only")),
                      Ellipsis))
a  
def test_signature_on_partial(self):
    from functools import partial

    def test():
        pass

    self.assertEqual(self.signature(partial(test)), ((), Ellipsis))

    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', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('b', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('c', Ellipsis, Ellipsis, "keyword_only"),
                       ('d', Ellipsis, Ellipsis, "keyword_only")),
                      Ellipsis))

    self.assertEqual(self.signature(partial(test, 1)),
                     ((('b', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('c', Ellipsis, Ellipsis, "keyword_only"),
                       ('d', Ellipsis, Ellipsis, "keyword_only")),
                      Ellipsis))

    self.assertEqual(self.signature(partial(test, 1, c=2)),
                     ((('b', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('c', 2, Ellipsis, "keyword_only"),
                       ('d', Ellipsis, Ellipsis, "keyword_only")),
                      Ellipsis))

    self.assertEqual(self.signature(partial(test, b=1, c=2)),
                     ((('a', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('b', 1, Ellipsis, "positional_or_keyword"),
                       ('c', 2, Ellipsis, "keyword_only"),
                       ('d', Ellipsis, Ellipsis, "keyword_only")),
                      Ellipsis))

    self.assertEqual(self.signature(partial(test, 0, b=1, c=2)),
                     ((('b', 1, Ellipsis, "positional_or_keyword"),
                       ('c', 2, Ellipsis, "keyword_only"),
                       ('d', Ellipsis, Ellipsis, "keyword_only"),),
                      Ellipsis))

    def test(a, *args, b, **kwargs):
        pass

    self.assertEqual(self.signature(partial(test, 1)),
                     ((('args', Ellipsis, Ellipsis, "var_positional"),
                       ('b', Ellipsis, Ellipsis, "keyword_only"),
                       ('kwargs', Ellipsis, Ellipsis, "var_keyword")),
                      Ellipsis))

    self.assertEqual(self.signature(partial(test, 1, 2, 3)),
                     ((('args', Ellipsis, Ellipsis, "var_positional"),
                       ('b', Ellipsis, Ellipsis, "keyword_only"),
                       ('kwargs', Ellipsis, Ellipsis, "var_keyword")),
                      Ellipsis))


    self.assertEqual(self.signature(partial(test, 1, 2, 3, test=True)),
                     ((('args', Ellipsis, Ellipsis, "var_positional"),
                       ('b', Ellipsis, Ellipsis, "keyword_only"),
                       ('kwargs', Ellipsis, Ellipsis, "var_keyword")),
                      Ellipsis))

    self.assertEqual(self.signature(partial(test, 1, 2, 3, test=1, b=0)),
                     ((('args', Ellipsis, Ellipsis, "var_positional"),
                       ('b', 0, Ellipsis, "keyword_only"),
                       ('kwargs', Ellipsis, Ellipsis, "var_keyword")),
                      Ellipsis))

    self.assertEqual(self.signature(partial(test, b=0)),
                     ((('a', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('args', Ellipsis, Ellipsis, "var_positional"),
                       ('b', 0, Ellipsis, "keyword_only"),
                       ('kwargs', Ellipsis, Ellipsis, "var_keyword")),
                      Ellipsis))

    self.assertEqual(self.signature(partial(test, b=0, test=1)),
                     ((('a', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('args', Ellipsis, Ellipsis, "var_positional"),
                       ('b', 0, Ellipsis, "keyword_only"),
                       ('kwargs', Ellipsis, Ellipsis, "var_keyword")),
                      Ellipsis))

    def test(a, b, c:int) -> 42:
        pass

    sig = test.__signature__ = inspect.signature(test)

    self.assertEqual(self.signature(partial(partial(test, 1))),
                     ((('b', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('c', Ellipsis, int, "positional_or_keyword")),
                      42))

    self.assertEqual(self.signature(partial(partial(test, 1), 2)),
                     ((('c', Ellipsis, int, "positional_or_keyword"),),
                      42))

    psig = inspect.signature(partial(partial(test, 1), 2))

    def foo(a):
        return a
    _foo = partial(partial(foo, a=10), a=20)
    self.assertEqual(self.signature(_foo),
                     ((('a', 20, Ellipsis, "positional_or_keyword"),),
                      Ellipsis))
    # 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, Ellipsis, "positional_or_keyword"),
                       ('c', Ellipsis, Ellipsis, "positional_or_keyword")),
                      Ellipsis))
    self.assertEqual(_foo(c=10), (1, 30, 10))
    _foo = partial(_foo, 2) # now 'b' has two values -
                            # positional and keyword
    with self.assertRaisesRegex(ValueError, "has incorrect arguments"):
        inspect.signature(_foo)

    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', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('b', 10, Ellipsis, "positional_or_keyword"),
                       ('c', 20, Ellipsis, "positional_or_keyword"),
                       ('d', 30, Ellipsis, "keyword_only")),
                      Ellipsis))
    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, a=10, c=13)
    ba = inspect.signature(_foo).bind(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), (10, 12, 13))
    _foo = partial(_foo, b=10)
    ba = inspect.signature(_foo).bind(12, 14)
    self.assertEqual(_foo(*ba.args, **ba.kwargs), (12, 14, 13))
a  
def test_signature_on_decorated(self):
    import functools

    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

    self.assertEqual(self.signature(Foo.bar),
                     ((('self', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('a', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('b', Ellipsis, Ellipsis, "positional_or_keyword")),
                      Ellipsis))

    self.assertEqual(self.signature(Foo().bar),
                     ((('a', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('b', Ellipsis, Ellipsis, "positional_or_keyword")),
                      Ellipsis))

    # 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', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('b', Ellipsis, Ellipsis, "positional_or_keyword")),
                      Ellipsis))

    self.assertEqual(self.signature(Foo().__call__),
                     ((('b', Ellipsis, Ellipsis, "positional_or_keyword"),),
                      Ellipsis))
a(  
def test_signature_on_class(self):
    class C:
        def __init__(self, a):
            pass

    self.assertEqual(self.signature(C),
                     ((('a', Ellipsis, Ellipsis, "positional_or_keyword"),),
                      Ellipsis))

    class CM(type):
        def __call__(cls, a):
            pass
    class C(metaclass=CM):
        def __init__(self, b):
            pass

    self.assertEqual(self.signature(C),
                     ((('a', Ellipsis, Ellipsis, "positional_or_keyword"),),
                      Ellipsis))

    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', Ellipsis, Ellipsis, "positional_or_keyword"),),
                      Ellipsis))

    self.assertEqual(self.signature(CM),
                     ((('name', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('bases', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('dct', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('foo', 1, Ellipsis, "keyword_only")),
                      Ellipsis))

    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', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('bases', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('dct', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('foo', 1, Ellipsis, "keyword_only")),
                      Ellipsis))

    self.assertEqual(self.signature(CM),
                     ((('nm', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('bs', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('dt', Ellipsis, Ellipsis, "positional_or_keyword")),
                      Ellipsis))

    self.assertEqual(self.signature(C),
                     ((('b', Ellipsis, Ellipsis, "positional_or_keyword"),),
                      Ellipsis))

    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', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('bases', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('dct', Ellipsis, Ellipsis, "positional_or_keyword"),
                       ('bar', 2, Ellipsis, "keyword_only")),
                      Ellipsis))
c                 2    G d dt               }| j                  | j                   |             dt        t        dfft        f        G d dt               }| j	                  t
        d      5  t        j                   |              d d d         G d d	||      }| j                  | j                   |             dt        t        dfft        f        G d
 dt               }| j	                  t        d      5  t        j                   |              d d d        t        j                  d   dk  ry  G d dt               }d |_
        | j                  | j                  |      dt        t        dfft        f       y # 1 sw Y   xY w# 1 sw Y   xxY w)Nc                       e Zd Zd Zy)CTestSignatureObject.test_signature_on_callable_objects.<locals>.Fooc                      y r
   r#   )r0   r%   s     r   r>   zLTestSignatureObject.test_signature_on_callable_objects.<locals>.Foo.__call__  s    r   N)__name__
__module____qualname__r>   r#   r   r   FoorK     s    r   rP   r%   positional_or_keywordc                       e Zd Zy)DTestSignatureObject.test_signature_on_callable_objects.<locals>.SpamNrM   rN   rO   r#   r   r   SpamrS         r   rU   rD   c                       e Zd Zy)CTestSignatureObject.test_signature_on_callable_objects.<locals>.BarNrT   r#   r   r   BarrX     rV   r   rY   c                       e Zd ZeZy)FTestSignatureObject.test_signature_on_callable_objects.<locals>.ToFailN)rM   rN   rO   r=   r>   r#   r   r   ToFailr[     s    Hr   r\   r9   r   r)   c                       e Zd Zy)GTestSignatureObject.test_signature_on_callable_objects.<locals>.WrappedNrT   r#   r   r   Wrappedr^     rV   r   r_   c                      y r
   r#   r$   s    r   <lambda>zHTestSignatureObject.test_signature_on_callable_objects.<locals>.<lambda>  s    r   )objectr5   r   r   r;   r/   r   r<   r-   r.   __wrapped__)r0   rP   rU   rY   r\   r_   s         r   "test_signature_on_callable_objectsz6TestSignatureObject.test_signature_on_callable_objects  s]   	& 	 	.85LMO"$	%	6 	##I/IJdf% K	$ 	 	.85LMO"$	%	V 	##J0LMfh' N A"	f 	,085LMO"$	%+ KJ NMs   .F;FF
Fc                 h    | j                  | j                  dd      ddt        dfft        f       y )N
   c                     | S r
   r#   r$   s    r   ra   z?TestSignatureObject.test_signature_on_lambdas.<locals>.<lambda>  s    ar   r%   rQ   rf   r4   rA   s    r   test_signature_on_lambdasz-TestSignatureObject.test_signature_on_lambdas  s3    9X/FGI"$	%r   ab  
def test_signature_equality(self):
    def foo(a, *, b:int) -> float: pass
    self.assertNotEqual(inspect.signature(foo), 42)

    def bar(a, *, b:int) -> float: pass
    self.assertEqual(inspect.signature(foo), inspect.signature(bar))

    def bar(a, *, b:int) -> int: pass
    self.assertNotEqual(inspect.signature(foo), inspect.signature(bar))

    def bar(a, *, b:int): pass
    self.assertNotEqual(inspect.signature(foo), inspect.signature(bar))

    def bar(a, *, b:int=42) -> float: pass
    self.assertNotEqual(inspect.signature(foo), inspect.signature(bar))

    def bar(a, *, c) -> float: pass
    self.assertNotEqual(inspect.signature(foo), inspect.signature(bar))

    def bar(a, b:int) -> float: pass
    self.assertNotEqual(inspect.signature(foo), inspect.signature(bar))
    def spam(b:int, a) -> float: pass
    self.assertNotEqual(inspect.signature(spam), inspect.signature(bar))

    def foo(*, a, b, c): pass
    def bar(*, c, b, a): pass
    self.assertEqual(inspect.signature(foo), inspect.signature(bar))

    def foo(*, a=1, b, c): pass
    def bar(*, c, b, a=1): pass
    self.assertEqual(inspect.signature(foo), inspect.signature(bar))

    def foo(pos, *, a=1, b, c): pass
    def bar(pos, *, c, b, a=1): pass
    self.assertEqual(inspect.signature(foo), inspect.signature(bar))

    def foo(pos, *, a, b, c): pass
    def bar(pos, *, c, b, a=1): pass
    self.assertNotEqual(inspect.signature(foo), 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.assertEqual(inspect.signature(foo), inspect.signature(bar))
c                     d }t        j                  |      }| j                  t        d      5  t	        |       d d d        y # 1 sw Y   y xY w)Nc                      y r
   r#   r$   s    r   r,   z:TestSignatureObject.test_signature_unhashable.<locals>.fooI      Dr   unhashable type)r   r   r;   r/   hash)r0   r,   r   s      r   test_signature_unhashablez-TestSignatureObject.test_signature_unhashableH  s:    $##I/@AI BAAs   AAa  
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)), '()')
a  
def test_signature_str_positional_only(self):
    P = inspect.Parameter

    def test(a_po, *, b, **kwargs):
        return a_po, kwargs

    sig = inspect.signature(test)
    new_params = list(sig.parameters.values())
    new_params[0] = new_params[0].replace(kind=P.POSITIONAL_ONLY)
    test.__signature__ = sig.replace(parameters=new_params)

    self.assertEqual(str(inspect.signature(test)),
                     '(<a_po>, *, b, **kwargs)')

    sig = inspect.signature(test)
    new_params = list(sig.parameters.values())
    new_params[0] = new_params[0].replace(name=None)
    test.__signature__ = sig.replace(parameters=new_params)
    self.assertEqual(str(inspect.signature(test)),
                     '(<0>, *, b, **kwargs)')
a  
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))
N)rM   rN   rO   staticmethodr   r-   r.   execr1   r7   rB   rH   rd   ri   ro   r#   r   r   r   r      s$   	I 	I Q ! !	F'?
 Q  	 Q  	 Q  	#$0 Q  	 Q  	( Q  	( Q ] ]	~ Q 1 1	f Q Q Q	f"%H%
 Q , ,	\ Q  	" Q  	. Q  	 r   r   c                   6    e Zd Zd Zd Zd Zd Zd Zd Zd Z	y)	TestParameterObjectc                 |   t         j                  }| j                  |j                  |j                  cxk  xr3 |j
                  cxk  xr! |j                  cxk  xr |j                  k  nc        | j                  t        |j                        d       | j                  dt        |j                        v        y )NPOSITIONAL_ONLY)r   	Parameter
assertTrueru   POSITIONAL_OR_KEYWORDVAR_POSITIONALKEYWORD_ONLYVAR_KEYWORDr5   r   repr)r0   Ps     r   test_signature_parameter_kindsz2TestParameterObject.test_signature_parameter_kinds  s    ))A,C,C J((J+,>>J<=MMJ 	K 	Q../1BC)T!2C2C-DDEr   c                 F   t        j                  ddt         j                  j                        }| j                  |j                  d       | j                  |j
                  d       | j                  |j                  |j                         | j                  |j                  t         j                  j                         | j                  t        d      5  t        j                  ddd       d d d        | j                  t        d      5  t        j                  dt         j                  j                         d d d        | j                  t        d	      5  t        j                  d t         j                  j                         d d d        | j                  t        d
      5  t        j                  ddt         j                  j                         d d d        | j                  t        d
      5  t        j                  ddt         j                  j                         d d d        t        j                  ddt         j                  j                        }| j                  t        d
      5  |j                  t         j                  j                         d d d        | j!                  t#        |      j%                  d             y # 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   exY w# 1 sw Y   #xY w# 1 sw Y   xY w# 1 sw Y   sxY w)Nr,   rf   r   r   zinvalid value123not a valid parameter name1r   znon-positional-only parameterzcannot have default valuesr%   rE   z
<Parameter)r   rv   ru   r5   r   r   assertIsr   r   r   r;   r<   r{   ry   rx   replacerw   r|   
startswithr0   ps     r   test_signature_parameter_objectz3TestParameterObject.test_signature_parameter_object  sB   eR#*#4#4#D#DF'B'allAGG,!2!2!B!BC##J@eRe< A ##J0LMc(9(9(E(EF N ##J%DFd):):)F)FGF ##J0LMc2#*#4#4#@#@B N ##J0LMc2#*#4#4#C#CE N c2#*#4#4#J#JL##J0LMII7,,;;I< N 	Q**<89/ A@ NMF F NM NM NMsH   K0K$0K1,1K>;1L:+LK!$K.1K;>LLL c                    t         j                  } |ddt         j                  j                        }| j                  ||       | j	                  |d       | j                  | |ddt         j                  j                               y )Nr,   rE   r   )r   rv   rz   r5   assertNotEqual)r0   r}   r   s      r   !test_signature_parameter_equalityz5TestParameterObject.test_signature_parameter_equality  ss    eRg&7&7&D&DEAAr"AeR#*#4#4#A#AC 	Dr   c                     t        j                  ddt         j                  j                        }| j                  t        d      5  t        |       d d d        y # 1 sw Y   y xY w)Nr,   rE   r   rm   )r   rv   rz   r;   r/   rn   r   s     r   #test_signature_parameter_unhashablez7TestParameterObject.test_signature_parameter_unhashable  sM    eR#*#4#4#A#AC ##I/@AG BAAs   AA%c                 H   t        j                  ddt         j                  j                        }| j                  ||j	                                | j                  ||j	                                |j	                  d      }| j                  |j                  d       |j	                  |j                        }| j                  ||       |j	                  d      }| j                  |j                  d       | j                  ||       | j                  t        d      5  |j	                  |j                        }d d d        |j	                  dd 	      }| j                  |j                  d        | j                  ||       |j	                  d|j                  	      }| j                  |j                  |j                         |j	                  d|j                        }| j                  |j                  |j                         | j                  ||       | j                  t        d
      5  |j	                  |j                        }d d d        |j	                  |j                        }| j                  ||       y # 1 sw Y   MxY w# 1 sw Y   ExY w)Nr,   rE   r      )r   r(   r   r   )r   r   zinvalid value forr   )r   rv   rz   assertIsNotr   r5   r   r   r   r   r;   r<   r   r   rx   r   )r0   r   p2s      r    test_signature_parameter_replacez4TestParameterObject.test_signature_parameter_replace  s   eR#*#4#4#A#AC 	AIIK(AIIK(YY!Y$*ZZ288Z,BZZUZ#%(B"##J0LM*B N ZZUDZ1bjj$'B"ZZUBHHZ5bjj"((+ ZZ)A)AZB"":":;B"##J0CD*B E ZZR__Z-Q' NM EDs   #J7JJJ!c                     t        j                  d t         j                  j                        }| j                  t	        |      d       |j                  d      }| j                  t	        |      d       y )Nr   z<>r   r   z<1>)r   rv   ru   r5   r   r   r   s     r   (test_signature_parameter_positional_onlyz<TestParameterObject.test_signature_parameter_positional_only  sX    d):):)J)JKQ&II3IQ'r   c                 &   t        j                  d t         j                  j                        }| j                  t              5  d|_        d d d        | j                  t              5  d|_        d d d        y # 1 sw Y   /xY w# 1 sw Y   y xY w)Nr   r(   {   )r   rv   ru   r*   r+   r,   r   r   s     r   %test_signature_parameter_immutabilityz9TestParameterObject.test_signature_parameter_immutability  sk    d):):)J)JK~.AE / ~.AF /. /. /.s   A;*B;BBN)
rM   rN   rO   r~   r   r   r   r   r   r   r#   r   r   rs   rs     s)    F:BD# J(r   rs   c                       e Zd Zed        Zd Zd Zd Zd Zd Z	d Z
d Zej                  d	   d
kD  r ed       ej                  d	   d
kD  r ed       ej                  d	   d
kD  r ed       d Zy)TestSignatureBindc                     t        j                  |       } |j                  |i |} | |j                  i |j                  S r
   )r   r   bindargskwargs)r   r   r   r   bas        r   callzTestSignatureBind.call  s?    %SXXt&v&RWW*		**r   c                    d }| j                  | j                  |      d       | j                  t        d      5  | j                  |d       d d d        | j                  t        d      5  | j                  |dd       d d d        | j                  t        d      5  | j                  |d       d d d        y # 1 sw Y   oxY w# 1 sw Y   HxY w# 1 sw Y   y xY w)Nc                       y)NrE   r#   r#   r   r   r&   z9TestSignatureBind.test_signature_bind_empty.<locals>.test  s    r   rE   too many positional argumentsr   rf   )spamztoo many keyword argumentsr5   r   r;   r/   r6   s     r   test_signature_bind_emptyz+TestSignatureBind.test_signature_bind_empty  s    	 	4"-##I/NOIIdA P##I/NOIIdABI' P##I/KLIIdI# ML	 POOOLLs#   B<,CC<CCCc                     d }| j                  | j                  |      di f       | j                  | j                  |d      di f       | j                  | j                  |dd      di f       | j                  | j                  |d      dd	dif       | j                  | j                  |dd      dd	dif       | j                  | j                  |d
      ddd
if       | j                  | j                  |ddd      dd	dif       y )Nc                  
    | |fS r
   r#   )r   r   s     r   r&   z7TestSignatureBind.test_signature_bind_var.<locals>.test  s    <r   r#   r   )r   r    )r   r    r(   r,   r,   rf   r   r   r5   r   r6   s     r   test_signature_bind_varz)TestSignatureBind.test_signature_bind_var  s   	  	42r(34+dBZ84A.=4U3b5%.5IJ46u~8NO4b1B3EF4A59 5%.1	3r   c                 :   d }| j                  | j                  |ddd      d       | j                  t        d      5  | j                  |dddd       d d d        | j                  t        d      5  | j                  |d       d d d        | j                  t        d	      5  | j                  |       d d d        dd}| j                  | j                  |ddd      d       | j                  | j                  |dd      d       dd}| j                  | j                  |d
d      d       | j                  | j                  |d
      d       | j                  | j                  |d
      d       y # 1 sw Y   %xY w# 1 sw Y   xY w# 1 sw Y   xY w)Nc                     | ||fS r
   r#   r%   bcs      r   r&   z=TestSignatureBind.test_signature_bind_just_args.<locals>.test      a7Nr   r   r    r)   r   r    r)   r      z'b' parameter lacking defaultz'a' parameter lacking defaultrf   c                     | ||fS r
   r#   r   s      r   r&   z=TestSignatureBind.test_signature_bind_just_args.<locals>.test+  r   r   )r   r    rf   c                     | ||fS r
   r#   r   s      r   r&   z=TestSignatureBind.test_signature_bind_just_args.<locals>.test0  r   r      )r%   r   )rf   r    r   r$   )rf   r    r)   r   )r   rf   r)   rh   r   r6   s     r   test_signature_bind_just_argsz/TestSignatureBind.test_signature_bind_just_args  s[   	 	4Aq19=##I/NOIIdAq!Q' P ##I/NOIIdA P ##I/NOIIdO P	4Aq19=4A.
;	424kB42.
;42.
;% PO PO POs#   E72F#F7FFFc                     d }| j                  | j                  |      d       | j                  | j                  |ddd      d       y )Nc                      | S r
   r#   r   s    r   r&   zATestSignatureBind.test_signature_bind_varargs_order.<locals>.test7  s    Kr   r#   r   r    r)   r   r   r6   s     r   !test_signature_bind_varargs_orderz3TestSignatureBind.test_signature_bind_varargs_order6  s@    	 	4"-4Aq19=r   c           
         dd}| j                  | j                  |ddddd      d       | j                  | j                  |dd      d       | j                  | j                  |dd	      d
       | j                  | j                  |dd      d       | j                  t        d      5  | j                  |dddd       d d d        y # 1 sw Y   y xY w)Nr)   c                     | |||fS r
   r#   )r%   r   r   r   s       r   r&   zDTestSignatureBind.test_signature_bind_args_and_varargs.<locals>.test>  s    aD= r   r   r    r      )r   r    r)   )r   r   )r   r    r)   r#   )r   r%   )r    r   r)   r#   r   z multiple values for argument 'c')r   r)   r   r6   s     r   $test_signature_bind_args_and_varargsz6TestSignatureBind.test_signature_bind_args_and_varargs=  s    	! 	4Aq!Q79JK4A.>412MB4a0-@##I%GIIIdAq!qI)I I Is   ,CCc                     d }| j                  | j                  |      i        | j                  | j                  |dd      ddd       y )Nc                      | S r
   r#   )r   s    r   r&   z?TestSignatureBind.test_signature_bind_just_kwargs.<locals>.testK  s    Mr   r(   hamr,   r   r   r6   s     r   test_signature_bind_just_kwargsz1TestSignatureBind.test_signature_bind_just_kwargsJ  sH    	 	4"-4U?!&6	8r   c           
         dd}| j                  | j                  |dd      dddi f       | j                  | j                  |dddd      ddddddf       | j                  | j                  |dddd      ddddddf       | j                  | j                  |dddd	      ddddddf       | j                  | j                  |dddd
      ddddddf       | j                  | j                  |ddddd      ddddddf       | j                  | j                  |dddd      dddddif       | j                  | j                  |ddd      dddi f       y )Nr)   c                     | |||fS r
   r#   )r%   r   r   r   s       r   r&   zCTestSignatureBind.test_signature_bind_args_and_kwargs.<locals>.testS  s    aF?"r   r   r    r(   r   r   )r   r%   r,   r   )r%   r   r,   r   )r   r,   r   r   )r   r   r,   r   r   r,   r   )r   r%   r   r   r   r6   s     r   #test_signature_bind_args_and_kwargsz5TestSignatureBind.test_signature_bind_args_and_kwargsR  s   	# 	4A.Aq">4A5uEQ5%#@A	C41u5IQ5%#@A	C41u5IQ5%#@A	C4aUGQ5%#@A	C4a1%eLQ5%#@A	C4Aqe<QE5>2	441Q7Q2	(r   r   r    a  
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,
                                 "'bar' parameter lacking default value"):
        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,
                                 'too many keyword arguments'):
        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,
                                 'too many keyword arguments'):
        self.call(test, 1, bar=2, spam='ham')

    with self.assertRaisesRegex(TypeError,
                                 "'bar' parameter lacking default value"):
        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,
                                 "'foo' parameter lacking default value"):
        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}))
aj  
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))
aD  
def test_signature_bind_positional_only(self):
    P = inspect.Parameter

    def test(a_po, b_po, c_po=3, foo=42, *, bar=50, **kwargs):
        return a_po, b_po, c_po, foo, bar, kwargs

    sig = inspect.signature(test)
    new_params = collections.OrderedDict(tuple(sig.parameters.items()))
    for name in ('a_po', 'b_po', 'c_po'):
        new_params[name] = new_params[name].replace(kind=P.POSITIONAL_ONLY)
    new_sig = sig.replace(parameters=new_params.values())
    test.__signature__ = new_sig

    self.assertEqual(self.call(test, 1, 2, 4, 5, bar=6),
                     (1, 2, 4, 5, 6, {}))

    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)
c                     G d d      } |       }t        j                  |j                  |      }t        j                  |      j                  d      }| j                  |df ||j                  i |j                         y )Nc                       e Zd Zd Zy)+TestSignatureBind.test_bind_self.<locals>.Fc                 
    | |fS r
   r#   )r%   r0   s     r   fz-TestSignatureBind.test_bind_self.<locals>.F.f  s    $wr   N)rM   rN   rO   r   r#   r   r   Fr     s    r   r   rf   rA   )		functoolspartialr   r   r   r   r5   r   r   )r0   r   an_f	partial_fr   s        r   test_bind_selfz TestSignatureBind.test_bind_self  so    	 	 s%%acc40	y)..B.7$Y%E299%EFr   N)rM   rN   rO   rp   r   r   r   r   r   r   r   r   r-   r.   rq   r   r#   r   r   r   r     s    + +

$3<4>*8(( Q 5 5	n Q  	  Q  	0Gr   r   c                       e Zd Zd Zd Zy)TestBoundArgumentsc                     d }t        j                  |      j                  d      }| j                  t        d      5  t        |       d d d        y # 1 sw Y   y xY w)Nc                      y r
   r#   r$   s    r   r,   zITestBoundArguments.test_signature_bound_arguments_unhashable.<locals>.foo  rl   r   r   rm   )r   r   r   r;   r/   rn   )r0   r,   r   s      r   )test_signature_bound_arguments_unhashablez<TestBoundArguments.test_signature_bound_arguments_unhashable  sE    s#((+##I/@AH BAAs   AAc                    d }t        j                  |      j                  d      }| j                  ||       t        j                  |      j                  d      }| j                  ||       t        j                  |      j                  d      }| j	                  ||       d|j
                  d<   | j                  ||       d }t        j                  |      j                  d      }| j	                  ||       y )Nc                      y r
   r#   r$   s    r   r,   zGTestBoundArguments.test_signature_bound_arguments_equality.<locals>.foo  rl   r   r   r    r%   c                      y r
   r#   r   s    r   r(   zGTestBoundArguments.test_signature_bound_arguments_equality.<locals>.bar  rl   r   )r   r   r   r5   r   	arguments)r0   r,   r   ba2ba3r(   ba4s          r   'test_signature_bound_arguments_equalityz:TestBoundArguments.test_signature_bound_arguments_equality  s    s#((+R $))!,S!$))!,B$cS!$))!,B$r   N)rM   rN   rO   r   r   r#   r   r   r   r     s    %r   r   )
__future__r   r   r   collectionsr   r-   	unittest2unittestfuncsigsr   TestCaser   rs   r   r   r#   r   r   <module>r      sm    @ @   
  {	(++ {	|o(++ odSG)) SGl%** %r   