graphdatascience 1.17__tar.gz → 1.18a1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphdatascience
-Version: 1.17
+Version: 1.18a1
 Summary: A Python client for the Neo4j Graph Data Science (GDS) library
 Home-page: https://neo4j.com/product/graph-data-science/
 Author: Neo4j
@@ -16,7 +16,6 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -25,14 +24,14 @@ Classifier: Topic :: Database
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
 Classifier: Typing :: Typed
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: multimethod<3.0,>=1.0
-Requires-Dist: neo4j<6.0,>=4.4.12
-Requires-Dist: numpy<2.3
+Requires-Dist: neo4j<7.0,>=4.4.12
+Requires-Dist: numpy<2.4
 Requires-Dist: pandas<3.0,>=1.0
-Requires-Dist: pyarrow<21.0,>=17.0
+Requires-Dist: pyarrow<22.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

{graphdatascience-1.17 → graphdatascience-1.18a1}/graphdatascience/algo/algo_proc_runner.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from abc import ABC
 from typing import Any
 
@@ -19,7 +21,7 @@ class AlgoProcRunner(IllegalAttrChecker, ABC):
         return self._query_runner.call_procedure(endpoint=self._namespace, params=params, logging=with_logging)
 
     @graph_type_check
-    def estimate(self, G: Graph, **config: Any) -> "Series[Any]":
+    def estimate(self, G: Graph, **config: Any) -> Series[Any]:
         self._namespace += "." + "estimate"
         return self._run_procedure(G, config, with_logging=False).squeeze()  # type: ignore
 
@@ -30,13 +32,13 @@ class StreamModeRunner(AlgoProcRunner):
 
 
 class StandardModeRunner(AlgoProcRunner):
-    def __call__(self, G: Graph, **config: Any) -> "Series[Any]":
+    def __call__(self, G: Graph, **config: Any) -> Series[Any]:
         return self._run_procedure(G, config).squeeze()  # type: ignore
 
 
 class GraphSageRunner(AlgoProcRunner):
     @graph_type_check
-    def __call__(self, G: Graph, **config: Any) -> tuple[GraphSageModel, "Series[Any]"]:
+    def __call__(self, G: Graph, **config: Any) -> tuple[GraphSageModel, Series[Any]]:
         result = self._run_procedure(G, config).squeeze()
         model_name = result["modelInfo"]["modelName"]
 

{graphdatascience-1.17 → graphdatascience-1.18a1}/graphdatascience/arrow_client/authenticated_flight_client.py

@@ -3,12 +3,13 @@ from __future__ import annotations
 import json
 import logging
 from dataclasses import dataclass
-from typing import Any, Iterator, Optional, Tuple, Union
+from typing import Any, Iterator
 
 from pyarrow import __version__ as arrow_version
 from pyarrow import flight
 from pyarrow._flight import (
     Action,
+    ActionType,
     FlightInternalError,
     FlightStreamReader,
     FlightTimedOutError,
@@ -32,12 +33,12 @@ class AuthenticatedArrowClient:
     @staticmethod
     def create(
         arrow_info: ArrowInfo,
-        auth: Optional[ArrowAuthentication] = None,
+        auth: ArrowAuthentication | None = None,
         encrypted: bool = False,
-        arrow_client_options: Optional[dict[str, Any]] = None,
-        connection_string_override: Optional[str] = None,
-        retry_config: Optional[RetryConfig] = None,
-        advertised_listen_address: Optional[Tuple[str, int]] = None,
+        arrow_client_options: dict[str, Any] | None = None,
+        connection_string_override: str | None = None,
+        retry_config: RetryConfig | None = None,
+        advertised_listen_address: tuple[str, int] | None = None,
     ) -> AuthenticatedArrowClient:
         connection_string: str
         if connection_string_override is not None:
@@ -73,11 +74,11 @@ class AuthenticatedArrowClient:
         host: str,
         retry_config: RetryConfig,
         port: int = 8491,
-        auth: Optional[ArrowAuthentication] = None,
+        auth: ArrowAuthentication | None = None,
         encrypted: bool = False,
-        arrow_client_options: Optional[dict[str, Any]] = None,
-        user_agent: Optional[str] = None,
-        advertised_listen_address: Optional[Tuple[str, int]] = None,
+        arrow_client_options: dict[str, Any] | None = None,
+        user_agent: str | None = None,
+        advertised_listen_address: tuple[str, int] | None = None,
     ):
         """Creates a new GdsArrowClient instance.
 
@@ -87,17 +88,17 @@ class AuthenticatedArrowClient:
             The host address of the GDS Arrow server
         port: int
             The host port of the GDS Arrow server (default is 8491)
-        auth: Optional[ArrowAuthentication]
+        auth: ArrowAuthentication | None
             An implementation of ArrowAuthentication providing a pair to be used for basic authentication
         encrypted: bool
             A flag that indicates whether the connection should be encrypted (default is False)
-        arrow_client_options: Optional[dict[str, Any]]
+        arrow_client_options: dict[str, Any] | None
             Additional options to be passed to the Arrow Flight client.
-        user_agent: Optional[str]
+        user_agent: str | None
             The user agent string to use for the connection. (default is `neo4j-graphdatascience-v[VERSION] pyarrow-v[PYARROW_VERSION])
-        retry_config: Optional[RetryConfig]
+        retry_config: RetryConfig | None
             The retry configuration to use for the Arrow requests send by the client.
-        advertised_listen_address: Optional[Tuple[str, int]]
+        advertised_listen_address: tuple[str, int] | None
             The advertised listen address of the GDS Arrow server. This will be used by remote projection and writeback operations.
         """
         self._host = host
@@ -142,13 +143,13 @@ class AuthenticatedArrowClient:
         h, p = self.advertised_listen_address
         return ConnectionInfo(h, p, self._encrypted)
 
-    def request_token(self) -> Optional[str]:
+    def request_token(self) -> str | None:
         """
         Requests a token from the server and returns it.
 
         Returns
         -------
-        Optional[str]
+        str | None
             a token from the server and returns it.
         """
 
@@ -174,12 +175,12 @@ class AuthenticatedArrowClient:
     def get_stream(self, ticket: Ticket) -> FlightStreamReader:
         return self._flight_client.do_get(ticket)
 
-    def do_action(self, endpoint: str, payload: Union[bytes, dict[str, Any]]) -> Iterator[Result]:
+    def do_action(self, endpoint: str, payload: bytes | dict[str, Any]) -> Iterator[Result]:
         payload_bytes = payload if isinstance(payload, bytes) else json.dumps(payload).encode("utf-8")
 
         return self._flight_client.do_action(Action(endpoint, payload_bytes))  # type: ignore
 
-    def do_action_with_retry(self, endpoint: str, payload: Union[bytes, dict[str, Any]]) -> Iterator[Result]:
+    def do_action_with_retry(self, endpoint: str, payload: bytes | dict[str, Any]) -> list[Result]:
         @retry(
             reraise=True,
             before=before_log("Send action", self._logger, logging.DEBUG),
@@ -187,11 +188,16 @@ class AuthenticatedArrowClient:
             stop=self._retry_config.stop,
             wait=self._retry_config.wait,
         )
-        def run_with_retry() -> Iterator[Result]:
-            return self.do_action(endpoint, payload)
+        def run_with_retry() -> list[Result]:
+            # the Flight response error code is only checked on iterator consumption
+            # we eagerly collect iterator here to trigger retry in case of an error
+            return list(self.do_action(endpoint, payload))
 
         return run_with_retry()
 
+    def list_actions(self) -> set[ActionType]:
+        return self._flight_client.list_actions()  # type: ignore
+
     def _instantiate_flight_client(self) -> flight.FlightClient:
         location = (
             flight.Location.for_grpc_tls(self._host, self._port)

{graphdatascience-1.17 → graphdatascience-1.18a1}/graphdatascience/arrow_client/middleware/auth_middleware.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import base64
 import time
-from typing import Any, Optional
+from typing import Any
 
 from pyarrow._flight import ClientMiddleware, ClientMiddlewareFactory
 
@@ -22,10 +22,10 @@ class AuthMiddleware(ClientMiddleware):  # type: ignore
     def __init__(self, auth: ArrowAuthentication, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
         self._auth = auth
-        self._token: Optional[str] = None
+        self._token: str | None = None
         self._token_timestamp = 0
 
-    def token(self) -> Optional[str]:
+    def token(self) -> str | None:
         # check whether the token is older than 10 minutes. If so, reset it.
         if self._token and int(time.time()) - self._token_timestamp > 600:
             self._token = None

graphdatascience-1.18a1/graphdatascience/arrow_client/v2/api_types.py

@@ -0,0 +1,49 @@
+from graphdatascience.arrow_client.arrow_base_model import ArrowBaseModel
+
+
+class JobIdConfig(ArrowBaseModel):
+    job_id: str
+
+
+UNKNOWN_PROGRESS = -1
+
+
+class JobStatus(ArrowBaseModel):
+    job_id: str
+    status: str
+    progress: float
+    description: str
+
+    def progress_known(self) -> bool:
+        if self.progress == UNKNOWN_PROGRESS:
+            return False
+        return True
+
+    def progress_percent(self) -> float | None:
+        if self.progress_known():
+            return self.progress * 100
+        return None
+
+    def base_task(self) -> str:
+        return self.description.split("::")[0].strip()
+
+    def sub_tasks(self) -> str | None:
+        task_split = self.description.split("::", maxsplit=1)
+        if len(task_split) > 1:
+            return task_split[1].strip()
+        return None
+
+    def aborted(self) -> bool:
+        return self.status == "Aborted"
+
+    def succeeded(self) -> bool:
+        return self.status == "Done"
+
+    def running(self) -> bool:
+        return self.status == "Running"
+
+
+class MutateResult(ArrowBaseModel):
+    mutate_millis: int
+    node_properties_written: int
+    relationships_written: int

{graphdatascience-1.17 → graphdatascience-1.18a1}/graphdatascience/arrow_client/v2/data_mapper_utils.py

@@ -1,10 +1,10 @@
 import json
-from typing import Any, Iterator
+from typing import Any
 
 from pyarrow._flight import Result
 
 
-def deserialize_single(input_stream: Iterator[Result]) -> dict[str, Any]:
+def deserialize_single(input_stream: list[Result]) -> dict[str, Any]:
     rows = deserialize(input_stream)
     if len(rows) != 1:
         raise ValueError(f"Expected exactly one result, got {len(rows)}")
@@ -12,8 +12,8 @@ def deserialize_single(input_stream: Iterator[Result]) -> dict[str, Any]:
     return rows[0]
 
 
-def deserialize(input_stream: Iterator[Result]) -> list[dict[str, Any]]:
+def deserialize(input_stream: list[Result]) -> list[dict[str, Any]]:
     def deserialize_row(row: Result):  # type:ignore
         return json.loads(row.body.to_pybytes().decode())
 
-    return [deserialize_row(row) for row in list(input_stream)]
+    return [deserialize_row(row) for row in input_stream]

graphdatascience-1.18a1/graphdatascience/arrow_client/v2/job_client.py

@@ -0,0 +1,94 @@
+import json
+from typing import Any
+
+from pandas import ArrowDtype, DataFrame
+from pyarrow._flight import Ticket
+from tenacity import Retrying, retry_if_result, wait_exponential
+
+from graphdatascience.arrow_client.authenticated_flight_client import AuthenticatedArrowClient
+from graphdatascience.arrow_client.v2.api_types import JobIdConfig, JobStatus
+from graphdatascience.arrow_client.v2.data_mapper_utils import deserialize_single
+from graphdatascience.query_runner.progress.progress_bar import TqdmProgressBar
+from graphdatascience.query_runner.termination_flag import TerminationFlag
+
+JOB_STATUS_ENDPOINT = "v2/jobs.status"
+RESULTS_SUMMARY_ENDPOINT = "v2/results.summary"
+
+
+class JobClient:
+    def __init__(self, progress_bar_options: dict[str, Any] | None = None):
+        self._progress_bar_options = progress_bar_options or {}
+
+    @staticmethod
+    def run_job_and_wait(
+        client: AuthenticatedArrowClient, endpoint: str, config: dict[str, Any], show_progress: bool
+    ) -> str:
+        job_id = JobClient.run_job(client, endpoint, config)
+        JobClient().wait_for_job(client, job_id, show_progress=show_progress)
+        return job_id
+
+    @staticmethod
+    def run_job(client: AuthenticatedArrowClient, endpoint: str, config: dict[str, Any]) -> str:
+        res = client.do_action_with_retry(endpoint, config)
+
+        single = deserialize_single(res)
+        return JobIdConfig(**single).job_id
+
+    def wait_for_job(
+        self,
+        client: AuthenticatedArrowClient,
+        job_id: str,
+        show_progress: bool,
+        termination_flag: TerminationFlag | None = None,
+    ) -> None:
+        progress_bar: TqdmProgressBar | None = None
+
+        if termination_flag is None:
+            termination_flag = TerminationFlag.create()
+
+        for attempt in Retrying(retry=retry_if_result(lambda _: True), wait=wait_exponential(min=0.1, max=5)):
+            with attempt:
+                termination_flag.assert_running()
+
+                arrow_res = client.do_action_with_retry(JOB_STATUS_ENDPOINT, JobIdConfig(jobId=job_id).dump_camel())
+                job_status = JobStatus(**deserialize_single(arrow_res))
+
+                if job_status.succeeded() or job_status.aborted():
+                    if progress_bar:
+                        progress_bar.finish(success=job_status.succeeded())
+                    return
+
+                if show_progress:
+                    if progress_bar is None:
+                        base_task = job_status.base_task()
+                        if base_task:
+                            progress_bar = TqdmProgressBar(
+                                task_name=base_task,
+                                relative_progress=job_status.progress_percent(),
+                                bar_options=self._progress_bar_options,
+                            )
+                    if progress_bar:
+                        progress_bar.update(job_status.status, job_status.progress_percent(), job_status.sub_tasks())
+
+    @staticmethod
+    def get_summary(client: AuthenticatedArrowClient, job_id: str) -> dict[str, Any]:
+        res = client.do_action_with_retry(RESULTS_SUMMARY_ENDPOINT, JobIdConfig(jobId=job_id).dump_camel())
+        return deserialize_single(res)
+
+    @staticmethod
+    def stream_results(client: AuthenticatedArrowClient, graph_name: str, job_id: str) -> DataFrame:
+        payload = {
+            "graphName": graph_name,
+            "jobId": job_id,
+        }
+
+        res = client.do_action_with_retry("v2/results.stream", payload)
+        export_job_id = JobIdConfig(**deserialize_single(res)).job_id
+
+        stream_payload = {"version": "v2", "name": export_job_id, "body": {}}
+
+        ticket = Ticket(json.dumps(stream_payload).encode("utf-8"))
+
+        get = client.get_stream(ticket)
+        arrow_table = get.read_all()
+        return arrow_table.to_pandas(types_mapper=ArrowDtype)  # type: ignore

graphdatascience-1.18a1/graphdatascience/arrow_client/v2/mutation_client.py

@@ -0,0 +1,52 @@
+import math
+import time
+
+from graphdatascience.arrow_client.authenticated_flight_client import AuthenticatedArrowClient
+from graphdatascience.arrow_client.v2.api_types import MutateResult
+from graphdatascience.arrow_client.v2.data_mapper_utils import deserialize_single
+
+
+class MutationClient:
+    MUTATE_ENDPOINT = "v2/results.mutate"
+
+    @staticmethod
+    def mutate_node_property(client: AuthenticatedArrowClient, job_id: str, mutate_property: str) -> MutateResult:
+        return MutationClient._mutate(
+            client=client,
+            job_id=job_id,
+            mutate_property=mutate_property,
+        )
+
+    @staticmethod
+    def mutate_relationship_property(
+        client: AuthenticatedArrowClient,
+        job_id: str,
+        mutate_relationship_type: str,
+        mutate_property: str | None,
+    ) -> MutateResult:
+        return MutationClient._mutate(
+            client=client,
+            job_id=job_id,
+            mutate_property=mutate_property,
+            mutate_relationship_type=mutate_relationship_type,
+        )
+
+    @staticmethod
+    def _mutate(
+        client: AuthenticatedArrowClient,
+        job_id: str,
+        mutate_property: str | None = None,
+        mutate_relationship_type: str | None = None,
+    ) -> MutateResult:
+        mutate_config = {
+            "jobId": job_id,
+        }
+        if mutate_relationship_type:
+            mutate_config["mutateRelationshipType"] = mutate_relationship_type
+        if mutate_property:
+            mutate_config["mutateProperty"] = mutate_property
+
+        start_time = time.time()
+        mutate_arrow_res = client.do_action_with_retry(MutationClient.MUTATE_ENDPOINT, mutate_config)
+        mutate_millis = math.ceil((time.time() - start_time) * 1000)
+        return MutateResult(mutateMillis=mutate_millis, **deserialize_single(mutate_arrow_res))

{graphdatascience-1.17 → graphdatascience-1.18a1}/graphdatascience/arrow_client/v2/remote_write_back_client.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 import time
-from typing import Any, Optional
+from typing import Any
 
 from graphdatascience import QueryRunner
 from graphdatascience.arrow_client.authenticated_flight_client import AuthenticatedArrowClient
 from graphdatascience.call_parameters import CallParameters
 from graphdatascience.procedure_surface.api.base_result import BaseResult
 from graphdatascience.query_runner.protocol.write_protocols import WriteProtocol
-from graphdatascience.query_runner.termination_flag import TerminationFlagNoop
+from graphdatascience.query_runner.termination_flag import TerminationFlag
 from graphdatascience.session.dbms.protocol_resolver import ProtocolVersionResolver
 
 
@@ -20,14 +20,14 @@ class RemoteWriteBackClient:
         protocol_version = ProtocolVersionResolver(query_runner).resolve()
         self._write_protocol = WriteProtocol.select(protocol_version)
 
-    # TODO: Add progress logging
     def write(
         self,
         graph_name: str,
         job_id: str,
-        concurrency: Optional[int] = None,
-        property_overwrites: Optional[dict[str, str]] = None,
-        relationship_type_overwrite: Optional[str] = None,
+        concurrency: int | None = None,
+        property_overwrites: dict[str, str] | None = None,
+        relationship_type_overwrite: str | None = None,
+        log_progress: bool = True,
     ) -> WriteBackResult:
         arrow_config = self._arrow_configuration()
 
@@ -49,7 +49,11 @@ class RemoteWriteBackClient:
         start_time = time.time()
 
         result = self._write_protocol.run_write_back(
-            self._query_runner, write_back_params, None, TerminationFlagNoop()
+            self._query_runner,
+            write_back_params,
+            None,
+            log_progress=log_progress,
+            terminationFlag=TerminationFlag.create(),
         ).squeeze()
         write_millis = int((time.time() - start_time) * 1000)
 

{graphdatascience-1.17 → graphdatascience-1.18a1}/graphdatascience/call_parameters.py

@@ -1,5 +1,5 @@
 from collections import OrderedDict
-from typing import Any, Optional
+from typing import Any
 from uuid import uuid4
 
 
@@ -9,7 +9,7 @@ class CallParameters(OrderedDict[str, Any]):
     def placeholder_str(self) -> str:
         return ", ".join([f"${k}" for k in self.keys()])
 
-    def get_job_id(self) -> Optional[str]:
+    def get_job_id(self) -> str | None:
         config = self["config"] if "config" in self else {}
 
         job_id = None

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

@@ -27,6 +27,17 @@ def filter_id_func_deprecation_warning() -> Callable[[F], F]:
                 message=r"The query used a deprecated function. \('id'.*",
             )
 
+            # with neo4j driver 6.0.0
+            warnings.filterwarnings(
+                "ignore",
+                message=r"warn: feature deprecated with replacement\. id is deprecated. It is replaced by elementId or consider using an application-generated id\.",
+            )
+            # with neo4j driver 6.0.0 + Neo4j 5.X
+            warnings.filterwarnings(
+                "ignore",
+                message=r"warn: feature deprecated without replacement\. id is deprecated and will be removed without a replacement\.",
+            )
+
             return func(self, *args, **kwargs)
 
         return cast(F, wrapper)

{graphdatascience-1.17 → graphdatascience-1.18a1}/graphdatascience/graph/base_graph_proc_runner.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
+import builtins
 import os
 import pathlib
 import warnings
-from typing import Any, List, Optional, Union
+from typing import Any
 
 import pandas as pd
 from multimethod import multimethod
@@ -36,7 +37,7 @@ from .graph_type_check import (
 )
 from .ogb_loader import OGBLLoader, OGBNLoader
 
-Strings = Union[str, List[str]]
+Strings = str | list[str]
 
 is_neo4j_4_driver = ServerVersion.from_string(neo4j_driver_version) < ServerVersion(5, 0, 0)
 
@@ -63,10 +64,10 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
     def construct(
         self,
         graph_name: str,
-        nodes: Union[DataFrame, list[DataFrame]],
-        relationships: Optional[Union[DataFrame, list[DataFrame]]] = None,
+        nodes: DataFrame | list[DataFrame],
+        relationships: DataFrame | list[DataFrame] | None = None,
         concurrency: int = 4,
-        undirected_relationship_types: Optional[list[str]] = None,
+        undirected_relationship_types: list[str] | None = None,
     ) -> Graph:
         nodes = nodes if isinstance(nodes, list) else [nodes]
 
@@ -292,11 +293,11 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
 
     def drop(
         self,
-        graph: Union[Graph, str],
+        graph: Graph | str,
         failIfMissing: bool = False,
         dbName: str = "",
-        username: Optional[str] = None,
-    ) -> Optional[Series[Any]]:
+        username: str | None = None,
+    ) -> Series[Any] | None:
         self._namespace += ".drop"
 
         if isinstance(graph, Graph):
