graphdatascience 1.15.1__tar.gz → 1.17a1__tar.gz

{graphdatascience-1.15.1/graphdatascience.egg-info → graphdatascience-1.17a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphdatascience
-Version: 1.15.1
+Version: 1.17a1
 Summary: A Python client for the Neo4j Graph Data Science (GDS) library
 Home-page: https://neo4j.com/product/graph-data-science/
 Author: Neo4j
@@ -32,12 +32,13 @@ Requires-Dist: multimethod<3.0,>=1.0
 Requires-Dist: neo4j<6.0,>=4.4.12
 Requires-Dist: numpy<2.3
 Requires-Dist: pandas<3.0,>=1.0
-Requires-Dist: pyarrow<20.0,>=16.0
+Requires-Dist: pyarrow<21.0,>=17.0
 Requires-Dist: textdistance<5.0,>=4.0
 Requires-Dist: tqdm<5.0,>=4.0
 Requires-Dist: typing-extensions<5.0,>=4.0
 Requires-Dist: requests
 Requires-Dist: tenacity>=9.0
+Requires-Dist: pydantic>=2.11
 Provides-Extra: ogb
 Requires-Dist: ogb<2.0,>=1.0; extra == "ogb"
 Provides-Extra: networkx

{graphdatascience-1.15.1 → graphdatascience-1.17a1}/graphdatascience/error/cypher_warning_handler.py

@@ -19,15 +19,12 @@ def filter_id_func_deprecation_warning() -> Callable[[F], F]:
                 message=r"^The query used a deprecated function: `id`\.",
             )
 
+            # previously      The query used a deprecated function. ('id' is no longer supported)
+            # since 2025.04.0 The query used a deprecated function. ('id' has been replaced by 'elementId or an application-generated id')
+            # since 2025.06   The query used a deprecated function. ('id' has been replaced by 'elementId or consider using an application-generated id')
             warnings.filterwarnings(
                 "ignore",
-                message=r"^The query used a deprecated function. \('id' is no longer supported\)",
-            )
-
-            # since 2025.04.0
-            warnings.filterwarnings(
-                "ignore",
-                message=r"^The query used a deprecated function. \('id' has been replaced by 'elementId or an application-generated id'\)",
+                message=r"The query used a deprecated function. \('id'.*",
             )
 
             return func(self, *args, **kwargs)

{graphdatascience-1.15.1 → graphdatascience-1.17a1}/graphdatascience/graph/graph_cypher_runner.py

@@ -6,6 +6,8 @@ from typing import Any, Optional
 
 from pandas import Series
 
+from graphdatascience.query_runner.query_mode import QueryMode
+
 from ..caller_base import CallerBase
 from ..query_runner.query_runner import QueryRunner
 from ..server_version.server_version import ServerVersion
@@ -45,7 +47,9 @@ class GraphCypherRunner(CallerBase):
 
         GraphCypherRunner._verify_query_ends_with_return_clause(self._namespace, query)
 
-        result: Optional[dict[str, Any]] = self._query_runner.run_cypher(query, params, database, False).squeeze()
+        result: Optional[dict[str, Any]] = self._query_runner.run_retryable_cypher(
+            query, params, database, custom_error=False, mode=QueryMode.READ
+        ).squeeze()
 
         if not result:
             raise ValueError("Projected graph cannot be empty.")
@@ -101,7 +105,7 @@ class GraphCypherRunner(CallerBase):
                             at_end = True
                             break
 
-            if query_token == "RETURN":
+            if query_token.upper() == "RETURN":
                 # State 1: We found the start of a `RETURN` clause.
                 # Check if it is the `RETURN gds.graph.project` call.
                 # We split tokens on `__separators` and flatten the nested iters.

{graphdatascience-1.15.1 → graphdatascience-1.17a1}/graphdatascience/graph/graph_entity_ops_runner.py

@@ -5,6 +5,8 @@ from warnings import filterwarnings
 import pandas as pd
 from pandas import DataFrame, Series
 
