def testfunc_varargs_ca2(a: str, b: int, c: None,
*varg: int) -> Tuple[int, str]:
check_argument_types()
res = 1
for arg in varg:
res *= arg
return res, a * b
def testmeth_varargs_ca2(self, q1, q2, *varargs, **varkw):
check_argument_types()
return [
len(varargs),
len(str(varargs[q1])), varkw[q2],
len(self.__class__.__name__)
]
def func_defaults_checkargs_py2(a, b, c=4, d=2.5):
# actually (str) -> str
check_argument_types()
try:
return a + b * c
except TypeError:
return 'invalid'
def testfunc_varargs_ca3(*args, **kwds):
check_argument_types()
longest = ''
for key in kwds:
if len(key) > len(longest):
longest = key
return longest*(args[0]//len(args)), kwds[longest]
def testmeth_varargs_class_ca1_py2(cls, *vargs_cls):
# actually (Tuple[str, int]) -> int
check_argument_types()
res = 1
for arg in vargs_cls:
res += len(arg[0]) * arg[1]
return res - len(cls.__name__)
def testfunc_varargs_ca4(**kwds: float) -> float:
check_argument_types()
longest = ''
for key in kwds:
if len(key) > len(longest):
longest = key
return 0 if longest == '' else kwds[longest]
def testfunc_varargs_ca2_py2(a, b, c, *varg):
# actually (str, int, None, int) -> Tuple[int, str]
check_argument_types()
res = 1
for arg in varg:
res *= arg
return res, a * b
def testmeth_varargs_static_ca1_py2(*vargs_st):
# actually (float) -> Tuple[int, float]
check_argument_types()
res = 1.0
for arg in vargs_st:
res *= arg
return len(vargs_st), res
def testfunc_varargs_ca1_py2(*argss):
# actually (float) -> Tuple[int, float]
check_argument_types()
res = 1.0
for arg in argss:
res *= arg
return len(argss), res
def testfunc_varargs_ca3(*args: int, **kwds: float) -> Tuple[str, float]:
check_argument_types()
longest = ''
for key in kwds:
if len(key) > len(longest):
longest = key
return longest * (args[0] // len(args)), kwds[longest]
def testmeth_varargs_ca2_py2(self, q1, q2, *varargs, **varkw):
# actually (int, str, float, int) -> List[int]
check_argument_types()
return [
len(varargs),
len(str(varargs[q1])), varkw[q2],
len(self.__class__.__name__)
]
def testfunc_varargs_ca4_py2(**kwds):
# actually (float) -> float
check_argument_types()
longest = ''
for key in kwds:
if len(key) > len(longest):
longest = key
return 0 if longest == '' else kwds[longest]
def testfunc_varargs_ca3_py2(*args, **kwds):
# actually (int, float) -> Tuple[str, float]
check_argument_types()
longest = ''
for key in kwds:
if len(key) > len(longest):
longest = key
return longest * (args[0] // len(args)), kwds[longest]
def testmeth_varargs_class_ca2(cls, q1_cls, q2_cls, *varargs_cls,
**varkw_cls):
check_argument_types()
return [
len(varargs_cls),
len(str(varargs_cls[q1_cls])), varkw_cls[q2_cls],
len(cls.__name__)
]
def testmeth_varargs_ca2(self, q1: int, q2: str, *varargs: float,
**varkw: int) -> List[int]:
check_argument_types()
return [
len(varargs),
len(str(varargs[q1])), varkw[q2],
len(self.__class__.__name__)
]
def testmeth_varargs_class_ca2(cls, q1_cls: int, q2_cls: str,
*varargs_cls: float,
**varkw_cls: int) -> List[int]:
check_argument_types()
return [
len(varargs_cls),
len(str(varargs_cls[q1_cls])), varkw_cls[q2_cls],
len(cls.__name__)
]
def testmeth_varargs_class_ca2_py2(cls, q1_cls, q2_cls, *varargs_cls,
**varkw_cls):
# actually (int, str, float, int) -> List[int]
check_argument_types()
return [
len(varargs_cls),
len(str(varargs_cls[q1_cls])), varkw_cls[q2_cls],
len(cls.__name__)
]
def testmeth_varargs_ca3b(self, q1, q2, *varargs, w1, w2, **varkw):
check_argument_types()
return [
len(varargs),
len(str(varargs[q1])), varkw[q2],
len(self.__class__.__name__),
int(w1 * w2[0]),
len(w2[1])
]
def testmeth_varargs_ca3b(self, q1, q2, *varargs, w1, w2, **varkw):
# type: (int, str, *float, float, Tuple[int, str], **int) -> List[int]
check_argument_types()
return [
len(varargs),
len(str(varargs[q1])), varkw[q2],
len(self.__class__.__name__),
int(w1 * w2[0]),
len(w2[1])
]
def testmeth_varargs_ca3(self, q1: int, q2: str, *varargs: float,
w1: float, w2: Tuple[int, str],
**varkw: int) -> List[int]:
check_argument_types()
return [
len(varargs),
len(str(varargs[q1])), varkw[q2],
len(self.__class__.__name__),
int(w1 * w2[0]),
len(w2[1])
]
def func_defaults_checkargs(a: str, b, c=4, d=2.5) -> str:
check_argument_types()
try:
return a + b * c
except TypeError:
return 'invalid'
def prop_ca1(self, *vargs_prop: str) -> None:
check_argument_types()
self._prop_ca1 = vargs_prop[0]
def prop_ca1(self) -> str:
check_argument_types()
return self._prop_ca1
def testmeth_varargs_static_ca2(q1_st: int, q2_st: str, *varargs_st: float,
**varkw_st: int) -> List[int]:
check_argument_types()
return [len(varargs_st), len(str(varargs_st[q1_st])), varkw_st[q2_st]]
def testmeth_varargs_static_ca1(*vargs_st: float) -> Tuple[int, float]:
check_argument_types()
res = 1.0
for arg in vargs_st:
res *= arg
return len(vargs_st), res
def testmeth_varargs_ca1(self, *vargs: Tuple[str, int]) -> int:
check_argument_types()
res = 1
for arg in vargs:
res += len(arg[0]) * arg[1]
return res - len(self.__class__.__name__)
def testfunc_varargs_ca6b(a1, a2, *vargss, b1, b2, **vkwds):
# type: (int, str, *float, int, str, **int) -> List[int]
check_argument_types()
return [len(vargss), len(str(vargss[a1])), vkwds[a2], b1, len(b2)]
def testfunc_varargs_ca6(a1: int, a2: str, *vargss: float, b1: int, b2: str,
**vkwds: int) -> List[int]:
check_argument_types()
return [len(vargss), len(str(vargss[a1])), vkwds[a2], b1, len(b2)]
def testprop3(self, value: Tuple[int, str]) -> None:
check_argument_types()
self._testprop3 = value
def testfunc_varargs_ca1(*argss: float) -> Tuple[int, float]:
check_argument_types()
res = 1.0
for arg in argss:
res *= arg
return len(argss), res
