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 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:
err = ReturnExecutionContext(self.wf).wrap(err)
if err.responsibility_type is self.invert:
return err
responsable = WrappedFunction.find_location(self.wf)
(decl, ind) = err.next_type_and_indicator()
err = err.with_inverted_responsibility_type()
err = err.with_frame(
Frame(decl,
ind,
declared=self.wf.declared(),
responsable=responsable))
inner = self.wf.inner
if isinstance(inner, WrappedFunction):
err = err.with_note(
f"The return value of method '{WrappedFunction.find_original(self.wf).__name__}' does violate the {self.wf.protocol.protocol_type()} '{self.wf.protocol.proto.__name__}'."
)
err = err.with_note(
f"The annotation '{inner.checker_for('return').describe()}' is incompatible with the {self.wf.protocol.protocol_type()}'s annotation '{self.wf.checker_for('return').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)
return err.with_previous_chain(previous_chain)
def wrap(self, err: UntypyTypeError) -> UntypyTypeError:
next_type, indicator = err.next_type_and_indicator()
err = err.with_frame(
Frame(f"list[{next_type}]", (" " * len("list[") + indicator), None,
None))
return self.upper.wrap(err)
def wrap(self, err: UntypyTypeError) -> UntypyTypeError:
(next_ty, indicator) = err.next_type_and_indicator()
return_id = IndicatorStr(next_ty, indicator)
original = WrappedFunction.find_original(self.fn)
try:
signature = inspect.signature(original) # TODO:!!! FIX BUILTINS
front_sig = []
for name in signature.parameters:
front_sig.append(
f"{name}: {self.fn.checker_for(name).describe()}")
front_sig = f"{original.__name__}(" + (
", ".join(front_sig)) + ") -> "
return_id = IndicatorStr(front_sig) + return_id
except:
return_id = IndicatorStr("???")
declared = WrappedFunction.find_location(self.fn)
return err.with_frame(
Frame(
return_id.ty,
return_id.indicator,
declared=declared,
responsable=declared,
))
def wrap(self, err: UntypyTypeError) -> UntypyTypeError:
declared = []
if isinstance(self.declared, Location):
declared.append(self.declared)
if isinstance(self.declared, list):
declared.extend(self.declared)
responsable = []
if isinstance(self.responsable, Location):
responsable.append(self.responsable)
if isinstance(self.responsable, list):
responsable.extend(self.responsable)
while len(declared) < len(responsable):
declared.append(None)
while len(declared) > len(responsable):
responsable.append(None)
for (d, r) in zip(declared, responsable):
(t, i) = err.next_type_and_indicator()
err = err.with_frame(Frame(t, i, d, r))
if self.upper_ctx is not None:
return self.upper_ctx.wrap(err)
else:
return err
def wrap(self, err: UntypyTypeError) -> UntypyTypeError:
type_declared = self.name() + "["
indicator = " " * len(type_declared)
for i, checker in enumerate(self.checkers):
if i == self.idx:
next_type, next_indicator = err.next_type_and_indicator()
type_declared += next_type
indicator += next_indicator
else:
type_declared += checker.describe()
indicator += " " * len(checker.describe())
if i != len(self.checkers) - 1: # not last element
type_declared += ", "
indicator += " "
type_declared += "]"
err = err.with_frame(
Frame(
type_declared,
indicator,
declared=self.declared(),
responsable=self.responsable(),
))
return self.upper.wrap(err)
def wrap(self, err: UntypyTypeError) -> UntypyTypeError:
t, i = err.next_type_and_indicator()
return err.with_frame(
Frame(t,
i,
responsable=Location.from_stack(self.caller),
declared=Location.from_code(self.declared)))
def wrap(self, err: UntypyTypeError) -> UntypyTypeError:
(t, i) = err.next_type_and_indicator()
return err.with_frame(
Frame(t,
i,
declared=None,
responsable=Location(file="dummy", line_no=0, line_span=1)))
def wrap(self, err: UntypyTypeError) -> UntypyTypeError:
(nt, ni) = err.next_type_and_indicator()
if nt == err.expected and nt == self.bv.inner.describe():
err.expected = self.bv.describe()
err.expected_indicator = "^" * len(self.bv.describe())
return self.upper.wrap(err)
def check(self, arg: Any, ctx: ExecutionContext) -> None:
res = self.callable(arg)
if not res:
exp = self.annotated.describe()
# raise error on falsy value
err = UntypyTypeError(given=arg, expected=exp)
if self.annotated.is_anonymous:
err = err.with_note(f"condition in {exp} does not hold")
(t, i) = err.next_type_and_indicator()
for info in self.annotated.info:
err = err.with_note(" - " + info)
raise ctx.wrap(err)
def wrap(self, err: UntypyTypeError) -> UntypyTypeError:
offset = self.ch.describe().find("[") + 1
(t, i) = err.next_type_and_indicator()
err = err.with_frame(
Frame(type_declared=self.ch.describe(),
indicator_line=(" " * offset) + i,
declared=None,
responsable=None))
return self.upper.wrap(err)
def wrap(self, err: UntypyTypeError) -> UntypyTypeError:
(next_ty, indicator) = err.next_type_and_indicator()
error_id = IndicatorStr(next_ty, indicator)
original = WrappedFunction.find_original(self.fn)
try:
signature = inspect.signature(original)
except ValueError:
# fails on some built-ins
signature = inspect.signature(self.fn)
wf = None
if (hasattr(self.fn, '__wf')):
wf = getattr(self.fn, '__wf')
elif isinstance(self.fn, WrappedFunction):
wf = self.fn
arglist = []
for name in signature.parameters:
if name is self.argument_name:
arglist.append(IndicatorStr(f"{name}: ") + error_id)
else:
if wf is not None:
arglist.append(
IndicatorStr(
f"{name}: {wf.checker_for(name).describe()}"))
else:
arglist.append(IndicatorStr(f"{name}"))
id = IndicatorStr(f"{format_name(original)}(") + IndicatorStr(
", ").join(arglist)
if wf is not None:
id += IndicatorStr(f") -> {wf.checker_for('return').describe()}")
else:
id += IndicatorStr(f")")
if self.declared is None:
declared = WrappedFunction.find_location(self.fn)
else:
declared = self.declared
if self.stack is not None:
responsable = Location.from_stack(self.stack)
else:
responsable = None
frame = Frame(id.ty,
id.indicator,
declared=declared,
responsable=responsable)
return err.with_frame(frame)
def wrap(self, err: UntypyTypeError) -> UntypyTypeError:
desc = lambda s: s.describe()
front_str = f"Callable[[{', '.join(map(desc, self.fn.argument_checker))}], "
responsable = WrappedFunction.find_location(self.fn.inner)
if self.invert:
(next_ty, indicator) = err.next_type_and_indicator()
err = ReturnExecutionContext(self.fn.inner).wrap(err)
err = err.with_frame(
Frame(f"{front_str}{next_ty}]",
(" " * len(front_str)) + indicator,
declared=None,
responsable=responsable))
err = err.with_inverted_responsibility_type()
return self.upper.wrap(err)
(next_ty, indicator) = err.next_type_and_indicator()
err = err.with_frame(
Frame(f"{front_str}{next_ty}]", (" " * len(front_str)) + indicator,
declared=None,
responsable=responsable))
return self.upper.wrap(err)
def declared_and_indicator(self, err: UntypyTypeError) -> Tuple[str, str]:
(next_ty, indicator) = err.next_type_and_indicator()
front_types = []
back_types = []
for n, ch in enumerate(self.fn.argument_checker):
if n < self.argument_num:
front_types.append(ch.describe())
elif n > self.argument_num:
back_types.append(ch.describe())
l = len(f"Callable[[{', '.join(front_types)}")
if len(front_types) > 0:
l += len(', ')
return f"Callable[[{', '.join(front_types + [next_ty] + back_types)}], {self.fn.return_checker.describe()}]", \
(" " * l) + indicator
def check(self, arg: Any, ctx: ExecutionContext) -> None:
res = self.callable(arg)
if not res:
# raise error on falsy value
err = UntypyTypeError(given=arg,
expected=self.annotated.describe())
err = err.with_note(
f"\n\nNote: Assertion in Callable failed with {repr(res)}.")
(t, i) = err.next_type_and_indicator()
err = err.with_frame(
Frame(t, i, WrappedFunction.find_location(self.callable),
None))
for info in self.annotated.info:
err = err.with_note(" - " + info)
raise ctx.wrap(err)
def wrap(self, err: UntypyTypeError) -> UntypyTypeError:
(next_ty, indicator) = err.next_type_and_indicator()
return_id = IndicatorStr(next_ty, indicator)
original = WrappedFunction.find_original(self.fn)
try:
signature = inspect.signature(original) # TODO:!!! FIX BUILTINS
front_sig = []
for name in signature.parameters:
front_sig.append(
f"{name}: {self.fn.checker_for(name).describe()}")
front_sig = f"{format_name(original)}(" + (
", ".join(front_sig)) + ") -> "
return_id = IndicatorStr(front_sig) + return_id
except:
return_id = IndicatorStr("???")
declared = WrappedFunction.find_location(self.fn)
responsable = declared
if responsable is not None:
if err.expected is not None and err.given is None:
# Missing Return-Value?
err = err.with_note("Did you miss a return statement?")
last_line = responsable.line_no + responsable.line_span - 1
responsable = responsable.narrow_in_span(
(responsable.file, last_line))
else:
responsable = responsable.narrow_in_span(self.reti_loc)
return err.with_frame(
Frame(
return_id.ty,
return_id.indicator,
declared=declared,
responsable=responsable,
))
def wrap(self, err: UntypyTypeError) -> UntypyTypeError:
next_type, indicator = err.next_type_and_indicator()
return err.with_frame(
Frame(f"list[{next_type}]", (" " * len("list[") + indicator),
declared=self.declared,
responsable=Location.from_stack(self.stack)))