code: def single_source_dijkstra_path(
      G, source, cutoff=None, weight="weight"
  ):
      """Find shortest weighted paths in G from a source node.
  
      Compute shortest path between source and all other reachable
      nodes for a weighted graph.
  
      Parameters
      ----------
      G : NetworkX graph
  
      source : node
          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
      -------
      paths : dictionary
          Dictionary of shortest path lengths keyed by target.
  
      Raises
      ------
      NodeNotFound
          If `source` is not in `G`.
  
      Examples
      --------
      >>> G = nx.path_graph(5)
      >>> path = nx.single_source_dijkstra_path(G, 0)
      >>> path[4]
      [0, 1, 2, 3, 4]
  
      Notes
      -----
      Edge weight attributes must be numerical.
      Distances are calculated as sums of weighted edges traversed.
  
      The weight function can be used to hide edges by returning None.
      So ``weight = lambda u, v, d: 1 if d['color']=="red" else None``
      will find the shortest red path.
  
      See Also
      --------
      single_source_dijkstra, single_source_bellman_ford
  
      """
      return multi_source_dijkstra_path(
          G, {source}, cutoff=cutoff, weight=weight
      )
  
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 4 for calling a global function with example usage: single_source_dijkstra_path(G, source, cutoff, weight) and returns: multi_source_dijkstra_path