code: def trace_and_update_module(
      module: tf.Module,
      tf_function: tf.types.experimental.GenericFunction,
      name: str,
      strip_control_dependencies: bool,
  ) -> function.ConcreteFunction:
      """Traces `tf_function` and saves under attr `name` of `module`.
  
      Args:
        module: A saveable module which will contain the traced `tf_function` under
          attr `name`.
        tf_function: A tf.function to trace.
        name: A name to same the traced `tf_function` to.
        strip_control_dependencies: Boolean. If True, automatic control dependencies
          will be stripped from the outputs of `tf_function`. This should almost
          always be False. It is useful only if you want to use the structure of the
          TF graph to perform any graph manipulations.
  
      Returns:
        The concrete function obtained from tracing `tf_function`.
      """
      resource_tracker = tracking.ResourceTracker()
      object_tracker = annotators.ObjectTracker()
      created_variables = []
  
      def _variable_creator(next_creator, **kwargs):
          var = next_creator(**kwargs)
          created_variables.append(var)
          return var
  
      # Trace `tf_function` to gather any resources in it using the
      # resource_tracker. These are then assigned to `module.resources` and tracked
      # before exporting to SavedModel.
      with tracking.resource_tracker_scope(
          resource_tracker
      ), annotators.object_tracker_scope(
          object_tracker
      ), tf.variable_creator_scope(
          _variable_creator
      ):
          concrete_fn = tf_function.get_concrete_function()
  
      # Prior to 2020/10/08, saving a tf.function with a concrete function signature
      # would ensure that the function was not re-traced in a round-trip to a
      # SavedModel. Since this is no longer the case, we save the concrete function
      # directly.
      if tf.compat.forward_compatible(2020, 10, 8):
          pruned_function = optimize_concrete_function(
              concrete_fn, strip_control_dependencies
          )
          module.pruned_variables = pruned_function.variables
          setattr(module, name, pruned_function)
      else:
          setattr(module, name, tf_function)
  
      # Any variables created need to be explicitly tracked.
      module.created_variables = created_variables
      # Resources need to be explicitly tracked.
      module.resources = resource_tracker.resources
      module.trackable_objects = object_tracker.trackable_objects
      # TODO(b/158011374) - Stop explicitly tracking initializers. Tracking the
      # table should be sufficient.
      initializers = []
      for resource in module.resources:
          if isinstance(
              resource, lookup_ops.InitializableLookupTableBase
          ):
              initializers.append(
                  resource._initializer
              )  # pylint: disable=protected-access
      module.initializers = initializers
      module.assets = [
          tf.saved_model.Asset(asset_filepath)
          for asset_filepath in concrete_fn.graph.get_collection(
              tf.compat.v1.GraphKeys.ASSET_FILEPATHS
          )
      ]
      return concrete_fn
  
imports: from typing import Any, Dict, Iterable, Mapping, Tuple, Union
  import tensorflow
  from tensorflow_transform import annotators
  from tensorflow_transform import common_types
  from tensorflow_transform import graph_tools
  from tensorflow_transform import tf2_utils
  from tensorflow_transform import tf_utils
  from tensorflow_transform.py_func import pyfunc_helper
  from tensorflow_transform.saved import constants
  from tensorflow_transform.saved import saved_model_loader
  from tensorflow_transform.saved import saved_transform_io
  from tensorflow.python.eager import function
  from tensorflow.python.eager import wrap_function
  from tensorflow.python.framework import composite_tensor
  from tensorflow.python.ops import lookup_ops
  from tensorflow.python.util import object_identity
label_desc: Use image node_id 6 for calling a global function with example usage: trace_and_update_module(module, tf_function, name, strip_control_dependencies) and returns: concrete_fn, var