+from graphdatascience.query_runner.query_mode import QueryMode
+
 from ..call_parameters import CallParameters
 from ..error.cypher_warning_handler import (
     filter_id_func_deprecation_warning,
@@ -158,12 +160,15 @@ class GraphNodePropertiesRunner(GraphEntityOpsBaseRunner):
             duplicate_properties = set(db_node_properties).intersection(set(node_properties))
             if duplicate_properties:
                 raise ValueError(
-                    f"Duplicate property keys '{duplicate_properties}' in db_node_properties and " f"node_properties."
+                    f"Duplicate property keys '{duplicate_properties}' in db_node_properties and node_properties."
                 )
 
             unique_node_ids = result["nodeId"].drop_duplicates().tolist()
-            db_properties_df = query_runner.run_cypher(
-                GraphNodePropertiesRunner._build_query(db_node_properties), {"ids": unique_node_ids}
+
+            db_properties_df = query_runner.run_retryable_cypher(
+                GraphNodePropertiesRunner._build_query(db_node_properties),
+                params={"ids": unique_node_ids},
+                mode=QueryMode.READ,
             )
 
             if "propertyValue" not in result.keys():
@@ -342,7 +347,7 @@ class GraphRelationshipsRunner(GraphEntityOpsBaseRunner):
     def stream(self, G: Graph, relationship_types: list[str] = ["*"], **config: Any) -> TopologyDataFrame:
         self._namespace += ".stream"
         params = CallParameters(graph_name=G.name(), relationship_types=relationship_types, config=config)
-        result = self._query_runner.call_procedure(endpoint=self._namespace, params=params)
+        result = self._query_runner.call_procedure(endpoint=self._namespace, params=params, retryable=True)
 
         return TopologyDataFrame(result)
 
@@ -360,7 +365,9 @@ class GraphRelationshipsBetaRunner(GraphEntityOpsBaseRunner):
         self._namespace += ".stream"
         params = CallParameters(graph_name=G.name(), relationship_types=relationship_types, config=config)
 
-        return TopologyDataFrame(self._query_runner.call_procedure(endpoint=self._namespace, params=params))
+        return TopologyDataFrame(
+            self._query_runner.call_procedure(endpoint=self._namespace, params=params, retryable=True)
+        )
 
     @property
     @compatible_with("toUndirected", min_inclusive=ServerVersion(2, 3, 0))
@@ -381,7 +388,7 @@ class GraphPropertyRunner(UncallableNamespace, IllegalAttrChecker):
         self._namespace += ".stream"
         params = CallParameters(graph_name=G.name(), graph_property=graph_property, config=config)
 
-        return self._query_runner.call_procedure(endpoint=self._namespace, params=params)
+        return self._query_runner.call_procedure(endpoint=self._namespace, params=params, retryable=True)
 
     @compatible_with("drop", min_inclusive=ServerVersion(2, 2, 0))
     @graph_type_check

{graphdatascience-1.15.1 → graphdatascience-1.17a1}/graphdatascience/graph/graph_object.py

@@ -68,7 +68,7 @@ class Graph:
         """
         return self._graph_info(["database"])  # type: ignore
 
-    def configuration(self) -> "Series[Any]":
+    def configuration(self) -> Series[Any]:
         """
         Returns:
             the configuration of the graph

{graphdatascience-1.15.1 → graphdatascience-1.17a1}/graphdatascience/graph_data_science.py

@@ -4,10 +4,12 @@ import warnings
 from types import TracebackType
 from typing import Any, Optional, Type, Union
 
+import neo4j
 from neo4j import Driver
 from pandas import DataFrame
 
 from graphdatascience.query_runner.arrow_authentication import UsernamePasswordAuthentication
+from graphdatascience.query_runner.query_mode import QueryMode
 
 from .call_builder import IndirectCallBuilder
 from .endpoints import AlphaEndpoints, BetaEndpoints, DirectEndpoints
@@ -40,6 +42,7 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
         arrow_tls_root_certs: Optional[bytes] = None,
         bookmarks: Optional[Any] = None,
         show_progress: bool = True,
+        arrow_client_options: Optional[dict[str, Any]] = None,
     ):
         """
         Construct a new GraphDataScience object.
@@ -63,14 +66,22 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
                 - True will make the client discover the connection URI to the GDS Arrow server via the Neo4j endpoint.
                 - False will make the client use Bolt for all operations.
         arrow_disable_server_verification : bool, default True
+            .. deprecated:: 1.16
+                Use arrow_client_options instead
+
             A flag that overrides other TLS settings and disables server verification for TLS connections.
         arrow_tls_root_certs : Optional[bytes], default None
+            .. deprecated:: 1.16
+                Use arrow_client_options instead
+
             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.
         show_progress : bool, default True
             A flag to indicate whether to show progress bars for running procedures.
+        arrow_client_options : Optional[dict[str, Any]], default None
+            Additional options to be passed to the Arrow Flight client.
         """
         if aura_ds:
             GraphDataScience._validate_endpoint(endpoint)
@@ -78,8 +89,11 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
         if isinstance(endpoint, QueryRunner):
             self._query_runner = endpoint
         else:
+            db_auth = None
+            if auth:
+                db_auth = neo4j.basic_auth(*auth)
             self._query_runner = Neo4jQueryRunner.create_for_db(
-                endpoint, auth, aura_ds, database, bookmarks, show_progress
+                endpoint, db_auth, aura_ds, database, bookmarks, show_progress
             )
 
         self._server_version = self._query_runner.server_version()
@@ -100,14 +114,19 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
                 username, password = auth
                 arrow_auth = UsernamePasswordAuthentication(username, password)
 
+            if arrow_client_options is None:
+                arrow_client_options = {}
+            if arrow_disable_server_verification:
+                arrow_client_options["disable_server_verification"] = True
+            if arrow_tls_root_certs is not None:
+                arrow_client_options["tls_root_certs"] = arrow_tls_root_certs
             self._query_runner = ArrowQueryRunner.create(
                 self._query_runner,
-                arrow_info,
-                arrow_auth,
-                self._query_runner.encrypted(),
-                arrow_disable_server_verification,
-                arrow_tls_root_certs,
-                None if arrow is True else arrow,
+                arrow_info=arrow_info,
+                arrow_authentication=arrow_auth,
+                encrypted=self._query_runner.encrypted(),
+                arrow_client_options=arrow_client_options,
+                connection_string_override=None if arrow is True else arrow,
             )
 
         self._query_runner.set_show_progress(show_progress)
@@ -195,7 +214,12 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
         return self._query_runner.last_bookmarks()
 
     def run_cypher(
-        self, query: str, params: Optional[dict[str, Any]] = None, database: Optional[str] = None
+        self,
+        query: str,
+        params: Optional[dict[str, Any]] = None,
+        database: Optional[str] = None,
+        retryable: bool = False,
+        mode: QueryMode = QueryMode.WRITE,
     ) -> DataFrame:
         """
         Run a Cypher query
@@ -208,6 +232,10 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
             parameters to the query
         database: str
             the database on which to run the query
+        retryable: bool
+            whether the query can be automatically retried. Make sure the query is idempotent if set to True.
+        mode: QueryMode
+            the query mode to use (READ or WRITE). Set based on the operation performed in the query.
 
         Returns:
             The query result as a DataFrame
@@ -218,7 +246,10 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
         if isinstance(self._query_runner, ArrowQueryRunner):
             qr = self._query_runner.fallback_query_runner()
 
-        return qr.run_cypher(query, params, database, False)
+        if retryable:
+            return qr.run_retryable_cypher(query, params, database, custom_error=False, mode=mode)
+        else:
+            return qr.run_cypher(query, params, database, custom_error=False, mode=mode)
 
     def driver_config(self) -> dict[str, Any]:
         """
@@ -235,11 +266,51 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
         driver: Driver,
         auth: Optional[tuple[str, str]] = None,
         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,
-    ) -> "GraphDataScience":
+        arrow_client_options: Optional[dict[str, Any]] = None,
+    ) -> GraphDataScience:
+        """
+        Construct a new GraphDataScience object from an existing Neo4j Driver.
+        This method is useful when you already have a Neo4j Driver instance and want to use it with the GDS client.
+
+        Parameters
+        ----------
+        driver: Driver
+            The Neo4j Driver instance to use.
+        auth : Optional[Tuple[str, str]], default None
+            A username, password pair for authentication.
+        database: Optional[str], default None
+            The Neo4j database to query against.
+        arrow : Union[str, bool], default True
+            Arrow connection information. This is either a string or a bool.
+
+            - 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.
+                - False will make the client use Bolt for all operations.
+        arrow_disable_server_verification : bool, default True
+            .. deprecated:: 1.16
+                Use arrow_client_options instead
+
+            A flag that overrides other TLS settings and disables server verification for TLS connections.
+        arrow_tls_root_certs : Optional[bytes], default None
+            .. deprecated:: 1.16
+                Use arrow_client_options instead
+
+            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.
+        show_progress : bool, default True
+            A flag to indicate whether to show progress bars for running procedures.
+        arrow_client_options : Optional[dict[str, Any]], default None
+            Additional options to be passed to the Arrow Flight client.
+        Returns:
+            A new GraphDataScience object. configured with the provided Neo4j Driver.
+        """
         return cls(
             driver,
             auth=auth,
@@ -248,6 +319,7 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
             arrow_disable_server_verification=arrow_disable_server_verification,
             arrow_tls_root_certs=arrow_tls_root_certs,
             bookmarks=bookmarks,
+            arrow_client_options=arrow_client_options,
         )
 
     @staticmethod

