Support gds.util.asNode(s) in Sessions

Author: FlorentinD

graphdatascience/call_builder.py

@@ -1,6 +1,6 @@
 from .algo.algo_endpoints import AlgoEndpoints
 from .error.uncallable_namespace import UncallableNamespace
-from .utils.util_endpoints import IndirectUtilAlphaEndpoints
+from .utils.direct_util_endpoints import IndirectUtilAlphaEndpoints
 
 
 class IndirectCallBuilder(AlgoEndpoints, UncallableNamespace):

graphdatascience/endpoints.py

@@ -23,7 +23,7 @@
     SystemBetaEndpoints,
 )
 from .topological_lp.topological_lp_endpoints import TopologicalLPAlphaEndpoints
-from .utils.util_endpoints import DirectUtilEndpoints
+from .utils.direct_util_endpoints import DirectUtilEndpoints
 
 """
 This class should inherit endpoint classes that only contain endpoints that can be called directly from

graphdatascience/graph_data_science.py

@@ -13,6 +13,7 @@
 from .query_runner.query_runner import QueryRunner
 from .server_version.server_version import ServerVersion
 from graphdatascience.graph.graph_proc_runner import GraphProcRunner
+from graphdatascience.utils.util_proc_runner import UtilProcRunner
 
 
 class GraphDataScience(DirectEndpoints, UncallableNamespace):
@@ -81,12 +82,16 @@ def __init__(
                 None if arrow is True else arrow,
             )
 
-        super().__init__(self._query_runner, "gds", self._server_version)
+        super().__init__(self._query_runner, namespace="gds", server_version=self._server_version)
 
     @property
     def graph(self) -> GraphProcRunner:
         return GraphProcRunner(self._query_runner, f"{self._namespace}.graph", self._server_version)
 
+    @property
+    def util(self) -> UtilProcRunner:
+        return UtilProcRunner(self._query_runner, f"{self._namespace}.util", self._server_version)
+
     @property
     def alpha(self) -> AlphaEndpoints:
         return AlphaEndpoints(self._query_runner, "gds.alpha", self._server_version)

graphdatascience/tests/integration/test_util_ops.py

@@ -6,6 +6,7 @@
 from graphdatascience.graph_data_science import GraphDataScience
 from graphdatascience.query_runner.neo4j_query_runner import Neo4jQueryRunner
 from graphdatascience.server_version.server_version import ServerVersion
+from graphdatascience.session.aura_graph_data_science import AuraGraphDataScience
 
 
 @pytest.fixture(autouse=True)
@@ -97,6 +98,14 @@ def test_util_asNode(gds: GraphDataScience) -> None:
     assert result["name"] == "A"
 
 
+@pytest.mark.cloud_architecture
+@pytest.mark.compatible_with(min_inclusive=ServerVersion(2, 7, 0))
+def test_remote_util_as_node(gds_with_cloud_setup: AuraGraphDataScience) -> None:
+    id = gds_with_cloud_setup.find_node_id(["Location"], {"name": "A"})
+    result = gds_with_cloud_setup.util.asNode(id)
+    assert result["name"] == "A"
+
+
 def test_util_asNodes(gds: GraphDataScience) -> None:
     ids = [
         gds.find_node_id(["Location"], {"name": "A"}),
@@ -106,6 +115,17 @@ def test_util_asNodes(gds: GraphDataScience) -> None:
     assert len(result) == 2
 
 
+@pytest.mark.cloud_architecture
+@pytest.mark.compatible_with(min_inclusive=ServerVersion(2, 7, 0))
+def test_remote_util_as_nodes(gds_with_cloud_setup: AuraGraphDataScience) -> None:
+    ids = [
+        gds_with_cloud_setup.find_node_id(["Location"], {"name": "A"}),
+        gds_with_cloud_setup.find_node_id(["Location"], {"name": 2}),
+    ]
+    result = gds_with_cloud_setup.util.asNodes(ids)
+    assert len(result) == 2
+
+
 def test_util_nodeProperty(gds: GraphDataScience, G: Graph) -> None:
     id = gds.find_node_id(["Location"], {"name": "A"})
     result = gds.util.nodeProperty(G, id, "population")

graphdatascience/tests/unit/conftest.py

@@ -44,6 +44,13 @@ def call_procedure(
 
         return self.run_cypher(query, params, database, custom_error)
 
+    def call_function(self, endpoint: str, params: Optional[CallParameters] = None) -> Any:
+        if params is None:
+            params = CallParameters()
+        query = f"RETURN {endpoint}({params.placeholder_str()})"
+
+        return self.run_cypher(query, params).squeeze()
+
     def run_cypher(
         self, query: str, params: Optional[Dict[str, Any]] = None, db: Optional[str] = None, custom_error: bool = True
     ) -> DataFrame:

graphdatascience/tests/unit/test_util_ops.py

@@ -1,4 +1,6 @@
+from graphdatascience.graph.graph_object import Graph
 from graphdatascience.graph_data_science import GraphDataScience
+from graphdatascience.session.aura_graph_data_science import AuraGraphDataScience
 from graphdatascience.tests.unit.conftest import CollectingQueryRunner
 
 
@@ -11,3 +13,55 @@ def test_list(runner: CollectingQueryRunner, gds: GraphDataScience) -> None:
 
     assert runner.last_query() == "CALL gds.list()"
     assert runner.last_params() == {}
+
+
+def test_as_node(runner: CollectingQueryRunner, gds: GraphDataScience) -> None:
+    gds.util.asNode(1)
+
+    assert runner.last_query() == "RETURN gds.util.asNode(1) AS node"
+
+
+def test_remote_as_node(runner: CollectingQueryRunner, aura_gds: AuraGraphDataScience) -> None:
+    aura_gds.util.asNode(1)
+
+    assert runner.last_query() == "MATCH (n) WHERE id(n) = $nodeId RETURN n"
+    assert runner.last_params() == {"nodeId": 1}
+
+
+def test_as_nodes(runner: CollectingQueryRunner, gds: GraphDataScience) -> None:
+    gds.util.asNodes([1, 2, 3])
+
+    assert runner.last_query() == "RETURN gds.util.asNodes([1, 2, 3]) AS nodes"
+
+
+def test_remote_as_nodes(runner: CollectingQueryRunner, aura_gds: AuraGraphDataScience) -> None:
+    aura_gds.util.asNodes([1, 2, 3])
+
+    assert runner.last_query() == "MATCH (n) WHERE id(n) IN $nodeIds RETURN collect(n)"
+    assert runner.last_params() == {"nodeId": [1, 2, 3]}
+
+
+def test_node_property(runner: CollectingQueryRunner, gds: GraphDataScience) -> None:
+    G = Graph("g", runner, gds._server_version)
+    gds.util.nodeProperty(G, 1, "my_prop", "my_label")
+
+    assert runner.last_query() == "RETURN gds.util.nodeProperty($graph_name, $node_id, $property_key, $node_label)"
+    assert runner.last_params() == {
+        "graph_name": "g",
+        "node_id": 1,
+        "property_key": "my_prop",
+        "node_label": "my_label",
+    }
+
+
+def test_remote_node_property(runner: CollectingQueryRunner, aura_gds: AuraGraphDataScience) -> None:
+    G = Graph("g", runner, aura_gds._server_version)
+    aura_gds.util.nodeProperty(G, 1, "my_prop", "my_label")
+
+    assert runner.last_query() == "RETURN gds.util.nodeProperty($graph_name, $node_id, $property_key, $node_label)"
+    assert runner.last_params() == {
+        "graph_name": "g",
+        "node_id": 1,
+        "property_key": "my_prop",
+        "node_label": "my_label",
+    }

graphdatascience/utils/util_endpoints.py renamed to graphdatascience/utils/direct_util_endpoints.py

@@ -4,7 +4,6 @@
 
 from ..caller_base import CallerBase
 from ..error.client_only_endpoint import client_only_endpoint
-from .util_proc_runner import UtilProcRunner
 from graphdatascience.call_parameters import CallParameters
 from graphdatascience.error.cypher_warning_handler import (
     filter_id_func_deprecation_warning,
@@ -86,10 +85,6 @@ def list(self) -> DataFrame:
         namespace = self._namespace + ".list"
         return self._query_runner.call_procedure(endpoint=namespace, custom_error=False)
 
-    @property
-    def util(self) -> UtilProcRunner:
-        return UtilProcRunner(self._query_runner, f"{self._namespace}.util", self._server_version)
-
 
 class IndirectUtilAlphaEndpoints(CallerBase):
     def oneHotEncoding(self, available_values: List[Any], selected_values: List[Any]) -> List[int]:

graphdatascience/utils/util_node_property_func_runner.py

@@ -0,0 +1,31 @@
+from typing import Any
+
+from graphdatascience.call_parameters import CallParameters
+from graphdatascience.error.illegal_attr_checker import IllegalAttrChecker
+from graphdatascience.graph.graph_object import Graph
+from graphdatascience.graph.graph_type_check import graph_type_check
+
+
+class NodePropertyFuncRunner(IllegalAttrChecker):
+    @graph_type_check
+    def __call__(self, G: Graph, node_id: int, property_key: str, node_label: str = "*") -> Any:
+        """
+        Get the property of a node with the given id.
+
+        Args:
+            G: The graph to get the node property from.
+            node_id: The id of the node to get the property from.
+            property_key: The key of the property to get.
+            node_label: The label of the node to get the property from.
+
+        Returns:
+            The property of the node with the given id.
+
+        """
+        params = CallParameters(
+            graph_name=G.name(),
+            node_id=node_id,
+            property_key=property_key,
+            node_label=node_label,
+        )
+        return self._query_runner.call_function(endpoint=self._namespace, params=params)

graphdatascience/utils/util_proc_runner.py

@@ -2,8 +2,7 @@
 
 from ..error.illegal_attr_checker import IllegalAttrChecker
 from ..error.uncallable_namespace import UncallableNamespace
-from ..graph.graph_object import Graph
-from ..graph.graph_type_check import graph_type_check
+from graphdatascience.utils.util_node_property_func_runner import NodePropertyFuncRunner
 
 
 class UtilProcRunner(UncallableNamespace, IllegalAttrChecker):
@@ -39,30 +38,6 @@ def asNodes(self, node_ids: List[int]) -> List[Any]:
 
         return result.iat[0, 0]  # type: ignore
 
-    @graph_type_check
-    def nodeProperty(self, G: Graph, node_id: int, property_key: str, node_label: str = "*") -> Any:
-        """
-        Get the property of a node with the given id.
-
-        Args:
-            G: The graph to get the node property from.
-            node_id: The id of the node to get the property from.
-            property_key: The key of the property to get.
-            node_label: The label of the node to get the property from.
-
-        Returns:
-            The property of the node with the given id.
-
-        """
-        self._namespace += ".nodeProperty"
-
-        query = f"RETURN {self._namespace}($graph_name, $node_id, $property_key, $node_label) as property"
-        params = {
-            "graph_name": G.name(),
-            "node_id": node_id,
-            "property_key": property_key,
-            "node_label": node_label,
-        }
-        result = self._query_runner.run_cypher(query, params)
-
-        return result.iat[0, 0]
+    @property
+    def nodeProperty(self) -> NodePropertyFuncRunner:
+        return NodePropertyFuncRunner(self._query_runner, self._namespace + ".nodeProperty", self._server_version)

graphdatascience/utils/util_remote_proc_runner.py

@@ -0,0 +1,48 @@
+from typing import Any, List
+
+from ..error.illegal_attr_checker import IllegalAttrChecker
+from ..error.uncallable_namespace import UncallableNamespace
+from graphdatascience.error.cypher_warning_handler import (
+    filter_id_func_deprecation_warning,
+)
+from graphdatascience.utils.util_node_property_func_runner import NodePropertyFuncRunner
+
+
+class UtilRemoteProcRunner(UncallableNamespace, IllegalAttrChecker):
+    @filter_id_func_deprecation_warning()
+    def asNode(self, node_id: int) -> Any:
+        """
+        Get a node from a node id.
+
+        Args:
+            node_id: The id of the node to get.
+
+        Returns:
+            The node with the given id.
+
+        """
+        query = "MATCH (n) WHERE id(n) = $nodeId RETURN n"
+        params = {"nodeId": node_id}
+
+        return self._query_runner.run_cypher(query=query, params=params).squeeze()
+
+    @filter_id_func_deprecation_warning()
+    def asNodes(self, node_ids: List[int]) -> List[Any]:
+        """
+        Get a list of nodes from a list of node ids.
+
+        Args:
+            node_ids: The ids of the nodes to get.
+
+        Returns:
+            The nodes with the given ids.
+
+        """
+        query = "MATCH (n) WHERE id(n) IN $nodeIds RETURN collect(n)"
+        params = {"nodeId": node_ids}
+
+        return self._query_runner.run_cypher(query=query, params=params).squeeze()  # type: ignore
+
+    @property
+    def nodeProperty(self) -> NodePropertyFuncRunner:
+        return NodePropertyFuncRunner(self._query_runner, self._namespace + ".nodeProperty", self._server_version)