reactivex 4.1.0__py3-none-any.whl → 5.0.0a2__py3-none-any.whl

reactivex/scheduler/eventloopscheduler.py

@@ -1,7 +1,7 @@
 import logging
 import threading
 from collections import deque
-from typing import Deque, Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import abc, typing
 from reactivex.disposable import Disposable
@@ -23,7 +23,7 @@ class EventLoopScheduler(PeriodicScheduler, abc.DisposableBase):
 
     def __init__(
         self,
-        thread_factory: Optional[typing.StartableFactory] = None,
+        thread_factory: typing.StartableFactory | None = None,
         exit_if_empty: bool = False,
     ) -> None:
         super().__init__()
@@ -32,15 +32,15 @@ class EventLoopScheduler(PeriodicScheduler, abc.DisposableBase):
         self._thread_factory: typing.StartableFactory = (
             thread_factory or default_thread_factory
         )
-        self._thread: Optional[typing.Startable] = None
+        self._thread: typing.Startable | None = None
         self._condition = threading.Condition(threading.Lock())
         self._queue: PriorityQueue[ScheduledItem] = PriorityQueue()
-        self._ready_list: Deque[ScheduledItem] = deque()
+        self._ready_list: deque[ScheduledItem] = deque()
 
         self._exit_if_empty = exit_if_empty
 
     def schedule(
-        self, action: typing.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: typing.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -59,7 +59,7 @@ class EventLoopScheduler(PeriodicScheduler, abc.DisposableBase):
         self,
         duetime: typing.RelativeTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -80,7 +80,7 @@ class EventLoopScheduler(PeriodicScheduler, abc.DisposableBase):
         self,
         duetime: typing.AbsoluteTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.
 
@@ -114,7 +114,7 @@ class EventLoopScheduler(PeriodicScheduler, abc.DisposableBase):
         self,
         period: typing.RelativeTime,
         action: typing.ScheduledPeriodicAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules a periodic piece of work.
 
@@ -154,12 +154,10 @@ class EventLoopScheduler(PeriodicScheduler, abc.DisposableBase):
         The loop is suspended/resumed using the condition which gets notified
         by calls to Schedule or calls to dispose."""
 
-        ready: Deque[ScheduledItem] = deque()
+        ready: deque[ScheduledItem] = deque()
 
         while True:
-
             with self._condition:
-
                 # The notification could be because of a call to dispose. This
                 # takes precedence over everything else: We'll exit the loop
                 # immediately. Subsequent calls to Schedule won't ever create a
@@ -188,7 +186,6 @@ class EventLoopScheduler(PeriodicScheduler, abc.DisposableBase):
 
             # Wait for next cycle, or if we're done let's exit if so configured
             with self._condition:
-
                 if self._ready_list:
                     continue
 

reactivex/scheduler/historicalscheduler.py

@@ -1,5 +1,4 @@
 from datetime import datetime
-from typing import Optional
 
 from .scheduler import UTC_ZERO
 from .virtualtimescheduler import VirtualTimeScheduler
@@ -9,7 +8,7 @@ class HistoricalScheduler(VirtualTimeScheduler):
     """Provides a virtual time scheduler that uses datetime for absolute time
     and timedelta for relative time."""
 
-    def __init__(self, initial_clock: Optional[datetime] = None) -> None:
+    def __init__(self, initial_clock: datetime | None = None) -> None:
         """Creates a new historical scheduler with the specified initial clock
         value.
 

reactivex/scheduler/immediatescheduler.py

@@ -1,5 +1,6 @@
+from collections.abc import MutableMapping
 from threading import Lock
-from typing import MutableMapping, Optional, TypeVar
+from typing import TypeVar
 from weakref import WeakKeyDictionary
 
 from reactivex import abc, typing
@@ -35,7 +36,7 @@ class ImmediateScheduler(Scheduler):
         return cls.singleton()
 
     def schedule(
-        self, action: typing.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: typing.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -54,7 +55,7 @@ class ImmediateScheduler(Scheduler):
         self,
         duetime: typing.RelativeTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -78,7 +79,7 @@ class ImmediateScheduler(Scheduler):
         self,
         duetime: typing.AbsoluteTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.
 

reactivex/scheduler/mainloop/gtkscheduler.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional, TypeVar, cast
+from typing import Any, TypeVar, cast
 
 from reactivex import abc, typing
 from reactivex.disposable import (
@@ -36,10 +36,9 @@ class GtkScheduler(PeriodicScheduler):
         self,
         time: typing.AbsoluteOrRelativeTime,
         action: typing.ScheduledSingleOrPeriodicAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
         periodic: bool = False,
     ) -> abc.DisposableBase:
-
         msecs = max(0, int(self.to_seconds(time) * 1000.0))
 
         sad = SingleAssignmentDisposable()
@@ -69,7 +68,7 @@ class GtkScheduler(PeriodicScheduler):
         return CompositeDisposable(sad, Disposable(dispose))
 
     def schedule(
-        self, action: typing.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: typing.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -87,7 +86,7 @@ class GtkScheduler(PeriodicScheduler):
         self,
         duetime: typing.RelativeTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -106,7 +105,7 @@ class GtkScheduler(PeriodicScheduler):
         self,
         duetime: typing.AbsoluteTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.
 
@@ -127,7 +126,7 @@ class GtkScheduler(PeriodicScheduler):
         self,
         period: typing.RelativeTime,
         action: typing.ScheduledPeriodicAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules a periodic piece of work to be executed in the loop.
 

reactivex/scheduler/mainloop/pygamescheduler.py

@@ -1,6 +1,6 @@
 import logging
 import threading
-from typing import Any, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import abc, typing
 from reactivex.internal import PriorityQueue
@@ -36,7 +36,7 @@ class PyGameScheduler(PeriodicScheduler):
         self._queue: PriorityQueue[ScheduledItem] = PriorityQueue()
 
     def schedule(
-        self, action: typing.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: typing.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -56,7 +56,7 @@ class PyGameScheduler(PeriodicScheduler):
         self,
         duetime: typing.RelativeTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
         Args:
@@ -76,7 +76,7 @@ class PyGameScheduler(PeriodicScheduler):
         self,
         duetime: typing.AbsoluteTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.
 

reactivex/scheduler/mainloop/qtscheduler.py

@@ -1,6 +1,6 @@
 import logging
 from datetime import timedelta
-from typing import Any, Optional, Set, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import abc, typing
 from reactivex.disposable import (
@@ -28,10 +28,10 @@ class QtScheduler(PeriodicScheduler):
         """
         super().__init__()
         self._qtcore = qtcore
-        self._periodic_timers: Set[Any] = set()
+        self._periodic_timers: set[Any] = set()
 
     def schedule(
-        self, action: typing.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: typing.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -49,7 +49,7 @@ class QtScheduler(PeriodicScheduler):
         self,
         duetime: typing.RelativeTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -85,7 +85,7 @@ class QtScheduler(PeriodicScheduler):
         self,
         duetime: typing.AbsoluteTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.
 
@@ -106,7 +106,7 @@ class QtScheduler(PeriodicScheduler):
         self,
         period: typing.RelativeTime,
         action: typing.ScheduledPeriodicAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules a periodic piece of work to be executed in the loop.
 

reactivex/scheduler/mainloop/tkinterscheduler.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import abc, typing
 from reactivex.disposable import (
@@ -30,7 +30,7 @@ class TkinterScheduler(PeriodicScheduler):
         self._root = root
 
     def schedule(
-        self, action: typing.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: typing.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -49,7 +49,7 @@ class TkinterScheduler(PeriodicScheduler):
         self,
         duetime: typing.RelativeTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -80,7 +80,7 @@ class TkinterScheduler(PeriodicScheduler):
         self,
         duetime: typing.AbsoluteTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.
 

reactivex/scheduler/mainloop/wxscheduler.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Optional, Set, TypeVar, cast
+from typing import Any, TypeVar, cast
 
 from reactivex import abc, typing
 from reactivex.disposable import (
@@ -39,7 +39,7 @@ class WxScheduler(PeriodicScheduler):
                 self.callback()
 
         self._timer_class = Timer
-        self._timers: Set[Timer] = set()
+        self._timers: set[Timer] = set()
 
     def cancel_all(self) -> None:
         """Cancel all scheduled actions.
@@ -54,7 +54,7 @@ class WxScheduler(PeriodicScheduler):
         self,
         time: typing.AbsoluteOrRelativeTime,
         action: typing.ScheduledSingleOrPeriodicAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
         periodic: bool = False,
     ) -> abc.DisposableBase:
         scheduler = self
@@ -89,7 +89,7 @@ class WxScheduler(PeriodicScheduler):
         return CompositeDisposable(sad, Disposable(dispose))
 
     def schedule(
-        self, action: typing.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: typing.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -120,7 +120,7 @@ class WxScheduler(PeriodicScheduler):
         self,
         duetime: typing.RelativeTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -139,7 +139,7 @@ class WxScheduler(PeriodicScheduler):
         self,
         duetime: typing.AbsoluteTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.
 
@@ -160,7 +160,7 @@ class WxScheduler(PeriodicScheduler):
         self,
         period: typing.RelativeTime,
         action: typing.ScheduledPeriodicAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules a periodic piece of work to be executed in the loop.
 

reactivex/scheduler/newthreadscheduler.py

@@ -1,7 +1,7 @@
 import logging
 import threading
 from datetime import datetime
-from typing import Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import abc, typing
 from reactivex.disposable import Disposable
@@ -18,16 +18,14 @@ log = logging.getLogger("Rx")
 class NewThreadScheduler(PeriodicScheduler):
     """Creates an object that schedules each unit of work on a separate thread."""
 
-    def __init__(
-        self, thread_factory: Optional[typing.StartableFactory] = None
-    ) -> None:
+    def __init__(self, thread_factory: typing.StartableFactory | None = None) -> None:
         super().__init__()
         self.thread_factory: typing.StartableFactory = (
             thread_factory or default_thread_factory
         )
 
     def schedule(
-        self, action: typing.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: typing.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -49,7 +47,7 @@ class NewThreadScheduler(PeriodicScheduler):
         self,
         duetime: typing.RelativeTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -72,7 +70,7 @@ class NewThreadScheduler(PeriodicScheduler):
         self,
         duetime: typing.AbsoluteTime,
         action: typing.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.
 
@@ -93,7 +91,7 @@ class NewThreadScheduler(PeriodicScheduler):
         self,
         period: typing.RelativeTime,
         action: typing.ScheduledPeriodicAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules a periodic piece of work.
 

reactivex/scheduler/periodicscheduler.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import abc, typing
 from reactivex.disposable import Disposable, MultipleAssignmentDisposable
@@ -18,7 +18,7 @@ class PeriodicScheduler(Scheduler, abc.PeriodicSchedulerBase):
         self,
         period: typing.RelativeTime,
         action: typing.ScheduledPeriodicAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules a periodic piece of work.
 
@@ -38,8 +38,8 @@ class PeriodicScheduler(Scheduler, abc.PeriodicSchedulerBase):
         seconds: float = self.to_seconds(period)
 
         def periodic(
-            scheduler: abc.SchedulerBase, state: Optional[_TState] = None
-        ) -> Optional[Disposable]:
+            scheduler: abc.SchedulerBase, state: _TState | None = None
+        ) -> Disposable | None:
             if disp.is_disposed:
                 return None
 

reactivex/scheduler/scheduleditem.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Any, Optional
+from typing import Any
 
 from reactivex import abc
 from reactivex.disposable import SingleAssignmentDisposable
@@ -7,16 +7,16 @@ from reactivex.disposable import SingleAssignmentDisposable
 from .scheduler import Scheduler
 
 
-class ScheduledItem(object):
+class ScheduledItem:
     def __init__(
         self,
         scheduler: Scheduler,
-        state: Optional[Any],
+        state: Any | None,
         action: abc.ScheduledAction[Any],
         duetime: datetime,
     ) -> None:
         self.scheduler: Scheduler = scheduler
-        self.state: Optional[Any] = state
+        self.state: Any | None = state
         self.action: abc.ScheduledAction[Any] = action
         self.duetime: datetime = duetime
         self.disposable: SingleAssignmentDisposable = SingleAssignmentDisposable()

reactivex/scheduler/scheduler.py

@@ -1,6 +1,6 @@
 from abc import abstractmethod
 from datetime import datetime, timedelta, timezone
-from typing import Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import abc, typing
 from reactivex.disposable import Disposable
@@ -30,7 +30,7 @@ class Scheduler(abc.SchedulerBase):
 
     @abstractmethod
     def schedule(
-        self, action: abc.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: abc.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -50,7 +50,7 @@ class Scheduler(abc.SchedulerBase):
         self,
         duetime: typing.RelativeTime,
         action: abc.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -71,7 +71,7 @@ class Scheduler(abc.SchedulerBase):
         self,
         duetime: typing.AbsoluteTime,
         action: abc.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.
 
@@ -88,7 +88,7 @@ class Scheduler(abc.SchedulerBase):
         return NotImplemented
 
     def invoke_action(
-        self, action: abc.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: abc.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Invoke the given given action. This is typically called by instances
         of ScheduledItem.

reactivex/scheduler/threadpoolscheduler.py

@@ -1,5 +1,5 @@
 from concurrent.futures import Future, ThreadPoolExecutor
-from typing import Any, Optional
+from typing import Any
 
 from reactivex import abc, typing
 
@@ -17,7 +17,7 @@ class ThreadPoolScheduler(NewThreadScheduler):
         ):
             self.executor: ThreadPoolExecutor = executor
             self.target: typing.StartableTarget = target
-            self.future: Optional["Future[Any]"] = None
+            self.future: Future[Any] | None = None
 
         def start(self) -> None:
             self.future = self.executor.submit(self.target)
@@ -26,7 +26,7 @@ class ThreadPoolScheduler(NewThreadScheduler):
             if self.future:
                 self.future.cancel()
 
-    def __init__(self, max_workers: Optional[int] = None) -> None:
+    def __init__(self, max_workers: int | None = None) -> None:
         self.executor: ThreadPoolExecutor = ThreadPoolExecutor(max_workers=max_workers)
 
         def thread_factory(

reactivex/scheduler/timeoutscheduler.py

@@ -1,5 +1,6 @@
+from collections.abc import MutableMapping
 from threading import Lock, Timer
-from typing import MutableMapping, Optional, TypeVar
+from typing import TypeVar
 from weakref import WeakKeyDictionary
 
 from reactivex import abc, typing
@@ -34,7 +35,7 @@ class TimeoutScheduler(PeriodicScheduler):
         return cls.singleton()
 
     def schedule(
-        self, action: abc.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: abc.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -65,7 +66,7 @@ class TimeoutScheduler(PeriodicScheduler):
         self,
         duetime: typing.RelativeTime,
         action: abc.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -101,7 +102,7 @@ class TimeoutScheduler(PeriodicScheduler):
         self,
         duetime: typing.AbsoluteTime,
         action: abc.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.
 

reactivex/scheduler/trampoline.py

@@ -1,6 +1,5 @@
 from collections import deque
 from threading import Condition, Lock
-from typing import Deque
 
 from reactivex.internal.priorityqueue import PriorityQueue
 
@@ -34,7 +33,7 @@ class Trampoline:
                 self._queue.clear()
 
     def _run(self) -> None:
-        ready: Deque[ScheduledItem] = deque()
+        ready: deque[ScheduledItem] = deque()
         while True:
             with self._lock:
                 while len(self._queue) > 0:

reactivex/scheduler/trampolinescheduler.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Optional, TypeVar
+from typing import TypeVar
 
 from reactivex import abc, typing
 from reactivex.abc.disposable import DisposableBase
@@ -26,14 +26,13 @@ class TrampolineScheduler(Scheduler):
     """
 
     def __init__(self) -> None:
-
         self._tramp = Trampoline()
 
     def get_trampoline(self) -> Trampoline:
         return self._tramp
 
     def schedule(
-        self, action: abc.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: abc.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -52,7 +51,7 @@ class TrampolineScheduler(Scheduler):
         self,
         duetime: typing.RelativeTime,
         action: abc.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -73,7 +72,7 @@ class TrampolineScheduler(Scheduler):
         self,
         duetime: typing.AbsoluteTime,
         action: abc.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.
 
@@ -108,7 +107,7 @@ class TrampolineScheduler(Scheduler):
 
     def ensure_trampoline(
         self, action: ScheduledAction[_TState]
-    ) -> Optional[DisposableBase]:
+    ) -> DisposableBase | None:
         """Method for testing the TrampolineScheduler."""
 
         if self.schedule_required():

reactivex/scheduler/virtualtimescheduler.py

@@ -1,7 +1,7 @@
 import logging
 import threading
 from datetime import datetime, timedelta
-from typing import Any, Optional, TypeVar
+from typing import Any, TypeVar
 
 from reactivex import abc, typing
 from reactivex.abc.scheduler import AbsoluteTime
@@ -54,7 +54,7 @@ class VirtualTimeScheduler(PeriodicScheduler):
         return self.to_datetime(self._clock)
 
     def schedule(
-        self, action: typing.ScheduledAction[_TState], state: Optional[_TState] = None
+        self, action: typing.ScheduledAction[_TState], state: _TState | None = None
     ) -> abc.DisposableBase:
         """Schedules an action to be executed.
 
@@ -73,7 +73,7 @@ class VirtualTimeScheduler(PeriodicScheduler):
         self,
         duetime: typing.RelativeTime,
         action: abc.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed after duetime.
 
@@ -94,7 +94,7 @@ class VirtualTimeScheduler(PeriodicScheduler):
         self,
         duetime: typing.AbsoluteTime,
         action: abc.ScheduledAction[_TState],
-        state: Optional[_TState] = None,
+        state: _TState | None = None,
     ) -> abc.DisposableBase:
         """Schedules an action to be executed at duetime.