code: def configuration_model(deg_sequence, create_using=None, seed=None):
      """Returns a random graph with the given degree sequence.
  
      The configuration model generates a random pseudograph (graph with
      parallel edges and self loops) by randomly assigning edges to
      match the given degree sequence.
  
      Parameters
      ----------
      deg_sequence :  list of nonnegative integers
          Each list entry corresponds to the degree of a node.
      create_using : NetworkX graph constructor, optional (default MultiGraph)
          Graph type to create. If graph instance, then cleared before populated.
      seed : integer, random_state, or None (default)
          Indicator of random number generation state.
          See :ref:`Randomness<randomness>`.
  
      Returns
      -------
      G : MultiGraph
          A graph with the specified degree sequence.
          Nodes are labeled starting at 0 with an index
          corresponding to the position in deg_sequence.
  
      Raises
      ------
      NetworkXError
          If the degree sequence does not have an even sum.
  
      See Also
      --------
      is_graphical
  
      Notes
      -----
      As described by Newman [1]_.
  
      A non-graphical degree sequence (not realizable by some simple
      graph) is allowed since this function returns graphs with self
      loops and parallel edges.  An exception is raised if the degree
      sequence does not have an even sum.
  
      This configuration model construction process can lead to
      duplicate edges and loops.  You can remove the self-loops and
      parallel edges (see below) which will likely result in a graph
      that doesn't have the exact degree sequence specified.
  
      The density of self-loops and parallel edges tends to decrease as
      the number of nodes increases. However, typically the number of
      self-loops will approach a Poisson distribution with a nonzero mean,
      and similarly for the number of parallel edges.  Consider a node
      with *k* stubs. The probability of being joined to another stub of
      the same node is basically (*k* - *1*) / *N*, where *k* is the
      degree and *N* is the number of nodes. So the probability of a
      self-loop scales like *c* / *N* for some constant *c*. As *N* grows,
      this means we expect *c* self-loops. Similarly for parallel edges.
  
      References
      ----------
      .. [1] M.E.J. Newman, "The structure and function of complex networks",
         SIAM REVIEW 45-2, pp 167-256, 2003.
  
      Examples
      --------
      You can create a degree sequence following a particular distribution
      by using the one of the distribution functions in
      :mod:`~networkx.utils.random_sequence` (or one of your own). For
      example, to create an undirected multigraph on one hundred nodes
      with degree sequence chosen from the power law distribution:
  
      >>> sequence = nx.random_powerlaw_tree_sequence(100, tries=5000)
      >>> G = nx.configuration_model(sequence)
      >>> len(G)
      100
      >>> actual_degrees = [d for v, d in G.degree()]
      >>> actual_degrees == sequence
      True
  
      The returned graph is a multigraph, which may have parallel
      edges. To remove any parallel edges from the returned graph:
  
      >>> G = nx.Graph(G)
  
      Similarly, to remove self-loops:
  
      >>> G.remove_edges_from(nx.selfloop_edges(G))
  
      """
      if sum(deg_sequence) % 2 != 0:
          msg = "Invalid degree sequence: sum of degrees must be even, not odd"
          raise nx.NetworkXError(msg)
  
      G = nx.empty_graph(0, create_using, default=nx.MultiGraph)
      if G.is_directed():
          raise nx.NetworkXNotImplemented(
              "not implemented for directed graphs"
          )
  
      G = _configuration_model(deg_sequence, G, seed=seed)
  
      return G
  
imports: import heapq
  import math
  from itertools import chain, combinations, zip_longest
  from operator import itemgetter
  import networkx
  from networkx.utils import py_random_state, random_weighted_sample
label_desc: Use image node_id 3 for calling a global function with example usage: configuration_model(deg_sequence, create_using, seed) and returns: G