def run(self, x): # Typecheck the input and output by deferring to the typing module's method # This works for both Python's type and typing's _GenericAlias check_type("Input", x, self.Input) out = self._run(x) check_type("Output", out, self.Output) return out
def _root(self) -> Dict[str, Any]: v = super()._root() type = self.type() check_type("type", type, Optional[k8sv1.SecretType]) if type: # omit empty v["type"] = type return v
async def test_cache_instruments(dummy_instruments, loop): hw_api = await hc.API.build_hardware_simulator( attached_instruments=dummy_instruments, loop=loop) await hw_api.cache_instruments() attached = hw_api.attached_instruments typeguard.check_type('left mount dict', attached[types.Mount.LEFT], PipetteDict)
async def test_cache_instruments_hc(monkeypatch, dummy_instruments, hardware_controller_lockfile, running_on_pi, cntrlr_mock_connect, loop): hw_api_cntrlr = await hc.API.build_hardware_controller(loop=loop) def mock_driver_model(mount): attached_pipette = {'left': LEFT_PIPETTE_MODEL, 'right': None} return attached_pipette[mount] def mock_driver_id(mount): attached_pipette = {'left': LEFT_PIPETTE_ID, 'right': None} return attached_pipette[mount] monkeypatch.setattr(hw_api_cntrlr._backend._smoothie_driver, 'read_pipette_model', mock_driver_model) monkeypatch.setattr(hw_api_cntrlr._backend._smoothie_driver, 'read_pipette_id', mock_driver_id) await hw_api_cntrlr.cache_instruments() attached = hw_api_cntrlr.attached_instruments typeguard.check_type('left mount dict default', attached[types.Mount.LEFT], PipetteDict) # If we pass a conflicting expectation we should get an error with pytest.raises(RuntimeError): await hw_api_cntrlr.cache_instruments({types.Mount.LEFT: 'p300_multi'}) # If we pass a matching expects it should work await hw_api_cntrlr.cache_instruments( {types.Mount.LEFT: LEFT_PIPETTE_PREFIX}) attached = hw_api_cntrlr.attached_instruments typeguard.check_type('left mount dict after expects', attached[types.Mount.LEFT], PipetteDict)
def _function_has_keyword_parameters(func, kwargs): """ Raise `TypeError` if `func` does not accept all the keyword arguments in `kwargs`. Args: func (callable) kwargs (dict): Some keyword arguments. """ parameters = _get_function_parameters(func) has_var_keyword = any([ parameter.kind == inspect.Parameter.VAR_KEYWORD for parameter in list(parameters.values()) ]) type_hints = get_type_hints(func) for kwarg in kwargs.keys(): if not has_var_keyword and (kwarg not in parameters or parameters[kwarg].kind == inspect.Parameter.VAR_POSITIONAL): raise TypeError('Function `%s` does not accept configured parameter `%s`.' % (_get_function_signature(func), kwarg)) try: if (kwarg in parameters and parameters[kwarg].default is not inspect.Parameter.empty and isinstance(parameters[kwarg].default, _HParam)): check_type(kwarg, kwargs[kwarg], parameters[kwarg].default.type) except TypeError: raise TypeError('Function `%s` requires parameter `%s` to be of type `%s`.' % (_get_function_signature(func), kwarg, parameters[kwarg].default.type)) try: if kwarg in type_hints: check_type(kwarg, kwargs[kwarg], type_hints[kwarg]) except TypeError: raise TypeError('Function `%s` requires parameter `%s` to be of type `%s`.' % (_get_function_signature(func), kwarg, type_hints[kwarg]))
def _root(self) -> Dict[str, Any]: v = super()._root() revision = self.revision() check_type("revision", revision, Optional[int]) if revision: # omit empty v["revision"] = revision return v
def execute_action(system: 'System', driver: AppDriver, current: GUIState) -> GUIState: """ Pop action from the buffer, and execute it, update the gui state :param system: `System` object :param driver: `AppDriver` object, used to perform operations on whatsapp gui :param current: current gui state :return: resultant state of gui after action is executed """ try: action: Action = system.action_buffer.pop() except IndexError: return current meta = actions[action.name] try: check_type(action.name.name, action.data, meta.data_type) except TypeError: system.logger.warning( "Action Data Typing incorrect for {} : got {} expected {}".format( action.name, action.data, meta.data_type)) return current current = meta.run(driver, current, system, action.data) return current
def __check_attr_type(self, field: str, attribute: Any) -> int: try: field_type = self.__annotations__[field] check_type(field, attribute, field_type) except TypeError as err: raise PyNFTException(-1, str(self), str(err)) return 0
def _root(self) -> Dict[str, Any]: v = super()._root() replicas = self.replicas() check_type("replicas", replicas, Optional[int]) if replicas: # omit empty v["replicas"] = replicas return v
def sane_timing_types(job_type: JobType, timing: TimingJobUnion) -> None: """ Determine if the `JobType` is fulfilled by the type of the specified `timing`. Parameters ---------- job_type : JobType :class:`~scheduler.job.JobType` to test agains. timing : TimingJobUnion The `timing` object to be tested. Raises ------ TypeError If the `timing` object has the wrong `Type` for a specific `JobType`. """ try: tg.check_type("timing", timing, JOB_TIMING_TYPE_MAPPING[job_type]["type"]) if job_type == JobType.CYCLIC: if not len(timing) == 1: raise TypeError except TypeError as err: raise SchedulerError( JOB_TIMING_TYPE_MAPPING[job_type]["err"]) from err
def load(cls: Type[T]) -> T: """Load a section of the configuration file. To load a new section, subclass ConfigSection and document the fields that you expect to parse, e.g. @dataclass class MyConfig(ConfigSection): title = "my_config_subsection" option : str = "default value" my_config = MyConfig.load() If the package typeguard is installed type defined in the metaclass will be verified. """ schema = get_type_hints(cls) cls_fields = { f.name: schema[f.name] for f in fields(cls) if f.name != "title" } kwargs = {} for k, v in Config.load_section(cls.title).items(): if k in cls_fields: ftype = cls_fields[k] try: if CONFIG_CHECK_TYPE: check_type(f"{cls.title}.{k}", v, ftype) except TypeError as err: logging.error(str(err)) else: kwargs[k] = v return cls(**kwargs) # type: ignore
def __call__(self, *, x: float = None, y: float = None, z: float = None, distance: float = None, dx: float = None, dy: float = None, dz: float = None, scores: dict = None, tag: str = None, team: Union[str, bool] = None, limit: int = None, sort: target.sort = None, level: int = None, gamemode: Any = None, name: str = None, x_rotation: float = None, y_rotation: float = None, advancements: dict = None, nbt: dict = None): assert check_argument_types() # Check gamemode this way to avoid a circular import from . import GamemodeType check_type("gamemode", gamemode, Optional[GamemodeType])
def _root(self) -> Dict[str, Any]: v = super()._root() namespace = self.namespace() check_type("namespace", namespace, Optional[str]) if namespace: # omit empty v["namespace"] = namespace return v
def checked_cast_complex(typ: Type[T], val: V, message: Optional[str] = None) -> T: """ Cast a value to a type (with a runtime safety check). Used for subscripted generics which isinstance cannot run against. Returns the value unchanged and checks its type at runtime. This signals to the typechecker that the value has the designated type. Like `typing.cast`_ ``check_cast`` performs no runtime conversion on its argument, but, unlike ``typing.cast``, ``checked_cast`` will throw an error if the value is not of the expected type. Args: typ: the type to cast to val: the value that we are casting message: message to print on error Returns: the ``val`` argument casted to typ .. _typing.cast: https://docs.python.org/3/library/typing.html#typing.cast """ try: check_type("val", val, typ) return cast(T, val) except TypeError: raise ValueError(message or f"Value was not of type {typ}: {val}")
def _root(self) -> Dict[str, Any]: v = super()._root() image = self.image() check_type("image", image, Optional[str]) if image: # omit empty v["image"] = image return v
def _validate_argument_type(expected_type, name: str, value) -> None: if "~" in str(expected_type): # this means that we have a TypeVar type, and those require # checking all the types of all the params as a whole, but we # don't have a good way of getting right now # TODO: #165 return original_check_type = typeguard.check_type original_qualified_name = typeguard.qualified_name def wrapped_qualified_name(obj): """Needed to be able to show the useful qualified name for mock specs""" if isinstance(obj, WrappedMock): return obj.get_qualified_name() return original_qualified_name(obj) def wrapped_check_type( argname, inner_value, inner_expected_type, *args, globals: Optional[Dict[str, Any]] = None, locals: Optional[Dict[str, Any]] = None, **kwargs, ): if _is_a_mock(inner_value): inner_type = _extract_mock_template(inner_value) if inner_type is None: return # Ugly hack to make mock objects not be subclass of Mock inner_value = WrappedMock(spec=inner_type) # typeguard only checks the previous caller stack, so in order to be # able to do forward type references we have to extract the caller # stack ourselves. if kwargs.get("memo") is None and globals is None and locals is None: globals, locals = _get_caller_vars() return original_check_type( argname, inner_value, inner_expected_type, *args, globals=globals, locals=locals, **kwargs, ) with unittest.mock.patch.object( typeguard, "check_type", new=wrapped_check_type), unittest.mock.patch.object( typeguard, "qualified_name", new=wrapped_qualified_name): try: typeguard.check_type(name, value, expected_type) except TypeError as type_error: raise TypeCheckError(str(type_error))
def __setattr__(self, name: str, value: Any) -> None: """Setup new config values. Define logic when setting attributes from other subconfig class.""" if (name == "config_fields" or not self.config_fields.frozen or name in [ *self.config_fields.vars, *self.config_fields.myproperties_list, *self.config_fields.properties_list, ]): if name != "config_fields" and name in self.config_fields.types: check_type(expected_type=self.config_fields.types[name], value=value, argname=name) object.__setattr__(self, name, value) elif name in self.config_fields.base_config_map: setattr( self.config_fields.base_config_map[name], name, value, ) else: raise AttributeError( f"Object {str(self)} is frozen. New attributes cannot be set and attribute '{name}' " "not found. Maybe you misspelled name. If you really need to change the value, set " "attribute frozen to false.")
def validate(self, *, prefix=''): assert is_dataclass(self), f"You forgot to annotate {type(self)} with @dataclass" for f in fields(self): fieldval = getattr(self, f.name) check_type(prefix + f.name, fieldval, f.type) if isinstance(fieldval, HParams): fieldval.validate(prefix=prefix + f.name + '.')
def _root(self) -> Dict[str, Any]: v = super()._root() management_state = self.management_state() check_type("management_state", management_state, Optional[operatorv1.ManagementState]) if management_state: # omit empty v["managementState"] = management_state samples_registry = self.samples_registry() check_type("samples_registry", samples_registry, Optional[str]) if samples_registry: # omit empty v["samplesRegistry"] = samples_registry architectures = self.architectures() check_type("architectures", architectures, Optional[List[str]]) if architectures: # omit empty v["architectures"] = architectures skipped_imagestreams = self.skipped_imagestreams() check_type("skipped_imagestreams", skipped_imagestreams, Optional[List[str]]) if skipped_imagestreams: # omit empty v["skippedImagestreams"] = skipped_imagestreams skipped_templates = self.skipped_templates() check_type("skipped_templates", skipped_templates, Optional[List[str]]) if skipped_templates: # omit empty v["skippedTemplates"] = skipped_templates return v
def _root(self) -> Dict[str, Any]: v = super()._root() ready = self.ready() check_type("ready", ready, Optional[bool]) if ready is not None: # omit empty v["ready"] = ready return v
def check_result_or_error(cls, values): # Workaround until pydantic supports StrictUnion # https://github.com/samuelcolvin/pydantic/pull/2092 id_val = values.get('id') check_type('', id_val, Union[int, str]) return values
def _root(self) -> Dict[str, Any]: v = super()._root() webhooks = self.webhooks() check_type("webhooks", webhooks, Optional[List["ValidatingWebhook"]]) if webhooks: # omit empty v["webhooks"] = webhooks return v
def _root(self) -> Dict[str, Any]: v = super()._root() count = self.count() check_type("count", count, Optional[int]) if count is not None: # omit empty v["count"] = count return v
def new_setattr(self: klass, name: str, value: Any) -> None: """Set the value of the given attribute on self to the given value. Check representation invariants for this class when not within an instance method of the class. """ cls_annotations = typing.get_type_hints(klass) if name in cls_annotations: try: _debug( f'Checking type of attribute {attr} for {klass.__qualname__} instance' ) check_type(name, value, cls_annotations[name]) except TypeError: raise AssertionError( f'{repr(value)} did not match type annotation for attribute "{name}: {cls_annotations[name]}"' ) super(klass, self).__setattr__(name, value) curframe = inspect.currentframe() callframe = inspect.getouterframes(curframe, 2) frame_locals = callframe[1].frame.f_locals if self is not frame_locals.get('self'): # Only validating if the attribute is not being set in a instance/class method init = getattr(klass, '__init__') try: _check_invariants(self, rep_invariants, init.__globals__) except AssertionError as e: raise AssertionError(str(e)) from None
def _root(self) -> Dict[str, Any]: v = super()._root() egress_selections = self.egress_selections() check_type("egress_selections", egress_selections, List["EgressSelection"]) v["egressSelections"] = egress_selections return v
def checker(x): try: check_type('check', x, val) except TypeError: return False else: return True
def type_check(value, expected_type) -> bool: """Check that the `value` satisfies type `expected_type`.""" if is_factory_instance(value): # If `value` is a @factory instance, what's relevant is the return type # of the `build()` method: we want to check if the return type is a # sub-type of the expected type. try: # If they are both classes, this is easy... return issubclass(value.__component_factory_return_type__, expected_type) except TypeError: # ...but in general this might fail (`issubclass` can't be used with # subscripted generics in Python 3.7, or with any type from the # `typing` module in Python 3.6). If the check fails we should print # a warning and conservatively return `True`. warn( f"Unable to check that {value.__component_factory_return_type__} is a " f"sub-type of {expected_type}.") return True try: # typeguard.check_type requires a name as the first argument for their # error message, but we want to catch their error so we can pass an # empty string. typeguard.check_type("", value, expected_type) except TypeError: return False return True
def new_setattr(self: klass, name: str, value: Any) -> None: """Set the value of the given attribute on self to the given value. Check representation invariants for this class when not within an instance method of the class. """ cls_annotations = typing.get_type_hints(klass) if name in cls_annotations: try: _debug( f"Checking type of attribute {attr} for {klass.__qualname__} instance" ) check_type(name, value, cls_annotations[name]) except TypeError: raise AssertionError( f"Value {_display_value(value)} did not match type annotation for attribute " f"{name}: {_display_annotation(cls_annotations[name])}" ) from None super(klass, self).__setattr__(name, value) curframe = inspect.currentframe() callframe = inspect.getouterframes(curframe, 2) frame_locals = callframe[1].frame.f_locals if self is not frame_locals.get("self"): # Only validating if the attribute is not being set in a instance/class method klass_mod = sys.modules.get(klass.__module__) if klass_mod is not None: try: _check_invariants(self, klass, klass_mod.__dict__) except PyTAContractError as e: raise AssertionError(str(e)) from None
def _root(self) -> Dict[str, Any]: v = super()._root() partition = self.partition() check_type("partition", partition, Optional[int]) if partition is not None: # omit empty v["partition"] = partition return v
def _construct_from_json(ty, json_val, key=""): """ Construct a value of type `ty` based on the json value `json_val`. """ if json_val is None: return json_val if is_hparam_type(ty): if isinstance(json_val, ty): return json_val if not isinstance(json_val, dict): raise TypeError( f"Tried to construct attribute {key} of type {ty} with value {json_val}" ) x = ty() x.override_from_json(json_val, key=key) return x if _is_list_type(ty): subtype = ty.__args__[0] return [ _construct_from_json(subtype, y, key + ".listitem") for y in json_val ] if _is_dict_type(ty): ktype = ty.__args__[0] vtype = ty.__args__[1] return { _construct_from_json(ktype, k, key + ".dictkey"): _construct_from_json(vtype, v, key + ".dictitem") for k, v in json_val.items() } check_type(key, json_val, ty) return json_val
def match_type(value: Any, type_: Type) -> bool: try: check_type("value", value, type_, None) # type: ignore except TypeError: return False return True