code: def dijkstra_path(G, source, target, weight="weight"):
      """Returns the shortest weighted path from source to target in G.
  
      Uses Dijkstra's Method to compute the shortest weighted path
      between two nodes in a graph.
  
      Parameters
      ----------
      G : NetworkX graph
  
      source : node
          Starting node
  
      target : node
          Ending node
  
      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
      -------
      path : list
          List of nodes in a shortest path.
  
      Raises
      ------
      NodeNotFound
          If `source` is not in `G`.
  
      NetworkXNoPath
          If no path exists between source and target.
  
      Examples
      --------
      >>> G = nx.path_graph(5)
      >>> print(nx.dijkstra_path(G, 0, 4))
      [0, 1, 2, 3, 4]
  
      Find edges of shortest path in Multigraph
  
      >>> G = nx.MultiDiGraph()
      >>> G.add_weighted_edges_from([(1, 2, 0.75), (1, 2, 0.5), (2, 3, 0.5), (1, 3, 1.5)])
      >>> nodes = nx.dijkstra_path(G, 1, 3)
      >>> edges = nx.utils.pairwise(nodes)
      >>> list((u, v, min(G[u][v], key=lambda k: G[u][v][k].get('weight', 1))) for u, v in edges)
      [(1, 2, 1), (2, 3, 0)]
  
      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.
  
      The weight function can be used to include node weights.
  
      >>> def func(u, v, d):
      ...     node_u_wt = G.nodes[u].get("node_weight", 1)
      ...     node_v_wt = G.nodes[v].get("node_weight", 1)
      ...     edge_wt = d.get("weight", 1)
      ...     return node_u_wt / 2 + node_v_wt / 2 + edge_wt
  
      In this example we take the average of start and end node
      weights of an edge and add it to the weight of the edge.
  
      The function :func:`single_source_dijkstra` computes both
      path and length-of-path if you need both, use that.
  
      See Also
      --------
      bidirectional_dijkstra
      bellman_ford_path
      single_source_dijkstra
      """
      (length, path) = single_source_dijkstra(
          G, source, target=target, weight=weight
      )
      return path
  
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 2 for calling a global function with example usage: dijkstra_path(G, source, target, weight) and returns: path