graphdatascience-1.17a1/graphdatascience/procedure_surface/arrow/wcc_arrow_endpoints.py

@@ -0,0 +1,191 @@
+import json
+from typing import Any, List, Optional
+
+from pandas import DataFrame
+
+from ...arrow_client.authenticated_flight_client import AuthenticatedArrowClient
+from ...arrow_client.v2.data_mapper_utils import deserialize_single
+from ...arrow_client.v2.job_client import JobClient
+from ...arrow_client.v2.mutation_client import MutationClient
+from ...arrow_client.v2.write_back_client import WriteBackClient
+from ...graph.graph_object import Graph
+from ..api.estimation_result import EstimationResult
+from ..api.wcc_endpoints import WccEndpoints, WccMutateResult, WccStatsResult, WccWriteResult
+from ..utils.config_converter import ConfigConverter
+
+WCC_ENDPOINT = "v2/community.wcc"
+
+
+class WccArrowEndpoints(WccEndpoints):
+    def __init__(self, arrow_client: AuthenticatedArrowClient, write_back_client: Optional[WriteBackClient] = None):
+        self._arrow_client = arrow_client
+        self._write_back_client = write_back_client
+
+    def mutate(
+        self,
+        G: Graph,
+        mutate_property: str,
+        threshold: Optional[float] = None,
+        relationship_types: Optional[List[str]] = None,
+        node_labels: Optional[List[str]] = None,
+        sudo: Optional[bool] = None,
+        log_progress: Optional[bool] = None,
+        username: Optional[str] = None,
+        concurrency: Optional[int] = None,
+        job_id: Optional[str] = None,
+        seed_property: Optional[str] = None,
+        consecutive_ids: Optional[bool] = None,
+        relationship_weight_property: Optional[str] = None,
+    ) -> WccMutateResult:
+        config = ConfigConverter.convert_to_gds_config(
+            graph_name=G.name(),
+            concurrency=concurrency,
+            consecutive_ids=consecutive_ids,
+            job_id=job_id,
+            log_progress=log_progress,
+            node_labels=node_labels,
+            relationship_types=relationship_types,
+            relationship_weight_property=relationship_weight_property,
+            seed_property=seed_property,
+            sudo=sudo,
+            threshold=threshold,
+        )
+
+        job_id = JobClient.run_job_and_wait(self._arrow_client, WCC_ENDPOINT, config)
+
+        mutate_result = MutationClient.mutate_node_property(self._arrow_client, job_id, mutate_property)
+        computation_result = JobClient.get_summary(self._arrow_client, job_id)
+
+        computation_result["nodePropertiesWritten"] = mutate_result.node_properties_written
+        computation_result["mutateMillis"] = 0
+
+        return WccMutateResult(**computation_result)
+
+    def stats(
+        self,
+        G: Graph,
+        threshold: Optional[float] = None,
+        relationship_types: Optional[List[str]] = None,
+        node_labels: Optional[List[str]] = None,
+        sudo: Optional[bool] = None,
+        log_progress: Optional[bool] = None,
+        username: Optional[str] = None,
+        concurrency: Optional[int] = None,
+        job_id: Optional[str] = None,
+        seed_property: Optional[str] = None,
+        consecutive_ids: Optional[bool] = None,
+        relationship_weight_property: Optional[str] = None,
+    ) -> WccStatsResult:
+        config = ConfigConverter.convert_to_gds_config(
+            graph_name=G.name(),
+            concurrency=concurrency,
+            consecutive_ids=consecutive_ids,
+            job_id=job_id,
+            log_progress=log_progress,
+            node_labels=node_labels,
+            relationship_types=relationship_types,
+            relationship_weight_property=relationship_weight_property,
+            seed_property=seed_property,
+            sudo=sudo,
+            threshold=threshold,
+        )
+
+        job_id = JobClient.run_job_and_wait(self._arrow_client, WCC_ENDPOINT, config)
+        computation_result = JobClient.get_summary(self._arrow_client, job_id)
+
+        return WccStatsResult(**computation_result)
+
+    def stream(
+        self,
+        G: Graph,
+        min_component_size: Optional[int] = None,
+        threshold: Optional[float] = None,
+        relationship_types: Optional[List[str]] = None,
+        node_labels: Optional[List[str]] = None,
+        sudo: Optional[bool] = None,
+        log_progress: Optional[bool] = None,
+        username: Optional[str] = None,
+        concurrency: Optional[int] = None,
+        job_id: Optional[str] = None,
+        seed_property: Optional[str] = None,
+        consecutive_ids: Optional[bool] = None,
+        relationship_weight_property: Optional[str] = None,
+    ) -> DataFrame:
+        config = ConfigConverter.convert_to_gds_config(
+            graph_name=G.name(),
+            concurrency=concurrency,
+            consecutive_ids=consecutive_ids,
+            job_id=job_id,
+            log_progress=log_progress,
+            min_component_size=min_component_size,
+            node_labels=node_labels,
+            relationship_types=relationship_types,
+            relationship_weight_property=relationship_weight_property,
+            seed_property=seed_property,
+            sudo=sudo,
+            threshold=threshold,
+        )
+
+        job_id = JobClient.run_job_and_wait(self._arrow_client, WCC_ENDPOINT, config)
+        return JobClient.stream_results(self._arrow_client, G.name(), job_id)
+
+    def write(
+        self,
+        G: Graph,
+        write_property: str,
+        min_component_size: Optional[int] = None,
+        threshold: Optional[float] = None,
+        relationship_types: Optional[List[str]] = None,
+        node_labels: Optional[List[str]] = None,
+        sudo: Optional[bool] = None,
+        log_progress: Optional[bool] = None,
+        username: Optional[str] = None,
+        concurrency: Optional[int] = None,
+        job_id: Optional[str] = None,
+        seed_property: Optional[str] = None,
+        consecutive_ids: Optional[bool] = None,
+        relationship_weight_property: Optional[str] = None,
+        write_concurrency: Optional[int] = None,
+    ) -> WccWriteResult:
+        config = ConfigConverter.convert_to_gds_config(
+            graph_name=G.name(),
+            concurrency=concurrency,
+            consecutive_ids=consecutive_ids,
+            job_id=job_id,
+            log_progress=log_progress,
+            min_component_size=min_component_size,
+            node_labels=node_labels,
+            relationship_types=relationship_types,
+            relationship_weight_property=relationship_weight_property,
+            seed_property=seed_property,
+            sudo=sudo,
+            threshold=threshold,
+        )
+
+        job_id = JobClient.run_job_and_wait(self._arrow_client, WCC_ENDPOINT, config)
+        computation_result = JobClient.get_summary(self._arrow_client, job_id)
+
+        if self._write_back_client is None:
+            raise Exception("Write back client is not initialized")
+
+        write_millis = self._write_back_client.write(
+            G.name(), job_id, write_concurrency if write_concurrency is not None else concurrency
+        )
+
+        computation_result["writeMillis"] = write_millis
+
+        return WccWriteResult(**computation_result)
+
+    def estimate(
+        self, G: Optional[Graph] = None, projection_config: Optional[dict[str, Any]] = None
+    ) -> EstimationResult:
+        if G is not None:
+            payload = {"graphName": G.name()}
+        elif projection_config is not None:
+            payload = projection_config
+        else:
+            raise ValueError("Either graph_name or projection_config must be provided.")
+
+        res = self._arrow_client.do_action_with_retry("v2/community.wcc.estimate", json.dumps(payload).encode("utf-8"))
+
+        return EstimationResult(**deserialize_single(res))

{graphdatascience-1.15.1 → graphdatascience-1.17a1}/graphdatascience/query_runner/arrow_query_runner.py

@@ -6,6 +6,7 @@ from typing import Any, Optional
 from pandas import DataFrame
 
 from graphdatascience.query_runner.arrow_authentication import ArrowAuthentication
+from graphdatascience.query_runner.query_mode import QueryMode
 from graphdatascience.retry_utils.retry_config import RetryConfig
 
 from ..call_parameters import CallParameters
@@ -24,8 +25,7 @@ class ArrowQueryRunner(QueryRunner):
         arrow_info: ArrowInfo,
         arrow_authentication: Optional[ArrowAuthentication] = None,
         encrypted: bool = False,
-        disable_server_verification: bool = False,
-        tls_root_certs: Optional[bytes] = None,
+        arrow_client_options: Optional[dict[str, Any]] = None,
         connection_string_override: Optional[str] = None,
         retry_config: Optional[RetryConfig] = None,
     ) -> ArrowQueryRunner:
@@ -33,13 +33,12 @@ class ArrowQueryRunner(QueryRunner):
             raise ValueError("Arrow is not enabled on the server")
 
         gds_arrow_client = GdsArrowClient.create(
-            arrow_info,
-            arrow_authentication,
-            encrypted,
-            disable_server_verification,
-            tls_root_certs,
-            connection_string_override,
+            arrow_info=arrow_info,
+            auth=arrow_authentication,
+            encrypted=encrypted,
+            connection_string_override=connection_string_override,
             retry_config=retry_config,
+            arrow_client_options=arrow_client_options,
         )
 
         return ArrowQueryRunner(gds_arrow_client, fallback_query_runner, fallback_query_runner.server_version())
