code: def _weight_function(G, weight):
      """Returns a function that returns the weight of an edge.
  
      The returned function is specifically suitable for input to
      functions :func:`_dijkstra` and :func:`_bellman_ford_relaxation`.
  
      Parameters
      ----------
      G : NetworkX graph.
  
      weight : string or function
          If it is callable, `weight` itself is returned. If it is a string,
          it is assumed to be the name of the edge attribute that represents
          the weight of an edge. In that case, a function is returned that
          gets the edge weight according to the specified edge attribute.
  
      Returns
      -------
      function
          This function returns a callable that accepts exactly three inputs:
          a node, an node adjacent to the first one, and the edge attribute
          dictionary for the eedge joining those nodes. That function returns
          a number representing the weight of an edge.
  
      If `G` is a multigraph, and `weight` is not callable, the
      minimum edge weight over all parallel edges is returned. If any edge
      does not have an attribute with key `weight`, it is assumed to
      have weight one.
  
      """
      if callable(weight):
          return weight
      # If the weight keyword argument is not callable, we assume it is a
      # string representing the edge attribute containing the weight of
      # the edge.
      if G.is_multigraph():
          return lambda u, v, d: min(
              attr.get(weight, 1) for attr in d.values()
          )
      return lambda u, v, data: data.get(weight, 1)
  
imports: from collections import deque
  from heapq import heappop, heappush
  from itertools import count
  import networkx
  from networkx.algorithms.shortest_paths.generic import _build_paths_from_predecessors
label_desc: Use image node_id 1 for calling a global function with example usage: _weight_function(G, weight) and returns: function, weight, function