Use the built-in list instead of List, etc

Author: nedtwigg

python/selfie-lib/selfie_lib/ArrayMap.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import ItemsView, Iterator, Mapping, Set
-from typing import Any, List, Tuple, TypeVar, Union
+from typing import Any, TypeVar, Union
 
 T = TypeVar("T")
 V = TypeVar("V")
@@ -44,7 +44,7 @@ class ListBackedSet(Set[T], ABC):
     def __len__(self) -> int: ...
 
     @abstractmethod
-    def __getitem__(self, index: Union[int, slice]) -> Union[T, List[T]]: ...
+    def __getitem__(self, index: Union[int, slice]) -> Union[T, list[T]]: ...
 
     @abstractmethod
     def __iter__(self) -> Iterator[T]: ...
@@ -57,13 +57,13 @@ def _binary_search(self, item: Any) -> int:
 
 
 class ArraySet(ListBackedSet[K]):
-    __data: List[K]
+    __data: list[K]
 
     def __init__(self):
         raise NotImplementedError("Use ArraySet.empty() or other class methods instead")
 
     @classmethod
-    def __create(cls, data: List[K]) -> "ArraySet[K]":
+    def __create(cls, data: list[K]) -> "ArraySet[K]":
         instance = super().__new__(cls)
         instance.__data = data  # noqa: SLF001
         return instance
@@ -80,7 +80,7 @@ def empty(cls) -> "ArraySet[K]":
     def __len__(self) -> int:
         return len(self.__data)
 
-    def __getitem__(self, index: Union[int, slice]) -> Union[K, List[K]]:
+    def __getitem__(self, index: Union[int, slice]) -> Union[K, list[K]]:
         return self.__data[index]
 
     def plusOrThis(self, element: K) -> "ArraySet[K]":
@@ -95,7 +95,7 @@ def plusOrThis(self, element: K) -> "ArraySet[K]":
 
 
 class _ArrayMapKeys(ListBackedSet[K]):
-    def __init__(self, data: List[Union[K, V]]):
+    def __init__(self, data: list[Union[K, V]]):
         self.__data = data
 
     def __len__(self) -> int:
@@ -118,8 +118,8 @@ def __iter__(self) -> Iterator[K]:
         return (self.__data[i] for i in range(0, len(self.__data), 2))  # type: ignore
 
 
-class _ArrayMapEntries(ListBackedSet[Tuple[K, V]], ItemsView[K, V]):
-    def __init__(self, data: List[Union[K, V]]):
+class _ArrayMapEntries(ListBackedSet[tuple[K, V]], ItemsView[K, V]):
+    def __init__(self, data: list[Union[K, V]]):
         self.__data = data
 
     def __len__(self) -> int:
@@ -138,21 +138,21 @@ def __getitem__(self, index: Union[int, slice]):  # type: ignore
         else:
             return (self.__data[2 * index], self.__data[2 * index + 1])
 
-    def __iter__(self) -> Iterator[Tuple[K, V]]:
+    def __iter__(self) -> Iterator[tuple[K, V]]:
         return (
             (self.__data[i], self.__data[i + 1]) for i in range(0, len(self.__data), 2)
         )  # type: ignore
 
 
 class ArrayMap(Mapping[K, V]):
-    __data: List[Union[K, V]]
+    __data: list[Union[K, V]]
     __keys: ListBackedSet[K]
 
     def __init__(self):
         raise NotImplementedError("Use ArrayMap.empty() or other class methods instead")
 
     @classmethod
-    def __create(cls, data: List[Union[K, V]]) -> "ArrayMap[K, V]":
+    def __create(cls, data: list[Union[K, V]]) -> "ArrayMap[K, V]":
         instance = cls.__new__(cls)
         instance.__data = data  # noqa: SLF001
         instance.__keys = _ArrayMapKeys(data)  # noqa: SLF001
@@ -195,7 +195,7 @@ def plus(self, key: K, value: V) -> "ArrayMap[K, V]":
         new_data.insert(insert_at * 2 + 1, value)
         return ArrayMap.__create(new_data)
 
-    def minus_sorted_indices(self, indices: List[int]) -> "ArrayMap[K, V]":
+    def minus_sorted_indices(self, indices: list[int]) -> "ArrayMap[K, V]":
         new_data = self.__data[:]
         adjusted_indices = [i * 2 for i in indices] + [i * 2 + 1 for i in indices]
         adjusted_indices.sort(reverse=True)

python/selfie-lib/selfie_lib/CommentTracker.py

@@ -1,7 +1,6 @@
 import threading
 from collections.abc import Iterable
 from enum import Enum, auto
-from typing import Dict, Tuple
 
 from .Slice import Slice
 from .TypedPath import TypedPath
@@ -20,7 +19,7 @@ def writable(self) -> bool:
 
 class CommentTracker:
     def __init__(self):
-        self.cache: Dict[TypedPath, WritableComment] = {}
+        self.cache: dict[TypedPath, WritableComment] = {}
         self.lock = threading.Lock()
 
     def paths_with_once(self) -> Iterable[TypedPath]:
