graphdatascience 1.20a2__tar.gz → 1.21a1__tar.gz

{graphdatascience-1.20a2/src/graphdatascience.egg-info → graphdatascience-1.21a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphdatascience
-Version: 1.20a2
+Version: 1.21a1
 Summary: A Python client for the Neo4j Graph Data Science (GDS) library
 Author-email: Neo4j <team-gds@neo4j.org>
 License-Expression: Apache-2.0

{graphdatascience-1.20a2 → graphdatascience-1.21a1}/pyproject.toml

@@ -54,8 +54,6 @@ rust-ext = ["neo4j-rust-ext >= 4.4.12, < 7.0"]
 
 
 [dependency-groups]
-# To install all development dependencies,
-# run `pip install --group dev -e .` inside repository root folder.#
 dev = [
     "tox>4.24",
     { include-group = "dev-base" },
@@ -89,6 +87,7 @@ docs-ci = [
     "sphinx == 7.3.7",
     "enum-tools[sphinx]==0.13.0",
     "autodoc_pydantic",
+    "networkx >= 2.0, < 4.0"
 ]
 notebook-base = [
     "nbconvert==7.16.6",
@@ -111,6 +110,10 @@ notebook-ci = [
 
 publish = ["build", "twine"]
 
+[tool.uv.extra-build-dependencies]
+torch-sparse = ["torch"]
+torch-scatter = ["torch"]
+
 [tool.setuptools]
 include-package-data = true
 zip-safe = false

{graphdatascience-1.20a2 → graphdatascience-1.21a1}/src/graphdatascience/arrow_client/arrow_info.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
-from ..query_runner.query_runner import QueryRunner
-from ..server_version.server_version import ServerVersion
+from graphdatascience.query_runner.query_runner import QueryRunner
+from graphdatascience.query_runner.query_type import QueryType
+from graphdatascience.server_version.server_version import ServerVersion
 
 
 @dataclass(frozen=True)
@@ -20,7 +21,7 @@ class ArrowInfo:
             debugYields.append("versions")
 
         procResult = query_runner.call_procedure(
-            endpoint="gds.debug.arrow", custom_error=False, yields=debugYields
+            endpoint="gds.debug.arrow", query_type=QueryType.SYSTEM, custom_error=False, yields=debugYields
         ).iloc[0]
 
         return ArrowInfo(

{graphdatascience-1.20a2 → graphdatascience-1.21a1}/src/graphdatascience/graph/graph_cypher_runner.py

@@ -6,13 +6,13 @@ from typing import Any
 
 from pandas import Series
 
+from graphdatascience.caller_base import CallerBase
+from graphdatascience.graph.graph_create_result import GraphCreateResult
+from graphdatascience.graph.graph_object import Graph
 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
-from .graph_create_result import GraphCreateResult
-from .graph_object import Graph
+from graphdatascience.query_runner.query_runner import QueryRunner
+from graphdatascience.query_runner.query_type import QueryType
+from graphdatascience.server_version.server_version import ServerVersion
 
 
 class GraphCypherRunner(CallerBase):
@@ -48,7 +48,7 @@ class GraphCypherRunner(CallerBase):
         GraphCypherRunner._verify_query_ends_with_return_clause(self._namespace, query)
 
         result: dict[str, Any] | None = self._query_runner.run_retryable_cypher(
-            query, params, database, custom_error=False, mode=QueryMode.READ
+            query, QueryType.USER_DIRECTED, params, database, custom_error=False, mode=QueryMode.READ
         ).squeeze()
 
         if not result:

{graphdatascience-1.20a2 → graphdatascience-1.21a1}/src/graphdatascience/graph/graph_entity_ops_runner.py

@@ -8,6 +8,7 @@ import pandas as pd
 from pandas import DataFrame, Series
 
 from graphdatascience.query_runner.query_mode import QueryMode
+from graphdatascience.query_runner.query_type import QueryType
 
 from ..call_parameters import CallParameters
 from ..error.cypher_warning_handler import (
@@ -169,6 +170,7 @@ class GraphNodePropertiesRunner(GraphEntityOpsBaseRunner):
 
             db_properties_df = query_runner.run_retryable_cypher(
                 GraphNodePropertiesRunner._build_query(db_node_properties),
+                QueryType.USER_TRANSPILED,
                 params={"ids": unique_node_ids},
                 mode=QueryMode.READ,
             )

{graphdatascience-1.20a2 → graphdatascience-1.21a1}/src/graphdatascience/graph/v2/graph_api.py

@@ -106,7 +106,7 @@ class GraphV2:
         """
         return self._backend.graph_info().density
 
-    def memory_usage(self) -> str:
+    def memory_usage(self) -> str | None:
         """
         Returns:
             the memory usage of the graph

{graphdatascience-1.20a2 → graphdatascience-1.21a1}/src/graphdatascience/graph_data_science.py

@@ -22,6 +22,7 @@ from .query_runner.arrow_info import ArrowInfo
 from .query_runner.arrow_query_runner import ArrowQueryRunner
 from .query_runner.neo4j_query_runner import Neo4jQueryRunner
 from .query_runner.query_runner import QueryRunner
+from .query_runner.query_type import QueryType
 from .server_version.server_version import ServerVersion
 from .utils.util_proc_runner import UtilProcRunner
 from .version import __min_server_version__
@@ -93,7 +94,7 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
         if isinstance(endpoint, QueryRunner):
             self._query_runner = endpoint
         else:
-            db_auth = None
+            db_auth: neo4j.Auth | None = None
             if auth:
                 db_auth = neo4j.basic_auth(*auth)
             neo4j_query_runner = Neo4jQueryRunner.create_for_db(
@@ -118,21 +119,29 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
             if auth is not None:
                 username, password = auth
                 arrow_auth = UsernamePasswordAuthentication(username, password)
+            if isinstance(endpoint, Neo4jQueryRunner):
+                if neo4j_auth := endpoint.get_auth():
+                    arrow_auth = UsernamePasswordAuthentication(neo4j_auth[0], neo4j_auth[1])
 
-            if arrow_client_options is None:
-                arrow_client_options = {}
-            if arrow_disable_server_verification:
-                disable_server_verification(arrow_client_options)
-            if arrow_tls_root_certs is not None:
-                set_tls_root_certs(arrow_client_options, arrow_tls_root_certs)
-            self._query_runner = ArrowQueryRunner.create(
-                self._query_runner,
-                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,
-            )
+            if isinstance(endpoint, Driver) and not auth:
+                warnings.warn(
+                    "Falling back to use Cypher for GDS. To use Arrow, you must explicitly provide the `auth` parameter."
+                )
+            else:
+                if arrow_client_options is None:
+                    arrow_client_options = {}
+                if arrow_disable_server_verification:
+                    disable_server_verification(arrow_client_options)
+                if arrow_tls_root_certs is not None:
+                    set_tls_root_certs(arrow_client_options, arrow_tls_root_certs)
+                self._query_runner = ArrowQueryRunner.create(
+                    self._query_runner,
+                    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,
+                )
 
         arrow_client = (
             None if not isinstance(self._query_runner, ArrowQueryRunner) else self._query_runner._gds_arrow_client
@@ -258,15 +267,16 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
             The query result as a DataFrame
         """
         qr = self._query_runner
+        query_type = QueryType.USER_DIRECTED
 
         # The Arrow query runner should not be used to execute arbitrary Cypher
         if isinstance(self._query_runner, ArrowQueryRunner):
             qr = self._query_runner.fallback_query_runner()
 
         if retryable:
-            return qr.run_retryable_cypher(query, params, database, custom_error=False, mode=mode)
+            return qr.run_retryable_cypher(query, query_type, params, database, custom_error=False, mode=mode)
         else:
-            return qr.run_cypher(query, params, database, custom_error=False, mode=mode)
+            return qr.run_cypher(query, query_type, params, database, custom_error=False, mode=mode)
 
     def driver_config(self) -> dict[str, Any]:
         """
@@ -310,6 +320,7 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
             The Neo4j Driver instance to use.
         auth : tuple[str, str] | None, default None
             A username, password pair for authentication.
+            Is required for enabling Arrow.
         database: str | None, default None
             The Neo4j database to query against.
         arrow : str | bool, default True

{graphdatascience-1.20a2 → graphdatascience-1.21a1}/src/graphdatascience/procedure_surface/api/catalog/graph_info.py

@@ -15,7 +15,7 @@ class GraphInfo(BaseResult):
     database: str
     database_location: str
     configuration: dict[str, Any]
-    memory_usage: str
+    memory_usage: str | None  # can be none if there was an error computing the usage
     size_in_bytes: int
     node_count: int
     relationship_count: int

{graphdatascience-1.20a2 → graphdatascience-1.21a1}/src/graphdatascience/procedure_surface/utils/result_utils.py

@@ -4,6 +4,7 @@ from pandas import DataFrame
 
 from graphdatascience.query_runner.query_mode import QueryMode
 from graphdatascience.query_runner.query_runner import QueryRunner
+from graphdatascience.query_runner.query_type import QueryType
 
 
 def transpose_property_columns(result: DataFrame, list_node_labels: bool) -> DataFrame:
@@ -25,6 +26,7 @@ def join_db_node_properties(result: DataFrame, db_node_properties: list[str], qu
     query = _build_query(db_node_properties)
     db_properties_df = query_runner.run_retryable_cypher(
         query,
+        QueryType.USER_TRANSPILED,
         params={"ids": (result["nodeId"].tolist())},
         mode=QueryMode.READ,
     )

graphdatascience-1.21a1/src/graphdatascience/query_runner/__init__.py

@@ -0,0 +1,5 @@
+from .query_mode import QueryMode
+from .query_runner import QueryRunner
+from .query_type import QueryType
+
+__all__ = ["QueryRunner", "QueryMode", "QueryType"]

{graphdatascience-1.20a2 → graphdatascience-1.21a1}/src/graphdatascience/query_runner/arrow_query_runner.py

@@ -9,6 +9,7 @@ from graphdatascience.arrow_client.authenticated_flight_client import Authentica
 from graphdatascience.arrow_client.v1.gds_arrow_client import GdsArrowClient
 from graphdatascience.query_runner.arrow_authentication import ArrowAuthentication
 from graphdatascience.query_runner.query_mode import QueryMode
+from graphdatascience.query_runner.query_type import QueryType
 from graphdatascience.retry_utils.retry_config import RetryConfigV2
 
 from ..call_parameters import CallParameters
@@ -64,31 +65,38 @@ class ArrowQueryRunner(QueryRunner):
     def run_cypher(
         self,
         query: str,
+        query_type: QueryType,
         params: dict[str, Any] | None = None,
         database: str | None = None,
         mode: QueryMode | None = None,
         custom_error: bool = True,
     ) -> DataFrame:
-        return self._fallback_query_runner.run_cypher(query, params, database, mode, custom_error=custom_error)
+        return self._fallback_query_runner.run_cypher(
+            query, query_type, params, database, mode, custom_error=custom_error
+        )
 
     def run_retryable_cypher(
         self,
         query: str,
+        query_type: QueryType,
         params: dict[str, Any] | None = None,
         database: str | None = None,
         mode: QueryMode | None = None,
         custom_error: bool = True,
     ) -> DataFrame:
         return self._fallback_query_runner.run_retryable_cypher(
-            query, params, database, mode, custom_error=custom_error
+            query, query_type, params, database, mode, custom_error=custom_error
         )
 
-    def call_function(self, endpoint: str, params: CallParameters | None = None) -> Any:
-        return self._fallback_query_runner.call_function(endpoint, params)
+    def call_function(
+        self, endpoint: str, query_type: QueryType = QueryType.USER_TRANSPILED, params: CallParameters | None = None
+    ) -> Any:
+        return self._fallback_query_runner.call_function(endpoint, query_type, params)
 
     def call_procedure(
         self,
         endpoint: str,
+        query_type: QueryType = QueryType.USER_TRANSPILED,
         params: CallParameters | None = None,
         yields: list[str] | None = None,
         database: str | None = None,
@@ -189,7 +197,14 @@ class ArrowQueryRunner(QueryRunner):
             )
 
         return self._fallback_query_runner.call_procedure(
-            endpoint, params, yields, database, logging=logging, retryable=retryable, custom_error=custom_error
+            endpoint,
+            query_type,
+            params,
+            yields,
+            database,
+            logging=logging,
+            retryable=retryable,
+            custom_error=custom_error,
         )
 
     def server_version(self) -> ServerVersion:

{graphdatascience-1.20a2 → graphdatascience-1.21a1}/src/graphdatascience/query_runner/cypher_graph_constructor.py

@@ -12,6 +12,7 @@ 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
+from .query_type import QueryType
 
 
 class CypherProjectionApi:
@@ -107,6 +108,7 @@ class CypherGraphConstructor(GraphConstructor):
         try:
             license: str = self._query_runner.run_retryable_cypher(
                 "CALL gds.debug.sysInfo() YIELD key, value WHERE key = 'gdsEdition' RETURN value",
+                QueryType.SYSTEM,
                 custom_error=False,
                 mode=QueryMode.READ,
             ).squeeze()
@@ -215,6 +217,7 @@ class CypherGraphConstructor(GraphConstructor):
             # not using retryable here as gds.graph.project adds a graph to the gds graph catalog
             self._query_runner.run_cypher(
                 query,
+                QueryType.USER_TRANSPILED,
                 {
                     "data": combined_df.values.tolist(),
                     "graph_name": self._graph_name,
@@ -377,6 +380,7 @@ class CypherGraphConstructor(GraphConstructor):
 
             self._query_runner.run_cypher(
                 query,
+                QueryType.USER_TRANSPILED,
                 {
                     "graph_name": self._graph_name,
                     "node_query": node_query,

{graphdatascience-1.20a2 → graphdatascience-1.21a1}/src/graphdatascience/query_runner/db_environment_resolver.py

@@ -1,18 +1,22 @@
 from graphdatascience.query_runner.neo4j_query_runner import Neo4jQueryRunner
+from graphdatascience.query_runner.query_type import QueryType
 
 
 class DbEnvironmentResolver:
     @staticmethod
     def hosted_in_aura(db_runner: Neo4jQueryRunner) -> bool:
         return (
-            db_runner.run_retryable_cypher("""
+            db_runner.run_retryable_cypher(
+                """
         CALL dbms.components() YIELD name, versions
         WHERE name = "Neo4j Kernel"
         UNWIND versions as v
         WITH name, v
         WHERE v ENDS WITH "aura"
         RETURN count(*) <> 0
-        """)
+        """,
+                QueryType.SYSTEM,
+            )
             .iloc[0]
             .item()
         ) is True

{graphdatascience-1.20a2 → graphdatascience-1.21a1}/src/graphdatascience/query_runner/neo4j_query_runner.py

@@ -11,6 +11,8 @@ from pandas import DataFrame
 from tenacity import retry, retry_if_exception, stop_after_delay, wait_fixed
 
 from graphdatascience.query_runner.query_mode import QueryMode
+from graphdatascience.query_runner.query_runner import QueryRunner
+from graphdatascience.query_runner.query_type import QueryType
 from graphdatascience.retry_utils.neo4j_retry_helper import is_retryable_neo4j_exception
 
 from ..call_parameters import CallParameters
@@ -23,7 +25,6 @@ from ..version import __version__
 from .cypher_graph_constructor import CypherGraphConstructor
 from .graph_constructor import GraphConstructor
 from .progress.query_progress_logger import QueryProgressLogger
-from .query_runner import QueryRunner
 
 
 class Neo4jQueryRunner(QueryRunner):
@@ -155,12 +156,24 @@ class Neo4jQueryRunner(QueryRunner):
         # progress logging should not retry a lot as it perodically fetches the latest progress anyway
         connectivity_retry_config = Neo4jQueryRunner.ConnectivityRetriesConfig(max_retries=2)
         # not using retryable cypher as failing is okay
-        return self.run_cypher(query=query, database=database, connectivity_retry_config=connectivity_retry_config)
+        return self.run_cypher(
+            query=query,
+            query_type=QueryType.USER_TRANSPILED,
+            database=database,
+            connectivity_retry_config=connectivity_retry_config,
+        )
+
+    def get_auth(self) -> tuple[str, str] | None:
+        if isinstance(self._auth, neo4j.Auth):
+            return self._auth.principal, self._auth.credentials
+        else:
+            return self._auth
 
     # only use for user defined queries
     def run_cypher(
         self,
         query: str,
+        query_type: QueryType,
         params: dict[str, Any] | None = None,
         database: str | None = None,
         mode: QueryMode | None = None,
@@ -186,7 +199,7 @@ class Neo4jQueryRunner(QueryRunner):
             default_access_mode=mode.neo4j_access_mode(),
         ) as session:
             try:
-                result = session.run(query, params)
+                result = session.run(self._wrap_query(query, query_type), params)
             except Exception as e:
                 if custom_error:
                     self.handle_driver_exception(session, e)
@@ -211,6 +224,7 @@ class Neo4jQueryRunner(QueryRunner):
     def run_retryable_cypher(
         self,
         query: str,
+        query_type: QueryType,
         params: dict[str, Any] | None = None,
         database: str | None = None,
         mode: QueryMode | None = None,
@@ -221,7 +235,7 @@ class Neo4jQueryRunner(QueryRunner):
             database = self._database
 
         if self._NEO4J_DRIVER_VERSION < SemanticVersion(5, 5, 0):
-            return self.run_cypher(query, params, database, mode, custom_error, connectivity_retry_config)
+            return self.run_cypher(query, query_type, params, database, mode, custom_error, connectivity_retry_config)
 
         if not mode:
             routing = neo4j.RoutingControl.WRITE
@@ -232,7 +246,7 @@ class Neo4jQueryRunner(QueryRunner):
             bookmark_manager = neo4j.GraphDatabase.bookmark_manager(self.bookmarks())
 
             result = self._driver.execute_query(
-                query_=query,
+                query_=self._wrap_query(query, query_type),
                 parameters_=params,
                 database_=database,
                 result_transformer_=neo4j.Result.to_df,
@@ -250,17 +264,26 @@ class Neo4jQueryRunner(QueryRunner):
             else:
                 raise e
 
-    def call_function(self, endpoint: str, params: CallParameters | None = None, custom_error: bool = True) -> Any:
+    def call_function(
+        self,
+        endpoint: str,
+        query_type: QueryType = QueryType.USER_TRANSPILED,
+        params: CallParameters | None = None,
+        custom_error: bool = True,
+    ) -> Any:
         if params is None:
             params = CallParameters()
         query = f"RETURN {endpoint}({params.placeholder_str()})"
 
         # we can use retryable cypher as we expect all gds functions to be idempotent
-        return self.run_retryable_cypher(query, params, custom_error=custom_error, mode=QueryMode.READ).squeeze()
+        return self.run_retryable_cypher(
+            query, query_type, params, custom_error=custom_error, mode=QueryMode.READ
+        ).squeeze()
 
     def call_procedure(
         self,
         endpoint: str,
+        query_type: QueryType = QueryType.USER_TRANSPILED,
         params: CallParameters | None = None,
         yields: list[str] | None = None,
         database: str | None = None,
@@ -277,9 +300,11 @@ class Neo4jQueryRunner(QueryRunner):
 
         def run_cypher_query() -> DataFrame:
             if retryable:
-                return self.run_retryable_cypher(query, params, database, custom_error=custom_error, mode=mode)
+                return self.run_retryable_cypher(
+                    query, query_type, params, database, custom_error=custom_error, mode=mode
+                )
             else:
-                return self.run_cypher(query, params, database, custom_error=custom_error)
+                return self.run_cypher(query, query_type, params, database, custom_error=custom_error)
 
         job_id = None if not params else params.get_job_id()
         if self._resolve_show_progress(logging) and job_id:
@@ -295,7 +320,7 @@ class Neo4jQueryRunner(QueryRunner):
             return self._server_version
 
         try:
-            server_version_string = self.call_function("gds.version", custom_error=False)
+            server_version_string = self.call_function("gds.version", query_type=QueryType.SYSTEM, custom_error=False)
             server_version = ServerVersion.from_string(server_version_string)
             self._server_version = server_version
             return server_version
@@ -501,6 +526,12 @@ class Neo4jQueryRunner(QueryRunner):
         warnings.filterwarnings("ignore", message=r".*returned by the procedure.* is deprecated.*")
         warnings.filterwarnings("ignore", message=r".*procedure field deprecated..*")
 
+    def _wrap_query(self, query: str, query_type: QueryType) -> neo4j.Query:
+        return neo4j.Query(
+            text=query,  # type: ignore[assignment]
+            metadata={"app": f"gds-v{__version__}", "type": query_type.value},
+        )
+
     class ConnectivityRetriesConfig(NamedTuple):
         max_retries: int = 600
         wait_time: int = 1

{graphdatascience-1.20a2 → graphdatascience-1.21a1}/src/graphdatascience/query_runner/progress/query_progress_logger.py

@@ -22,7 +22,6 @@ class QueryProgressLogger:
         polling_interval: float = 0.5,
         progress_bar_options: dict[str, Any] = {},
     ):
-        self._run_cypher_func = run_cypher_func
         self._server_version_func = server_version_func
         self._static_progress_provider = StaticProgressProvider()
         self._query_progress_provider = QueryProgressProvider(run_cypher_func, server_version_func)

{graphdatascience-1.20a2 → graphdatascience-1.21a1}/src/graphdatascience/query_runner/protocol/project_protocols.py

@@ -8,6 +8,7 @@ from tenacity import retry, retry_if_result
 from graphdatascience.call_parameters import CallParameters
 from graphdatascience.query_runner.protocol.status import Status
 from graphdatascience.query_runner.query_runner import QueryRunner
+from graphdatascience.query_runner.query_type import QueryType
 from graphdatascience.query_runner.termination_flag import TerminationFlag
 from graphdatascience.retry_utils.retry_utils import before_log, job_wait_strategy
 from graphdatascience.session.dbms.protocol_version import ProtocolVersion
@@ -69,7 +70,14 @@ class ProjectProtocolV1(ProjectProtocol):
     ) -> DataFrame:
         versioned_endpoint = ProtocolVersion.V1.versioned_procedure_name(endpoint)
         return query_runner.call_procedure(
-            versioned_endpoint, params, yields, database=database, logging=logging, retryable=False, custom_error=False
+            versioned_endpoint,
+            QueryType.USER_TRANSPILED,
+            params,
+            yields,
+            database=database,
+            logging=logging,
+            retryable=False,
+            custom_error=False,
         )
 
 
@@ -102,7 +110,14 @@ class ProjectProtocolV2(ProjectProtocol):
     ) -> DataFrame:
         versioned_endpoint = ProtocolVersion.V2.versioned_procedure_name(endpoint)
         return query_runner.call_procedure(
-            versioned_endpoint, params, yields, database=database, logging=logging, retryable=False, custom_error=False
+            versioned_endpoint,
+            QueryType.USER_TRANSPILED,
+            params,
+            yields,
+            database=database,
+            logging=logging,
+            retryable=False,
+            custom_error=False,
         )
 
 
@@ -144,6 +159,7 @@ class ProjectProtocolV3(ProjectProtocol):
         # We need to pin the driver to a specific cluster member
         response = query_runner.call_procedure(
             ProtocolVersion.V3.versioned_procedure_name(endpoint),
+            QueryType.USER_TRANSPILED,
             params,
             yields,
             database,
@@ -165,6 +181,7 @@ class ProjectProtocolV3(ProjectProtocol):
             termination_flag.assert_running()
             return projection_query_runner.call_procedure(
                 ProtocolVersion.V3.versioned_procedure_name(endpoint),
+                QueryType.USER_TRANSPILED,
                 params,
                 yields,
                 database=database,

{graphdatascience-1.20a2 → graphdatascience-1.21a1}/src/graphdatascience/query_runner/protocol/write_protocols.py

@@ -75,8 +75,8 @@ class RemoteWriteBackV1(WriteProtocol):
     ) -> DataFrame:
         return query_runner.call_procedure(
             ProtocolVersion.V1.versioned_procedure_name("gds.arrow.write"),
-            parameters,
-            yields,
+            params=parameters,
+            yields=yields,
             retryable=False,
             database=None,
             logging=False,
@@ -116,8 +116,8 @@ class RemoteWriteBackV2(WriteProtocol):
     ) -> DataFrame:
         return query_runner.call_procedure(
             ProtocolVersion.V2.versioned_procedure_name("gds.arrow.write"),
-            parameters,
-            yields,
+            params=parameters,
+            yields=yields,
             retryable=False,
             database=None,
             logging=False,
@@ -168,8 +168,8 @@ class RemoteWriteBackV3(WriteProtocol):
             terminationFlag.assert_running()
             result = query_runner.call_procedure(
                 ProtocolVersion.V3.versioned_procedure_name("gds.arrow.write"),
-                parameters,
-                yields,
+                params=parameters,
+                yields=yields,
                 retryable=True,
                 logging=False,
                 mode=QueryMode.WRITE,

{graphdatascience-1.20a2 → graphdatascience-1.21a1}/src/graphdatascience/query_runner/query_runner.py

@@ -3,11 +3,11 @@ from typing import Any
 
 from pandas import DataFrame
 
+from graphdatascience.call_parameters import CallParameters
+from graphdatascience.query_runner.graph_constructor import GraphConstructor
 from graphdatascience.query_runner.query_mode import QueryMode
-
-from ..call_parameters import CallParameters
-from ..server_version.server_version import ServerVersion
-from .graph_constructor import GraphConstructor
+from graphdatascience.query_runner.query_type import QueryType
+from graphdatascience.server_version.server_version import ServerVersion
 
 
 class QueryRunner(ABC):
@@ -15,6 +15,7 @@ class QueryRunner(ABC):
     def call_procedure(
         self,
         endpoint: str,
+        query_type: QueryType = QueryType.USER_TRANSPILED,
         params: CallParameters | None = None,
         yields: list[str] | None = None,
         database: str | None = None,
@@ -26,13 +27,16 @@ class QueryRunner(ABC):
         pass
 
     @abstractmethod
-    def call_function(self, endpoint: str, params: CallParameters | None = None) -> Any:
+    def call_function(
+        self, endpoint: str, query_type: QueryType = QueryType.USER_TRANSPILED, params: CallParameters | None = None
+    ) -> Any:
         pass
 
     @abstractmethod
     def run_cypher(
         self,
         query: str,
+        query_type: QueryType,
         params: dict[str, Any] | None = None,
         database: str | None = None,
         mode: QueryMode | None = None,
@@ -44,6 +48,7 @@ class QueryRunner(ABC):
     def run_retryable_cypher(
         self,
         query: str,
+        query_type: QueryType,
         params: dict[str, Any] | None = None,
         database: str | None = None,
         mode: QueryMode | None = None,

graphdatascience-1.21a1/src/graphdatascience/query_runner/query_type.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+# following https://neo4j.com/docs/operations-manual/current/monitoring/logging/#attach-metadata-tx
+class QueryType(Enum):
+    SYSTEM = "system"  # a query automatically run by the app.
+    USER_DIRECTED = "user-direct"  # a query the user directly submitted to/through the app.
+    USER_ACTION = "user-action"  # a query resulting from an action the user performed.
+    USER_TRANSPILED = "user-transpiled"  # a query that has been derived from the user input.