docs: def with_timeout(timeout, d, reactor=reactor):
      """Returns a `Deferred` that is in all respects equivalent to `d`, e.g. when `cancel()` is called on it `Deferred`,
      the wrapped `Deferred` will also be cancelled; however, a `Timeout` will be fired after the `timeout` number of
      seconds if `d` has not fired by that time.
  
      When a `Timeout` is raised, `d` will be cancelled. It is up to the caller to worry about how `d` handles
      cancellation, i.e. whether it has full/true support for cancelling, or does cancelling it just prevent its callbacks
      from being fired but doesn't cancel the underlying operation.
  
      """
      if timeout is None or not isinstance(d, Deferred):
          return d
  
      ret = Deferred(canceller=lambda _: (
          d.cancel(),
          timeout_d.cancel(),
      ))
  
      timeout_d = sleep(timeout, reactor)
      timeout_d.addCallback(lambda _: (
          d.cancel(),
          ret.errback(Failure(Timeout())) if not ret.called else None,
      ))
  
      timeout_d.addErrback(lambda f: f.trap(CancelledError))
  
      d.addCallback(lambda result: (
          timeout_d.cancel(),
          ret.callback(result),
      ))
  
      d.addErrback(lambda f: (
          if_(not f.check(CancelledError), lambda: (
              timeout_d.cancel(),
              ret.errback(f),
              )),
      ))
  
      return ret