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 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)
signature = inspect.signature(original)
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"{original.__name__}(") + 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 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:
(type_declared, indicator_line) = self.declared_and_indicator(err)
declared = WrappedFunction.find_location(self.fn.inner)
responsable = Location.from_stack(self.stack)
frame = Frame(
type_declared,
indicator_line,
declared=declared,
responsable=responsable,
)
err = err.with_frame(frame)
err = err.with_inverted_responsibility_type()
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"{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:
err = err.with_frame(Frame(self.name, None, None, None))
if self.upper is not None:
err = self.upper.wrap(err)
return err
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)))
