graphdatascience 1.13__tar.gz → 1.14__tar.gz

{graphdatascience-1.13/graphdatascience.egg-info → graphdatascience-1.14}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: graphdatascience
-Version: 1.13
+Version: 1.14
 Summary: A Python client for the Neo4j Graph Data Science (GDS) library
 Home-page: https://neo4j.com/product/graph-data-science/
 Author: Neo4j
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Database
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
@@ -27,11 +28,11 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: multimethod<2.0,>=1.0
+Requires-Dist: multimethod<3.0,>=1.0
 Requires-Dist: neo4j<6.0,>=4.4.12
-Requires-Dist: numpy<2.0
+Requires-Dist: numpy<2.3
 Requires-Dist: pandas<3.0,>=1.0
-Requires-Dist: pyarrow<19.0,>=15.0.2
+Requires-Dist: pyarrow<20.0,>=16.0
 Requires-Dist: textdistance<5.0,>=4.0
 Requires-Dist: tqdm<5.0,>=4.0
 Requires-Dist: typing-extensions<5.0,>=4.0
@@ -43,6 +44,18 @@ Provides-Extra: networkx
 Requires-Dist: networkx<4.0,>=2.0; extra == "networkx"
 Provides-Extra: rust-ext
 Requires-Dist: neo4j-rust-ext<6.0,>=4.4.12; extra == "rust-ext"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # Neo4j Graph Data Science Client
 

{graphdatascience-1.13 → graphdatascience-1.14}/graphdatascience/algo/algo_proc_runner.py

@@ -14,6 +14,7 @@ class AlgoProcRunner(IllegalAttrChecker, ABC):
     @graph_type_check
     def _run_procedure(self, G: Graph, config: dict[str, Any], with_logging: bool = True) -> DataFrame:
         params = CallParameters(graph_name=G.name(), config=config)
+        params.ensure_job_id_in_config()
 
         return self._query_runner.call_procedure(endpoint=self._namespace, params=params, logging=with_logging)
 

graphdatascience-1.14/graphdatascience/call_parameters.py

@@ -0,0 +1,40 @@
+from collections import OrderedDict
+from typing import Any, Optional
+from uuid import uuid4
+
+
+class CallParameters(OrderedDict[str, Any]):
+    # since Python 3.6 also initializing through CallParameters(**kwargs) is order preserving
+
+    def placeholder_str(self) -> str:
+        return ", ".join([f"${k}" for k in self.keys()])
+
+    def get_job_id(self) -> Optional[str]:
+        config = self["config"] if "config" in self else {}
+
+        job_id = None
+        if "jobId" in config:
+            job_id = config["jobId"]
+
+        if "job_id" in config:
+            job_id = config["job_id"]
+
+        if job_id is None:
+            return None
+
+        return str(job_id)
+
+    def ensure_job_id_in_config(self) -> str:
+        """
+        Ensure that a job id is present in the `config` parameter. If not, generate a new one.
+        This enables the client to check on the progress later on.
+        """
+        config = self.get("config")
+
+        assert config is not None, "config is not set in the parameters. This method should not be called."
+
+        job_id = self.get_job_id()
+        if job_id is None:
+            job_id = str(uuid4())
+            config["jobId"] = job_id
+        return job_id

{graphdatascience-1.13 → graphdatascience-1.14}/graphdatascience/graph/base_graph_proc_runner.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import pathlib
 import warnings
@@ -31,7 +33,6 @@ from .graph_sample_runner import GraphSampleRunner
 from .graph_type_check import (
     from_graph_type_check,
     graph_type_check,
-    graph_type_check_optional,
 )
 from .ogb_loader import OGBLLoader, OGBNLoader
 
@@ -237,6 +238,7 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
         params = CallParameters(
             graph_name=graph_name, node_count=node_count, average_degree=average_degree, config=config
         )
+        params.ensure_job_id_in_config()
 
         result = self._query_runner.call_procedure(
             endpoint=self._namespace,
@@ -263,6 +265,8 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
             relationship_filter=relationship_filter,
             config=config,
         )