@@ -64,9 +63,22 @@ class ArrowQueryRunner(QueryRunner):
         query: str,
         params: Optional[dict[str, Any]] = None,
         database: Optional[str] = None,
+        mode: Optional[QueryMode] = None,
         custom_error: bool = True,
     ) -> DataFrame:
-        return self._fallback_query_runner.run_cypher(query, params, database, custom_error)
+        return self._fallback_query_runner.run_cypher(query, params, database, mode, custom_error=custom_error)
+
+    def run_retryable_cypher(
+        self,
+        query: str,
+        params: Optional[dict[str, Any]] = None,
+        database: Optional[str] = None,
+        mode: Optional[QueryMode] = None,
+        custom_error: bool = True,
+    ) -> DataFrame:
+        return self._fallback_query_runner.run_retryable_cypher(
+            query, params, database, mode, custom_error=custom_error
+        )
 
     def call_function(self, endpoint: str, params: Optional[CallParameters] = None) -> Any:
         return self._fallback_query_runner.call_function(endpoint, params)
@@ -77,7 +89,9 @@ class ArrowQueryRunner(QueryRunner):
         params: Optional[CallParameters] = None,
         yields: Optional[list[str]] = None,
         database: Optional[str] = None,
+        mode: QueryMode = QueryMode.READ,
         logging: bool = False,
