Use old-style generics.

Author: nedtwigg

python/selfie-lib/selfie_lib/Atomic.py

@@ -1,7 +1,9 @@
-from typing import Callable
+from typing import Callable, Generic, TypeVar
 
+T = TypeVar("T")
 
-class AtomicReference[T]:
+
+class AtomicReference(Generic[T]):
     """
     This has the same API as Java's AtomicReference, but it doesn't make any sense in the Python runtime.
     The point of keeping it is that it makes the port from Kotlin more 1:1

python/selfie-lib/selfie_lib/FS.py

@@ -1,15 +1,17 @@
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Callable, Iterator
+from typing import Callable, Iterator, TypeVar
 
 from selfie_lib.TypedPath import TypedPath
 
+T = TypeVar("T")
+
 
 class FS(ABC):
     def file_exists(self, typed_path: TypedPath) -> bool:
         return Path(typed_path.absolute_path).is_file()
 
-    def file_walk[T](
+    def file_walk(
         self, typed_path: TypedPath, walk: Callable[[Iterator[TypedPath]], T]
     ) -> T:
         def walk_generator(path: TypedPath) -> Iterator[TypedPath]:

python/selfie-lib/selfie_lib/Selfie.py

@@ -17,7 +17,7 @@ def expect_selfie(actual: str) -> StringSelfie: ...
 
 
 @overload
-def expect_selfie[T](actual: T) -> ReprSelfie[T]: ...
+def expect_selfie(actual: T) -> ReprSelfie[T]: ...
 
 
 def expect_selfie(

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, List, Optional
+from typing import Any, Generic, List, Optional, TypeVar
 
 from .Literals import (
     LiteralFormat,
@@ -15,8 +15,10 @@
 from .SnapshotSystem import DiskStorage, Mode, SnapshotSystem, _selfieSystem
 from .WriteTracker import recordCall as recordCall
 
+T = TypeVar("T")
 
-class ReprSelfie[T]:
+
+class ReprSelfie(Generic[T]):
     def __init__(self, actual: T):
         self.actual = actual
 
@@ -168,12 +170,12 @@ def to_be(self, expected: str) -> str:
             )
 
 
-def _checkSrc[T](value: T) -> T:
+def _checkSrc(value: T) -> T:
     _selfieSystem().mode.can_write(False, recordCall(True), _selfieSystem())
     return value
 
 
-def _toBeDidntMatch[T](expected: Optional[T], actual: T, fmt: LiteralFormat[T]) -> T:
+def _toBeDidntMatch(expected: Optional[T], actual: T, fmt: LiteralFormat[T]) -> T:
     call = recordCall(False)
     writable = _selfieSystem().mode.can_write(expected is None, call, _selfieSystem())
     if writable: