Use more generic semantic_version for non gds version

Author: FlorentinD

graphdatascience/query_runner/gds_arrow_client.py

@@ -18,8 +18,7 @@
 from pyarrow.types import is_dictionary
 from tenacity import retry, retry_if_exception_type, stop_after_attempt, stop_after_delay, wait_exponential
 
-from graphdatascience.server_version.server_version import ServerVersion
-
+from ..semantic_version.semantic_version import SemanticVersion
 from ..version import __version__
 from .arrow_endpoint_version import ArrowEndpointVersion
 from .arrow_info import ArrowInfo
@@ -676,7 +675,7 @@ def _do_get(
             message=r"Passing a BlockManager to DataFrame is deprecated",
         )
 
-        if ServerVersion.from_string(pandas.__version__) >= ServerVersion(2, 0, 0):
+        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)

graphdatascience/query_runner/neo4j_query_runner.py

@@ -13,6 +13,7 @@
 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
@@ -24,7 +25,7 @@
 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(
@@ -60,7 +61,7 @@ def create_for_db(
         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(
@@ -93,7 +94,7 @@ def create_for_session(
             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(
@@ -175,13 +176,13 @@ def run_cypher(
 
             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
@@ -342,7 +343,7 @@ def _verify_connectivity(
         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/semantic_version/semantic_version.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import re
+
+
+class InvalidServerVersionError(Exception):
+    pass
+
+
+class SemanticVersion:
+    """
+    A representation of a semantic version, such as for python packages.
+    """
+
+    def __init__(self, major: int, minor: int, patch: int):
+        self.major = major
+        self.minor = minor
+        self.patch = patch
+
+    @classmethod
+    def from_string(cls, version: str) -> SemanticVersion:
+        server_version_match = re.search(r"^(\d+)\.(\d+)\.(\d+)", version)
+        if not server_version_match:
+            raise InvalidServerVersionError(f"{version} is not a valid semantic version")
+
+        return cls(*map(int, server_version_match.groups()))
+
+    def __lt__(self, other: SemanticVersion) -> bool:
+        if self.major != other.major:
+            return self.major < other.major
+
+        if self.minor != other.minor:
+            return self.minor < other.minor
+
+        if self.patch != other.patch:
+            return self.patch < other.patch
+
+        return False
+
+    def __ge__(self, other: SemanticVersion) -> bool:
+        return not self.__lt__(other)
+
+    def __str__(self) -> str:
+        return f"{self.major}.{self.minor}.{self.patch}"