@@ -328,7 +329,7 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
 
         return result.squeeze()  # type: ignore
 
-    def list(self, G: Optional[Union[Graph, str]] = None) -> DataFrame:
+    def list(self, G: Graph | str | None = None) -> DataFrame:
         self._namespace += ".list"
 
         if isinstance(G, Graph):
@@ -413,7 +414,7 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
     def streamNodeProperties(
         self,
         G: Graph,
-        node_properties: List[str],
+        node_properties: builtins.list[str],
         node_labels: Strings = ["*"],
         separate_property_columns: bool = False,
         **config: Any,
@@ -449,7 +450,7 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
     def streamRelationshipProperties(
         self,
         G: Graph,
-        relationship_properties: List[str],
+        relationship_properties: builtins.list[str],
         relationship_types: Strings = ["*"],
         separate_property_columns: bool = False,
         **config: Any,
@@ -489,10 +490,10 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
     def writeNodeProperties(
         self,
         G: Graph,
-        node_properties: List[str],
+        node_properties: builtins.list[str],
         node_labels: Strings = ["*"],
         **config: Any,
-    ) -> "Series[Any]":
+    ) -> Series[Any]:
         self._namespace += ".writeNodeProperties"
 
         return self._handle_properties(G, node_properties, node_labels, config).squeeze()  # type: ignore
@@ -503,7 +504,7 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
         relationship_type: str,
         relationship_property: str = "",
         **config: Any,
-    ) -> "Series[Any]":
+    ) -> Series[Any]:
         self._namespace += ".writeRelationship"
         params = CallParameters(
             graph_name=G.name(),
@@ -525,7 +526,7 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
     def _(
         self,
         G: Graph,
-        node_properties: List[str],
+        node_properties: builtins.list[str],
         **config: Any,
     ) -> Series:  # type: ignore
         self._namespace += ".removeNodeProperties"
@@ -546,7 +547,7 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
     def _(
         self,
         G: Graph,
-        node_properties: List[str],
+        node_properties: builtins.list[str],
         node_labels: Strings,
         **config: Any,
     ) -> Series:  # type: ignore
@@ -555,7 +556,7 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
         return self._handle_properties(G, node_properties, node_labels, config).squeeze()  # type: ignore
 
     @graph_type_check
-    def deleteRelationships(self, G: Graph, relationship_type: str) -> "Series[Any]":
+    def deleteRelationships(self, G: Graph, relationship_type: str) -> Series[Any]:
         self._namespace += ".deleteRelationships"
 
         params = CallParameters(

{graphdatascience-1.17 → graphdatascience-1.18a1}/graphdatascience/graph/graph_alpha_proc_runner.py

@@ -1,5 +1,4 @@
 import os
-from typing import Optional, Union
 
 from pandas import DataFrame
 
@@ -36,10 +35,10 @@ class GraphAlphaProcRunner(UncallableNamespace, IllegalAttrChecker):
     def construct(
         self,
         graph_name: str,
-        nodes: Union[DataFrame, list[DataFrame]],
-        relationships: Union[DataFrame, list[DataFrame]],
+        nodes: DataFrame | list[DataFrame],
+        relationships: DataFrame | list[DataFrame],
         concurrency: int = 4,
-        undirected_relationship_types: Optional[list[str]] = None,
+        undirected_relationship_types: list[str] | None = None,
     ) -> Graph:
         nodes = nodes if isinstance(nodes, list) else [nodes]
         relationships = relationships if isinstance(relationships, list) else [relationships]

{graphdatascience-1.17 → graphdatascience-1.18a1}/graphdatascience/graph/graph_beta_proc_runner.py

@@ -1,4 +1,4 @@
-from typing import Any, Union
+from typing import Any
 
 from ..call_parameters import CallParameters
 from ..error.illegal_attr_checker import IllegalAttrChecker
@@ -9,7 +9,7 @@ from .graph_export_runner import GraphExportCsvEndpoints
 from .graph_object import Graph
 from .graph_project_runner import GraphProjectBetaRunner
 
-Strings = Union[str, list[str]]
+Strings = str | list[str]
 
 
 class GraphBetaProcRunner(UncallableNamespace, IllegalAttrChecker):