From 884ff3d5bdf2c12c737f67a5e31e0dd5a21e3845 Mon Sep 17 00:00:00 2001 From: Jelle Zijlstra Date: Thu, 10 Oct 2024 18:32:26 -0700 Subject: [PATCH] Modernize representation of types --- pyanalyze/test_value.py | 31 +++++++++++++++++-------------- pyanalyze/value.py | 10 ++++------ 2 files changed, 21 insertions(+), 20 deletions(-) diff --git a/pyanalyze/test_value.py b/pyanalyze/test_value.py index 42aa4a76..b47b5cf4 100644 --- a/pyanalyze/test_value.py +++ b/pyanalyze/test_value.py @@ -204,7 +204,7 @@ def test_subclass_value() -> None: assert_can_assign(val, TypedValue(type)) assert_cannot_assign(val, SubclassValue(TypedValue(str))) val = SubclassValue(TypedValue(str)) - assert "Type[str]" == str(val) + assert str(val) == "type[str]" assert TypedValue(str) == val.typ assert val.is_type(str) assert not val.is_type(int) @@ -288,7 +288,7 @@ def test_multi_valued_value() -> None: [TypedValue(int), KnownValue(None), TypedValue(str)] ) == val | TypedValue(str) - assert "Optional[int]" == str(val) + assert str(val) == "int | None" assert_can_assign(val, KnownValue(1)) assert_can_assign(val, KnownValue(None)) assert_cannot_assign(val, KnownValue("")) @@ -299,20 +299,23 @@ def test_multi_valued_value() -> None: val, AnyValue(AnySource.marker) | TypedValue(int) | KnownValue(None) ) - assert "Literal[1, 2]" == str(KnownValue(1) | KnownValue(2)) - assert "Literal[1, 2, None]" == str( - KnownValue(1) | KnownValue(2) | KnownValue(None) + assert str(KnownValue(1) | KnownValue(2)) == "Literal[1, 2]" + assert ( + str(KnownValue(1) | KnownValue(2) | KnownValue(None)) == "Literal[1, 2, None]" ) - assert "Union[int, str]" == str(TypedValue(int) | TypedValue(str)) - assert "Union[int, str, None]" == str( - TypedValue(int) | TypedValue(str) | KnownValue(None) + assert str(TypedValue(int) | TypedValue(str)) == "int | str" + assert ( + str(TypedValue(int) | TypedValue(str) | KnownValue(None)) == "int | str | None" ) - assert "Union[int, str, Literal[1, 2], None]" == str( - TypedValue(int) - | TypedValue(str) - | KnownValue(None) - | KnownValue(1) - | KnownValue(2) + assert ( + str( + TypedValue(int) + | TypedValue(str) + | KnownValue(None) + | KnownValue(1) + | KnownValue(2) + ) + == "int | str | Literal[1, 2] | None" ) diff --git a/pyanalyze/value.py b/pyanalyze/value.py index 58a76902..91cbbdba 100644 --- a/pyanalyze/value.py +++ b/pyanalyze/value.py @@ -1923,7 +1923,7 @@ def get_type_value(self) -> Value: return AnyValue(AnySource.inference) def __str__(self) -> str: - return f"Type[{self.typ}]" + return f"type[{self.typ}]" @classmethod def make(cls, origin: Value, *, exactly: bool = False) -> Value: @@ -2087,15 +2087,13 @@ def __str__(self) -> str: body = ", ".join(repr(val.val) for val in literals) return f"Literal[{body}]" else: - if not literals and has_none and len(others) == 1: - return f"Optional[{others[0]}]" elements = [str(val) for val in others] if literals: body = ", ".join(repr(val.val) for val in literals) elements.append(f"Literal[{body}]") if has_none: elements.append("None") - return f"Union[{', '.join(elements)}]" + return " | ".join(elements) def walk_values(self) -> Iterable["Value"]: yield self @@ -2233,10 +2231,10 @@ def get_type_value(self) -> Value: def __str__(self) -> str: if self.bound is not None: - return f"{self.typevar} <: {self.bound}" + return f"{self.typevar}: {self.bound}" elif self.constraints: constraints = ", ".join(map(str, self.constraints)) - return f"{self.typevar} in ({constraints})" + return f"{self.typevar}: ({constraints})" return str(self.typevar)