Generics for ObservableDeferred

Now that `Deferred` is a generic class, let's update `ObeservableDeferred` to
follow suit.

changelog.d/10491.misc

@@ -0,0 +1 @@
+Improve type annotations for `ObservableDeferred`.

synapse/notifier.py

@@ -111,8 +111,9 @@ def __init__(
         self.last_notified_token = current_token
         self.last_notified_ms = time_now_ms
 
-        with PreserveLoggingContext():
-            self.notify_deferred = ObservableDeferred(defer.Deferred())
+        self.notify_deferred: ObservableDeferred[StreamToken] = ObservableDeferred(
+            defer.Deferred()
+        )
 
     def notify(
         self,

synapse/storage/persist_events.py

@@ -170,7 +170,9 @@ async def add_to_queue(
             end_item = queue[-1]
         else:
             # need to make a new queue item
-            deferred = ObservableDeferred(defer.Deferred(), consumeErrors=True)
+            deferred: ObservableDeferred[_PersistResult] = ObservableDeferred(
+                defer.Deferred(), consumeErrors=True
+            )
 
             end_item = _EventPersistQueueItem(
                 events_and_contexts=[],

synapse/util/async_helpers.py

@@ -23,6 +23,7 @@
     Awaitable,
     Callable,
     Dict,
+    Generic,
     Hashable,
     Iterable,
     List,
@@ -52,7 +53,7 @@
 _T = TypeVar("_T")
 
 
-class ObservableDeferred:
+class ObservableDeferred(Generic[_T]):
     """Wraps a deferred object so that we can add observer deferreds. These
     observer deferreds do not affect the callback chain of the original
     deferred.
@@ -70,7 +71,7 @@ class ObservableDeferred:
 
     __slots__ = ["_deferred", "_observers", "_result"]
 
-    def __init__(self, deferred: defer.Deferred, consumeErrors: bool = False):
+    def __init__(self, deferred: defer.Deferred[_T], consumeErrors: bool = False):
         object.__setattr__(self, "_deferred", deferred)
         object.__setattr__(self, "_result", None)
         object.__setattr__(self, "_observers", set())
@@ -115,15 +116,15 @@ def errback(f):
 
         deferred.addCallbacks(callback, errback)
 
-    def observe(self) -> defer.Deferred:
+    def observe(self) -> defer.Deferred[_T]:
         """Observe the underlying deferred.
 
         This returns a brand new deferred that is resolved when the underlying
         deferred is resolved. Interacting with the returned deferred does not
         effect the underlying deferred.
         """
         if not self._result:
-            d: defer.Deferred[Any] = defer.Deferred()
+            d: defer.Deferred[_T] = defer.Deferred()
 
             def remove(r):
                 self._observers.discard(d)
@@ -137,7 +138,7 @@ def remove(r):
             success, res = self._result
             return defer.succeed(res) if success else defer.fail(res)
 
-    def observers(self) -> List[defer.Deferred]:
+    def observers(self) -> List[defer.Deferred[_T]]:
         return self._observers
 
     def has_called(self) -> bool:
@@ -146,7 +147,7 @@ def has_called(self) -> bool:
     def has_succeeded(self) -> bool:
         return self._result is not None and self._result[0] is True
 
-    def get_result(self) -> Any:
+    def get_result(self) -> _T:
         return self._result[1]
 
     def __getattr__(self, name: str) -> Any: