def wrap(self, err: UntypyTypeError) -> UntypyTypeError: (original_expected, _ind) = err.next_type_and_indicator() err = ArgumentExecutionContext(self.wf, None, self.arg_name).wrap(err) responsable = WrappedFunction.find_location(self.wf) (decl, ind) = err.next_type_and_indicator() err = err.with_frame( Frame(decl, ind, declared=self.wf.declared(), responsable=responsable)) err = err.with_note( f"The argument '{self.arg_name}' of method '{WrappedFunction.find_original(self.wf).__name__}' violates the {self.wf.protocol.protocol_type()} '{self.wf.protocol.proto.__name__}'." ) err = err.with_note( f"The annotation '{original_expected}' is incompatible with the {self.wf.protocol.protocol_type()}'s annotation '{self.wf.checker_for(self.arg_name).describe()}'\nwhen checking against the following value:" ) previous_chain = UntypyTypeError( self.me, f"{self.wf.protocol.protoname()}" ).with_note( f"Type '{type(self.me).__name__}' does not implement {self.wf.protocol.protocol_type()} '{self.wf.protocol.protoname()}' correctly." ) previous_chain = self.ctx.wrap(previous_chain) # err = err.with_inverted_responsibility_type() return err.with_previous_chain(previous_chain)
def wrap(self, err: UntypyTypeError) -> UntypyTypeError: (original_expected, _ind) = err.next_type_and_indicator() err = ArgumentExecutionContext(self.wf, None, self.arg_name).wrap(err) responsable = WrappedFunction.find_location(self.wf) (decl, ind) = err.next_type_and_indicator() err = err.with_frame( Frame(decl, ind, declared=self.wf.declared(), responsable=responsable)) err = err.with_note( f"Argument {self.arg_name} of method {WrappedFunction.find_original(self.wf).__name__} violates the type declared by the {self.wf.protocol.protocol_type()} {self.wf.protocol.proto.__name__}." ) err = err.with_note( f"Annotation {original_expected} is incompatible with the {self.wf.protocol.protocol_type()}'s annotation {self.wf.checker_for(self.arg_name).describe()}." ) previous_chain = UntypyTypeError( self.me, f"{self.wf.protocol.protoname()}" ).with_header( f"{type(self.me).__name__} does not implement {self.wf.protocol.protocol_type()} {self.wf.protocol.protoname()} correctly." ) previous_chain = self.ctx.wrap(previous_chain) # err = err.with_inverted_responsibility_type() return err.with_previous_chain(previous_chain)
def wrap(self, err: UntypyTypeError) -> UntypyTypeError: (original_expected, _ind) = err.next_type_and_indicator() err = ArgumentExecutionContext(self.tc.inner, None, self.arg_name).wrap(err) func_decl = WrappedFunction.find_location(self.tc.inner) name = WrappedFunction.find_original(self.tc.inner).__name__ (decl, ind) = err.next_type_and_indicator() err = err.with_frame( Frame(decl, ind, declared=None, responsable=func_decl)) previous_chain = UntypyTypeError( f"def {name}{self.tc.inner.describe()}", f"{self.tc.describe()}") (decl, ind) = previous_chain.next_type_and_indicator() previous_chain = previous_chain.with_frame( Frame(decl, ind, declared=func_decl, responsable=None)) err = err.with_note( f"The argument '{self.arg_name}' of method '{name}' violates the signature of {self.tc.describe()}." ) previous_chain = self.upper.wrap(previous_chain) return err.with_previous_chain(previous_chain)
def wrapper(*args, **kwargs): # first is this fn caller = sys._getframe(1) (args, kwargs, bindings) = self.wrap_arguments(lambda n: ArgumentExecutionContext(self, caller, n), args, kwargs) ret = self.inner(*args, **kwargs) ret = self.wrap_return(ret, bindings, ReturnExecutionContext(self)) return ret
def wrapper_cls(*args, **kwargs): caller = sys._getframe(1) (args, kwargs, bindings) = self.wrap_arguments( lambda n: ArgumentExecutionContext( self, caller, n, declared=self.declared()), args, kwargs) ret = fn(*args, **kwargs) return self.wrap_return(ret, bindings, ReturnExecutionContext(self))
def wrapper_self(me, *args, **kwargs): if name == '__init__': me.__return_ctx = None me.__inner = self.create_fn() caller = sys._getframe(1) (args, kwargs, bindings) = self.wrap_arguments( lambda n: ArgumentExecutionContext( wrapper_self, caller, n, declared=self.declared()), (me.__inner, *args), kwargs) ret = fn(*args, **kwargs) if me.__return_ctx is None: return self.wrap_return(ret, bindings, ReturnExecutionContext(self)) else: return self.wrap_return(ret, bindings, me.__return_ctx)
def wrapper(me, *args, **kwargs): inner_object = me.__inner inner_ctx = me.__ctx caller = sys._getframe(1) (args, kwargs, bind1) = self.wrap_arguments( lambda n: ArgumentExecutionContext(fn_of_protocol, caller, n), (inner_object, *args), kwargs) if isinstance(self.inner, WrappedFunction): (args, kwargs, bind2) = self.inner.wrap_arguments( lambda n: ProtocolArgumentExecutionContext( self, n, inner_object, inner_ctx), args, kwargs) ret = fn(*args, **kwargs) if isinstance(self.inner, WrappedFunction): ret = self.inner.wrap_return( ret, bind2, ProtocolReturnExecutionContext(self, ResponsibilityType.IN, inner_object, inner_ctx)) return self.wrap_return( ret, bind1, ProtocolReturnExecutionContext(self, ResponsibilityType.OUT, inner_object, inner_ctx))