+        params.ensure_job_id_in_config()
+
         result = self._query_runner.call_procedure(
             endpoint=self._namespace,
             logging=True,
@@ -292,7 +296,7 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
         failIfMissing: bool = False,
         dbName: str = "",
         username: Optional[str] = None,
-    ) -> Optional["Series[Any]"]:
+    ) -> Optional[Series[Any]]:
         self._namespace += ".drop"
 
         if isinstance(graph, Graph):
@@ -315,7 +319,7 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
 
         return None
 
-    def exists(self, graph_name: str) -> "Series[Any]":
+    def exists(self, graph_name: str) -> Series[Any]:
         self._namespace += ".exists"
         result = self._query_runner.call_procedure(
             endpoint=self._namespace,
@@ -324,13 +328,17 @@ class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
 
         return result.squeeze()  # type: ignore
 
-    @graph_type_check_optional
-    def list(self, G: Optional[Graph] = None) -> DataFrame:
+    def list(self, G: Optional[Union[Graph, str]] = None) -> DataFrame:
         self._namespace += ".list"
 
+        if isinstance(G, Graph):
+            graph_name = G.name()
+        elif isinstance(G, str):
+            graph_name = G
+
         params = CallParameters()
         if G:
-            params["graph_name"] = G.name()
+            params["graph_name"] = graph_name
 
         return self._query_runner.call_procedure(
             endpoint=self._namespace,

{graphdatascience-1.13 → graphdatascience-1.14}/graphdatascience/graph/graph_entity_ops_runner.py

@@ -101,7 +101,7 @@ class GraphNodePropertiesRunner(GraphEntityOpsBaseRunner):
     def stream(
         self,
         G: Graph,
-        node_properties: list[str],
+        node_properties: Union[str, list[str]],
         node_labels: Strings = ["*"],
         separate_property_columns: bool = False,
         db_node_properties: list[str] = [],
@@ -109,6 +109,9 @@ class GraphNodePropertiesRunner(GraphEntityOpsBaseRunner):
     ) -> DataFrame:
         self._namespace += ".stream"
 
+        if isinstance(node_properties, str):
+            node_properties = [node_properties]
+
         # find if list contain duplicates
         if len(set(node_properties)) != len(node_properties):
             raise ValueError(f"The provided node_properties contain duplicate property names: `{node_properties}`.")

{graphdatascience-1.13 → graphdatascience-1.14}/graphdatascience/graph/graph_remote_project_runner.py

@@ -22,6 +22,7 @@ class GraphProjectRemoteRunner(IllegalAttrChecker):
         undirected_relationship_types: Optional[list[str]] = None,
         inverse_indexed_relationship_types: Optional[list[str]] = None,
         batch_size: Optional[int] = None,
+        logging: bool = True,
     ) -> GraphCreateResult:
         if inverse_indexed_relationship_types is None:
             inverse_indexed_relationship_types = []
@@ -45,5 +46,6 @@ class GraphProjectRemoteRunner(IllegalAttrChecker):
         result = self._query_runner.call_procedure(
             endpoint=SessionQueryRunner.GDS_REMOTE_PROJECTION_PROC_NAME,
             params=params,
+            logging=True,
         ).squeeze()
         return GraphCreateResult(Graph(graph_name, self._query_runner), result)

{graphdatascience-1.13 → graphdatascience-1.14}/graphdatascience/graph/graph_type_check.py

@@ -1,5 +1,5 @@
 from functools import wraps
-from typing import Any, Callable, Optional, TypeVar, cast
+from typing import Any, Callable, TypeVar, cast
 
 from .graph_object import Graph
 
@@ -20,20 +20,6 @@ def graph_type_check(func: F) -> F:
     return cast(F, wrapper)
 
 
-def graph_type_check_optional(func: F) -> F:
-    @wraps(func)
-    def wrapper(self: Any, G: Optional[Graph] = None, *args: Any, **kwargs: Any) -> Any:
-        if isinstance(G, str):
-            raise TypeError(
-                f"The parameter 'G' takes a `Graph` object, but received string '{G}'. "
-                "To resolve a graph name string into a `Graph` object, please use `gds.graph.get`"
-            )
-
-        return func(self, G, *args, **kwargs)
-
-    return cast(F, wrapper)
-
-
 def from_graph_type_check(func: F) -> F:
     @wraps(func)
     def wrapper(self: Any, graph_name: str, from_G: Graph, *args: Any, **kwargs: Any) -> Any:

{graphdatascience-1.13 → graphdatascience-1.14}/graphdatascience/graph/ogb_loader.py

@@ -108,12 +108,12 @@ class OGBNLoader(OGBLoader):
             "nodeId": list(range(node_count)),
         }
         if "node_feat" in graph and graph["node_feat"] is not None:
-            node_dict["features"] = graph["node_feat"].tolist()
+            node_dict["features"] = graph["node_feat"].tolist()  # type: ignore
 
         if len(dataset.labels[0]) == 1:
             node_dict["classLabel"] = [cl[0] for cl in dataset.labels]
         else:
-            node_dict["classLabel"] = dataset.labels.tolist()
+            node_dict["classLabel"] = dataset.labels.tolist()  # type: ignore
 
         split = dataset.get_idx_split()
         node_labels = ["Train" for _ in range(node_count)]
@@ -170,13 +170,13 @@ class OGBNLoader(OGBLoader):
             }
 
             if node_label in node_features:
-                node_dict["features"] = node_features[node_label].tolist()
+                node_dict["features"] = node_features[node_label].tolist()  # type: ignore
 
             if node_label in class_labels:
                 if len(class_labels[node_label]) == 1:
                     node_dict["classLabel"] = [cl[0] for cl in class_labels[node_label]]
                 else:
-                    node_dict["classLabel"] = class_labels[node_label].tolist()
+                    node_dict["classLabel"] = class_labels[node_label].tolist()  # type: ignore
 
             node_id_offsets[node_label] = current_offset
             current_offset += node_count
@@ -243,7 +243,7 @@ class OGBLLoader(OGBLoader):
             "labels": "N",
         }
         if "node_feat" in graph and graph["node_feat"] is not None:
-            node_dict["features"] = graph["node_feat"].tolist()
+            node_dict["features"] = graph["node_feat"].tolist()  # type: ignore
         nodes = pd.DataFrame(node_dict)
 
         self._logger.info("Preparing relationship data for transfer to server...")
@@ -283,7 +283,7 @@ class OGBLLoader(OGBLoader):
             }
 
             if node_label in node_features:
-                node_dict["features"] = node_features[node_label].tolist()
+                node_dict["features"] = node_features[node_label].tolist()  # type: ignore
 
             node_id_offsets[node_label] = current_offset
             current_offset += node_count

{graphdatascience-1.13 → graphdatascience-1.14}/graphdatascience/query_runner/arrow_endpoint_version.py

@@ -4,8 +4,8 @@ from enum import Enum
 
 
 class ArrowEndpointVersion(Enum):
-    ALPHA = ""
     V1 = "v1/"
+    V2 = "v2/"
 
     def version(self) -> str:
         return self._name_.lower()
@@ -15,17 +15,10 @@ class ArrowEndpointVersion(Enum):
 
     @staticmethod
     def from_arrow_info(supported_arrow_versions: list[str]) -> ArrowEndpointVersion:
-        # Fallback for pre 2.6.0 servers that do not support versions
-        if len(supported_arrow_versions) == 0:
-            return ArrowEndpointVersion.ALPHA
-
         # If the server supports versioned endpoints, we try v1 first
         if ArrowEndpointVersion.V1.version() in supported_arrow_versions:
             return ArrowEndpointVersion.V1
 
-        if ArrowEndpointVersion.ALPHA.version() in supported_arrow_versions:
-            return ArrowEndpointVersion.ALPHA
-
         raise UnsupportedArrowEndpointVersion(supported_arrow_versions)
 
 

{graphdatascience-1.13 → graphdatascience-1.14}/graphdatascience/query_runner/cypher_graph_constructor.py

@@ -386,7 +386,8 @@ class CypherGraphConstructor(GraphConstructor):
             )
 
         def _node_query(self, node_df: DataFrame) -> tuple[str, list[list[Any]]]:
-            node_list = node_df.values.tolist()
+            # ignore type as tolist return depends on number of dimensions)
+            node_list: list[list[Any]] = node_df.values.tolist()  # type: ignore
             node_columns = list(node_df.columns)
             node_id_index = node_columns.index("nodeId")
 
@@ -411,7 +412,7 @@ class CypherGraphConstructor(GraphConstructor):
             return f"UNWIND $nodes as node RETURN node[{node_id_index}] as id{label_query}{property_query}", node_list
 
         def _relationship_query(self, rel_df: DataFrame) -> tuple[str, list[list[Any]]]:
-            rel_list = rel_df.values.tolist()
+            rel_list: list[list[Any]] = rel_df.values.tolist()  # type: ignore
             rel_columns = list(rel_df.columns)
             source_id_index = rel_columns.index("sourceNodeId")
             target_id_index = rel_columns.index("targetNodeId")

{graphdatascience-1.13 → graphdatascience-1.14}/graphdatascience/query_runner/gds_arrow_client.py

@@ -9,15 +9,16 @@ from dataclasses import dataclass
 from types import TracebackType
 from typing import Any, Callable, Dict, Iterable, Optional, Type, Union
 
+import pandas
 import pyarrow
 from neo4j.exceptions import ClientError
-from pandas import DataFrame
 from pyarrow import Array, ChunkedArray, DictionaryArray, RecordBatch, Table, chunked_array, flight
 from pyarrow import __version__ as arrow_version
 from pyarrow.flight import ClientMiddleware, ClientMiddlewareFactory
 from pyarrow.types import is_dictionary
 from tenacity import retry, retry_if_exception_type, stop_after_attempt, stop_after_delay, wait_exponential
 
+from ..semantic_version.semantic_version import SemanticVersion
 from ..version import __version__
 from .arrow_endpoint_version import ArrowEndpointVersion
 from .arrow_info import ArrowInfo
@@ -154,7 +155,7 @@ class GdsArrowClient:
         node_labels: Optional[list[str]] = None,
         list_node_labels: bool = False,
         concurrency: Optional[int] = None,
-    ) -> DataFrame:
+    ) -> pandas.DataFrame:
         """
         Get node properties from the graph.
 
@@ -194,7 +195,7 @@ class GdsArrowClient:
 
         return self._do_get(database, graph_name, proc, concurrency, config)
 
-    def get_node_labels(self, graph_name: str, database: str, concurrency: Optional[int] = None) -> DataFrame:
+    def get_node_labels(self, graph_name: str, database: str, concurrency: Optional[int] = None) -> pandas.DataFrame:
         """
         Get all nodes and their labels from the graph.
 
@@ -216,7 +217,7 @@ class GdsArrowClient:
 
     def get_relationships(
         self, graph_name: str, database: str, relationship_types: list[str], concurrency: Optional[int] = None
-    ) -> DataFrame:
+    ) -> pandas.DataFrame:
         """
         Get relationships from the graph.
 
@@ -251,7 +252,7 @@ class GdsArrowClient:
         relationship_properties: Union[str, list[str]],
         relationship_types: list[str],
         concurrency: Optional[int] = None,
-    ) -> DataFrame:
+    ) -> pandas.DataFrame:
         """
         Get relationships and their properties from the graph.
 
@@ -488,7 +489,7 @@ class GdsArrowClient:
     def upload_nodes(
         self,
         graph_name: str,
-        node_data: Union[pyarrow.Table, Iterable[pyarrow.RecordBatch], DataFrame],
+        node_data: Union[pyarrow.Table, Iterable[pyarrow.RecordBatch], pandas.DataFrame],
         batch_size: int = 10_000,
         progress_callback: Callable[[int], None] = lambda x: None,
     ) -> None:
@@ -511,7 +512,7 @@ class GdsArrowClient:
     def upload_relationships(
         self,
         graph_name: str,
-        relationship_data: Union[pyarrow.Table, Iterable[pyarrow.RecordBatch], DataFrame],
+        relationship_data: Union[pyarrow.Table, Iterable[pyarrow.RecordBatch], pandas.DataFrame],
         batch_size: int = 10_000,
         progress_callback: Callable[[int], None] = lambda x: None,
     ) -> None:
@@ -534,7 +535,7 @@ class GdsArrowClient:
     def upload_triplets(
         self,
         graph_name: str,
-        triplet_data: Union[pyarrow.Table, Iterable[pyarrow.RecordBatch], DataFrame],
+        triplet_data: Union[pyarrow.Table, Iterable[pyarrow.RecordBatch], pandas.DataFrame],
         batch_size: int = 10_000,
         progress_callback: Callable[[int], None] = lambda x: None,
     ) -> None:
@@ -590,13 +591,13 @@ class GdsArrowClient:
         self,
         graph_name: str,
         entity_type: str,
-        data: Union[pyarrow.Table, list[pyarrow.RecordBatch], DataFrame],
+        data: Union[pyarrow.Table, list[pyarrow.RecordBatch], pandas.DataFrame],
         batch_size: int,
         progress_callback: Callable[[int], None],
     ) -> None:
         if isinstance(data, pyarrow.Table):
             batches = data.to_batches(batch_size)
-        elif isinstance(data, DataFrame):
+        elif isinstance(data, pandas.DataFrame):
             batches = pyarrow.Table.from_pandas(data).to_batches(batch_size)
         else:
             batches = data
@@ -635,7 +636,7 @@ class GdsArrowClient:
         procedure_name: str,
         concurrency: Optional[int],
         configuration: dict[str, Any],
-    ) -> DataFrame:
+    ) -> pandas.DataFrame:
         payload: dict[str, Any] = {
             "database_name": database,
             "graph_name": graph_name,
@@ -674,7 +675,11 @@ class GdsArrowClient:
             message=r"Passing a BlockManager to DataFrame is deprecated",
         )
 
-        return self._sanitize_arrow_table(arrow_table).to_pandas()  # type: ignore
+        if SemanticVersion.from_string(pandas.__version__) >= SemanticVersion(2, 0, 0):
+            return arrow_table.to_pandas(types_mapper=pandas.ArrowDtype)  # type: ignore
+        else:
+            arrow_table = self._sanitize_arrow_table(arrow_table)
+            return arrow_table.to_pandas()  # type: ignore
 
     def __enter__(self) -> GdsArrowClient:
         return self
@@ -695,15 +700,11 @@ class GdsArrowClient:
         return self._arrow_endpoint_version.prefix() + action_type
 
     def _versioned_flight_descriptor(self, flight_descriptor: dict[str, Any]) -> dict[str, Any]:
-        return (
-            flight_descriptor
-            if self._arrow_endpoint_version == ArrowEndpointVersion.ALPHA
-            else {
-                "name": "PUT_MESSAGE",
-                "version": ArrowEndpointVersion.V1.version(),
-                "body": flight_descriptor,
-            }
-        )
+        return {
+            "name": "PUT_COMMAND",
+            "version": ArrowEndpointVersion.V1.version(),
+            "body": flight_descriptor,
+        }
 
     @staticmethod
     def _sanitize_arrow_table(arrow_table: Table) -> Table:

{graphdatascience-1.13 → graphdatascience-1.14}/graphdatascience/query_runner/neo4j_query_runner.py

@@ -5,7 +5,6 @@ import re
 import time
 import warnings
 from typing import Any, NamedTuple, Optional, Union
-from uuid import uuid4
 
 import neo4j
 from pandas import DataFrame
@@ -14,6 +13,7 @@ from ..call_parameters import CallParameters
 from ..error.endpoint_suggester import generate_suggestive_error_message
 from ..error.gds_not_installed import GdsNotFound
 from ..error.unable_to_connect import UnableToConnectError
+from ..semantic_version.semantic_version import SemanticVersion
 from ..server_version.server_version import ServerVersion
 from ..version import __version__
 from .cypher_graph_constructor import CypherGraphConstructor
@@ -25,7 +25,7 @@ from .query_runner import QueryRunner
 class Neo4jQueryRunner(QueryRunner):
     _AURA_DS_PROTOCOL = "neo4j+s"
     _LOG_POLLING_INTERVAL = 0.5
