code: def maximum_spanning_edges(
      G,
      algorithm="kruskal",
      weight="weight",
      keys=True,
      data=True,
      ignore_nan=False,
  ):
      """Generate edges in a maximum spanning forest of an undirected
      weighted graph.
  
      A maximum spanning tree is a subgraph of the graph (a tree)
      with the maximum possible sum of edge weights.  A spanning forest is a
      union of the spanning trees for each connected component of the graph.
  
      Parameters
      ----------
      G : undirected Graph
         An undirected graph. If `G` is connected, then the algorithm finds a
         spanning tree. Otherwise, a spanning forest is found.
  
      algorithm : string
         The algorithm to use when finding a maximum spanning tree. Valid
         choices are 'kruskal', 'prim', or 'boruvka'. The default is 'kruskal'.
  
      weight : string
         Edge data key to use for weight (default 'weight').
  
      keys : bool
         Whether to yield edge key in multigraphs in addition to the edge.
         If `G` is not a multigraph, this is ignored.
  
      data : bool, optional
         If True yield the edge data along with the edge.
  
      ignore_nan : bool (default: False)
          If a NaN is found as an edge weight normally an exception is raised.
          If `ignore_nan is True` then that edge is ignored instead.
  
      Returns
      -------
      edges : iterator
         An iterator over edges in a maximum spanning tree of `G`.
         Edges connecting nodes `u` and `v` are represented as tuples:
         `(u, v, k, d)` or `(u, v, k)` or `(u, v, d)` or `(u, v)`
  
         If `G` is a multigraph, `keys` indicates whether the edge key `k` will
         be reported in the third position in the edge tuple. `data` indicates
         whether the edge datadict `d` will appear at the end of the edge tuple.
  
         If `G` is not a multigraph, the tuples are `(u, v, d)` if `data` is True
         or `(u, v)` if `data` is False.
  
      Examples
      --------
      >>> from networkx.algorithms import tree
  
      Find maximum spanning edges by Kruskal's algorithm
  
      >>> G = nx.cycle_graph(4)
      >>> G.add_edge(0, 3, weight=2)
      >>> mst = tree.maximum_spanning_edges(G, algorithm="kruskal", data=False)
      >>> edgelist = list(mst)
      >>> sorted(sorted(e) for e in edgelist)
      [[0, 1], [0, 3], [1, 2]]
  
      Find maximum spanning edges by Prim's algorithm
  
      >>> G = nx.cycle_graph(4)
      >>> G.add_edge(0, 3, weight=2)  # assign weight 2 to edge 0-3
      >>> mst = tree.maximum_spanning_edges(G, algorithm="prim", data=False)
      >>> edgelist = list(mst)
      >>> sorted(sorted(e) for e in edgelist)
      [[0, 1], [0, 3], [2, 3]]
  
      Notes
      -----
      For Borůvka's algorithm, each edge must have a weight attribute, and
      each edge weight must be distinct.
  
      For the other algorithms, if the graph edges do not have a weight
      attribute a default weight of 1 will be used.
  
      Modified code from David Eppstein, April 2006
      http://www.ics.uci.edu/~eppstein/PADS/
      """
      try:
          algo = ALGORITHMS[algorithm]
      except KeyError as err:
          msg = f"{algorithm} is not a valid choice for an algorithm."
          raise ValueError(msg) from err
  
      return algo(
          G,
          minimum=False,
          weight=weight,
          keys=keys,
          data=data,
          ignore_nan=ignore_nan,
      )
  
imports: from dataclasses import dataclass, field
  from enum import Enum
  from heapq import heappop, heappush
  from itertools import count
  from math import isnan
  from operator import itemgetter
  from queue import PriorityQueue
  import networkx
  from networkx.utils import UnionFind, not_implemented_for, py_random_state
label_desc: Use image node_id 5 for calling a global function with example usage: maximum_spanning_edges(G, algorithm, weight, keys, data, ignore_nan) and returns: algo