code: def dijkstra_predecessor_and_distance(
      G, source, cutoff=None, weight="weight"
  ):
      """Compute weighted shortest path length and predecessors.
  
      Uses Dijkstra's Method to obtain the shortest weighted paths
      and return dictionaries of predecessors for each node and
      distance for each node from the `source`.
  
      Parameters
      ----------
      G : NetworkX graph
  
      source : node label
          Starting node for path
  
      cutoff : integer or float, optional
          Length (sum of edge weights) at which the search is stopped.
          If cutoff is provided, only return paths with summed weight <= cutoff.
  
      weight : string or function
          If this is a string, then edge weights will be accessed via the
          edge attribute with this key (that is, the weight of the edge
          joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
          such edge attribute exists, the weight of the edge is assumed to
          be one.
  
          If this is a function, the weight of an edge is the value
          returned by the function. The function must accept exactly three
          positional arguments: the two endpoints of an edge and the
          dictionary of edge attributes for that edge. The function must
          return a number or None to indicate a hidden edge.
  
      Returns
      -------
      pred, distance : dictionaries
          Returns two dictionaries representing a list of predecessors
          of a node and the distance to each node.
  
      Raises
      ------
      NodeNotFound
          If `source` is not in `G`.
  
      Notes
      -----
      Edge weight attributes must be numerical.
      Distances are calculated as sums of weighted edges traversed.
  
      The list of predecessors contains more than one element only when
      there are more than one shortest paths to the key node.
  
      Examples
      --------
      >>> G = nx.path_graph(5, create_using=nx.DiGraph())
      >>> pred, dist = nx.dijkstra_predecessor_and_distance(G, 0)
      >>> sorted(pred.items())
      [(0, []), (1, [0]), (2, [1]), (3, [2]), (4, [3])]
      >>> sorted(dist.items())
      [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
  
      >>> pred, dist = nx.dijkstra_predecessor_and_distance(G, 0, 1)
      >>> sorted(pred.items())
      [(0, []), (1, [0])]
      >>> sorted(dist.items())
      [(0, 0), (1, 1)]
      """
      if source not in G:
          raise nx.NodeNotFound(
              f"Node {source} is not found in the graph"
          )
      weight = _weight_function(G, weight)
      pred = {source: []}  # dictionary of predecessors
      return (
          pred,
          _dijkstra(G, source, weight, pred=pred, cutoff=cutoff),
      )
  
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 12 for calling a global function with example usage: dijkstra_predecessor_and_distance(G, source, cutoff, weight) and returns: pred,  _dijkstra