graphdatascience 1.10a1__tar.gz → 1.11__tar.gz

{graphdatascience-1.10a1/graphdatascience.egg-info → graphdatascience-1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: graphdatascience
-Version: 1.10a1
+Version: 1.11
 Summary: A Python client for the Neo4j Graph Data Science (GDS) library
 Home-page: https://neo4j.com/product/graph-data-science/
 Author: Neo4j
@@ -29,9 +29,10 @@ 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<15.0,>=10.0
+Requires-Dist: pyarrow<17.0,>=14.0.1
 Requires-Dist: textdistance<5.0,>=4.0
 Requires-Dist: tqdm<5.0,>=4.0
 Requires-Dist: typing-extensions<5.0,>=4.0
@@ -141,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.10a1 → graphdatascience-1.11}/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.10a1 → graphdatascience-1.11}/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.10a1 → graphdatascience-1.11}/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.10a1 → graphdatascience-1.11}/graphdatascience/graph/base_graph_proc_runner.py

@@ -15,11 +15,12 @@ from ..error.uncallable_namespace import UncallableNamespace
 from ..server_version.compatible_with import compatible_with
 from ..server_version.server_version import ServerVersion
 from .graph_entity_ops_runner import (
-    GraphElementPropertyRunner,
     GraphLabelRunner,
     GraphNodePropertiesRunner,
+    GraphNodePropertyRunner,
     GraphPropertyRunner,
     GraphRelationshipPropertiesRunner,
+    GraphRelationshipPropertyRunner,
     GraphRelationshipRunner,
     GraphRelationshipsRunner,
 )
@@ -379,9 +380,9 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
         )
 
     @property
-    def nodeProperty(self) -> GraphElementPropertyRunner:
+    def nodeProperty(self) -> GraphNodePropertyRunner:
         self._namespace += ".nodeProperty"
-        return GraphElementPropertyRunner(self._query_runner, self._namespace, self._server_version)
+        return GraphNodePropertyRunner(self._query_runner, self._namespace, self._server_version)
 
     @property
     def nodeProperties(self) -> GraphNodePropertiesRunner:
@@ -389,9 +390,9 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
         return GraphNodePropertiesRunner(self._query_runner, self._namespace, self._server_version)
 
     @property
-    def relationshipProperty(self) -> GraphElementPropertyRunner:
+    def relationshipProperty(self) -> GraphRelationshipPropertyRunner:
         self._namespace += ".relationshipProperty"
-        return GraphElementPropertyRunner(self._query_runner, self._namespace, self._server_version)
+        return GraphRelationshipPropertyRunner(self._query_runner, self._namespace, self._server_version)
 
     @property
     def relationshipProperties(self) -> GraphRelationshipPropertiesRunner:
@@ -516,8 +517,7 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
         ).squeeze()
 
     @multimethod
-    def removeNodeProperties(self) -> None:
-        ...
+    def removeNodeProperties(self) -> None: ...
 
     @removeNodeProperties.register
     @graph_type_check

{graphdatascience-1.10a1 → graphdatascience-1.11}/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.10a1 → graphdatascience-1.11}/graphdatascience/graph/graph_entity_ops_runner.py

@@ -70,11 +70,24 @@ class GraphEntityOpsBaseRunner(UncallableNamespace, IllegalAttrChecker):
         )
 
 
-class GraphElementPropertyRunner(GraphEntityOpsBaseRunner):
+class GraphNodePropertyRunner(GraphEntityOpsBaseRunner):
     @compatible_with("stream", min_inclusive=ServerVersion(2, 2, 0))
-    def stream(self, G: Graph, node_properties: str, node_labels: Strings = ["*"], **config: Any) -> DataFrame:
+    @filter_id_func_deprecation_warning()
+    def stream(
+        self,
+        G: Graph,
+        node_property: str,
+        node_labels: Strings = ["*"],
+        db_node_properties: List[str] = [],
+        **config: Any,
+    ) -> DataFrame:
         self._namespace += ".stream"
-        return self._handle_properties(G, node_properties, node_labels, config)
+
+        result = self._handle_properties(G, node_property, node_labels, config)
+
+        return GraphNodePropertiesRunner._process_result(
+            self._query_runner, list(node_property), False, db_node_properties, result, config
+        )
 
 
 class GraphNodePropertiesRunner(GraphEntityOpsBaseRunner):
@@ -93,6 +106,19 @@ class GraphNodePropertiesRunner(GraphEntityOpsBaseRunner):
 
         result = self._handle_properties(G, node_properties, node_labels, config)
 
+        return GraphNodePropertiesRunner._process_result(
+            self._query_runner, node_properties, separate_property_columns, db_node_properties, result, config
+        )
+
+    @staticmethod
+    def _process_result(
+        query_runner: QueryRunner,
+        node_properties: List[str],
+        separate_property_columns: bool,
+        db_node_properties: List[str],
+        result: DataFrame,
+        config: Dict[str, Any],
+    ) -> DataFrame:
         # new format was requested, but the query was run via Cypher
         if separate_property_columns and "propertyValue" in result.keys():
             wide_result = result.pivot(index=["nodeId"], columns=["nodeProperty"], values="propertyValue")
@@ -106,7 +132,7 @@ class GraphNodePropertiesRunner(GraphEntityOpsBaseRunner):
         # old format was requested but the query was run via Arrow
         elif not separate_property_columns and "propertyValue" not in result.keys():
             id_vars = ["nodeId", "nodeLabels"] if config.get("listNodeLabels", False) else ["nodeId"]
-            result = result.melt(id_vars=id_vars).rename(columns={"variable": "nodeProperty", "value": "propertyValue"})
+            result = result.melt(id_vars=id_vars, var_name="nodeProperty", value_name="propertyValue")
 
         if db_node_properties:
             duplicate_properties = set(db_node_properties).intersection(set(node_properties))
@@ -116,16 +142,20 @@ class GraphNodePropertiesRunner(GraphEntityOpsBaseRunner):
                 )
 
             unique_node_ids = result["nodeId"].drop_duplicates().tolist()
