def test_typechecked_no_annotations(self, recwarn): def foo(a, b): pass typechecked(foo) func_name = function_name(foo) assert len(recwarn) == 1 assert str(recwarn[0].message) == ( 'no type annotations present -- not typechecking {}'.format(func_name))
def __new__(cls, name: str, bases: Any, dct: Dict[Any, Any]) -> type: # type: ignore newly = super().__new__(cls, name, bases, dct) if _has_type_annotations(newly.__init__): # type: ignore newly.__init__ = typechecked(always=True)( newly.__init__) # type: ignore if hasattr(newly, '__call__') and _has_type_annotations( newly.__call__): newly.__call__ = typechecked(always=True)( newly.__call__) # type: ignore if hasattr(newly, 'can_process') and _has_type_annotations( newly.can_process): # type: ignore newly.can_process = typechecked(always=True)( newly.can_process) # type: ignore return newly
def typechecked_compatible(function): """Turns off type checking for old incompatible python versions. Mainly for new syntax like list[str] which raise TypeError. """ if sys.version_info.minor < 9: return function return typechecked(function)
def register_method(self, method_name: str, func: Callable): """ Register FastRPC method :param method_name: Name of the method - how it will be called from the outside :param func: The function that will handle that call """ if self.enforce_types: self.methods[method_name] = typechecked(func) else: self.methods[method_name] = func
def typecheck_wrap(*args: Any, **kwargs: Any) -> Any: from hpc.autoscale.node.node import Node # noqa from hpc.autoscale.node.bucket import NodeBucket # noqa from hpc.autoscale.job.job import Job # noqa # let's not require that this is installed unless # they turn on runtime type checking from typeguard import typechecked return typechecked(function)(*args, **kwargs)
def decorator(fn: Callable[..., Any]) -> Callable[..., Any]: method_name = fn.__name__ if not name else name if validate and not self._validate(fn): raise ValueError('no type annotations present to: {0}'.format(method_name)) fn_annotations = get_type_hints(fn) fn.jsonrpc_method_name = method_name # type: ignore fn.jsonrpc_method_sig = fn_annotations # type: ignore fn.jsonrpc_method_return = fn_annotations.pop('return', None) # type: ignore fn.jsonrpc_method_params = fn_annotations # type: ignore fn.jsonrpc_validate = validate # type: ignore fn.jsonrpc_options = options # type: ignore fn_wrapped = typechecked(fn) if validate else fn self.get_jsonrpc_site().register(method_name, fn_wrapped) return fn_wrapped
def register_view_function(self, view_func: Callable[..., Any], name: Optional[str] = None, validate: bool = True, **options: Any) -> Callable[..., Any]: fn = self._get_function(view_func) fn_annotations = get_type_hints(fn) method_name = getattr(fn, '__name__', '<noname>') if not name else name setattr(fn, 'jsonrpc_method_name', method_name) setattr(fn, 'jsonrpc_method_sig', fn_annotations) setattr(fn, 'jsonrpc_method_return', fn_annotations.pop('return', None)) setattr(fn, 'jsonrpc_method_params', fn_annotations) setattr(fn, 'jsonrpc_validate', validate) setattr(fn, 'jsonrpc_options', options) view_func_wrapped = typechecked(view_func) if validate else view_func self.get_jsonrpc_site().register(method_name, view_func_wrapped) return view_func_wrapped
def __call__(cls, *args, **kwargs): """this is called every time we create an instance of the class """ #======================================== # Enforce instance attribute types if args: raise ValueError("Only Keyword Argumetns are accepted") sig = signature(cls.__init__) for kw in kwargs: if not kwargs.get(kw, False): raise AttributeError(f"Must set attribute: <{kw}>") model_dict = { kw: (sig.parameters[kw].annotation, ...) for kw in kwargs } Model = create_model("Test", **model_dict) try: validated = Model(**{kw: val for kw, val in kwargs.items()}) kwargs = validated.dict() except ValidationError as e: raise e except Exception as e: raise e #======================================== # Enforce instance method annotations # get only functions defined in class that are not builtins funcs = { k: v for k, v in dict(inspect.getmembers(cls)).items() if not k.startswith("__") and callable(v) } # wrap every user function with <typechecked> decorator for name, obj in funcs.items(): setattr(cls, name, typechecked(obj)) return super().__call__(*args, **kwargs)
def wrapped(self): if self._wrapped is None: self._wrapped = typeguard.typechecked(self.func) return self._wrapped
def get_typechecked_f_and_hintcount(f): hintcount = get_type_hint_count(f) typechecked_f = typechecked(f, always=True) return typechecked_f, hintcount
def decorator(*args: Tuple[Any, ...], **kwargs: Any) -> type: if prohibit_args: check_args(*args, **kwargs) return typechecked(decorated)(*args, **kwargs)
def __init__(self) -> None: self.pull = typechecked(always=True)(self.pull) # type: ignore