def dict_incomplete_value(): incomplete_value = {"a": str(TD)} assert_is_value( incomplete_value, DictIncompleteValue([(KnownValue("a"), TypedValue(str))]), ) assert_is_value(incomplete_value.setdefault("b"), KnownValue(None)) assert_is_value( incomplete_value, DictIncompleteValue([ (KnownValue("a"), TypedValue(str)), (KnownValue("b"), KnownValue(None)), ]), ) assert_is_value( incomplete_value.setdefault("a"), MultiValuedValue([KnownValue(None), TypedValue(str)]), ) assert_is_value( incomplete_value, DictIncompleteValue([ (KnownValue("a"), TypedValue(str)), (KnownValue("b"), KnownValue(None)), (KnownValue("a"), KnownValue(None)), ]), )
def capybara(cond): if cond: lst = [1 for _ in range(3)] else: lst = [2 for _ in range(3)] assert_is_value( lst, MultiValuedValue([ make_weak(GenericValue(list, [KnownValue(1)])), make_weak(GenericValue(list, [KnownValue(2)])), ]), ) lst.extend([3, 4]) # TODO: this is wrong; it drops all but the last Union member assert_is_value( lst, make_weak( GenericValue( list, [ MultiValuedValue( [KnownValue(2), KnownValue(3), KnownValue(4)]) ], )), )
def capybara(cond): if cond: template = "{a} {b}" else: template = "{a} {b} {c}" string = template.format(a="a", b="b", c="c") assert_is_value(string, TypedValue(str))
def weak_typed(): weak_dict = {i: str(i) for i in range(5)} assert_is_value( weak_dict, make_weak( GenericValue( dict, [TypedValue(int), TypedValue(str)])), ) assert_is_value(weak_dict.setdefault(3, str(TD)), TypedValue(str)) int_or_3 = MultiValuedValue([TypedValue(int), KnownValue(3)]) assert_is_value( weak_dict, make_weak(GenericValue(dict, [int_or_3, TypedValue(str)]))) assert_is_value( weak_dict.setdefault(3), MultiValuedValue([TypedValue(str), KnownValue(None)]), ) assert_is_value( weak_dict, make_weak( GenericValue( dict, [ int_or_3, MultiValuedValue( [TypedValue(str), KnownValue(None)]), ], )), )
def capybara(arg) -> None: lst1: List[Literal["a"]] = ["a" for _ in arg] lst2 = [*lst1, "b"] assert_is_value( lst2, make_weak( GenericValue( list, [MultiValuedValue([KnownValue("a"), KnownValue("b")])])), ) lst2.append("c") assert_is_value( lst2, make_weak( GenericValue( list, [ MultiValuedValue([ KnownValue("a"), KnownValue("b"), KnownValue("c") ]) ], )), )
def capybara(x: int, y: str) -> None: lst = [x] assert_is_value(lst, SequenceIncompleteValue(list, [TypedValue(int)])) lst.extend([y]) assert_is_value( lst, SequenceIncompleteValue( list, [TypedValue(int), TypedValue(str)])) # If we extend with a set, don't use a SequenceIncompleteValue any more, # because we don't know how many values were added or in what order. # (Technically we do know for a one-element set, but that doesn't seem worth # writing a special case for.) lst.extend({float(1.0)}) assert_is_value( lst, make_weak( GenericValue( list, [ MultiValuedValue([ TypedValue(int), TypedValue(str), TypedValue(float) ]) ], )), ) lst: List[int] = [3] assert_is_value(lst, GenericValue(list, [TypedValue(int)])) lst.extend([x]) assert_is_value(lst, GenericValue(list, [TypedValue(int)]))
def strong_typed(strong_dict: Dict[int, str]): expected = GenericValue(dict, [TypedValue(int), TypedValue(str)]) assert_is_value(strong_dict, expected) assert_is_value(strong_dict.setdefault(3, str(TD)), TypedValue(str)) assert_is_value(strong_dict, expected) assert_is_value( strong_dict.setdefault(3), MultiValuedValue([TypedValue(str), KnownValue(None)]), ) assert_is_value(strong_dict, expected)
def capybara(cond): lst = () if cond else (1, ) assert_is_value( lst, MultiValuedValue([KnownValue(()), KnownValue((1, ))])) if len(lst) == 1: assert_is_value(lst, KnownValue((1, ))) else: assert_is_value(lst, KnownValue(())) if len(lst) > 0: assert_is_value(lst, KnownValue((1, ))) else: assert_is_value(lst, KnownValue(()))
def capybara(td: TD, dct: Dict[str, int], rev: ReversedDict[str, int]): d = {1: 2} assert_is_value(d[1], KnownValue(2)) assert_is_value(td["a"], TypedValue(int)) assert_is_value(dct["key"], TypedValue(int)) assert_is_value(rev[1], TypedValue(str))
def capybara() -> None: lst = ["a", "b"] assert_is_value(lst, KnownValue(["a", "b"])) lst.extend(func()) assert_is_value( lst, make_weak( GenericValue( list, [ MultiValuedValue([ KnownValue("a"), KnownValue("b"), KnownValue("c"), KnownValue("d"), ]) ], )), ) lst.extend(["e"]) assert_is_value( lst, make_weak( GenericValue( list, [ MultiValuedValue([ KnownValue("a"), KnownValue("b"), KnownValue("c"), KnownValue("d"), KnownValue("e"), ]) ], )), ) lst.append("f") assert_is_value( lst, make_weak( GenericValue( list, [ MultiValuedValue([ KnownValue("a"), KnownValue("b"), KnownValue("c"), KnownValue("d"), KnownValue("e"), KnownValue("f"), ]) ], )), )
def capybara(x: int, y: str) -> None: assert_is_value( [x] + [y], SequenceIncompleteValue( list, [TypedValue(int), TypedValue(str)]), ) assert_is_value( [x] + [1], SequenceIncompleteValue( list, [TypedValue(int), KnownValue(1)]), ) left: List[int] = [] right: List[str] = [] assert_is_value( left + right, GenericValue( list, [MultiValuedValue([TypedValue(int), TypedValue(str)])]), ) assert_is_value(left + left, GenericValue(list, [TypedValue(int)])) union_list1 = left if x else right union_list2 = left if y else right assert_is_value( # need to call list.__add__ directly because we just give up on unions # in the binop implementation list.__add__(union_list1, union_list2), MultiValuedValue([ GenericValue(list, [TypedValue(int)]), GenericValue( list, [MultiValuedValue([TypedValue(int), TypedValue(str)])]), GenericValue( list, [MultiValuedValue([TypedValue(str), TypedValue(int)])]), GenericValue(list, [TypedValue(str)]), ]), )
def capybara(x: int): lst = {x} assert_is_value(lst, SequenceIncompleteValue(set, [TypedValue(int)])) lst.add(1) assert_is_value( lst, SequenceIncompleteValue( set, [TypedValue(int), KnownValue(1)])) lst: Set[str] = {"x"} assert_is_value(lst, GenericValue(set, [TypedValue(str)])) lst.add("y") assert_is_value(lst, GenericValue(set, [TypedValue(str)]))
def capybara(x: type, y): assert_is_value(x, TypedValue(type)) if issubclass(x, str): assert_is_value(x, SubclassValue(TypedValue(str))) if issubclass(y, (int, str)): assert_is_value( y, MultiValuedValue([ SubclassValue(TypedValue(int)), SubclassValue(TypedValue(str)) ]), )
def capybara(x: int, y: str) -> None: dct = {} assert_is_value(dct, KnownValue({})) dct["x"] = x assert_is_value( dct, DictIncompleteValue([(KnownValue("x"), TypedValue(int))])) dct[y] = "x" assert_is_value( dct, DictIncompleteValue([ (KnownValue("x"), TypedValue(int)), (TypedValue(str), KnownValue("x")), ]), )
def capybara(val: Value) -> None: reveal_type(dump_value) # E: inference_failure dump_value(reveal_type) # E: inference_failure assert_is_value(1, KnownValue(1)) assert_is_value(1, KnownValue(2)) # E: inference_failure assert_is_value(1, val) # E: inference_failure
def capybara(s: str, b: bytes): assert_is_value(s.encode("utf-8"), TypedValue(bytes)) assert_is_value(b.decode("utf-8"), TypedValue(six.text_type))
def capybara(a: int, unresolved): incomplete_value = {a: 1, "b": 2, "c": "s"} assert_is_value( incomplete_value, DictIncompleteValue([ (TypedValue(int), KnownValue(1)), (KnownValue("b"), KnownValue(2)), (KnownValue("c"), KnownValue("s")), ]), ) assert_is_value(incomplete_value["b"], KnownValue(2)) assert_is_value(incomplete_value[1], KnownValue(1)) assert_is_value( incomplete_value[unresolved], MultiValuedValue( [KnownValue(1), KnownValue(2), KnownValue("s")]), ) # unknown key assert_is_value(incomplete_value["other string"], UNRESOLVED_VALUE) # MultiValuedValue key = "b" if unresolved else "c" assert_is_value( incomplete_value[key], MultiValuedValue([KnownValue(2), KnownValue("s")]), )
def capybara(x): assert_is_value(len("a"), KnownValue(1)) assert_is_value(len(list(x)), TypedValue(int)) # if we don't know the type, there should be no error len(x)
def capybara(): assert_is_value(cast(str, 1), TypedValue(str)) assert_is_value(cast("str", 1), TypedValue(str)) assert_is_value(cast("List[str]", 1), GenericValue(list, [TypedValue(str)]))
def capybara(typ: type): assert_is_value(typ.__subclasses__(), GenericValue(list, [TypedValue(type)])) assert_is_value(Parent.__subclasses__(), KnownValue([Child]))
def typeddict(td: TD): td.setdefault({}) # E: unhashable_key td.setdefault(0) # E: invalid_typeddict_key td.setdefault("c") # E: invalid_typeddict_key td.setdefault("a", "s") # E: incompatible_argument assert_is_value(td.setdefault("b", "x"), TypedValue(str))
def capybara(x: int): lst = [x] assert_is_value(lst, SequenceIncompleteValue(list, [TypedValue(int)])) lst.append(1) assert_is_value( lst, SequenceIncompleteValue( list, [TypedValue(int), KnownValue(1)])) lst: List[str] = ["x"] assert_is_value(lst, GenericValue(list, [TypedValue(str)])) lst.append("y") assert_is_value(lst, GenericValue(list, [TypedValue(str)])) lst = ["x"] assert_is_value(lst, KnownValue(["x"])) lst.append(3) assert_is_value( lst, SequenceIncompleteValue( list, [KnownValue("x"), KnownValue(3)]))
def capybara(): lst: List[str] = ["x"] assert_is_value(lst, GenericValue(list, [TypedValue(str)])) lst.append(1)
def capybara(): assert_is_value("{}".format(0), TypedValue(str)) assert_is_value("{x}".format(x=0), TypedValue(str)) assert_is_value("{} {x.imag!r:.2d}".format(0, x=0), TypedValue(str)) assert_is_value("{x[0]} {y[x]}".format(x=[0], y={"x": 0}), TypedValue(str)) assert_is_value("{{X}} {}".format(0), TypedValue(str)) assert_is_value("{0:.{1:d}e}".format(0, 1), TypedValue(str)) assert_is_value("{:<{width}}".format("", width=1), TypedValue(str))
def capybara(o: object) -> None: assert_is_value(o, TypedValue(object)) if callable(o): assert_is_value(o, CallableValue(ANY_SIGNATURE))
def capybara(o: object) -> None: assert_is_value(o, TypedValue(object)) if inspect.isfunction(o): assert_is_value(o, TypedValue(FunctionType))
def capybara(x): # no arguments assert_is_value(set(), KnownValue(set())) assert_is_value(list(), KnownValue([])) # KnownValue assert_is_value(tuple([1, 2, 3]), KnownValue((1, 2, 3))) # Comprehensions one_two = MultiValuedValue([KnownValue(1), KnownValue(2)]) assert_is_value(tuple(i for i in (1, 2)), GenericValue(tuple, [one_two])) assert_is_value(tuple({i: i for i in (1, 2)}), GenericValue(tuple, [one_two])) # SequenceIncompleteValue assert_is_value(tuple([int(x)]), SequenceIncompleteValue(tuple, [TypedValue(int)])) # fallback assert_is_value(tuple(x), TypedValue(tuple)) # argument that is iterable but does not have __iter__ assert_is_value(tuple(str(x)), GenericValue(tuple, [TypedValue(str)]))