-            db_properties_df = self._query_runner.run_cypher(
-                self._build_query(db_node_properties), {"ids": unique_node_ids}
+            db_properties_df = query_runner.run_cypher(
+                GraphNodePropertiesRunner._build_query(db_node_properties), {"ids": unique_node_ids}
             )
 
             if "propertyValue" not in result.keys():
                 result = result.join(db_properties_df.set_index("nodeId"), on="nodeId")
             else:
-                db_properties_df = db_properties_df.melt(id_vars=["nodeId"]).rename(
-                    columns={"variable": "nodeProperty", "value": "propertyValue"}
+                db_properties_df = db_properties_df.melt(
+                    id_vars=["nodeId"], var_name="nodeProperty", value_name="propertyValue"
                 )
+
+                if "nodeProperty" not in result.keys():
+                    result["nodeProperty"] = node_properties[0]
+
                 result = pd.concat([result, db_properties_df])
 
         return result
@@ -140,7 +170,7 @@ class GraphNodePropertiesRunner(GraphEntityOpsBaseRunner):
         return reduce(add_property, db_node_properties, query_prefix)
 
     @compatible_with("write", min_inclusive=ServerVersion(2, 2, 0))
-    def write(self, G: Graph, node_properties: List[str], node_labels: Strings = ["*"], **config: Any) -> "Series[Any]":
+    def write(self, G: Graph, node_properties: Strings, node_labels: Strings = ["*"], **config: Any) -> "Series[Any]":
         self._namespace += ".write"
         return self._handle_properties(G, node_properties, node_labels, config).squeeze()  # type: ignore
 
@@ -160,6 +190,16 @@ class GraphNodePropertiesRunner(GraphEntityOpsBaseRunner):
         ).squeeze()
 
 
+class GraphRelationshipPropertyRunner(GraphEntityOpsBaseRunner):
+    @compatible_with("stream", min_inclusive=ServerVersion(2, 2, 0))
+    def stream(
+        self, G: Graph, relationship_property: str, relationship_types: Strings = ["*"], **config: Any
+    ) -> DataFrame:
+        self._namespace += ".stream"
+        relationship_types = [relationship_types] if isinstance(relationship_types, str) else relationship_types
+        return self._handle_properties(G, relationship_property, relationship_types, config)
+
+
 class GraphRelationshipPropertiesRunner(GraphEntityOpsBaseRunner):
     @compatible_with("stream", min_inclusive=ServerVersion(2, 2, 0))
     def stream(
@@ -172,6 +212,8 @@ class GraphRelationshipPropertiesRunner(GraphEntityOpsBaseRunner):
     ) -> DataFrame:
         self._namespace += ".stream"
 
+        relationship_types = [relationship_types] if isinstance(relationship_types, str) else relationship_types
+
         result = self._handle_properties(G, relationship_properties, relationship_types, config)
 
         # new format was requested, but the query was run via Cypher

{graphdatascience-1.10a1 → graphdatascience-1.11}/graphdatascience/graph/graph_remote_proc_runner.py

@@ -5,5 +5,4 @@ from graphdatascience.graph.graph_remote_project_runner import GraphProjectRemot
 class GraphRemoteProcRunner(BaseGraphProcRunner):
     @property
     def project(self) -> GraphProjectRemoteRunner:
-        self._namespace += ".project.remoteDb"
         return GraphProjectRemoteRunner(self._query_runner, self._namespace, self._server_version)

graphdatascience-1.11/graphdatascience/graph/graph_remote_project_runner.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import List, Optional
+
+from ..error.illegal_attr_checker import IllegalAttrChecker
+from ..query_runner.aura_db_query_runner import AuraDbQueryRunner
+from ..server_version.compatible_with import compatible_with
+from .graph_object import Graph
+from graphdatascience.call_parameters import CallParameters
+from graphdatascience.graph.graph_create_result import GraphCreateResult
+from graphdatascience.server_version.server_version import ServerVersion
+
+
+class GraphProjectRemoteRunner(IllegalAttrChecker):
+    @compatible_with("project", min_inclusive=ServerVersion(2, 7, 0))
+    def __call__(
+        self,
+        graph_name: str,
+        query: str,
+        concurrency: int = 4,
+        undirected_relationship_types: Optional[List[str]] = None,
+        inverse_indexed_relationship_types: Optional[List[str]] = None,
+        batch_size: Optional[int] = None,
+    ) -> GraphCreateResult:
+        if inverse_indexed_relationship_types is None:
+            inverse_indexed_relationship_types = []
+        if undirected_relationship_types is None:
+            undirected_relationship_types = []
+
+        arrow_configuration = {}
+        if batch_size is not None:
+            arrow_configuration["batchSize"] = batch_size
+
+        params = CallParameters(
+            graph_name=graph_name,
+            query=query,
+            concurrency=concurrency,
+            undirected_relationship_types=undirected_relationship_types,
+            inverse_indexed_relationship_types=inverse_indexed_relationship_types,
+            arrow_configuration=arrow_configuration,
+        )
+
+        result = self._query_runner.call_procedure(
+            endpoint=AuraDbQueryRunner.GDS_REMOTE_PROJECTION_PROC_NAME,
+            params=params,
+        ).squeeze()
+        return GraphCreateResult(Graph(graph_name, self._query_runner, self._server_version), result)

{graphdatascience-1.10a1 → graphdatascience-1.11}/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):
@@ -23,11 +24,12 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
 
     def __init__(
         self,
+        /,
         endpoint: Union[str, Driver, QueryRunner],
         auth: Optional[Tuple[str, str]] = None,
         aura_ds: bool = False,
         database: Optional[str] = None,
-        arrow: bool = True,
+        arrow: Union[str, bool] = True,
         arrow_disable_server_verification: bool = True,
         arrow_tls_root_certs: Optional[bytes] = None,
         bookmarks: Optional[Any] = None,
@@ -43,19 +45,20 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
             A username, password pair for database authentication.
         aura_ds : bool, default False
             A flag that indicates that that the client is used to connect
-            to a Neo4j Aura instance.
+            to a Neo4j AuraDS instance.
         database: Optional[str], default None
             The Neo4j database to query against.
-        arrow : bool, default True
-            A flag that indicates that the client should use Apache Arrow
-            for data streaming if it is available on the server.
+        arrow : Union[str, bool], default True
+            Arrow connection information. This is either a bool or a string.
+            If it is a string, it will be interpreted as a connection URL to a GDS Arrow Server.
+            If it is a bool,
+                True will make the client discover the connection URI to the GDS Arrow server via the Neo4j endpoint,
+                while False will make the client use Bolt for all operations.
         arrow_disable_server_verification : bool, default True
-            A flag that indicates that, if the flight client is connecting with
-            TLS, that it skips server verification. If this is enabled, all
-            other TLS settings are overridden.
+            A flag that overrides other TLS settings and disables server verification for TLS connections.
         arrow_tls_root_certs : Optional[bytes], default None
-            PEM-encoded certificates that are used for the connecting to the
-            Arrow Flight server.
+            PEM-encoded certificates that are used for the connection to the
+            GDS Arrow Flight server.
         bookmarks : Optional[Any], default None
             The Neo4j bookmarks to require a certain state before the next query gets executed.
         """
@@ -76,14 +79,19 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
                 self._query_runner.encrypted(),
                 arrow_disable_server_verification,
                 arrow_tls_root_certs,
+                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.10a1 → graphdatascience-1.11}/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]