+        retryable: bool = False,
         custom_error: bool = True,
     ) -> DataFrame:
         if params is None:
@@ -171,7 +185,9 @@ class ArrowQueryRunner(QueryRunner):
                 graph_name, self._database_or_throw(), relationship_types, concurrency
             )
 
-        return self._fallback_query_runner.call_procedure(endpoint, params, yields, database, logging, custom_error)
+        return self._fallback_query_runner.call_procedure(
+            endpoint, params, yields, database, logging=logging, retryable=retryable, custom_error=custom_error
+        )
 
     def server_version(self) -> ServerVersion:
         return self._fallback_query_runner.server_version()
@@ -211,10 +227,10 @@ class ArrowQueryRunner(QueryRunner):
         self._fallback_query_runner.close()
         self._gds_arrow_client.close()
 
-    def clone(self, host: str, port: int) -> "QueryRunner":
+    def cloneWithoutRouting(self, host: str, port: int) -> "QueryRunner":
         return ArrowQueryRunner(
             self._gds_arrow_client,
-            self._fallback_query_runner.clone(host, port),
+            self._fallback_query_runner.cloneWithoutRouting(host, port),
             self._server_version,
         )
 

{graphdatascience-1.15.1 → graphdatascience-1.17a1}/graphdatascience/query_runner/cypher_graph_constructor.py

