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)]))
