code: def wrap(fn):
      """Returns a callable object that will restore the current `StackContext`
      when executed.
  
      Use this whenever saving a callback to be executed later in a
      different execution context (either in a different thread or
      asynchronously in the same thread).
      """
      # Check if function is already wrapped
      if fn is None or hasattr(fn, "_wrapped"):
          return fn
  
      # Capture current stack head
      # TODO: Any other better way to store contexts and update them in wrapped function?
      cap_contexts = [_state.contexts]
  
      if not cap_contexts[0][0] and not cap_contexts[0][1]:
          # Fast path when there are no active contexts.
          def null_wrapper(*args, **kwargs):
              try:
                  current_state = _state.contexts
                  _state.contexts = cap_contexts[0]
                  return fn(*args, **kwargs)
              finally:
                  _state.contexts = current_state
  
          null_wrapper._wrapped = True
          return null_wrapper
  
      def wrapped(*args, **kwargs):
          ret = None
          try:
              # Capture old state
              current_state = _state.contexts
  
              # Remove deactivated items
              cap_contexts[0] = contexts = _remove_deactivated(
                  cap_contexts[0]
              )
  
              # Force new state
              _state.contexts = contexts
  
              # Current exception
              exc = (None, None, None)
              top = None
  
              # Apply stack contexts
              last_ctx = 0
              stack = contexts[0]
  
              # Apply state
              for n in stack:
                  try:
                      n.enter()
                      last_ctx += 1
                  except:
                      # Exception happened. Record exception info and store top-most handler
                      exc = sys.exc_info()
                      top = n.old_contexts[1]
  
              # Execute callback if no exception happened while restoring state
              if top is None:
                  try:
                      ret = fn(*args, **kwargs)
                  except:
                      exc = sys.exc_info()
                      top = contexts[1]
  
              # If there was exception, try to handle it by going through the exception chain
              if top is not None:
                  exc = _handle_exception(top, exc)
              else:
                  # Otherwise take shorter path and run stack contexts in reverse order
                  while last_ctx > 0:
                      last_ctx -= 1
                      c = stack[last_ctx]
  
                      try:
                          c.exit(*exc)
                      except:
                          exc = sys.exc_info()
                          top = c.old_contexts[1]
                          break
                  else:
                      top = None
  
                  # If if exception happened while unrolling, take longer exception handler path
                  if top is not None:
                      exc = _handle_exception(top, exc)
  
              # If exception was not handled, raise it
              if exc != (None, None, None):
                  raise_exc_info(exc)
          finally:
              _state.contexts = current_state
          return ret
  
      wrapped._wrapped = True
      return wrapped
  
imports: from __future__ import absolute_import, division, print_function, with_statement
  import sys
  import threading
  from .util import raise_exc_info
label_desc: Use image node_id 2 for calling a global function with example usage: wrap(fn) and returns: wrapped, fn, null_wrapper, ret, fn