code: def pagerank(
      G,
      alpha=0.85,
      personalization=None,
      max_iter=100,
      tol=1.0e-6,
      nstart=None,
      weight="weight",
      dangling=None,
  ):
      """Returns the PageRank of the nodes in the graph.
  
      PageRank computes a ranking of the nodes in the graph G based on
      the structure of the incoming links. It was originally designed as
      an algorithm to rank web pages.
  
      Parameters
      ----------
      G : graph
        A NetworkX graph.  Undirected graphs will be converted to a directed
        graph with two directed edges for each undirected edge.
  
      alpha : float, optional
        Damping parameter for PageRank, default=0.85.
  
      personalization: dict, optional
        The "personalization vector" consisting of a dictionary with a
        key some subset of graph nodes and personalization value each of those.
        At least one personalization value must be non-zero.
        If not specified, a nodes personalization value will be zero.
        By default, a uniform distribution is used.
  
      max_iter : integer, optional
        Maximum number of iterations in power method eigenvalue solver.
  
      tol : float, optional
        Error tolerance used to check convergence in power method solver.
        The iteration will stop after a tolerance of ``len(G) * tol`` is reached.
  
      nstart : dictionary, optional
        Starting value of PageRank iteration for each node.
  
      weight : key, optional
        Edge data key to use as weight.  If None weights are set to 1.
  
      dangling: dict, optional
        The outedges to be assigned to any "dangling" nodes, i.e., nodes without
        any outedges. The dict key is the node the outedge points to and the dict
        value is the weight of that outedge. By default, dangling nodes are given
        outedges according to the personalization vector (uniform if not
        specified). This must be selected to result in an irreducible transition
        matrix (see notes under google_matrix). It may be common to have the
        dangling dict to be the same as the personalization dict.
  
  
      Returns
      -------
      pagerank : dictionary
         Dictionary of nodes with PageRank as value
  
      Examples
      --------
      >>> G = nx.DiGraph(nx.path_graph(4))
      >>> pr = nx.pagerank(G, alpha=0.9)
  
      Notes
      -----
      The eigenvector calculation is done by the power iteration method
      and has no guarantee of convergence.  The iteration will stop after
      an error tolerance of ``len(G) * tol`` has been reached. If the
      number of iterations exceed `max_iter`, a
      :exc:`networkx.exception.PowerIterationFailedConvergence` exception
      is raised.
  
      The PageRank algorithm was designed for directed graphs but this
      algorithm does not check if the input graph is directed and will
      execute on undirected graphs by converting each edge in the
      directed graph to two edges.
  
      See Also
      --------
      google_matrix
  
      Raises
      ------
      PowerIterationFailedConvergence
          If the algorithm fails to converge to the specified tolerance
          within the specified number of iterations of the power iteration
          method.
  
      References
      ----------
      .. [1] A. Langville and C. Meyer,
         "A survey of eigenvector methods of web information retrieval."
         http://citeseer.ist.psu.edu/713792.html
      .. [2] Page, Lawrence; Brin, Sergey; Motwani, Rajeev and Winograd, Terry,
         The PageRank citation ranking: Bringing order to the Web. 1999
         http://dbpubs.stanford.edu:8090/pub/showDoc.Fulltext?lang=en&doc=1999-66&format=pdf
  
      """
      return _pagerank_scipy(
          G,
          alpha,
          personalization,
          max_iter,
          tol,
          nstart,
          weight,
          dangling,
      )
  
imports: from warnings import warn
  import networkx
label_desc: Use image node_id 1 for calling a global function with example usage: pagerank(G, alpha, personalization, max_iter, tol, nstart, weight, dangling) and returns: _pagerank_scipy