code: def fully_connect_graph_dynamic(
      graph,
      exclude_self_edges=False,
      name="fully_connect_graph_dynamic",
  ):
      """Adds edges to a graph by fully-connecting the nodes.
  
      This method does not require the number of nodes per graph to be constant,
      or to be known at graph building time.
  
      Args:
        graph: A `graphs.GraphsTuple` with `None` values for the edges, senders and
          receivers.
        exclude_self_edges (default=False): Excludes self-connected edges.
        name: (string, optional) A name for the operation.
  
      Returns:
        A `graphs.GraphsTuple` containing `Tensor`s with fully-connected edges.
  
      Raises:
        ValueError: if any of the `EDGES`, `RECEIVERS` or `SENDERS` field is not
          `None` in `graph`.
      """
      _validate_edge_fields_are_all_none(graph)
  
      with tf.name_scope(name):
  
          def body(i, senders, receivers, n_edge):
              edges = _create_complete_edges_from_nodes_dynamic(
                  graph.n_node[i], exclude_self_edges
              )
              return (
                  i + 1,
                  senders.write(i, edges[SENDERS]),
                  receivers.write(i, edges[RECEIVERS]),
                  n_edge.write(i, edges[N_EDGE]),
              )
  
          num_graphs = get_num_graphs(graph)
          loop_condition = lambda i, *_: tf.less(i, num_graphs)
          initial_loop_vars = [0] + [
              tf.TensorArray(
                  dtype=tf.int32, size=num_graphs, infer_shape=False
              )
              for _ in range(3)  # senders, receivers, n_edge
          ]
          (
              _,
              senders_array,
              receivers_array,
              n_edge_array,
          ) = tf.while_loop(
              loop_condition, body, initial_loop_vars, back_prop=False
          )
  
          n_edge = n_edge_array.concat()
          offsets = _compute_stacked_offsets(graph.n_node, n_edge)
          senders = senders_array.concat() + offsets
          receivers = receivers_array.concat() + offsets
          senders.set_shape(offsets.shape)
          receivers.set_shape(offsets.shape)
  
          receivers.set_shape([None])
          senders.set_shape([None])
  
          num_graphs = graph.n_node.get_shape().as_list()[0]
          n_edge.set_shape([num_graphs])
  
          return graph._replace(
              senders=senders, receivers=receivers, n_edge=n_edge
          )
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import collections
  import functools
  from absl import logging
  from graph_nets import graphs
  from graph_nets import utils_np
  import six
  from six.moves import range
  import tensorflow
  import tree
label_desc: Use image node_id 21 for calling a global function with example usage: fully_connect_graph_dynamic(graph, exclude__edges, name) and returns: graph, unknown,  senders,  receivers,  n_edge