Refactor typing.TypeVar into PEP695 syntax (UP046 & UP047)

Author: aljazerzen

edb/common/ast/base.py

@@ -27,7 +27,6 @@
 from typing import (
     Any,
     Callable,
-    TypeVar,
     cast,
     get_type_hints,
     TYPE_CHECKING,
@@ -39,9 +38,6 @@
 from edb.common import typing_inspect
 
 
-T = TypeVar('T')
-
-
 class ASTError(Exception):
     pass
 
@@ -69,7 +65,7 @@ def __init__(self, factory):
         self.factory = factory
 
 
-def field(*, factory: Callable[[], T]) -> T:
+def field[T](*, factory: Callable[[], T]) -> T:
     return cast(T, _FieldSpec(factory=factory))
 
 
@@ -275,7 +271,7 @@ def __deepcopy__(self, memo):
     def _init_copy(self):
         return self.__class__()
 
-    def replace(self: T, **changes) -> T:
+    def replace[T](self: T, **changes) -> T:
         copied = copy.copy(self)
         for field, value in changes.items():
             object.__setattr__(copied, field, value)

edb/common/asyncutil.py

@@ -33,10 +33,7 @@
 import warnings
 
 
-_T = TypeVar('_T')
-
-
-async def deferred_shield(arg: Awaitable[_T]) -> _T:
+async def deferred_shield[T](arg: Awaitable[T]) -> T:
     '''Wait for a future, deferring cancellation until it is complete.
 
     If you do
@@ -74,9 +71,9 @@ async def deferred_shield(arg: Awaitable[_T]) -> _T:
     return task.result()
 
 
-async def debounce(
-    input: Callable[[], Awaitable[_T]],
-    output: Callable[[list[_T]], Awaitable[None]],
+async def debounce[T](
+    input: Callable[[], Awaitable[T]],
+    output: Callable[[list[T]], Awaitable[None]],
     *,
     max_wait: float,
     delay_amt: float,

edb/common/checked.py

@@ -20,9 +20,7 @@
 from typing import (
     Any,
     ClassVar,
-    Generic,
     Optional,
-    TypeVar,
     AbstractSet,
     Iterable,
     Iterator,
@@ -51,11 +49,6 @@
 ]
 
 
-T = TypeVar("T")
-K = TypeVar("K")
-V = TypeVar("V")
-
-
 class ParametricContainer:
 
     types: ClassVar[Optional[tuple[type, ...]]] = None
@@ -81,7 +74,7 @@ def __restore__(
         return cls[params](data)  # type: ignore
 
 
-class AbstractCheckedList(Generic[T]):
+class AbstractCheckedList[T]:
     type: type
     _container: list[T]
 
@@ -128,7 +121,7 @@ def __repr__(self) -> str:
         return f"{_type_repr(type(self))}({repr(self._container)})"
 
 
-class FrozenCheckedList(
+class FrozenCheckedList[T](
     ParametricContainer,
     parametric.SingleParametricType[T],
     AbstractCheckedList[T],
@@ -179,7 +172,7 @@ def __mul__(self, n: int) -> FrozenCheckedList[T]:
     __rmul__ = __mul__
 
 
-class CheckedList(
+class CheckedList[T](
     ParametricContainer,
     parametric.SingleParametricType[T],
     AbstractCheckedList[T],
@@ -265,7 +258,7 @@ def sort(self, *, key: Any = None, reverse: bool = False) -> None:
         self._container.sort(key=key, reverse=reverse)
 
 
-class AbstractCheckedSet(AbstractSet[T]):
+class AbstractCheckedSet[T](AbstractSet[T]):
     type: type
     _container: AbstractSet[T]
 
@@ -326,7 +319,7 @@ def issuperset(self, other: AbstractSet[Any]) -> bool:
         return self.__ge__(other)
 
 
-class FrozenCheckedSet(
+class FrozenCheckedSet[T](
     ParametricContainer,
     parametric.SingleParametricType[T],
     AbstractCheckedSet[T],
@@ -400,7 +393,7 @@ def __xor__(  # type: ignore
     symmetric_difference = __xor__
 
 
-class CheckedSet(
+class CheckedSet[T](
     ParametricContainer,
     parametric.SingleParametricType[T],
     AbstractCheckedSet[T],
@@ -520,7 +513,7 @@ def _type_repr(obj: Any) -> str:
     return repr(obj)
 
 
-class AbstractCheckedDict(Generic[K, V]):
+class AbstractCheckedDict[K, V]:
     keytype: type
     valuetype: type
     _container: dict[K, V]
@@ -557,7 +550,7 @@ def __repr__(self) -> str:
         return f"{_type_repr(type(self))}({repr(self._container)})"
 
 
-class CheckedDict(
+class CheckedDict[K, V](
     ParametricContainer,
     parametric.KeyValueParametricType[K, V],
     AbstractCheckedDict[K, V],
@@ -617,7 +610,7 @@ def fromkeys(
         return new
 
 
-def _identity(cls: type, value: T) -> T:
+def _identity[T](cls: type, value: T) -> T:
     return value
 
 

edb/common/compiler.py

@@ -21,44 +21,42 @@
 
 from typing import (
     Any,
-    Generic,
     Optional,
-    TypeVar,
     ContextManager,
+    Self,
 )
 
 import collections
 import re
 
 
-ContextLevel_T = TypeVar('ContextLevel_T', bound='ContextLevel')
-
-
 class ContextLevel:
-    _stack: CompilerContext[ContextLevel]
+    _stack: CompilerContext[Self]
 
-    def __init__(self, prevlevel: Optional[ContextLevel], mode: Any) -> None:
+    def __init__(self, prevlevel: Optional[Self], mode: Any) -> None:
         pass
 
     def on_pop(
-        self: ContextLevel_T,
-        prevlevel: Optional[ContextLevel_T],
+        self: Self,
+        prevlevel: Optional[Self],
     ) -> None:
         pass
 
     def new(
-        self: ContextLevel_T,
+        self: Self,
         mode: Any=None,
-    ) -> CompilerContextManager[ContextLevel_T]:
-        return self._stack.new(mode, self)  # type: ignore
+    ) -> CompilerContextManager[Self]:
+        return self._stack.new(mode, self)
 
     def reenter(
-        self: ContextLevel_T,
-    ) -> CompilerReentryContextManager[ContextLevel_T]:
-        return CompilerReentryContextManager(self._stack, self)  # type: ignore
+        self: Self,
+    ) -> CompilerReentryContextManager[Self]:
+        return CompilerReentryContextManager(self._stack, self)
 
 
-class CompilerContextManager(ContextManager[ContextLevel_T]):
+class CompilerContextManager[ContextLevel_T: ContextLevel](
+    ContextManager[ContextLevel_T]
+):
     def __init__(
         self,
         context: CompilerContext[ContextLevel_T],
@@ -76,7 +74,9 @@ def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
         self.context.pop()
 
 
-class CompilerReentryContextManager(ContextManager[ContextLevel_T]):
+class CompilerReentryContextManager[ContextLevel_T: ContextLevel](
+    ContextManager[ContextLevel_T]
+):
     def __init__(
         self,
         context: CompilerContext[ContextLevel_T],
@@ -92,7 +92,7 @@ def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
         self.context.pop()
 
 
-class CompilerContext(Generic[ContextLevel_T]):
+class CompilerContext[ContextLevel_T: ContextLevel]:
     stack: list[ContextLevel_T]
     ContextLevelClass: type[ContextLevel_T]
     default_mode: Any
@@ -131,7 +131,7 @@ def _push(
                 raise AssertionError(
                     'Calling new() on a context other than the current one')
             level = self.ContextLevelClass(prevlevel, mode)
-        level._stack = self  # type: ignore
+        level._stack = self
         self.stack.append(level)
         return level
 

edb/common/lru.py

@@ -23,7 +23,7 @@
 import functools
 
 
-from typing import TypeVar, Callable
+from typing import Callable
 
 
 class LRUMapping(collections.abc.MutableMapping):
@@ -81,9 +81,6 @@ def __iter__(self):
         return iter(self._dict)
 
 
-Tf = TypeVar('Tf', bound=Callable)
-
-
 class _NoPickle:
     def __init__(self, obj):
         self.obj = obj
@@ -98,7 +95,7 @@ def __setstate__(self, _d):
         self.obj = None
 
 
-def lru_method_cache(size: int | None=128) -> Callable[[Tf], Tf]:
+def lru_method_cache[Tf: Callable](size: int | None=128) -> Callable[[Tf], Tf]:
     """A version of lru_cache for methods that shouldn't leak memory.
 
     Basically the idea is that we generate a per-object lru-cached
@@ -125,5 +122,5 @@ def func(self, *args, **kwargs):
     return transformer
 
 
-def method_cache(f: Tf) -> Tf:
+def method_cache[Tf: Callable](f: Tf) -> Tf:
     return lru_method_cache(None)(f)

edb/common/markup/serializer/base.py

@@ -19,8 +19,6 @@
 
 from __future__ import annotations
 
-from typing import TypeVar
-
 import collections
 import collections.abc
 import decimal
@@ -51,10 +49,7 @@
 __all__ = 'serialize',
 
 
-T = TypeVar('T')
-
-
-def no_ref_detect(func: T) -> T:
+def no_ref_detect[T](func: T) -> T:
     """Serializer decorated with ``no_ref_detect`` will be executed without
     prior checking the memo if object was already serialized"""
 

edb/common/parametric.py

@@ -20,7 +20,6 @@
 from typing import (
     Any,
     ClassVar,
-    Generic,
     Optional,
     TypeVar,
     get_type_hints,
@@ -40,10 +39,6 @@
 ]
 
 
-T = TypeVar("T")
-V = TypeVar("V")
-
-
 try:
     from types import GenericAlias
 except ImportError:
@@ -323,12 +318,12 @@ def __reduce__(self) -> tuple[Any, ...]:
         )
 
 
-class SingleParametricType(ParametricType, Generic[T]):
+class SingleParametricType[T](ParametricType):
 
     type: ClassVar[type[T]]  # type: ignore
 
 
-class KeyValueParametricType(ParametricType, Generic[T, V]):
+class KeyValueParametricType[T, V](ParametricType):
 
     keytype: ClassVar[type[T]]  # type: ignore
     valuetype: ClassVar[type[V]]  # type: ignore