-    _NEO4J_DRIVER_VERSION = ServerVersion.from_string(neo4j.__version__)
+    _NEO4J_DRIVER_VERSION = SemanticVersion.from_string(neo4j.__version__)
 
     @staticmethod
     def create_for_db(
@@ -61,7 +61,7 @@ class Neo4jQueryRunner(QueryRunner):
         else:
             raise ValueError(f"Invalid endpoint type: {type(endpoint)}")
 
-        if Neo4jQueryRunner._NEO4J_DRIVER_VERSION >= ServerVersion(5, 21, 0):
+        if Neo4jQueryRunner._NEO4J_DRIVER_VERSION >= SemanticVersion(5, 21, 0):
             notifications_logger = logging.getLogger("neo4j.notifications")
             # the client does not expose YIELD fields so we just skip these warnings for now
             notifications_logger.addFilter(
@@ -94,7 +94,7 @@ class Neo4jQueryRunner(QueryRunner):
             instance_description="GDS Session",
         )
 
-        if Neo4jQueryRunner._NEO4J_DRIVER_VERSION >= ServerVersion(5, 21, 0):
+        if Neo4jQueryRunner._NEO4J_DRIVER_VERSION >= SemanticVersion(5, 21, 0):
             notifications_logger = logging.getLogger("neo4j.notifications")
             # the client does not expose YIELD fields so we just skip these warnings for now
             notifications_logger.addFilter(
@@ -176,13 +176,13 @@ class Neo4jQueryRunner(QueryRunner):
 
             df = result.to_df()
 
-            if self._NEO4J_DRIVER_VERSION < ServerVersion(5, 0, 0):
+            if self._NEO4J_DRIVER_VERSION < SemanticVersion(5, 0, 0):
                 self._last_bookmarks = [session.last_bookmark()]
             else:
                 self._last_bookmarks = session.last_bookmarks()
 
             if (
-                Neo4jQueryRunner._NEO4J_DRIVER_VERSION >= ServerVersion(5, 21, 0)
+                Neo4jQueryRunner._NEO4J_DRIVER_VERSION >= SemanticVersion(5, 21, 0)
                 and result._warn_notification_severity == "WARNING"
             ):
                 # the client does not expose YIELD fields so we just skip these warnings for now
@@ -222,8 +222,8 @@ class Neo4jQueryRunner(QueryRunner):
         def run_cypher_query() -> DataFrame:
             return self.run_cypher(query, params, database, custom_error)
 
-        if self._resolve_show_progress(logging):
-            job_id = self._extract_or_create_job_id(params)
+        job_id = None if not params else params.get_job_id()
+        if self._resolve_show_progress(logging) and job_id:
             return self._progress_logger.run_with_progress_logging(run_cypher_query, job_id, database)
         else:
             return run_cypher_query()
@@ -310,22 +310,6 @@ class Neo4jQueryRunner(QueryRunner):
     def set_show_progress(self, show_progress: bool) -> None:
         self._show_progress = show_progress
 
-    @staticmethod
-    def _extract_or_create_job_id(params: CallParameters) -> str:
-        config = params["config"] if "config" in params else {}
-
-        job_id = None
-        if "jobId" in config:
-            job_id = config["jobId"]
-
-        if "job_id" in config:
-            job_id = config["job_id"]
-
-        if not job_id:
-            return str(uuid4())
-
-        return str(job_id)
-
     @staticmethod
     def handle_driver_exception(session: neo4j.Session, e: Exception) -> None:
         reg_gds_hit = re.search(
@@ -359,7 +343,7 @@ class Neo4jQueryRunner(QueryRunner):
         retrys = 0
         while retrys < retry_config.max_retries:
             try:
-                if self._NEO4J_DRIVER_VERSION < ServerVersion(5, 0, 0):
+                if self._NEO4J_DRIVER_VERSION < SemanticVersion(5, 0, 0):
                     warnings.filterwarnings(
                         "ignore",
                         category=neo4j.ExperimentalWarning,

{graphdatascience-1.13 → graphdatascience-1.14}/graphdatascience/query_runner/progress/progress_provider.py

@@ -7,6 +7,8 @@ from typing import Optional
 class TaskWithProgress:
     task_name: str
     progress_percent: str
+    status: str
+    sub_tasks_description: Optional[str] = None
 
 
 class ProgressProvider(ABC):