def check_CLIActionType_type(func: CLIActionType) -> None: """ Check that the given CLIActionType obeys its function type signature. Raises TypeError if the function is of the incorrect type. """ config_check = check_function_type(func, [HammerDriver, Callable[[str], None]], Optional[dict]) if config_check is None: return string_check = check_function_type(func, [HammerDriver, Callable[[str], None]], Optional[str]) if string_check is None: return raise TypeError( "func does not appear to be a CLIActionType. Check for config returned {config}; check for string returned {string}".format( config=config_check, string=string_check))
def check_CLIActionType_type(func: CLIActionType) -> None: """ Check that the given CLIActionType obeys its function type signature. Raises TypeError if the function is of the incorrect type. """ config_check = check_function_type(func, [HammerDriver, Callable[[str], None]], Optional[dict]) if config_check is None: return string_check = check_function_type(func, [HammerDriver, Callable[[str], None]], Optional[str]) if string_check is None: return raise TypeError( "func does not appear to be a CLIActionType. Check for config returned {config}; check for string returned {string}" .format(config=config_check, string=string_check))
def test_check_function_type(self) -> None: def test1(x: int) -> str: return str(x + 5) check_function_type(test1, [int], str) def test2(a: int, b: float) -> None: print("{a}{b}".format(a=a, b=b)) check_function_type(test2, [int, float], None) # type: ignore def test3(a: int, b: int) -> List[int]: return [a, b] check_function_type(test3, [int, int], List[int]) def test4(a: int, b: int) -> List[int]: return [a, b] check_function_type(test4, [int, int], List[int]) # Check that dict == typing.Dict, etc. def test5(a: int) -> dict: return {"a": a} check_function_type(test5, [int], Dict) # Check that dict == typing.Dict, etc. def test6(a: int) -> Optional[dict]: return {"a": a} check_function_type(test6, [int], Optional[Dict]) with self.assertRaises(TypeError): # Different # of arguments check_function_type(test1, [int, int], str) with self.assertRaises(TypeError): # Different return type check_function_type(test1, [int], bool) with self.assertRaises(TypeError): # Different argument type check_function_type(test1, [str], str) with self.assertRaises(TypeError): # Different # of arguments and different return type check_function_type(test3, [int], bool) with self.assertRaises(TypeError): # Entirely different check_function_type(test3, [], dict)
def test_check_function_type(self) -> None: def test1(x: int) -> str: return str(x + 5) assert_function_type(test1, [int], str) def test2(a: int, b: float) -> None: print("{a}{b}".format(a=a, b=b)) assert_function_type(test2, [int, float], None) # type: ignore def test3(a: int, b: int) -> List[int]: return [a, b] assert_function_type(test3, [int, int], List[int]) def test4(a: int, b: int) -> List[int]: return [a, b] assert_function_type(test4, [int, int], List[int]) # Check that dict == typing.Dict, etc. def test5(a: int) -> dict: return {"a": a} assert_function_type(test5, [int], Dict) # Check that dict == typing.Dict, etc. def test6(a: int) -> Optional[dict]: return {"a": a} assert_function_type(test6, [int], Optional[Dict]) # Check that Union types get handled properly. def test7(a: Union[int, float]) -> Union[bool, str]: return str(a) assert_function_type(test7, [Union[int, float]], Union[bool, str]) # Check that stringly-typed annotations work. def test8(a: "int") -> "list": return [a + a] assert_function_type(test8, ["int"], "list") # type: ignore assert_function_type(test8, ["int"], list) # type: ignore assert_function_type(test8, [int], "list") # type: ignore assert_function_type(test8, [int], list) # Check that untyped arguments don't crash. def test9(x) -> str: return str(x) test9_return = check_function_type(test9, [int], str) assert test9_return is not None self.assertTrue("incorrect signature" in test9_return) with self.assertRaises(TypeError): # Different # of arguments assert_function_type(test1, [int, int], str) with self.assertRaises(TypeError): # Different return type assert_function_type(test1, [int], bool) with self.assertRaises(TypeError): # Different argument type assert_function_type(test1, [str], str) with self.assertRaises(TypeError): # Different # of arguments and different return type assert_function_type(test3, [int], bool) with self.assertRaises(TypeError): # Entirely different assert_function_type(test3, [], dict)
def is_string_action(func: CLIActionType) -> bool: """Return True if the given function is a CLIActionConfigType.""" return check_function_type(func, [HammerDriver, Callable[[str], None]], Optional[str]) is None
def test_check_function_type(self) -> None: def test1(x: int) -> str: return str(x + 5) assert_function_type(test1, [int], str) def test2(a: int, b: float) -> None: print("{a}{b}".format(a=a, b=b)) assert_function_type(test2, [int, float], None) # type: ignore def test3(a: int, b: int) -> List[int]: return [a, b] assert_function_type(test3, [int, int], List[int]) def test4(a: int, b: int) -> List[int]: return [a, b] assert_function_type(test4, [int, int], List[int]) # Check that dict == typing.Dict, etc. def test5(a: int) -> dict: return {"a": a} assert_function_type(test5, [int], Dict) # Check that dict == typing.Dict, etc. def test6(a: int) -> Optional[dict]: return {"a": a} assert_function_type(test6, [int], Optional[Dict]) # Check that Union types get handled properly. def test7(a: Union[int, float]) -> Union[bool, str]: return str(a) assert_function_type(test7, [Union[int, float]], Union[bool, str]) # Check that stringly-typed annotations work. def test8(a: "int") -> "list": return [a + a] assert_function_type(test8, ["int"], "list") # type: ignore assert_function_type(test8, ["int"], list) # type: ignore assert_function_type(test8, [int], "list") # type: ignore assert_function_type(test8, [int], list) # Check that untyped arguments don't crash. def test9(x) -> str: return str(x) test9_return = check_function_type(test9, [int], str) assert test9_return is not None self.assertTrue("incorrect signature" in test9_return) with self.assertRaises(TypeError): # Different # of arguments assert_function_type(test1, [int, int], str) with self.assertRaises(TypeError): # Different return type assert_function_type(test1, [int], bool) with self.assertRaises(TypeError): # Different argument type assert_function_type(test1, [str], str) with self.assertRaises(TypeError): # Different # of arguments and different return type assert_function_type(test3, [int], bool) with self.assertRaises(TypeError): # Entirely different assert_function_type(test3, [], dict)
def is_string_action(func: CLIActionType) -> bool: """Return True if the given function is a CLIActionConfigType.""" return check_function_type(func, [HammerDriver, Callable[[str], None]], Optional[str]) is None