
    `                         S SK JrJrJr  S SKrS SKrS SKrS SKrS SK	r
 " S S\R                  5      r " S S\R                  5      r " S S\R                  5      r " S	 S
\R                  5      rg)    )absolute_importdivisionprint_functionNc                   H   \ rS rSr\S 5       r\R                  S   S:  a  \" S5        S r	S r
\R                  S   S:  a  \" S5        \R                  S   S:  a  \" S	5        \R                  S   S:  a  \" S
5        S rS r\R                  S   S:  a  \" S5        \R                  S   S:  a  \" S5        \R                  S   S:  a  \" S5        \R                  S   S:  a  \" S5        \R                  S   S:  a  \" S5        \R                  S   S:  a  \" S5        S rS r\R                  S   S:  a  \" S5        S r\R                  S   S:  a  \" S5        \R                  S   S:  a  \" S5        \R                  S   S:  a  \" S5        SrgSrg)TestSignatureObject   c                     [         R                  " U 5      n[        S UR                  R	                  5        5       5      UR
                  UR                  L a  [        4$ UR
                  4$ )Nc              3   (  #    U  H  nUR                   UR                  UR                  L a  [        OUR                  UR                  UR                  L a  [        OUR                  [        UR                  5      R                  5       4v   M     g 7fN)namedefaultemptyEllipsis
annotationstrkindlower).0params     :platform/gsutil/third_party/funcsigs/tests/test_inspect.py	<genexpr>0TestSignatureObject.signature.<locals>.<genexpr>   sp      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   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                 N   S n[         R                  " U5      nU R                  [        5         SUl        S S S 5        [
        R                  S S S:  a  g U R                  [        5         S UR                  S'   S S S 5        g ! , (       d  f       NT= f! , (       d  f       g = f)Nc                     g r    as    r   test=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_immutability/TestSignatureObject.test_signature_immutability=   s    	%~.CG / BQ&(y)"&CNN3 *) /. *)s   B,B
B
B$c                 X    S nU R                  U R                  U5      S[        45        g )Nc                      g r   r&   r&   r"   r   r)   9TestSignatureObject.test_signature_on_noarg.<locals>.testM   r+   r"   r&   assertEqualr   r   r4   r)   s     r   test_signature_on_noarg+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                    U R                  [        S5         [        R                  " [        5        S S S 5        U R                  [        S5         [        R                  " [        R
                  5        [        [        S5      (       a  [        S5      e S S S 5        U R                  [        S5         [        R                  " [        R
                  5        [        [        S5      (       a  [        S5      e S S S 5        U R                  [        S5         [        R                  " [        5        S S S 5        g ! , (       d  f       GN= f! , (       d  f       N= f! , (       d  f       Nk= f! , (       d  f       g = f)Nnot supported by signaturepypy_version_infoz'no signature found for builtin function)	assertRaisesRegex
ValueErrorr   r   type__call__hasattrr1   minr4   s    r   "test_signature_on_builtin_function6TestSignatureObject.test_signature_on_builtin_functionv   s   ##J0LMd# N##J0LMdmm,s/00 !=>> 1 N
 ##J0LMcll+s/00 !=>> 1 N
 ##J%NP c"P P NMMM
 NM
P Ps1   D<AE4AEE0<
E
E
E-0
E>c                 .   U R                  [        S5         [        R                  " S5        S S S 5        U R                  [        S5         [        R                  R                  S5        S S S 5        g ! , (       d  f       NM= f! , (       d  f       g = f)Nis not a callable object*   zis not a Python function)rB   r3   r   r   	Signaturefrom_functionrH   s    r   test_signature_on_non_function2TestSignatureObject.test_signature_on_non_function   sk    ##I/IJb! K ##I/IJ++B/ KJ KJ KJs   A5 B5
B
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                 J    " S S[         5      nU R                  U R                  U" 5       5      S[        [        S44[        45         " S S[         5      nU R	                  [
        S5         [        R                  " U" 5       5        S S S 5         " S S	X!5      nU R                  U R                  U" 5       5      S[        [        S44[        45         " S
 S[         5      nU R	                  [        S5         [        R                  " U" 5       5        S S S 5        [        R                  S   S:  a  g  " S S[         5      nS Ul
        U R                  U R                  U5      S[        [        S44[        45        g ! , (       d  f       N= f! , (       d  f       N= f)Nc                       \ rS rSrS rSrg)CTestSignatureObject.test_signature_on_callable_objects.<locals>.Fooi  c                     g r   r&   )r4   r(   s     r   rE   LTestSignatureObject.test_signature_on_callable_objects.<locals>.Foo.__call__  s    r"   r&   N)__name__
__module____qualname____firstlineno__rE   __static_attributes__r&   r"   r   FoorT     s    r"   r\   r(   positional_or_keywordc                       \ rS rSrSrg)DTestSignatureObject.test_signature_on_callable_objects.<locals>.Spami  r&   NrW   rX   rY   rZ   r[   r&   r"   r   Spamr_         r"   ra   rL   c                       \ rS rSrSrg)CTestSignatureObject.test_signature_on_callable_objects.<locals>.Bari  r&   Nr`   r&   r"   r   Barrd     rb   r"   re   c                       \ rS rSr\rSrg)FTestSignatureObject.test_signature_on_callable_objects.<locals>.ToFaili  r&   N)rW   rX   rY   rZ   rD   rE   r[   r&   r"   r   ToFailrg     s    Hr"   rh   r@   r   r-   c                       \ rS rSrSrg)GTestSignatureObject.test_signature_on_callable_objects.<locals>.Wrappedi  r&   Nr`   r&   r"   r   Wrappedrj     rb   r"   rk   c                     g r   r&   r'   s    r   <lambda>HTestSignatureObject.test_signature_on_callable_objects.<locals>.<lambda>  s    r"   )objectr;   r   r   rB   r3   r   rC   r1   r2   __wrapped__)r4   r\   ra   re   rh   rk   s         r   "test_signature_on_callable_objects6TestSignatureObject.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                 j    U R                  U R                  SS j5      SS[        S44[        45        g )N
   c                     U $ r   r&   r'   s    r   rm   ?TestSignatureObject.test_signature_on_lambdas.<locals>.<lambda>  s    ar"   r(   r]   rt   r:   rH   s    r   test_signature_on_lambdas-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                     S n[         R                  " U5      nU R                  [        S5         [	        U5        S S S 5        g ! , (       d  f       g = f)Nc                     g r   r&   r'   s    r   r0   :TestSignatureObject.test_signature_unhashable.<locals>.fooI      Dr"   unhashable type)r   r   rB   r3   hash)r4   r0   r    s      r   test_signature_unhashable-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))
r&   N)rW   rX   rY   rZ   staticmethodr   r1   r2   execr5   r=   rI   rP   rq   rx   r   r[   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                   >    \ rS rSrS rS rS rS rS rS r	S r
S	rg
)TestParameterObjecti  c                    [         R                  nU R                  UR                  UR                  s=:  =(       a=    UR
                  s=:  =(       a&    UR                  s=:  =(       a    UR                  :  Os  5        U R                  [        UR                  5      S5        U R                  S[        UR                  5      ;   5        g )NPOSITIONAL_ONLY)r   	Parameter
assertTruer   POSITIONAL_OR_KEYWORDVAR_POSITIONALKEYWORD_ONLYVAR_KEYWORDr;   r   repr)r4   Ps     r   test_signature_parameter_kinds2TestParameterObject.test_signature_parameter_kinds  s    ))A,C,C J J((J J+,>>J J<=MMJ 	K 	Q../1BC)T!2C2C-DDEr"   c                 `   [         R                  " SS[         R                  R                  S9nU R                  UR                  S5        U R                  UR
                  S5        U R                  UR                  UR                  5        U R                  UR                  [         R                  R                  5        U R                  [        S5         [         R                  " SSSS9  S S S 5        U R                  [        S5         [         R                  " S[         R                  R                  S9  S S S 5        U R                  [        S	5         [         R                  " S [         R                  R                  S9  S S S 5        U R                  [        S
5         [         R                  " SS[         R                  R                  S9  S S S 5        U R                  [        S
5         [         R                  " SS[         R                  R                  S9  S S S 5        [         R                  " SS[         R                  R                  S9nU R                  [        S
5         UR                  [         R                  R                  S9  S S S 5        U R!                  [#        U5      R%                  S5      5        g ! , (       d  f       GN= f! , (       d  f       GN= f! , (       d  f       GNk= f! , (       d  f       GN0= f! , (       d  f       N= f! , (       d  f       N= f)Nr0   rt   r   r   zinvalid value123not a valid parameter name1r   znon-positional-only parameterzcannot have default valuesr(   rM   z
<Parameter)r   r   r   r;   r   r   assertIsr   r   r   rB   rC   r   r   r   replacer   r   
startswithr4   ps     r   test_signature_parameter_object3TestParameterObject.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.K.K*$/K<1/L,(L
K
K'*
K9<
L
L
L-c           	         [         R                  nU" SS[         R                  R                  S9nU R                  X"5        U R	                  US5        U R                  X!" SS[         R                  R                  S95        g )Nr0   rM   r   )r   r   r   r;   assertNotEqual)r4   r   r   s      r   !test_signature_parameter_equality5TestParameterObject.test_signature_parameter_equality  sq    eRg&7&7&D&DEAr"AeR#*#4#4#A#AC 	Dr"   c                     [         R                  " SS[         R                  R                  S9nU R                  [        S5         [        U5        S S S 5        g ! , (       d  f       g = f)Nr0   rM   r   r~   )r   r   r   rB   r3   r   r   s     r   #test_signature_parameter_unhashable7TestParameterObject.test_signature_parameter_unhashable  sM    eR#*#4#4#A#AC ##I/@AG BAAs   A
A(c                    [         R                  " SS[         R                  R                  S9nU R                  XR	                  5       5        U R                  XR	                  5       5        UR	                  SS9nU R                  UR                  S5        UR	                  UR                  S9nU R                  X5        UR	                  SS9nU R                  UR                  S5        U R                  X!5        U R                  [        S5         UR	                  UR                  S9nS S S 5        UR	                  SS S	9nU R                  UR                  S 5        U R                  X!5        UR	                  SUR                  S	9nU R                  UR                  UR                  5        UR	                  SUR                  S9nU R                  UR                  UR                  5        U R                  X!5        U R                  [        S
5         UR	                  UR                  S9nS S S 5        UR	                  UR                  S9nU R                  X!5        g ! , (       d  f       GN@= f! , (       d  f       NK= f)Nr0   rM   r      )r   r,   r   r   )r   r   zinvalid value forr   )r   r   r   assertIsNotr   r;   r   r   r   r   rB   rC   r   r   r   r   )r4   r   p2s      r    test_signature_parameter_replace4TestParameterObject.test_signature_parameter_replace  s   eR#*#4#4#A#AC 	IIK(IIK(YY!Y$*ZZ288Z,ZZUZ#%(B"##J0LM*B N ZZUDZ1bjj$'B"ZZUBHHZ5bjj"((+ ZZ)A)AZB"":":;B"##J0CD*B E ZZR__Z-' NM EDs   I'I9'
I69
Jc                     [         R                  " S [         R                  R                  S9nU R                  [	        U5      S5        UR                  SS9nU R                  [	        U5      S5        g )Nr   z<>r   r   z<1>)r   r   r   r;   r   r   r   s     r   (test_signature_parameter_positional_only<TestParameterObject.test_signature_parameter_positional_only  sX    d):):)J)JKQ&II3IQ'r"   c                 6   [         R                  " S [         R                  R                  S9nU R                  [        5         SUl        S S S 5        U R                  [        5         SUl        S S S 5        g ! , (       d  f       N4= f! , (       d  f       g = f)Nr   r,   {   )r   r   r   r.   r/   r0   r   r   s     r   %test_signature_parameter_immutability9TestParameterObject.test_signature_parameter_immutability  sk    d):):)J)JK~.AE / ~.AF /. /. /.s   A9(B
9
B

Br&   N)rW   rX   rY   rZ   r   r   r   r   r   r   r   r[   r&   r"   r   r   r     s)    F:BD# J(r"   r   c                       \ rS rSr\S 5       rS rS rS rS r	S r
S rS	 r\R                  S
   S:  a  \" S5        \R                  S
   S:  a  \" S5        \R                  S
   S:  a  \" S5        S rSrg)TestSignatureBindi  c                     [         R                  " U 5      nUR                  " U0 UD6nU " UR                  0 UR                  D6$ r   )r   r   bindargskwargs)r   r   r   r    bas        r   callTestSignatureBind.call  s=    %XXt&v&RWW*		**r"   c                    S nU R                  U R                  U5      S5        U R                  [        S5         U R                  US5        S S S 5        U R                  [        S5         U R                  USSS9  S S S 5        U R                  [        S5         U R                  USS9  S S S 5        g ! , (       d  f       Nn= f! , (       d  f       NO= f! , (       d  f       g = f)Nc                      g)NrM   r&   r&   r"   r   r)   9TestSignatureBind.test_signature_bind_empty.<locals>.test  s    r"   rM   too many positional argumentsr   rt   )spamztoo many keyword argumentsr;   r   rB   r3   r<   s     r   test_signature_bind_empty+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#   B6,CC6
C
C
C&c           	         S nU R                  U R                  U5      S0 45        U R                  U R                  US5      S0 45        U R                  U R                  USS5      S0 45        U R                  U R                  USS9SS	S045        U R                  U R                  USSS9SS	S045        U R                  U R                  US
S9SSS
045        U R                  U R                  USSSS9SS	S045        g )Nc                      X4$ r   r&   )r   r   s     r   r)   7TestSignatureBind.test_signature_bind_var.<locals>.test  s
    <r"   r&   r   )r   r#   )r   r#   r,   r0   r0   rt   r   r   r;   r   r<   s     r   test_signature_bind_var)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                 J   S nU R                  U R                  USSS5      S5        U R                  [        S5         U R                  USSSS5        S S S 5        U R                  [        S5         U R                  US5        S S S 5        U R                  [        S	5         U R                  U5        S S S 5        SS jnU R                  U R                  USSS5      S5        U R                  U R                  USS5      S5        SS jnU R                  U R                  US
SS9S5        U R                  U R                  US
S9S5        U R                  U R                  US
S9S5        g ! , (       d  f       GN#= f! , (       d  f       GN= f! , (       d  f       N= f)Nc                 
    XU4$ r   r&   r(   bcs      r   r)   =TestSignatureBind.test_signature_bind_just_args.<locals>.test      7Nr"   r   r#   r-   r   r#   r-   r      z'b' parameter lacking defaultz'a' parameter lacking defaultrt   c                 
    XU4$ r   r&   r   s      r   r)   r   +  r   r"   )r   r#   rt   c                 
    XU4$ r   r&   r   s      r   r)   r   0  r   r"      )r(   r   )rt   r#   r   r'   )rt   r#   r-   r   )r   rt   r-   rw   r   r<   s     r   test_signature_bind_just_args/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#   E02F#F0
E?
F
F"c                     S nU R                  U R                  U5      S5        U R                  U R                  USSS5      S5        g )Nc                      U $ r   r&   r   s    r   r)   ATestSignatureBind.test_signature_bind_varargs_order.<locals>.test7  s    Kr"   r&   r   r#   r-   r   r   r<   s     r   !test_signature_bind_varargs_order3TestSignatureBind.test_signature_bind_varargs_order6  s@    	 	4"-4Aq19=r"   c           
         SS jnU R                  U R                  USSSSS5      S5        U R                  U R                  USS5      S5        U R                  U R                  USSS	9S
5        U R                  U R                  USSS9S5        U R                  [        S5         U R                  USSSSS9  S S S 5        g ! , (       d  f       g = f)Nr-   c                 
    XX#4$ r   r&   )r(   r   r   r   s       r   r)   DTestSignatureBind.test_signature_bind_args_and_varargs.<locals>.test>  s    = 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   r<   s     r   $test_signature_bind_args_and_varargs6TestSignatureBind.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                     S nU R                  U R                  U5      0 5        U R                  U R                  USSS9SSS.5        g )Nc                      U $ r   r&   )r   s    r   r)   ?TestSignatureBind.test_signature_bind_just_kwargs.<locals>.testK  s    Mr"   r,   hamr0   r   r   r<   s     r   test_signature_bind_just_kwargs1TestSignatureBind.test_signature_bind_just_kwargsJ  sH    	 	4"-4U?!&6	8r"   c                    SS jnU R                  U R                  USS5      SSS0 45        U R                  U R                  USSSSS9SSSSSS.45        U R                  U R                  USSSSS9SSSSSS.45        U R                  U R                  USSSSS	9SSSSSS.45        U R                  U R                  USSSSS
9SSSSSS.45        U R                  U R                  USSSSSS9SSSSSS.45        U R                  U R                  USSSSS9SSSSS045        U R                  U R                  USSSS9SSS0 45        g )Nr-   c                 
    XX#4$ r   r&   )r(   r   r   r   s       r   r)   CTestSignatureBind.test_signature_bind_args_and_kwargs.<locals>.testS  s    ?"r"   r   r#   r,   r   r   )r   r(   r0   r   )r(   r   r0   r   )r   r0   r   r   )r   r   r0   r   r   r0   r   )r   r(   r   r   r   r<   s     r   #test_signature_bind_args_and_kwargs5TestSignatureBind.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                 
    " S S5      nU" 5       n[         R                  " UR                  U5      n[        R                  " U5      R                  SS9nU R                  US4U" UR                  0 UR                  D65        g )Nc                       \ rS rSrS rSrg)+TestSignatureBind.test_bind_self.<locals>.Fi  c                     X4$ r   r&   )r(   r4   s     r   f-TestSignatureBind.test_bind_self.<locals>.F.f  s	    wr"   r&   N)rW   rX   rY   rZ   r   r[   r&   r"   r   Fr     s    r"   r   rt   rH   )		functoolspartialr   r   r   r   r;   r   r   )r4   r   an_f	partial_fr   s        r   test_bind_self TestSignatureBind.test_bind_self  so    	 	 s%%acc40	y)..B.7$Y%E299%EFr"   r&   N)rW   rX   rY   rZ   r   r   r   r   r   r   r   r   r   r1   r2   r   r   r[   r&   r"   r   r   r     s    + +

$3<4>*8(( Q 5 5	n Q  	  Q  	0Gr"   r   c                        \ rS rSrS rS rSrg)TestBoundArgumentsi  c                     S n[         R                  " U5      R                  S5      nU R                  [        S5         [        U5        S S S 5        g ! , (       d  f       g = f)Nc                     g r   r&   r'   s    r   r0   ITestBoundArguments.test_signature_bound_arguments_unhashable.<locals>.foo  r}   r"   r   r~   )r   r   r   rB   r3   r   )r4   r0   r   s      r   )test_signature_bound_arguments_unhashable<TestBoundArguments.test_signature_bound_arguments_unhashable  sE    s#((+##I/@AH BAAs   A
A"c                     S n[         R                  " U5      R                  S5      nU R                  X"5        [         R                  " U5      R                  S5      nU R                  X#5        [         R                  " U5      R                  S5      nU R	                  X$5        SUR
                  S'   U R                  X$5        S n[         R                  " U5      R                  S5      nU R	                  X&5        g )Nc                     g r   r&   r'   s    r   r0   GTestBoundArguments.test_signature_bound_arguments_equality.<locals>.foo  r}   r"   r   r#   r(   c                     g r   r&   r   s    r   r,   GTestBoundArguments.test_signature_bound_arguments_equality.<locals>.bar  r}   r"   )r   r   r   r;   r   	arguments)r4   r0   r   ba2ba3r,   ba4s          r   'test_signature_bound_arguments_equality:TestBoundArguments.test_signature_bound_arguments_equality  s    s#((+ $))!,!$))!,B$c!$))!,B$r"   r&   N)rW   rX   rY   rZ   r  r  r[   r&   r"   r   r  r    s    %r"   r  )
__future__r   r   r   collectionsr   r1   	unittest2unittestfuncsigsr   TestCaser   r   r   r  r&   r"   r   <module>r     sm    @ @   
  {	(++ {	|o(++ odSG)) SGl%** %r"   