Add stats endpoint to BellmanFord

Author: FlorentinD

graphdatascience/procedure_surface/api/pathfinding/all_shortest_path_endpoints.py

@@ -2,9 +2,6 @@
 
 from abc import ABC, abstractmethod
 
-from graphdatascience.procedure_surface.api.pathfinding.single_source_bellman_ford_endpoints import (
-    SingleSourceBellmanFordEndpoints,
-)
 from graphdatascience.procedure_surface.api.pathfinding.single_source_delta_endpoints import SingleSourceDeltaEndpoints
 from graphdatascience.procedure_surface.api.pathfinding.single_source_dijkstra_endpoints import (
     SingleSourceDijkstraEndpoints,
@@ -28,9 +25,3 @@ def delta(self) -> SingleSourceDeltaEndpoints:
     def dijkstra(self) -> SingleSourceDijkstraEndpoints:
         """Access to Dijkstra shortest path algorithm endpoints."""
         ...
-
-    @property
-    @abstractmethod
-    def bellman_ford(self) -> SingleSourceBellmanFordEndpoints:
-        """Access to Bellman-Ford shortest path algorithm endpoints."""
-        ...

graphdatascience/procedure_surface/api/pathfinding/single_source_bellman_ford_endpoints.py

@@ -10,6 +10,14 @@
 from graphdatascience.procedure_surface.api.estimation_result import EstimationResult
 
 
+class BellmanFordStatsResult(BaseResult):
+    pre_processing_millis: int
+    compute_millis: int
+    post_processing_millis: int
+    contains_negative_cycle: bool
+    configuration: dict[str, Any]
+
+
 class BellmanFordWriteResult(BaseResult):
     pre_processing_millis: int
     compute_millis: int
@@ -80,6 +88,54 @@ def stream(
             totalCost, nodeIds, costs, index, and isNegativeCycle.
         """
 
+    @abstractmethod
+    def stats(
+        self,
+        G: GraphV2,
+        source_node: int,
+        relationship_weight_property: str | None = None,
+        relationship_types: list[str] | None = None,
+        node_labels: list[str] | None = None,
+        sudo: bool = False,
+        log_progress: bool = True,
+        username: str | None = None,
+        concurrency: int | None = None,
+        job_id: str | None = None,
+    ) -> BellmanFordStatsResult:
+        """
+        Runs the Bellman-Ford shortest path algorithm and returns statistics about the execution.
+
+        The Bellman-Ford algorithm can detect negative cycles in the graph.
+
+        Parameters
+        ----------
+        G : GraphV2
+            The graph to run the algorithm on.
+        source_node : int
+            The source node for the shortest path computation.
+        relationship_weight_property : str | None, default=None
+            The relationship property to use as weights.
+        relationship_types : list[str] | None, default=None
+            Filter on relationship types.
+        node_labels : list[str] | None, default=None
+            Filter on node labels.
+        sudo : bool, default=False
+            Run the algorithm with elevated privileges.
+        log_progress : bool, default=True
+            Whether to log progress.
+        username : str | None, default=None
+            Username for the operation.
+        concurrency : int | None, default=None
+            Concurrency configuration.
+        job_id : str | None, default=None
+            Job ID for the operation.
+
+        Returns
+        -------
+        BellmanFordStatsResult
+            Object containing statistics from the execution, including whether negative cycles were detected.
+        """
+
     @abstractmethod
     def mutate(
         self,

graphdatascience/procedure_surface/arrow/pathfinding/all_shortest_path_arrow_endpoints.py

@@ -3,9 +3,6 @@
 from graphdatascience.arrow_client.authenticated_flight_client import AuthenticatedArrowClient
 from graphdatascience.arrow_client.v2.remote_write_back_client import RemoteWriteBackClient
 from graphdatascience.procedure_surface.api.pathfinding.all_shortest_path_endpoints import AllShortestPathEndpoints
-from graphdatascience.procedure_surface.api.pathfinding.single_source_bellman_ford_endpoints import (
-    SingleSourceBellmanFordEndpoints,
-)
 from graphdatascience.procedure_surface.api.pathfinding.single_source_delta_endpoints import SingleSourceDeltaEndpoints
 from graphdatascience.procedure_surface.api.pathfinding.single_source_dijkstra_endpoints import (
     SingleSourceDijkstraEndpoints,
@@ -39,7 +36,3 @@ def delta(self) -> SingleSourceDeltaEndpoints:
     @property
     def dijkstra(self) -> SingleSourceDijkstraEndpoints:
         return self._dijkstra
-
-    @property
-    def bellman_ford(self) -> SingleSourceBellmanFordEndpoints:
-        return self._bellman_ford

graphdatascience/procedure_surface/arrow/pathfinding/single_source_bellman_ford_arrow_endpoints.py

@@ -10,6 +10,7 @@
 from graphdatascience.procedure_surface.api.estimation_result import EstimationResult
 from graphdatascience.procedure_surface.api.pathfinding.single_source_bellman_ford_endpoints import (
     BellmanFordMutateResult,
+    BellmanFordStatsResult,
     BellmanFordWriteResult,
     SingleSourceBellmanFordEndpoints,
 )
@@ -61,6 +62,36 @@ def stream(
 
         return result
 
+    def stats(
+        self,
+        G: GraphV2,
+        source_node: int,
+        relationship_weight_property: str | None = None,
+        relationship_types: list[str] | None = None,
+        node_labels: list[str] | None = None,
+        sudo: bool = False,
+        log_progress: bool = True,
+        username: str | None = None,
+        concurrency: int | None = None,
+        job_id: str | None = None,
+    ) -> BellmanFordStatsResult:
+        config = self._endpoints_helper.create_base_config(
+            G,
+            sourceNode=source_node,
+            relationshipWeightProperty=relationship_weight_property,
+            relationshipTypes=relationship_types,
+            nodeLabels=node_labels,
+            sudo=sudo,
+            logProgress=log_progress,
+            username=username,
+            concurrency=concurrency,
+            jobId=job_id,
+        )
+
+        result = self._endpoints_helper.run_job_and_get_summary("v2/pathfinding.singleSource.bellmanFord", config)
+
+        return BellmanFordStatsResult(**result)
+
     def mutate(
         self,
         G: GraphV2,

graphdatascience/procedure_surface/cypher/pathfinding/single_source_bellman_ford_cypher_endpoints.py

@@ -9,6 +9,7 @@
 from graphdatascience.procedure_surface.api.estimation_result import EstimationResult
 from graphdatascience.procedure_surface.api.pathfinding.single_source_bellman_ford_endpoints import (
     BellmanFordMutateResult,
+    BellmanFordStatsResult,
     BellmanFordWriteResult,
     SingleSourceBellmanFordEndpoints,
 )
@@ -63,6 +64,37 @@ def stream(
             ],  # skip reoute column
         )
 
+    def stats(
+        self,
+        G: GraphV2,
+        source_node: int,
+        relationship_weight_property: str | None = None,
+        relationship_types: list[str] | None = None,
+        node_labels: list[str] | None = None,
+        sudo: bool = False,
+        log_progress: bool = True,
+        username: str | None = None,
+        concurrency: int | None = None,
+        job_id: str | None = None,
+    ) -> BellmanFordStatsResult:
+        config = ConfigConverter.convert_to_gds_config(
+            sourceNode=source_node,
+            relationshipWeightProperty=relationship_weight_property,
+            relationshipTypes=relationship_types,
+            nodeLabels=node_labels,
+            sudo=sudo,
+            logProgress=log_progress,
+            username=username,
+            concurrency=concurrency,
+            jobId=job_id,
+        )
+        params = CallParameters(graph_name=G.name(), config=config)
+        params.ensure_job_id_in_config()
+
+        result = self._query_runner.call_procedure("gds.bellmanFord.stats", params=params, logging=log_progress).iloc[0]
+
+        return BellmanFordStatsResult(**result.to_dict())
+
     def mutate(
         self,
         G: GraphV2,

graphdatascience/session/session_v2_endpoints.py

@@ -36,6 +36,9 @@
 from graphdatascience.procedure_surface.api.pathfinding.k_spanning_tree_endpoints import KSpanningTreeEndpoints
 from graphdatascience.procedure_surface.api.pathfinding.prize_steiner_tree_endpoints import PrizeSteinerTreeEndpoints
 from graphdatascience.procedure_surface.api.pathfinding.shortest_path_endpoints import ShortestPathEndpoints
+from graphdatascience.procedure_surface.api.pathfinding.single_source_bellman_ford_endpoints import (
+    SingleSourceBellmanFordEndpoints,
+)
 from graphdatascience.procedure_surface.api.pathfinding.spanning_tree_endpoints import SpanningTreeEndpoints
 from graphdatascience.procedure_surface.api.pathfinding.steiner_tree_endpoints import SteinerTreeEndpoints
 from graphdatascience.procedure_surface.api.similarity.knn_endpoints import KnnEndpoints
@@ -100,6 +103,9 @@
 from graphdatascience.procedure_surface.arrow.pathfinding.shortest_path_arrow_endpoints import (
     ShortestPathArrowEndpoints,
 )
+from graphdatascience.procedure_surface.arrow.pathfinding.single_source_bellman_ford_arrow_endpoints import (
+    BellmanFordArrowEndpoints,
+)
 from graphdatascience.procedure_surface.arrow.pathfinding.spanning_tree_arrow_endpoints import (
     SpanningTreeArrowEndpoints,
 )
@@ -155,6 +161,10 @@ def articulation_points(self) -> ArticulationPointsEndpoints:
     def betweenness_centrality(self) -> BetweennessEndpoints:
         return BetweennessArrowEndpoints(self._arrow_client, self._write_back_client, show_progress=self._show_progress)
 
+    @property
+    def bellman_ford(self) -> SingleSourceBellmanFordEndpoints:
+        return BellmanFordArrowEndpoints(self._arrow_client, self._write_back_client, show_progress=self._show_progress)
+
     @property
     def clique_counting(self) -> CliqueCountingEndpoints:
         return CliqueCountingArrowEndpoints(

graphdatascience/tests/integrationV2/procedure_surface/arrow/pathfinding/test_single_source_bellman_ford_arrow_endpoints.py

@@ -84,6 +84,20 @@ def test_bellman_ford_stream(bellman_ford_endpoints: BellmanFordArrowEndpoints,
     assert len(result_df) == 5
 
 
+def test_bellman_ford_stats(bellman_ford_endpoints: BellmanFordArrowEndpoints, sample_graph: GraphV2) -> None:
+    result = bellman_ford_endpoints.stats(
+        G=sample_graph,
+        source_node=0,
+        relationship_weight_property="cost",
+    )
+
+    assert result.pre_processing_millis >= 0
+    assert result.compute_millis >= 0
+    assert result.post_processing_millis >= 0
+    assert result.contains_negative_cycle is False
+    assert "sourceNode" in result.configuration
+
+
 def test_bellman_ford_mutate(bellman_ford_endpoints: BellmanFordArrowEndpoints, sample_graph: GraphV2) -> None:
     result = bellman_ford_endpoints.mutate(
         G=sample_graph,

graphdatascience/tests/integrationV2/procedure_surface/cypher/pathfinding/test_single_source_bellman_ford_cypher_endpoints.py

@@ -71,6 +71,20 @@ def test_bellman_ford_stream(bellman_ford_endpoints: BellmanFordCypherEndpoints,
     assert len(result_df) > 0
 
 
+def test_bellman_ford_stats(bellman_ford_endpoints: BellmanFordCypherEndpoints, sample_graph: GraphV2) -> None:
+    result = bellman_ford_endpoints.stats(
+        G=sample_graph,
+        source_node=find_node_by_name(bellman_ford_endpoints._query_runner, "A"),
+        relationship_weight_property="cost",
+    )
+
+    assert result.pre_processing_millis >= 0
+    assert result.compute_millis >= 0
+    assert result.post_processing_millis >= 0
+    assert result.contains_negative_cycle is False
+    assert "sourceNode" in result.configuration
+
+
 def test_bellman_ford_mutate(bellman_ford_endpoints: BellmanFordCypherEndpoints, sample_graph: GraphV2) -> None:
     result = bellman_ford_endpoints.mutate(
         G=sample_graph,