code: def context_teardown(func: Callable):
      
      @wraps(func)
      async def wrapper(*args, **kwargs) -> None:
          async def teardown_callback(exception: Optional[Exception]):
              try:
                  await generator.asend(exception)
              except StopAsyncIteration:
                  pass
              finally:
                  await generator.aclose()
  
          try:
              ctx = next(arg for arg in args[:2] if isinstance(arg, Context))
          except StopIteration:
              raise RuntimeError('the first positional argument to {}() has to be a Context '
                                 'instance'.format(callable_name(func))) from None
  
          generator = func(*args, **kwargs)
          try:
              await generator.asend(None)
          except StopAsyncIteration:
              pass
          except BaseException:
              await generator.aclose()
              raise
          else:
              ctx.add_teardown_callback(teardown_callback, True)
  
      if iscoroutinefunction(func):
          func = async_generator(func)
      elif not isasyncgenfunction(func):
          raise TypeError('{} must be an async generator function'.format(callable_name(func)))
  
      return wrapper
docs: Wrap an async generator function to execute the rest of the function at context teardown.
  
      This function returns an async function, which, when called, starts the wrapped async
      generator. The wrapped async function is run until the first ``yield`` statement
      (``await async_generator.yield_()`` on Python 3.5). When the context is being torn down, the
      exception that ended the context, if any, is sent to the generator.
  
      For example::
  
          class SomeComponent(Component):
              @context_teardown
              async def start(self, ctx: Context):
                  service = SomeService()
                  ctx.add_resource(service)
                  exception = yield
                  service.stop()
  
      :param func: an async generator function
      :return: an async function