eventsourcing 9.4.0a4__py3-none-any.whl → 9.4.0a6__py3-none-any.whl

eventsourcing/sqlite.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import sqlite3
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, Iterator, List, Sequence, Type
+from typing import TYPE_CHECKING, Any
 from uuid import UUID
 
 from eventsourcing.persistence import (
@@ -32,6 +32,7 @@ from eventsourcing.persistence import (
 from eventsourcing.utils import Environment, resolve_topic, strtobool
 
 if TYPE_CHECKING:
+    from collections.abc import Iterator, Sequence
     from types import TracebackType
 
 SQLITE3_DEFAULT_LOCK_TIMEOUT = 5
@@ -103,7 +104,7 @@ class SQLiteTransaction:
 
     def __exit__(
         self,
-        exc_type: Type[BaseException] | None,
+        exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
     ) -> None:
@@ -254,7 +255,7 @@ class SQLiteRecorder(Recorder):
         self.datastore = datastore
         self.create_table_statements = self.construct_create_table_statements()
 
-    def construct_create_table_statements(self) -> List[str]:
+    def construct_create_table_statements(self) -> list[str]:
         return []
 
     def create_table(self) -> None:
@@ -278,7 +279,7 @@ class SQLiteAggregateRecorder(SQLiteRecorder, AggregateRecorder):
             f"SELECT * FROM {self.events_table_name} WHERE originator_id=? "
         )
 
-    def construct_create_table_statements(self) -> List[str]:
+    def construct_create_table_statements(self) -> list[str]:
         statements = super().construct_create_table_statements()
         statements.append(
             "CREATE TABLE IF NOT EXISTS "
@@ -294,7 +295,7 @@ class SQLiteAggregateRecorder(SQLiteRecorder, AggregateRecorder):
         return statements
 
     def insert_events(
-        self, stored_events: List[StoredEvent], **kwargs: Any
+        self, stored_events: list[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
         with self.datastore.transaction(commit=True) as c:
             return self._insert_events(c, stored_events, **kwargs)
@@ -302,7 +303,7 @@ class SQLiteAggregateRecorder(SQLiteRecorder, AggregateRecorder):
     def _insert_events(
         self,
         c: SQLiteCursor,
-        stored_events: List[StoredEvent],
+        stored_events: list[StoredEvent],
         **_: Any,
     ) -> Sequence[int] | None:
         params = [
@@ -325,9 +326,9 @@ class SQLiteAggregateRecorder(SQLiteRecorder, AggregateRecorder):
         lte: int | None = None,
         desc: bool = False,
         limit: int | None = None,
-    ) -> List[StoredEvent]:
+    ) -> list[StoredEvent]:
         statement = self.select_events_statement
-        params: List[Any] = [originator_id.hex]
+        params: list[Any] = [originator_id.hex]
         if gt is not None:
             statement += "AND originator_version>? "
             params.append(gt)
@@ -369,7 +370,7 @@ class SQLiteApplicationRecorder(
             f"SELECT MAX(rowid) FROM {self.events_table_name}"
         )
 
-    def construct_create_table_statements(self) -> List[str]:
+    def construct_create_table_statements(self) -> list[str]:
         statement = (
             "CREATE TABLE IF NOT EXISTS "
             f"{self.events_table_name} ("
@@ -385,7 +386,7 @@ class SQLiteApplicationRecorder(
     def _insert_events(
         self,
         c: SQLiteCursor,
-        stored_events: List[StoredEvent],
+        stored_events: list[StoredEvent],
         **_: Any,
     ) -> Sequence[int] | None:
         returning = []
@@ -410,12 +411,12 @@ class SQLiteApplicationRecorder(
         topics: Sequence[str] = (),
         *,
         inclusive_of_start: bool = True,
-    ) -> List[Notification]:
+    ) -> list[Notification]:
         """
         Returns a list of event notifications
         from 'start', limited by 'limit'.
         """
-        params: List[int | str] = []
+        params: list[int | str] = []
         statement = f"SELECT rowid, * FROM {self.events_table_name} "
         has_where = False
         if start is not None:
@@ -494,7 +495,7 @@ class SQLiteTrackingRecorder(SQLiteRecorder, TrackingRecorder):
             "application_name=? AND notification_id=?"
         )
 
-    def construct_create_table_statements(self) -> List[str]:
+    def construct_create_table_statements(self) -> list[str]:
         statements = super().construct_create_table_statements()
         statements.append(
             "CREATE TABLE IF NOT EXISTS tracking ("
@@ -552,7 +553,7 @@ class SQLiteProcessRecorder(
     def _insert_events(
         self,
         c: SQLiteCursor,
-        stored_events: List[StoredEvent],
+        stored_events: list[StoredEvent],
         **kwargs: Any,
     ) -> Sequence[int] | None:
         returning = super()._insert_events(c, stored_events, **kwargs)
@@ -616,7 +617,7 @@ class SQLiteFactory(InfrastructureFactory[SQLiteTrackingRecorder]):
         application_recorder_topic = self.env.get(self.APPLICATION_RECORDER_TOPIC)
 
         if application_recorder_topic:
-            application_recorder_class: Type[SQLiteApplicationRecorder] = resolve_topic(
+            application_recorder_class: type[SQLiteApplicationRecorder] = resolve_topic(
                 application_recorder_topic
             )
             assert issubclass(application_recorder_class, SQLiteApplicationRecorder)
@@ -630,7 +631,7 @@ class SQLiteFactory(InfrastructureFactory[SQLiteTrackingRecorder]):
         return recorder
 
     def tracking_recorder(
-        self, tracking_recorder_class: Type[SQLiteTrackingRecorder] | None = None
+        self, tracking_recorder_class: type[SQLiteTrackingRecorder] | None = None
     ) -> SQLiteTrackingRecorder:
         if tracking_recorder_class is None:
             tracking_recorder_topic = self.env.get(self.TRACKING_RECORDER_TOPIC)
@@ -653,7 +654,7 @@ class SQLiteFactory(InfrastructureFactory[SQLiteTrackingRecorder]):
         process_recorder_topic = self.env.get(self.PROCESS_RECORDER_TOPIC)
 
         if process_recorder_topic:
-            process_recorder_class: Type[SQLiteProcessRecorder] = resolve_topic(
+            process_recorder_class: type[SQLiteProcessRecorder] = resolve_topic(
                 process_recorder_topic
             )
             assert issubclass(process_recorder_class, SQLiteProcessRecorder)

eventsourcing/system.py

@@ -7,23 +7,10 @@ from abc import ABC, abstractmethod
 from collections import defaultdict
 from queue import Full, Queue
 from types import FrameType, ModuleType
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    ClassVar,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-    Union,
-    cast,
-)
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator, Sequence
     from typing_extensions import Self
 
 from eventsourcing.application import (
@@ -44,14 +31,14 @@ from eventsourcing.persistence import (
 )
 from eventsourcing.utils import EnvType, get_topic, resolve_topic
 
-ProcessingJob = Tuple[DomainEventProtocol, Tracking]
+ProcessingJob = tuple[DomainEventProtocol, Tracking]
 
 
 class RecordingEvent:
     def __init__(
         self,
         application_name: str,
-        recordings: List[Recording],
+        recordings: list[Recording],
         previous_max_notification_id: int | None,
     ):
         self.application_name = application_name
@@ -59,7 +46,7 @@ class RecordingEvent:
         self.previous_max_notification_id = previous_max_notification_id
 
 
-ConvertingJob = Optional[Union[RecordingEvent, List[Notification]]]
+ConvertingJob = Optional[Union[RecordingEvent, list[Notification]]]
 
 
 class Follower(Application):
@@ -75,8 +62,8 @@ class Follower(Application):
 
     def __init__(self, env: EnvType | None = None) -> None:
         super().__init__(env)
-        self.readers: Dict[str, NotificationLogReader] = {}
-        self.mappers: Dict[str, Mapper] = {}
+        self.readers: dict[str, NotificationLogReader] = {}
+        self.mappers: dict[str, Mapper] = {}
         self.recorder: ProcessRecorder
         self.is_threading_enabled = False
         self.processing_lock = threading.Lock()
@@ -129,7 +116,7 @@ class Follower(Application):
         stop: int | None = None,
         *,
         inclusive_of_start: bool = True,
-    ) -> Iterator[List[Notification]]:
+    ) -> Iterator[list[Notification]]:
         """
         Pulls batches of unseen :class:`~eventsourcing.persistence.Notification`
         objects from the notification log reader of the named application.
@@ -142,15 +129,15 @@ class Follower(Application):
         )
 
     def filter_received_notifications(
-        self, notifications: List[Notification]
-    ) -> List[Notification]:
+        self, notifications: list[Notification]
+    ) -> list[Notification]:
         if self.follow_topics:
             return [n for n in notifications if n.topic in self.follow_topics]
         return notifications
 
     def convert_notifications(
         self, leader_name: str, notifications: Iterable[Notification]
-    ) -> List[ProcessingJob]:
+    ) -> list[ProcessingJob]:
         """
         Uses the given :class:`~eventsourcing.persistence.Mapper` to convert
         each received :class:`~eventsourcing.persistence.Notification`
@@ -252,7 +239,7 @@ class Leader(Application):
     def __init__(self, env: EnvType | None = None) -> None:
         super().__init__(env)
         self.previous_max_notification_id: int | None = None
-        self.followers: List[RecordingEventReceiver] = []
+        self.followers: list[RecordingEventReceiver] = []
 
     def lead(self, follower: RecordingEventReceiver) -> None:
         """
@@ -264,12 +251,12 @@ class Leader(Application):
         self,
         *objs: MutableOrImmutableAggregate | DomainEventProtocol | None,
         **kwargs: Any,
-    ) -> List[Recording]:
+    ) -> list[Recording]:
         if self.previous_max_notification_id is None:
             self.previous_max_notification_id = self.recorder.max_notification_id()
         return super().save(*objs, **kwargs)
 
-    def _notify(self, recordings: List[Recording]) -> None:
+    def _notify(self, recordings: list[Recording]) -> None:
         """
         Calls :func:`receive_recording_event` on each follower
         whenever new events have just been saved.
@@ -302,11 +289,11 @@ class System:
     Defines a system of applications.
     """
 
-    __caller_modules: ClassVar[Dict[int, ModuleType]] = {}
+    __caller_modules: ClassVar[dict[int, ModuleType]] = {}
 
     def __init__(
         self,
-        pipes: Iterable[Iterable[Type[Application]]],
+        pipes: Iterable[Iterable[type[Application]]],
     ):
         # Remember the caller frame's module, so that we might identify a topic.
         caller_frame = cast(FrameType, cast(FrameType, inspect.currentframe()).f_back)
@@ -314,8 +301,8 @@ class System:
         type(self).__caller_modules[id(self)] = module
 
         # Build nodes and edges.
-        self.edges: List[Tuple[str, str]] = []
-        classes: Dict[str, Type[Application]] = {}
+        self.edges: list[tuple[str, str]] = []
+        classes: dict[str, type[Application]] = {}
         for pipe in pipes:
             follower_cls = None
             for cls in pipe:
@@ -329,14 +316,14 @@ class System:
                     if edge not in self.edges:
                         self.edges.append(edge)
 
-        self.nodes: Dict[str, str] = {}
+        self.nodes: dict[str, str] = {}
         for name in classes:
             topic = get_topic(classes[name])
             self.nodes[name] = topic
 
         # Identify leaders and followers.
-        self.follows: Dict[str, List[str]] = defaultdict(list)
-        self.leads: Dict[str, List[str]] = defaultdict(list)
+        self.follows: dict[str, list[str]] = defaultdict(list)
+        self.leads: dict[str, list[str]] = defaultdict(list)
         for edge in self.edges:
             self.leads[edge[0]].append(edge[1])
             self.follows[edge[1]].append(edge[0])
@@ -358,27 +345,27 @@ class System:
                 raise TypeError("Not a process application class: %s" % classes[name])
 
     @property
-    def leaders(self) -> List[str]:
+    def leaders(self) -> list[str]:
         return list(self.leads.keys())
 
     @property
-    def leaders_only(self) -> List[str]:
+    def leaders_only(self) -> list[str]:
         return [name for name in self.leads if name not in self.follows]
 
     @property
-    def followers(self) -> List[str]:
+    def followers(self) -> list[str]:
         return list(self.follows.keys())
 
     @property
-    def processors(self) -> List[str]:
+    def processors(self) -> list[str]:
         return [name for name in self.leads if name in self.follows]
 
-    def get_app_cls(self, name: str) -> Type[Application]:
+    def get_app_cls(self, name: str) -> type[Application]:
         cls = resolve_topic(self.nodes[name])
         assert issubclass(cls, Application)
         return cls
 
-    def leader_cls(self, name: str) -> Type[Leader]:
+    def leader_cls(self, name: str) -> type[Leader]:
         cls = self.get_app_cls(name)
         if issubclass(cls, Leader):
             return cls
@@ -386,7 +373,7 @@ class System:
         assert issubclass(cls, Leader)
         return cls
 
-    def follower_cls(self, name: str) -> Type[Follower]:
+    def follower_cls(self, name: str) -> type[Follower]:
         cls = self.get_app_cls(name)
         assert issubclass(cls, Follower)
         return cls
@@ -431,7 +418,7 @@ class Runner(ABC):
         """
 
     @abstractmethod
-    def get(self, cls: Type[TApplication]) -> TApplication:
+    def get(self, cls: type[TApplication]) -> TApplication:
         """
         Returns an application instance for given application class.
         """
@@ -471,8 +458,8 @@ class SingleThreadedRunner(Runner, RecordingEventReceiver):
         Initialises runner with the given :class:`System`.
         """
         super().__init__(system=system, env=env)
-        self.apps: Dict[str, Application] = {}
-        self._recording_events_received: List[RecordingEvent] = []
+        self.apps: dict[str, Application] = {}
+        self._recording_events_received: list[RecordingEvent] = []
         self._prompted_names_lock = threading.Lock()
         self._prompted_names: set[str] = set()
         self._processing_lock = threading.Lock()
@@ -556,7 +543,7 @@ class SingleThreadedRunner(Runner, RecordingEventReceiver):
             app.close()
         self.apps.clear()
 
-    def get(self, cls: Type[TApplication]) -> TApplication:
+    def get(self, cls: type[TApplication]) -> TApplication:
         app = self.apps[cls.name]
         assert isinstance(app, cls)
         return app
@@ -579,11 +566,11 @@ class NewSingleThreadedRunner(Runner, RecordingEventReceiver):
         Initialises runner with the given :class:`System`.
         """
         super().__init__(system=system, env=env)
-        self.apps: Dict[str, Application] = {}
-        self._recording_events_received: List[RecordingEvent] = []
+        self.apps: dict[str, Application] = {}
+        self._recording_events_received: list[RecordingEvent] = []
         self._recording_events_received_lock = threading.Lock()
         self._processing_lock = threading.Lock()
-        self._previous_max_notification_ids: Dict[str, int] = {}
+        self._previous_max_notification_ids: dict[str, int] = {}
 
         # Construct followers.
         for name in self.system.followers:
@@ -710,7 +697,7 @@ class NewSingleThreadedRunner(Runner, RecordingEventReceiver):
             app.close()
         self.apps.clear()
 
-    def get(self, cls: Type[TApplication]) -> TApplication:
+    def get(self, cls: type[TApplication]) -> TApplication:
         app = self.apps[cls.name]
         assert isinstance(app, cls)
         return app
@@ -727,8 +714,8 @@ class MultiThreadedRunner(Runner):
         Initialises runner with the given :class:`System`.
         """
         super().__init__(system=system, env=env)
-        self.apps: Dict[str, Application] = {}
-        self.threads: Dict[str, MultiThreadedRunnerThread] = {}
+        self.apps: dict[str, Application] = {}
+        self.threads: dict[str, MultiThreadedRunnerThread] = {}
         self.has_errored = threading.Event()
 
         # Construct followers.
@@ -807,7 +794,7 @@ class MultiThreadedRunner(Runner):
             if thread.error:
                 raise thread.error
 
-    def get(self, cls: Type[TApplication]) -> TApplication:
+    def get(self, cls: type[TApplication]) -> TApplication:
         app = self.apps[cls.name]
         assert isinstance(app, cls)
         return app
@@ -831,7 +818,7 @@ class MultiThreadedRunnerThread(RecordingEventReceiver, threading.Thread):
         self.is_stopping = threading.Event()
         self.has_started = threading.Event()
         self.is_prompted = threading.Event()
-        self.prompted_names: List[str] = []
+        self.prompted_names: list[str] = []
         self.prompted_names_lock = threading.Lock()
         self.is_running = threading.Event()
 
@@ -891,10 +878,10 @@ class NewMultiThreadedRunner(Runner, RecordingEventReceiver):
         Initialises runner with the given :class:`System`.
         """
         super().__init__(system=system, env=env)
-        self.apps: Dict[str, Application] = {}
-        self.pulling_threads: Dict[str, List[PullingThread]] = {}
-        self.processing_queues: Dict[str, Queue[List[ProcessingJob] | None]] = {}
-        self.all_threads: List[PullingThread | ConvertingThread | ProcessingThread] = []
+        self.apps: dict[str, Application] = {}
+        self.pulling_threads: dict[str, list[PullingThread]] = {}
+        self.processing_queues: dict[str, Queue[list[ProcessingJob] | None]] = {}
+        self.all_threads: list[PullingThread | ConvertingThread | ProcessingThread] = []
         self.has_errored = threading.Event()
 
         # Construct followers.
@@ -933,7 +920,7 @@ class NewMultiThreadedRunner(Runner, RecordingEventReceiver):
         # Start the processing threads.
         for follower_name in self.system.followers:
             follower = cast(Follower, self.apps[follower_name])
-            processing_queue: Queue[List[ProcessingJob] | None] = Queue(
+            processing_queue: Queue[list[ProcessingJob] | None] = Queue(
                 maxsize=self.QUEUE_MAX_SIZE
             )
             self.processing_queues[follower_name] = processing_queue
@@ -1010,7 +997,7 @@ class NewMultiThreadedRunner(Runner, RecordingEventReceiver):
             if thread.error:
                 raise thread.error
 
-    def get(self, cls: Type[TApplication]) -> TApplication:
+    def get(self, cls: type[TApplication]) -> TApplication:
         app = self.apps[cls.name]
         assert isinstance(app, cls)
         return app
@@ -1111,7 +1098,7 @@ class ConvertingThread(threading.Thread):
     def __init__(
         self,
         converting_queue: Queue[ConvertingJob],
-        processing_queue: Queue[List[ProcessingJob] | None],
+        processing_queue: Queue[list[ProcessingJob] | None],
         follower: Follower,
         leader_name: str,
         has_errored: threading.Event,
@@ -1181,7 +1168,7 @@ class ProcessingThread(threading.Thread):
 
     def __init__(
         self,
-        processing_queue: Queue[List[ProcessingJob] | None],
+        processing_queue: Queue[list[ProcessingJob] | None],
         follower: Follower,
         has_errored: threading.Event,
     ):
@@ -1264,7 +1251,7 @@ class NotificationLogReader:
         stop: int | None = None,
         topics: Sequence[str] = (),
         inclusive_of_start: bool = True,
-    ) -> Iterator[List[Notification]]:
+    ) -> Iterator[list[Notification]]:
         """
         Returns a generator that yields lists of event notifications
         from the reader's notification log, starting from given start

eventsourcing/tests/application.py

@@ -10,7 +10,7 @@ from decimal import Decimal
 from threading import Event, get_ident
 from time import sleep
 from timeit import timeit
-from typing import ClassVar, Dict, Type
+from typing import ClassVar
 from unittest import TestCase
 from uuid import UUID, uuid4
 
@@ -30,8 +30,8 @@ TIMEIT_FACTOR = int(os.environ.get("TEST_TIMEIT_FACTOR", default=10))
 
 class ExampleApplicationTestCase(TestCase):
     timeit_number: ClassVar[int] = TIMEIT_FACTOR
-    started_ats: ClassVar[Dict[Type[TestCase], datetime]] = {}
-    counts: ClassVar[Dict[Type[TestCase], int]] = {}
+    started_ats: ClassVar[dict[type[TestCase], datetime]] = {}
+    counts: ClassVar[dict[type[TestCase], int]] = {}
     expected_factory_topic: str
 
     def test_example_application(self):

eventsourcing/tests/persistence.py

@@ -10,7 +10,7 @@ from tempfile import NamedTemporaryFile
 from threading import Event, Thread, get_ident
 from time import sleep
 from timeit import timeit
-from typing import Any, Dict, List
+from typing import Any
 from unittest import TestCase
 from uuid import UUID, uuid4
 
@@ -429,11 +429,11 @@ class ApplicationRecorderTestCase(TestCase, ABC):
         recorder = self.create_recorder()
 
         errors_happened = Event()
-        errors: List[Exception] = []
+        errors: list[Exception] = []
 
         counts = {}
-        threads: Dict[int, int] = {}
-        durations: Dict[int, float] = {}
+        threads: dict[int, int] = {}
+        durations: dict[int, float] = {}
 
         num_writers = 10
         num_writes_per_writer = 100
@@ -536,8 +536,8 @@ class ApplicationRecorderTestCase(TestCase, ABC):
         errors_happened = Event()
 
         counts = {}
-        threads: Dict[int, int] = {}
-        durations: Dict[int, float] = {}
+        threads: dict[int, int] = {}
+        durations: dict[int, float] = {}
 
         # Match this to the batch page size in postgres insert for max throughput.
         num_events = 500
@@ -642,7 +642,7 @@ class ApplicationRecorderTestCase(TestCase, ABC):
         with recorder.subscribe(gt=max_notification_id1) as subscription:
 
             # Receive events from the subscription.
-            notifications: List[Notification] = []
+            notifications: list[Notification] = []
             for notification in subscription:
                 notifications.append(notification)
                 if len(notifications) == 2:
@@ -696,7 +696,7 @@ class ApplicationRecorderTestCase(TestCase, ABC):
         with recorder.subscribe(gt=max_notification_id2) as subscription:
 
             # Receive events from the subscription.
-            notifications: List[Notification] = []
+            notifications: list[Notification] = []
             for notification in subscription:
                 notifications.append(notification)
                 if len(notifications) == 1:
@@ -1285,7 +1285,7 @@ class CustomType2:
         return type(self) is type(other) and self.__dict__ == other.__dict__
 
 
-class MyDict(dict):
+class Mydict(dict):
     def __repr__(self):
         return f"{type(self).__name__}({super().__repr__()})"
 
@@ -1391,13 +1391,13 @@ class TranscoderTestCase(TestCase):
         self.assertEqual(data, b"{}")
         self.assertEqual(obj, self.transcoder.decode(data))
 
-        # Dict with single key.
+        # dict with single key.
         obj = {"a": 1}
         data = self.transcoder.encode(obj)
         self.assertEqual(data, b'{"a":1}')
         self.assertEqual(obj, self.transcoder.decode(data))
 
-        # Dict with many keys.
+        # dict with many keys.
         obj = {"a": 1, "b": 2}
         data = self.transcoder.encode(obj)
         self.assertEqual(data, b'{"a":1,"b":2}')
@@ -1444,7 +1444,7 @@ class TranscoderTestCase(TestCase):
         self.assertEqual(obj, self.transcoder.decode(data))
 
     def test_dict_subclass(self):
-        my_dict = MyDict({"a": 1})
+        my_dict = Mydict({"a": 1})
         data = self.transcoder.encode(my_dict)
         self.assertEqual(b'{"_type_":"mydict","_data_":{"a":1}}', data)
         copy = self.transcoder.decode(data)

eventsourcing/utils.py

@@ -2,25 +2,13 @@ from __future__ import annotations
 
 import importlib
 import sys
+from collections.abc import Iterator, Mapping, Sequence
 from functools import wraps
 from inspect import isfunction
 from random import random
 from threading import Lock
 from time import sleep
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Dict,
-    Iterator,
-    List,
-    Mapping,
-    Sequence,
-    Type,
-    TypeVar,
-    no_type_check,
-    overload,
-)
+from typing import TYPE_CHECKING, Any, Callable, TypeVar, no_type_check, overload
 
 if TYPE_CHECKING:
     from types import FunctionType, WrapperDescriptorType
@@ -32,8 +20,8 @@ class TopicError(Exception):
     """
 
 
-_type_cache: Dict[type, str] = {}
-_topic_cache: Dict[str, Any] = {}
+_type_cache: dict[type, str] = {}
+_topic_cache: dict[str, Any] = {}
 _topic_cache_lock = Lock()
 
 
@@ -138,7 +126,7 @@ def clear_topic_cache() -> None:
 
 
 def retry(
-    exc: Type[Exception] | Sequence[Type[Exception]] = Exception,
+    exc: type[Exception] | Sequence[type[Exception]] = Exception,
     max_attempts: int = 1,
     wait: float = 0,
     stall: float = 0,
@@ -223,7 +211,7 @@ def strtobool(val: str) -> bool:
     raise ValueError(msg)
 
 
-def reversed_keys(d: Dict[Any, Any]) -> Iterator[Any]:
+def reversed_keys(d: dict[Any, Any]) -> Iterator[Any]:
     return reversed(d.keys())
 
 
@@ -237,7 +225,7 @@ EnvType = Mapping[str, str]
 T = TypeVar("T")
 
 
-class Environment(Dict[str, str]):
+class Environment(dict[str, str]):
     def __init__(self, name: str = "", env: EnvType | None = None):
         super().__init__(env or {})
         self.name = name
@@ -255,7 +243,7 @@ class Environment(Dict[str, str]):
                 return value
         return default
 
-    def create_keys(self, key: str) -> List[str]:
+    def create_keys(self, key: str) -> list[str]:
         keys = []
         if self.name:
             keys.append(self.name.upper() + "_" + key)