code: def teardown_appcontext(self, fn):
          
          self._defer(lambda app: app.teardown_appcontext(fn))
          return fn
docs: Registers a function to be called when the application context
          ends.  These functions are typically also called when the request
          context is popped.
  
          Example::
  
              ctx = app.app_context()
              ctx.push()
              ...
              ctx.pop()
  
          When ``ctx.pop()`` is executed in the above example, the teardown
          functions are called just before the app context moves from the
          stack of active contexts.  This becomes relevant if you are using
          such constructs in tests.
  
          Since a request context typically also manages an application
          context it would also be called when you pop a request context.
  
          When a teardown function was called because of an unhandled exception
          it will be passed an error object. If an :meth:`errorhandler` is
          registered, it will handle the exception and the teardown will not
          receive it.
  
          The return values of teardown functions are ignored.