code: def fully_connect_graph_static(
      graph, exclude_self_edges=False, name="fully_connect_graph_static"
  ):
      """Adds edges to a graph by fully-connecting the nodes.
  
      This method can be used if the number of nodes for each graph in `graph` is
      constant and known at graph building time: it will be inferred by dividing
      the number of nodes in the batch(the length of `graph.nodes`) by the number of
      graphs in the batch (the length of `graph.n_node`). It is an error to call
      this method with batches of graphs with dynamic or uneven sizes; in the latter
      case, the method may silently yield an incorrect result.
  
      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`.
        ValueError: If the number of graphs (extracted from `graph.n_node` leading
          dimension) or number of nodes (extracted from `graph.nodes` leading
          dimension) is not known at construction time, or if the latter does not
          divide the former (observe that this is only a necessary condition for
          the constantness of the number of nodes per graph).
      """
      _validate_edge_fields_are_all_none(graph)
  
      num_graphs = graph.n_node.shape.as_list()[0]
      if num_graphs is None:
          raise ValueError(
              "Number of graphs must be known at construction time when "
              "using `fully_connect_graph_static`. Did you mean to use "
              "`fully_connect_graph_dynamic`?"
          )
      num_nodes = graph.nodes.shape.as_list()[0]
      if num_nodes is None:
          raise ValueError(
              "Number of nodes must be known at construction time when "
              "using `fully_connect_graph_static`. Did you mean to use "
              "`fully_connect_graph_dynamic`?"
          )
      if num_nodes % num_graphs != 0:
          raise ValueError(
              "Number of nodes must be the same in all graphs when "
              "using `fully_connect_graph_static`. Did you mean to use "
              "`fully_connect_graph_dynamic`?"
          )
      num_nodes_per_graph = num_nodes // num_graphs
  
      with tf.name_scope(name):
          one_graph_edges = _create_complete_edges_from_nodes_static(
              num_nodes_per_graph, exclude_self_edges
          )
          n_edges = num_nodes_per_graph * (num_nodes_per_graph - 1)
          if not exclude_self_edges:
              n_edges += num_nodes_per_graph
  
          all_graph_edges = {
              k: tf.tile(v, [num_graphs])
              for k, v in six.iteritems(one_graph_edges)
          }
          offsets = [
              num_nodes_per_graph
              * i  # pylint: disable=g-complex-comprehension
              for i in range(num_graphs)
              for _ in range(n_edges)
          ]
          all_graph_edges[RECEIVERS] += offsets
          all_graph_edges[SENDERS] += offsets
          return graph.replace(**all_graph_edges)
  
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 20 for calling a global function with example usage: fully_connect_graph_static(graph, exclude__edges, name) and returns: graph