graphdatascience 1.11a3__tar.gz → 1.11a4__tar.gz

{graphdatascience-1.11a3/graphdatascience.egg-info → graphdatascience-1.11a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: graphdatascience
-Version: 1.11a3
+Version: 1.11a4
 Summary: A Python client for the Neo4j Graph Data Science (GDS) library
 Home-page: https://neo4j.com/product/graph-data-science/
 Author: Neo4j
@@ -29,7 +29,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: multimethod<2.0,>=1.0
-Requires-Dist: neo4j<6.0,>=4.4.2
+Requires-Dist: neo4j<6.0,>=4.4.12
 Requires-Dist: numpy<2.0
 Requires-Dist: pandas<3.0,>=1.0
 Requires-Dist: pyarrow<17.0,>=14.0.1
@@ -142,8 +142,6 @@ The manual is versioned to cover all GDS Python Client versions, so make sure to
 Operations known to not yet work with `graphdatascience`:
 
 * [Numeric utility functions](https://neo4j.com/docs/graph-data-science/current/management-ops/utility-functions/#utility-functions-numeric) (will never be supported)
-* [Cypher on GDS](https://neo4j.com/docs/graph-data-science/current/management-ops/create-cypher-db/) (might be supported in the future)
-* [Projecting graphs using Cypher Aggregation](https://neo4j.com/docs/graph-data-science/current/management-ops/projections/graph-project-cypher-aggregation/) (might be supported in the future)
 
 
 ## License

{graphdatascience-1.11a3 → graphdatascience-1.11a4}/README.md

@@ -98,8 +98,6 @@ The manual is versioned to cover all GDS Python Client versions, so make sure to
 Operations known to not yet work with `graphdatascience`:
 
 * [Numeric utility functions](https://neo4j.com/docs/graph-data-science/current/management-ops/utility-functions/#utility-functions-numeric) (will never be supported)
-* [Cypher on GDS](https://neo4j.com/docs/graph-data-science/current/management-ops/create-cypher-db/) (might be supported in the future)
-* [Projecting graphs using Cypher Aggregation](https://neo4j.com/docs/graph-data-science/current/management-ops/projections/graph-project-cypher-aggregation/) (might be supported in the future)
 
 
 ## License

{graphdatascience-1.11a3 → graphdatascience-1.11a4}/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-1.11a3 → graphdatascience-1.11a4}/graphdatascience/endpoints.py

@@ -23,7 +23,7 @@ from .system.system_endpoints import (
     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
@@ -44,7 +44,7 @@ class DirectEndpoints(
 
 
 """
-This class should inherit endpoint classes that only expose calls of the `gds.beta` namespace.
+This class should inherit endpoint classes that only expose calls of the `gds.alpha` namespace.
 Example of such endpoints: "gds.alpha.listProgress".
 """
 
@@ -65,6 +65,21 @@ class AlphaEndpoints(
         return IndirectAlphaCallBuilder(self._query_runner, f"{self._namespace}.{attr}", self._server_version)
 
 
+class AlphaRemoteEndpoints(
+    GraphAlphaEndpoints,
+    PipelineAlphaEndpoints,
+    ModelAlphaEndpoints,
+    SingleModeAlphaAlgoEndpoints,
+    SystemAlphaEndpoints,
+    AlphaConfigEndpoints,
+):
+    def __init__(self, query_runner: QueryRunner, namespace: str, server_version: ServerVersion):
+        super().__init__(query_runner, namespace, server_version)
+
+    def __getattr__(self, attr: str) -> IndirectAlphaCallBuilder:
+        return IndirectAlphaCallBuilder(self._query_runner, f"{self._namespace}.{attr}", self._server_version)
+
+
 """
 This class should inherit endpoint classes that only expose calls of the `gds.beta` namespace.
 Example of such endpoints:  "gds.beta.listProgress".

{graphdatascience-1.11a3 → graphdatascience-1.11a4}/graphdatascience/graph/graph_cypher_runner.py

@@ -1,6 +1,10 @@
+from __future__ import annotations
+
 import re
 from itertools import chain, zip_longest
-from typing import Any, Optional
+from typing import Any, Dict, Optional
+
+from pandas import Series
 
 from ..caller_base import CallerBase
 from ..query_runner.query_runner import QueryRunner
@@ -41,7 +45,10 @@ class GraphCypherRunner(CallerBase):
 
         GraphCypherRunner._verify_query_ends_with_return_clause(self._namespace, query)
 
-        result = self._query_runner.run_cypher(query, params, database, False).squeeze()
+        result: Optional[Dict[str, Any]] = self._query_runner.run_cypher(query, params, database, False).squeeze()
+
+        if not result:
+            raise ValueError("Projected graph cannot be empty.")
 
         try:
             graph_name = str(result["graphName"])
@@ -50,7 +57,7 @@ class GraphCypherRunner(CallerBase):
                 f"Invalid query, the query must end with the `RETURN {self._namespace}(...)` call: {query}"
             )
 
-        return GraphCreateResult(Graph(graph_name, self._query_runner, self._server_version), result)
+        return GraphCreateResult(Graph(graph_name, self._query_runner, self._server_version), Series(data=result))
 
     __separators = re.compile(r"[,(.]")
 

{graphdatascience-1.11a3 → graphdatascience-1.11a4}/graphdatascience/graph_data_science.py

@@ -13,6 +13,7 @@ from .query_runner.neo4j_query_runner import Neo4jQueryRunner
 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 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
                 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-1.11a3 → graphdatascience-1.11a4}/graphdatascience/model/link_prediction_model.py

@@ -41,5 +41,5 @@ class LPModel(PipelineModel):
             A list of LinkFeatures of the pipeline.
 
         """
-        steps: List[Dict[str, Any]] = self._list_info()["modelInfo"][0]["pipeline"]["featureSteps"]
+        steps: List[Dict[str, Any]] = self._list_info()["modelInfo"]["pipeline"]["featureSteps"]
         return [LinkFeature(s["name"], s["config"]) for s in steps]

{graphdatascience-1.11a3 → graphdatascience-1.11a4}/graphdatascience/model/model.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
 from typing import Any, Dict
 
@@ -21,34 +23,32 @@ class Model(ABC):
     def _endpoint_prefix(self) -> str:
         pass
 
-    def _list_info(self) -> DataFrame:
+    def _list_info(self) -> Series[Any]:
+        params = CallParameters(name=self.name())
+
+        result: Series[Any]
         if self._server_version < ServerVersion(2, 5, 0):
-            query = "CALL gds.beta.model.list($name)"
+            result = self._query_runner.call_procedure(
+                "gds.beta.model.list", params=params, custom_error=False
+            ).squeeze()
         else:
-            query = """
-                    CALL gds.model.list($name)
-                    YIELD
-                      modelName, modelType, modelInfo,
-                      creationTime, trainConfig, graphSchema,
-                      loaded, stored, published
-                    RETURN
-                      modelName, modelType,
-                      modelInfo {.*, modelName: modelName, modelType: modelType} AS modelInfo,
-                      creationTime, trainConfig, graphSchema,
-                      loaded, stored, published, published AS shared
-                    """
-
-        params = {"name": self.name()}
-
-        # FIXME use call procedure + do post processing on the client side
-        info = self._query_runner.run_cypher(query, params, custom_error=False)
-
-        if len(info) == 0:
+            result = self._query_runner.call_procedure("gds.model.list", params=params, custom_error=False).squeeze()
+
+            if not result.empty:
+                #  2.5 compat format
+                result["modelInfo"] = {
+                    **result["modelInfo"],
+                    "modelName": result["modelName"],
+                    "modelType": result["modelType"],
+                }
+                result["shared"] = result["published"]
+
+        if result.empty:
             raise ValueError(f"There is no '{self.name()}' in the model catalog")
 
-        return info
+        return result
 
-    def _estimate_predict(self, predict_mode: str, graph_name: str, config: Dict[str, Any]) -> "Series[Any]":
+    def _estimate_predict(self, predict_mode: str, graph_name: str, config: Dict[str, Any]) -> Series[Any]:
         endpoint = f"{self._endpoint_prefix()}{predict_mode}.estimate"
         config["modelName"] = self.name()
         params = CallParameters(graph_name=graph_name, config=config)
@@ -76,9 +76,9 @@ class Model(ABC):
             The type of the model.
 
         """
-        return self._list_info()["modelInfo"][0]["modelType"]  # type: ignore
+        return self._list_info()["modelInfo"]["modelType"]  # type: ignore
 
-    def train_config(self) -> "Series[Any]":
+    def train_config(self) -> Series[Any]:
         """
         Get the train config of the model.
 
@@ -86,10 +86,10 @@ class Model(ABC):
             The train config of the model.
 
         """
-        train_config: "Series[Any]" = Series(self._list_info()["trainConfig"][0])
+        train_config: Series[Any] = Series(self._list_info()["trainConfig"])
         return train_config
 
-    def graph_schema(self) -> "Series[Any]":
+    def graph_schema(self) -> Series[Any]:
         """
         Get the graph schema of the model.
 
@@ -97,7 +97,7 @@ class Model(ABC):
             The graph schema of the model.
 
         """
-        graph_schema: "Series[Any]" = Series(self._list_info()["graphSchema"][0])
+        graph_schema: Series[Any] = Series(self._list_info()["graphSchema"])
         return graph_schema
 
     def loaded(self) -> bool:
@@ -108,7 +108,7 @@ class Model(ABC):
             True if the model is loaded in memory, False otherwise.
 
         """
-        return self._list_info()["loaded"].squeeze()  # type: ignore
+        return self._list_info()["loaded"]  # type: ignore
 
     def stored(self) -> bool:
         """
@@ -118,7 +118,7 @@ class Model(ABC):
             True if the model is stored on disk, False otherwise.
 
         """
-        return self._list_info()["stored"].squeeze()  # type: ignore
+        return self._list_info()["stored"]  # type: ignore
 
     def creation_time(self) -> Any:  # neo4j.time.DateTime not exported
         """
@@ -128,7 +128,7 @@ class Model(ABC):
             The creation time of the model.
 
         """
-        return self._list_info()["creationTime"].squeeze()
+        return self._list_info()["creationTime"]
 
     def shared(self) -> bool:
         """
@@ -138,7 +138,7 @@ class Model(ABC):
             True if the model is shared, False otherwise.
 
         """
-        return self._list_info()["shared"].squeeze()  # type: ignore
+        return self._list_info()["shared"]  # type: ignore
 
     @compatible_with("published", min_inclusive=ServerVersion(2, 5, 0))
     def published(self) -> bool:
@@ -149,9 +149,9 @@ class Model(ABC):
             True if the model is published, False otherwise.
 
         """
-        return self._list_info()["published"].squeeze()  # type: ignore
+        return self._list_info()["published"]  # type: ignore
 
-    def model_info(self) -> "Series[Any]":
+    def model_info(self) -> Dict[str, Any]:
         """
         Get the model info of the model.
 
@@ -159,7 +159,7 @@ class Model(ABC):
             The model info of the model.
 
         """
-        return Series(self._list_info()["modelInfo"].squeeze())
+        return Series(self._list_info()["modelInfo"])  # type: ignore
 
     def exists(self) -> bool:
         """
@@ -179,7 +179,7 @@ class Model(ABC):
             endpoint=endpoint, params=params, yields=yields, custom_error=False
         ).squeeze()
 
-    def drop(self, failIfMissing: bool = False) -> "Series[Any]":
+    def drop(self, failIfMissing: bool = False) -> Series[Any]:
         """
         Drop the model.
 
@@ -190,27 +190,29 @@ class Model(ABC):
             The result of the drop operation.
 
         """
+        params = CallParameters(model_name=self._name, fail_if_missing=failIfMissing)
         if self._server_version < ServerVersion(2, 5, 0):
-            query = "CALL gds.beta.model.drop($model_name, $fail_if_missing)"
+            return self._query_runner.call_procedure(  # type: ignore
+                "gds.beta.model.drop", params=params, custom_error=False
+            ).squeeze()
         else:
-            query = """
-                    CALL gds.model.drop($model_name, $fail_if_missing)
-                    YIELD
-                      modelName, modelType, modelInfo,
-                      creationTime, trainConfig, graphSchema,
-                      loaded, stored, published
-                    RETURN
-                      modelName, modelType,
-                      modelInfo {.*, modelName: modelName, modelType: modelType} AS modelInfo,
-                      creationTime, trainConfig, graphSchema,
-                      loaded, stored, published, published AS shared
-                    """
-
-        params = {"model_name": self._name, "fail_if_missing": failIfMissing}
-        # FIXME use call procedure + do post processing on the client side
-        return self._query_runner.run_cypher(query, params, custom_error=False).squeeze()  # type: ignore
-
-    def metrics(self) -> "Series[Any]":
+            result: Series[Any] = self._query_runner.call_procedure(
+                "gds.model.drop", params=params, custom_error=False
+            ).squeeze()
+
+            if result.empty:
+                return result
+
+            #  modelInfo {.*, modelName: modelName, modelType: modelType} AS modelInfo
+            result["modelInfo"] = {
+                **result["modelInfo"],
+                "modelName": result["modelName"],
+                "modelType": result["modelType"],
+            }
+            result["shared"] = result["published"]
+            return result
+
+    def metrics(self) -> Series[Any]:
         """
         Get the metrics of the model.
 
@@ -218,8 +220,8 @@ class Model(ABC):
             The metrics of the model.
 
         """
-        model_info = self._list_info()["modelInfo"][0]
-        metrics: "Series[Any]" = Series(model_info["metrics"])
+        model_info = self._list_info()["modelInfo"]
+        metrics: Series[Any] = Series(model_info["metrics"])
         return metrics
 
     @graph_type_check
@@ -242,7 +244,7 @@ class Model(ABC):
         return self._query_runner.call_procedure(endpoint=endpoint, params=params, logging=True)
 
     @graph_type_check
-    def predict_stream_estimate(self, G: Graph, **config: Any) -> "Series[Any]":
+    def predict_stream_estimate(self, G: Graph, **config: Any) -> Series[Any]:
         """
         Estimate the prediction on the given graph using the model and stream the results as DataFrame
 
@@ -257,7 +259,7 @@ class Model(ABC):
         return self._estimate_predict("stream", G.name(), config)
 
     @graph_type_check
-    def predict_mutate(self, G: Graph, **config: Any) -> "Series[Any]":
+    def predict_mutate(self, G: Graph, **config: Any) -> Series[Any]:
         """
         Predict on the given graph using the model and mutate the graph with the results.
 
@@ -278,7 +280,7 @@ class Model(ABC):
         ).squeeze()
 
     @graph_type_check
-    def predict_mutate_estimate(self, G: Graph, **config: Any) -> "Series[Any]":
+    def predict_mutate_estimate(self, G: Graph, **config: Any) -> Series[Any]:
         """
         Estimate the memory needed to predict on the given graph using the model.
 

{graphdatascience-1.11a3 → graphdatascience-1.11a4}/graphdatascience/model/model_proc_runner.py

@@ -1,4 +1,6 @@
-from typing import Any, Dict, List, Optional, Tuple
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 from pandas import DataFrame, Series
 
@@ -49,23 +51,29 @@ class TransECreator(UncallableNamespace, IllegalAttrChecker):
 class ModelProcRunner(ModelResolver):
     @client_only_endpoint("gds.model")
     def get(self, model_name: str) -> Model:
+        params = CallParameters(model_name=model_name)
         if self._server_version < ServerVersion(2, 5, 0):
-            query = "CALL gds.beta.model.list($model_name) YIELD modelInfo RETURN modelInfo.modelType AS modelType"
+            endpoint = "gds.beta.model.list"
+            yields = ["modelInfo"]
+            result_25: Series[Any] = self._query_runner.call_procedure(
+                endpoint=endpoint, params=params, yields=yields, custom_error=False
+            ).squeeze()
+            model_type = str(result_25["modelInfo"]["modelType"]) if not result_25.empty else None
         else:
-            query = "CALL gds.model.list($model_name) YIELD modelType"
-
-        params = {"model_name": model_name}
-        # FIXME use call procedure + do post processing on the client side
-        result = self._query_runner.run_cypher(query, params, custom_error=False)
-
-        if len(result) == 0:
+            endpoint = "gds.model.list"
+            yields = ["modelType"]
+            result: Union[str, Series[Any]] = self._query_runner.call_procedure(
+                endpoint=endpoint, params=params, yields=yields, custom_error=False
+            ).squeeze()
+            model_type = result if isinstance(result, str) else None
+
+        if model_type is None:
             raise ValueError(f"No loaded model named '{model_name}' exists")
 
-        model_type = str(result["modelType"].squeeze())
         return self._resolve_model(model_type, model_name)
 
     @compatible_with("store", min_inclusive=ServerVersion(2, 5, 0))
-    def store(self, model: Model, failIfUnsupportedType: bool = True) -> "Series[Any]":
+    def store(self, model: Model, failIfUnsupportedType: bool = True) -> Series[Any]:
         self._namespace += ".store"
         params = CallParameters(model_name=model.name(), fail_flag=failIfUnsupportedType)
 
@@ -88,7 +96,7 @@ class ModelProcRunner(ModelResolver):
         return self._resolve_model(model_type, model_name)
 
     @compatible_with("load", min_inclusive=ServerVersion(2, 5, 0))
-    def load(self, model_name: str) -> Tuple[Model, "Series[Any]"]:
+    def load(self, model_name: str) -> Tuple[Model, Series[Any]]:
         self._namespace += ".load"
 
         params = CallParameters(model_name=model_name)
@@ -101,7 +109,7 @@ class ModelProcRunner(ModelResolver):
         return proc_runner.get(result["modelName"]), result
 
     @compatible_with("delete", min_inclusive=ServerVersion(2, 5, 0))
-    def delete(self, model: Model) -> "Series[Any]":
+    def delete(self, model: Model) -> Series[Any]:
         self._namespace += ".delete"
         params = CallParameters(model_name=model.name())
         return self._query_runner.call_procedure(endpoint=self._namespace, params=params).squeeze()  # type: ignore
@@ -117,7 +125,7 @@ class ModelProcRunner(ModelResolver):
         return self._query_runner.call_procedure(endpoint=self._namespace, params=params)
 
     @compatible_with("exists", min_inclusive=ServerVersion(2, 5, 0))
-    def exists(self, model_name: str) -> "Series[Any]":
+    def exists(self, model_name: str) -> Series[Any]:
         self._namespace += ".exists"
 
         return self._query_runner.call_procedure(  # type: ignore
@@ -125,7 +133,7 @@ class ModelProcRunner(ModelResolver):
         ).squeeze()
 
     @compatible_with("drop", min_inclusive=ServerVersion(2, 5, 0))
-    def drop(self, model: Model) -> "Series[Any]":
+    def drop(self, model: Model) -> Series[Any]:
         self._namespace += ".drop"
 
         return self._query_runner.call_procedure(  # type: ignore

{graphdatascience-1.11a3 → graphdatascience-1.11a4}/graphdatascience/model/node_classification_model.py

@@ -62,7 +62,7 @@ class NCModel(PipelineModel):
             The classes of the model.
 
         """
-        return self._list_info()["modelInfo"][0]["classes"]  # type: ignore
+        return self._list_info()["modelInfo"]["classes"]  # type: ignore
 
     def feature_properties(self) -> List[str]:
         """
@@ -72,5 +72,5 @@ class NCModel(PipelineModel):
             The feature properties of the model.
 
         """
-        features: List[Dict[str, Any]] = self._list_info()["modelInfo"][0]["pipeline"]["featureProperties"]
+        features: List[Dict[str, Any]] = self._list_info()["modelInfo"]["pipeline"]["featureProperties"]
         return [f["feature"] for f in features]

{graphdatascience-1.11a3 → graphdatascience-1.11a4}/graphdatascience/model/node_regression_model.py

@@ -21,5 +21,5 @@ class NRModel(PipelineModel):
             The feature properties of the model.
 
         """
-        features: List[Dict[str, Any]] = self._list_info()["modelInfo"][0]["pipeline"]["featureProperties"]
+        features: List[Dict[str, Any]] = self._list_info()["modelInfo"]["pipeline"]["featureProperties"]
         return [f["feature"] for f in features]

{graphdatascience-1.11a3 → graphdatascience-1.11a4}/graphdatascience/model/pipeline_model.py

@@ -75,7 +75,7 @@ class PipelineModel(Model, ABC):
             The best parameters for the pipeline model.
 
         """
-        best_params: Dict[str, Any] = self._list_info()["modelInfo"][0]["bestParameters"]
+        best_params: Dict[str, Any] = self._list_info()["modelInfo"]["bestParameters"]
         return Series(best_params)
 
     def node_property_steps(self) -> List[NodePropertyStep]:
@@ -86,7 +86,7 @@ class PipelineModel(Model, ABC):
             The node property steps for the pipeline model.
 
         """
-        steps: List[Dict[str, Any]] = self._list_info()["modelInfo"][0]["pipeline"]["nodePropertySteps"]
+        steps: List[Dict[str, Any]] = self._list_info()["modelInfo"]["pipeline"]["nodePropertySteps"]
         return [NodePropertyStep(s["name"], s["config"]) for s in steps]
 
     def metrics(self) -> "Series[Any]":
@@ -97,6 +97,6 @@ class PipelineModel(Model, ABC):
             The metrics for the pipeline model.
 
         """
-        model_metrics: Dict[str, Any] = self._list_info()["modelInfo"][0]["metrics"]
+        model_metrics: Dict[str, Any] = self._list_info()["modelInfo"]["metrics"]
         metric_scores: Dict[str, MetricScores] = {k: MetricScores.create(v) for k, v in (model_metrics.items())}
         return Series(metric_scores)

{graphdatascience-1.11a3 → graphdatascience-1.11a4}/graphdatascience/query_runner/arrow_query_runner.py

@@ -64,6 +64,9 @@ class ArrowQueryRunner(QueryRunner):
     ) -> DataFrame:
         return self._fallback_query_runner.run_cypher(query, params, database, custom_error)
 
+    def call_function(self, endpoint: str, params: Optional[CallParameters] = None) -> Any:
+        return self._fallback_query_runner.call_function(endpoint, params)
+
     def call_procedure(
         self,
         endpoint: str,

{graphdatascience-1.11a3 → graphdatascience-1.11a4}/graphdatascience/query_runner/aura_db_query_runner.py

@@ -35,6 +35,9 @@ class AuraDbQueryRunner(QueryRunner):
     ) -> DataFrame:
         return self._db_query_runner.run_cypher(query, params, database, custom_error)
 
+    def call_function(self, endpoint: str, params: Optional[CallParameters] = None) -> Any:
+        return self._gds_query_runner.call_function(endpoint, params)
+
     def call_procedure(
         self,
         endpoint: str,

{graphdatascience-1.11a3 → graphdatascience-1.11a4}/graphdatascience/query_runner/neo4j_query_runner.py

@@ -131,6 +131,13 @@ class Neo4jQueryRunner(QueryRunner):
 
             return df
 
+    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 call_procedure(
         self,
         endpoint: str,

{graphdatascience-1.11a3 → graphdatascience-1.11a4}/graphdatascience/query_runner/query_runner.py

@@ -21,6 +21,10 @@ class QueryRunner(ABC):
     ) -> DataFrame:
         pass
 
+    @abstractmethod
+    def call_function(self, endpoint: str, params: Optional[CallParameters] = None) -> Any:
+        pass
+
     @abstractmethod
     def run_cypher(
         self,