@@ -42,7 +41,7 @@ def hasWritableComment(self, call: CallStack, layout: SnapshotFileLayout) -> boo
                 return new_comment.writable
 
     @staticmethod
-    def commentString(typedPath: TypedPath) -> Tuple[str, int]:
+    def commentString(typedPath: TypedPath) -> tuple[str, int]:
         comment, line = CommentTracker.__commentAndLine(typedPath)
         if comment == WritableComment.NO_COMMENT:
             raise ValueError("No writable comment found")
@@ -54,7 +53,7 @@ def commentString(typedPath: TypedPath) -> Tuple[str, int]:
             raise ValueError("Invalid comment type")
 
     @staticmethod
-    def __commentAndLine(typedPath: TypedPath) -> Tuple[WritableComment, int]:
+    def __commentAndLine(typedPath: TypedPath) -> tuple[WritableComment, int]:
         with open(typedPath.absolute_path, encoding="utf-8") as file:
             content = Slice(file.read())
         for comment_str in [

python/selfie-lib/selfie_lib/Lens.py

@@ -1,7 +1,7 @@
 import re
 from abc import ABC, abstractmethod
 from collections.abc import Iterator
-from typing import Callable, Generic, List, Optional, Protocol, TypeVar, Union
+from typing import Callable, Generic, Optional, Protocol, TypeVar, Union
 
 from .Snapshot import Snapshot, SnapshotValue
 
@@ -15,7 +15,7 @@ def __call__(self, snapshot: Snapshot) -> Snapshot:
 
 class CompoundLens(Lens):
     def __init__(self):
-        self.lenses: List[Lens] = []
+        self.lenses: list[Lens] = []
 
     def __call__(self, snapshot: Snapshot) -> Snapshot:
         current = snapshot

python/selfie-lib/selfie_lib/PerCharacterEscaper.py

@@ -1,16 +1,15 @@
-from typing import List
 
 
 class PerCharacterEscaper:
     def __init__(
         self,
         escape_code_point: int,
-        escaped_code_points: List[int],
-        escaped_by_code_points: List[int],
+        escaped_code_points: list[int],
+        escaped_by_code_points: list[int],
     ):
         self.__escape_code_point: int = escape_code_point
-        self.__escaped_code_points: List[int] = escaped_code_points
-        self.__escaped_by_code_points: List[int] = escaped_by_code_points
+        self.__escaped_code_points: list[int] = escaped_code_points
+        self.__escaped_by_code_points: list[int] = escaped_by_code_points
 
     def __first_offset_needing_escape(self, input_string: str) -> int:
         length: int = len(input_string)
@@ -28,7 +27,7 @@ def escape(self, input_string: str) -> str:
         if no_escapes == -1:
             return input_string
         else:
-            result: List[str] = []
+            result: list[str] = []
             result.append(input_string[:no_escapes])
             for char in input_string[no_escapes:]:
                 codepoint: int = ord(char)
@@ -52,7 +51,7 @@ def unescape(self, input_string: str) -> str:
         if no_escapes == -1:
             return input_string
         else:
-            result: List[str] = [input_string[:no_escapes]]
+            result: list[str] = [input_string[:no_escapes]]
             skip_next: bool = False
             for i in range(no_escapes, len(input_string)):
                 if skip_next:
@@ -76,18 +75,18 @@ def unescape(self, input_string: str) -> str:
 
     @classmethod
     def self_escape(cls, escape_policy: str) -> "PerCharacterEscaper":
-        code_points: List[int] = [ord(c) for c in escape_policy]
+        code_points: list[int] = [ord(c) for c in escape_policy]
         escape_code_point: int = code_points[0]
         return cls(escape_code_point, code_points, code_points)
 
     @classmethod
     def specified_escape(cls, escape_policy: str) -> "PerCharacterEscaper":
-        code_points: List[int] = [ord(c) for c in escape_policy]
+        code_points: list[int] = [ord(c) for c in escape_policy]
         if len(code_points) % 2 != 0:
             raise ValueError(
                 "Escape policy string must have an even number of characters."
             )
         escape_code_point: int = code_points[0]
-        escaped_code_points: List[int] = code_points[0::2]
-        escaped_by_code_points: List[int] = code_points[1::2]
+        escaped_code_points: list[int] = code_points[0::2]
+        escaped_by_code_points: list[int] = code_points[1::2]
         return cls(escape_code_point, escaped_code_points, escaped_by_code_points)

python/selfie-lib/selfie_lib/SelfieImplementations.py

@@ -1,7 +1,7 @@
 import base64
 from abc import ABC, abstractmethod
 from itertools import chain
-from typing import Any, Generic, List, Optional, TypeVar
+from typing import Any, Generic, Optional, TypeVar
 
 from .Literals import (
     LiteralFormat,
@@ -114,7 +114,7 @@ def __init__(
         self,
         actual: Snapshot,
         disk: DiskStorage,
-        only_facets: Optional[List[str]] = None,
+        only_facets: Optional[list[str]] = None,
     ):
         super().__init__("<IT IS AN ERROR FOR THIS TO BE VISIBLE>", actual, disk)
         self.only_facets = only_facets
@@ -247,7 +247,7 @@ def _assertEqual(
         )
 
 
-def _serializeOnlyFacets(snapshot: Snapshot, keys: List[str]) -> str:
+def _serializeOnlyFacets(snapshot: Snapshot, keys: list[str]) -> str:
     writer = []
     for key in keys:
         if not key:

python/selfie-lib/selfie_lib/SnapshotFile.py

@@ -1,6 +1,6 @@
 import base64
 from threading import Lock
-from typing import List, Optional, Tuple
+from typing import Optional
 
 from .ArrayMap import ArrayMap
 from .Snapshot import Snapshot, SnapshotValue
@@ -14,12 +14,12 @@ class SnapshotFile:
 
     def __init__(self):
         self.unix_newlines: bool = True
-        self.metadata: Optional[Tuple[str, str]] = None
+        self.metadata: Optional[tuple[str, str]] = None
         self.snapshots: ArrayMap[str, Snapshot] = ArrayMap.empty()
         self._lock: Lock = Lock()
         self.was_set_at_test_time: bool = False
 
-    def serialize(self, valueWriter: List[str]):
+    def serialize(self, valueWriter: list[str]):
         if self.metadata is not None:
             self.writeEntry(
                 valueWriter,
@@ -37,7 +37,7 @@ def serialize(self, valueWriter: List[str]):
 
     @staticmethod
     def writeEntry(
-        valueWriter: List[str], key: str, facet: Optional[str], value: SnapshotValue
+        valueWriter: list[str], key: str, facet: Optional[str], value: SnapshotValue
     ):
         valueWriter.append("╔═ ")
         valueWriter.append(SnapshotValueReader.name_esc.escape(key))
@@ -70,7 +70,7 @@ def set_at_test_time(self, key: str, snapshot: Snapshot) -> None:
             self.snapshots = self.snapshots.plus_or_noop_or_replace(key, snapshot)
             self.was_set_at_test_time = True
 
-    def remove_all_indices(self, indices: List[int]) -> None:
+    def remove_all_indices(self, indices: list[int]) -> None:
         with self._lock:
             if not indices:
                 return

python/selfie-lib/selfie_lib/SnapshotValueReader.py

@@ -1,5 +1,5 @@
 import base64
-from typing import Callable, List, Optional
+from typing import Callable, Optional
 
 from .LineReader import LineReader
 from .ParseException import ParseException
@@ -33,7 +33,7 @@ def next_value(self) -> SnapshotValue:
         self.__reset_line()
 
         # Read value
-        buffer: List[str] = []
+        buffer: list[str] = []
 
         def consumer(line: str) -> None:
             # Check for special condition and append to buffer accordingly

python/selfie-lib/selfie_lib/WithinTestGC.py

@@ -1,6 +1,5 @@
 from collections.abc import Iterable
 from threading import Lock
-from typing import List, Tuple
 
 from .ArrayMap import ArrayMap, ArraySet
 from .Snapshot import Snapshot
@@ -42,7 +41,7 @@ def find_stale_snapshots_within(
         snapshots: ArrayMap[str, Snapshot],
         tests_that_ran: ArrayMap[str, "WithinTestGC"],
         tests_that_didnt_run: Iterable[str],
-    ) -> List[int]:
+    ) -> list[int]:
         stale_indices = []
 
         # combine what we know about methods that did run with what we know about the tests that didn't
@@ -57,7 +56,7 @@ def find_stale_snapshots_within(
         key_idx = 0
         while key_idx < len(keys) and gc_idx < len(gc_roots):
             key: str = keys[key_idx]  # type: ignore
-            gc: Tuple[str, WithinTestGC] = gc_roots[gc_idx]  # type: ignore
+            gc: tuple[str, WithinTestGC] = gc_roots[gc_idx]  # type: ignore
             if key.startswith(gc[0]):
                 if len(key) == len(gc[0]):
                     # startWith + same length = exact match, no suffix

python/selfie-lib/selfie_lib/WriteTracker.py

@@ -4,7 +4,7 @@
 from abc import ABC
 from functools import total_ordering
 from pathlib import Path
-from typing import Dict, Generic, List, Optional, TypeVar, cast
+from typing import Generic, Optional, TypeVar, cast
 
 from .FS import FS
 from .Literals import LiteralString, LiteralTodoStub, LiteralValue, TodoStub
@@ -60,7 +60,7 @@ def __hash__(self):
 
 
 class CallStack:
-    def __init__(self, location: CallLocation, rest_of_stack: List[CallLocation]):
+    def __init__(self, location: CallLocation, rest_of_stack: list[CallLocation]):
         self.location = location
         self.rest_of_stack = rest_of_stack
 
@@ -131,7 +131,7 @@ def __init__(self, snapshot: U, call_stack: CallStack):
 class WriteTracker(ABC, Generic[T, U]):
     def __init__(self):
         self.lock = threading.Lock()
-        self.writes: Dict[T, FirstWrite[U]] = {}
+        self.writes: dict[T, FirstWrite[U]] = {}
 
     def recordInternal(
         self,