code: def map_structure(modality, func, *structure, **kwargs):
      """Creates a new structure by applying `func` to each atom in `structure`.
  
      - For Modality.CORE: Refer to
      [tf.nest](https://www.tensorflow.org/api_docs/python/tf/nest)
      for the definition of a structure.
  
      Applies `func(x[0], x[1], ...)` where x[i] enumerates all atoms in
      `structure[i]`.  All items in `structure` must have the same arity,
      and the return value will contain results with the same structure layout.
  
      Examples:
  
      * A single Python dict:
  
      >>> a = {"hello": 24, "world": 76}
      >>> tf.nest.map_structure(lambda p: p * 2, a)
      {'hello': 48, 'world': 152}
  
      * Multiple Python dictionaries:
  
      >>> d1 = {"hello": 24, "world": 76}
      >>> d2 = {"hello": 36, "world": 14}
      >>> tf.nest.map_structure(lambda p1, p2: p1 + p2, d1, d2)
      {'hello': 60, 'world': 90}
  
      * A single Python list:
  
      >>> a = [24, 76, "ab"]
      >>> tf.nest.map_structure(lambda p: p * 2, a)
      [48, 152, 'abab']
  
      * Scalars:
  
      >>> tf.nest.map_structure(lambda x, y: x + y, 3, 4)
      7
  
      * Empty structures:
  
      >>> tf.nest.map_structure(lambda x: x + 1, ())
      ()
  
      * Check the types of iterables:
  
      >>> s1 = (((1, 2), 3), 4, (5, 6))
      >>> s1_list = [[[1, 2], 3], 4, [5, 6]]
      >>> tf.nest.map_structure(lambda x, y: None, s1, s1_list)
      Traceback (most recent call last):
      ...
      TypeError: The two structures don't have the same nested structure
  
      * Type check is set to False:
  
      >>> s1 = (((1, 2), 3), 4, (5, 6))
      >>> s1_list = [[[1, 2], 3], 4, [5, 6]]
      >>> tf.nest.map_structure(lambda x, y: None, s1, s1_list, check_types=False)
      (((None, None), None), None, (None, None))
  
      - For Modality.DATA: Applies `func(x[0], x[1], ...)` where x[i] is an entry in
      `structure[i]`.  All structures in `structure` must have the same arity,
      and the return value will contain the results in the same structure.
  
      Args:
        modality: enum value of supported modality [Modality.CORE or Modality.DATA]
        func: A callable that accepts as many arguments as there are structures.
        *structure: - For Modality.CORE: atom or nested structure. - For
          Modality.DATA: scalar, or tuple or list of constructed scalars and/or
          other tuples/lists, or scalars.  Note: numpy arrays are considered
          scalars.
        **kwargs: Valid keyword args are: * `check_types`: - For Modality.CORE: If
          set to `True` (default) the types of iterables within the structures have
          to be same (e.g. `map_structure(func, [1], (1,))` raises a `TypeError`
          exception). To allow this set this argument to `False`. Note that
          namedtuples with identical name and fields are always considered to have
          the same shallow structure. - For Modality.DATA: only valid keyword
          argument is `check_types`. If set to `True` (default) the types of
          iterables within the structures have to be same (e.g. `map_structure(func,
          [1], (1,))` raises a `TypeError` exception). To allow this set this
          argument to `False`. * `expand_composites`: Valid for Modality.CORE only.
          If set to `True`, then composite tensors such as `tf.sparse.SparseTensor`
          and `tf.RaggedTensor` are expanded into their component tensors.  If
          `False` (the default), then composite tensors are not expanded.
  
      Returns:
        A new structure with the same arity as `structure[0]`, whose atoms
        correspond to `func(x[0], x[1], ...)` where `x[i]` is the atom in the
        corresponding location in `structure[i]`. If there are different structure
        types and `check_types` is `False` the structure types of the first
        structure will be used.
  
      Raises:
        TypeError: If `func` is not callable or if the structures do not match
          each other by depth tree.
        ValueError: If no structure is provided or if the structures do not match
          each other by type.
        ValueError: If wrong keyword arguments are provided.
      """
      if modality == Modality.CORE:
          return _tf_core_map_structure(func, *structure, **kwargs)
      elif modality == Modality.DATA:
          return _tf_data_map_structure(func, *structure, **kwargs)
      else:
          raise ValueError(
              "Unknown modality used {} for nested structure".format(
                  modality
              )
          )
  
imports: import collections
  import enum
  import wrapt
  from tensorflow.python import pywrap_tensorflow
  from tensorflow.python.platform import tf_logging
  from tensorflow.python.util import _pywrap_utils
  from tensorflow.python.util.compat import collections_abc
  from tensorflow.python.util.custom_nest_protocol import CustomNestProtocol
label_desc: Use image node_id 22 for calling a global function with example usage: map_structure(modality, func) and returns: _tf_core_map_structure, _tf_data_map_structure