@@ -7,6 +7,8 @@ from uuid import uuid4
 
 from pandas import DataFrame, concat
 
+from graphdatascience.query_runner.query_mode import QueryMode
+
 from ..server_version.server_version import ServerVersion
 from .graph_constructor import GraphConstructor
 from .query_runner import QueryRunner
@@ -104,15 +106,16 @@ class CypherGraphConstructor(GraphConstructor):
 
     def _should_warn_about_arrow_missing(self) -> bool:
         try:
-            license: str = self._query_runner.run_cypher(
-                "CALL gds.debug.sysInfo() YIELD key, value WHERE key = 'gdsEdition' RETURN value", custom_error=False
+            license: str = self._query_runner.run_retryable_cypher(
+                "CALL gds.debug.sysInfo() YIELD key, value WHERE key = 'gdsEdition' RETURN value",
+                custom_error=False,
+                mode=QueryMode.READ,
             ).squeeze()
             should_warn = license == "Licensed"
         except Exception as e:
             # It's not a user's concern whether Arrow is set up or not in AuraDS.
-            if (
-                "There is no procedure with the name `gds.debug.sysInfo` "
-                "registered for this database instance." in str(e)
+            if "There is no procedure with the name `gds.debug.sysInfo` registered for this database instance." in str(
+                e
             ):
                 should_warn = False
             else:
@@ -210,6 +213,7 @@ class CypherGraphConstructor(GraphConstructor):
                 "undirectedRelationshipTypes": self._undirected_relationship_types,
             }
 
+            # not using retryable here as gds.graph.project adds a graph to the gds graph catalog
             self._query_runner.run_cypher(
                 query,
                 {