WIP: continue from test_spatial_types.py

Author: robsdedude

CHANGELOG.md

@@ -87,6 +87,13 @@
   does not offer the `commit`, `rollback`, `close`, and `closed` methods.  
   Those methods would have caused a hard to interpreted error previously. Hence,
   they have been removed.
+- Deprecated Nodes' and Relationships' `id` property (`int`) in favor of
+  `element_id` (`str`).  
+  This also affects `Graph` objects as `graph.nodes[...]` and
+ `graph.relationships[...]` now prefers strings over integers.
+- `ServerInfo.connection_id` has been deprecated and will be removed in a
+  future release. There is no replacement as this is considered internal
+  information.
 
 
 ## Version 4.4

neo4j/api.py

@@ -308,6 +308,8 @@ def agent(self):
         return self._metadata.get("server")
 
     @property
+    @deprecated("The connection id is considered internal information "
+                "and will no longer be exposed in future versions.")
     def connection_id(self):
         """ Unique identifier for the remote server connection.
         """

neo4j/graph/__init__.py

@@ -31,7 +31,10 @@
 
 from collections.abc import Mapping
 
-from ..meta import deprecated
+from ..meta import (
+    deprecated,
+    deprecation_warn,
+)
 
 
 class Graph:
@@ -253,6 +256,20 @@ def __init__(self, entity_dict):
         self._entity_dict = entity_dict
 
     def __getitem__(self, e_id):
+        # TODO: 6.0 - remove this compatibility shim
+        if isinstance(e_id, (int, float, complex)):
+            deprecation_warn(
+                "Accessing entities by an integer id is deprecated, "
+                "use the new style element_id (str) instead"
+            )
+            if isinstance(e_id, float) and int(e_id) == e_id:
+                # Non-int floats would always fail for legacy IDs
+                e_id = int(e_id)
+            elif isinstance(e_id, complex) and int(e_id.real) == e_id:
+                # complex numbers with imaginary parts or non-integer real
+                # parts would always fail for legacy IDs
+                e_id = int(e_id.real)
+            e_id = str(e_id)
         return self._entity_dict[e_id]
 
     def __len__(self):

neo4j/time/__init__.py

@@ -1657,6 +1657,19 @@ def tzinfo(self):
 
     # OPERATIONS #
 
+    @staticmethod
+    def _native_time_to_ticks(native_time):
+        return int(3600000000000 * native_time.hour
+                   + 60000000000 * native_time.minute
+                   + NANO_SECONDS * native_time.second
+                   + 1000 * native_time.microsecond)
+
+    def _check_both_naive_or_tz_aware(self, other):
+        if (isinstance(other, (time, Time))
+                and ((self.tzinfo is None) ^ (other.tzinfo is None))):
+            raise TypeError("can't compare offset-naive and offset-aware "
+                            "times")
+
     def __hash__(self):
         """"""
         return hash(self.__ticks) ^ hash(self.tzinfo)
@@ -1666,10 +1679,7 @@ def __eq__(self, other):
         if isinstance(other, Time):
             return self.__ticks == other.__ticks and self.tzinfo == other.tzinfo
         if isinstance(other, time):
-            other_ticks = (3600000000000 * other.hour
-                           + 60000000000 * other.minute
-                           + NANO_SECONDS * other.second
-                           + 1000 * other.microsecond)
+            other_ticks = self._native_time_to_ticks(other)
             return self.ticks == other_ticks and self.tzinfo == other.tzinfo
         return False
 
@@ -1679,50 +1689,50 @@ def __ne__(self, other):
 
     def __lt__(self, other):
         """`<` comparison with :class:`.Time` or :class:`datetime.time`."""
+        self._check_both_naive_or_tz_aware(other)
         if isinstance(other, Time):
             return (self.tzinfo == other.tzinfo
                     and self.ticks < other.ticks)
         if isinstance(other, time):
             if self.tzinfo != other.tzinfo:
                 return False
-            other_ticks = 3600 * other.hour + 60 * other.minute + other.second + (other.microsecond / 1000000)
-            return self.ticks < other_ticks
+            return self.ticks < self._native_time_to_ticks(other)
         return NotImplemented
 
     def __le__(self, other):
         """`<=` comparison with :class:`.Time` or :class:`datetime.time`."""
+        self._check_both_naive_or_tz_aware(other)
         if isinstance(other, Time):
             return (self.tzinfo == other.tzinfo
                     and self.ticks <= other.ticks)
         if isinstance(other, time):
             if self.tzinfo != other.tzinfo:
                 return False
-            other_ticks = 3600 * other.hour + 60 * other.minute + other.second + (other.microsecond / 1000000)
-            return self.ticks <= other_ticks
+            return self.ticks <= self._native_time_to_ticks(other)
         return NotImplemented
 
     def __ge__(self, other):
         """`>=` comparison with :class:`.Time` or :class:`datetime.time`."""
+        self._check_both_naive_or_tz_aware(other)
         if isinstance(other, Time):
             return (self.tzinfo == other.tzinfo
                     and self.ticks >= other.ticks)
         if isinstance(other, time):
             if self.tzinfo != other.tzinfo:
                 return False
-            other_ticks = 3600 * other.hour + 60 * other.minute + other.second + (other.microsecond / 1000000)
-            return self.ticks >= other_ticks
+            return self.ticks >= self._native_time_to_ticks(other)
         return NotImplemented
 
     def __gt__(self, other):
         """`>` comparison with :class:`.Time` or :class:`datetime.time`."""
+        self._check_both_naive_or_tz_aware(other)
         if isinstance(other, Time):
             return (self.tzinfo == other.tzinfo
                     and self.ticks >= other.ticks)
         if isinstance(other, time):
             if self.tzinfo != other.tzinfo:
                 return False
-            other_ticks = 3600 * other.hour + 60 * other.minute + other.second + (other.microsecond / 1000000)
-            return self.ticks >= other_ticks
+            return self.ticks >= self._native_time_to_ticks(other)
         return NotImplemented
 
     def __copy__(self):
@@ -2203,7 +2213,8 @@ def __eq__(self, other):
         `==` comparison with :class:`.DateTime` or :class:`datetime.datetime`.
         """
         if isinstance(other, (DateTime, datetime)):
-            return self.date() == other.date() and self.time() == other.time()
+            return (self.date() == other.date()
+                    and self.timetz() == other.timetz())
         return False
 
     def __ne__(self, other):
@@ -2218,7 +2229,7 @@ def __lt__(self, other):
         """
         if isinstance(other, (DateTime, datetime)):
             if self.date() == other.date():
-                return self.time() < other.time()
+                return self.timetz() < other.timetz()
             else:
                 return self.date() < other.date()
         return NotImplemented

neo4j/time/hydration.py

@@ -136,7 +136,7 @@ def dehydrate_datetime(value):
     """ Dehydrator for `datetime` values.
 
     :param value:
-    :type value: datetime
+    :type value: datetime or DateTime
     :return:
     """
 
@@ -167,7 +167,8 @@ def seconds_and_nanoseconds(dt):
     else:
         # with time offset
         seconds, nanoseconds = seconds_and_nanoseconds(value)
-        return Structure(b"F", seconds, nanoseconds, tz.utcoffset(value).seconds)
+        return Structure(b"F", seconds, nanoseconds,
+                         int(tz.utcoffset(value).total_seconds()))
 
 
 def hydrate_duration(months, days, seconds, nanoseconds):

testkitbackend/_async/requests.py

@@ -18,6 +18,7 @@
 
 import json
 from os import path
+import warnings
 
 import neo4j
 from neo4j._async_compat.util import AsyncUtil
@@ -411,6 +412,17 @@ async def ResultSingle(backend, data):
     ))
 
 
+async def ResultSingleOptional(backend, data):
+    result = backend.results[data["resultId"]]
+    with warnings.catch_warnings(record=True) as warning_list:
+        record = await result.single(strict=False)
+    if record:
+        record = totestkit.record(record)
+    await backend.send_response("RecordOptional", {
+        "record": record, "warnings": list(map(str, warning_list))
+    })
+
+
 async def ResultPeek(backend, data):
     result = backend.results[data["resultId"]]
     record = await result.peek()

testkitbackend/_sync/requests.py

@@ -18,6 +18,7 @@
 
 import json
 from os import path
+import warnings
 
 import neo4j
 from neo4j._async_compat.util import Util
@@ -411,6 +412,17 @@ def ResultSingle(backend, data):
     ))
 
 
+def ResultSingleOptional(backend, data):
+    result = backend.results[data["resultId"]]
+    with warnings.catch_warnings(record=True) as warning_list:
+        record = result.single(strict=False)
+    if record:
+        record = totestkit.record(record)
+    backend.send_response("RecordOptional", {
+        "record": record, "warnings": list(map(str, warning_list))
+    })
+
+
 def ResultPeek(backend, data):
     result = backend.results[data["resultId"]]
     record = result.peek()

testkitbackend/fromtestkit.py

@@ -16,7 +16,21 @@
 # limitations under the License.
 
 
+from datetime import timedelta
+
+import pytz
+
 from neo4j import Query
+from neo4j.spatial import (
+    CartesianPoint,
+    WGS84Point,
+)
+from neo4j.time import (
+    Date,
+    DateTime,
+    Duration,
+    Time,
+)
 
 
 def to_cypher_and_params(data):
@@ -54,24 +68,79 @@ def to_query_and_params(data):
 def to_param(m):
     """ Converts testkit parameter format to driver (python) parameter
     """
-    value = m["data"]["value"]
+    data = m["data"]
     name = m["name"]
     if name == "CypherNull":
         return None
     if name == "CypherString":
-        return str(value)
+        return str(data["value"])
     if name == "CypherBool":
-        return bool(value)
+        return bool(data["value"])
     if name == "CypherInt":
-        return int(value)
+        return int(data["value"])
     if name == "CypherFloat":
-        return float(value)
+        return float(data["value"])
     if name == "CypherString":
-        return str(value)
+        return str(data["value"])
     if name == "CypherBytes":
-        return bytearray([int(byte, 16) for byte in value.split()])
+        return bytearray([int(byte, 16) for byte in data["value"].split()])
     if name == "CypherList":
-        return [to_param(v) for v in value]
+        return [to_param(v) for v in data["value"]]
     if name == "CypherMap":
-        return {k: to_param(value[k]) for k in value}
-    raise Exception("Unknown param type " + name)
+        return {k: to_param(data["value"][k]) for k in data["value"]}
+    if name == "CypherPoint":
+        coords = [data["x"], data["y"]]
+        if data.get("z") is not None:
+            coords.append(data["z"])
+        if data["system"] == "cartesian":
+            return CartesianPoint(coords)
+        if data["system"] == "wgs84":
+            return WGS84Point(coords)
+        raise ValueError("Unknown point system: {}".format(data["system"]))
+    if name == "CypherDate":
+        return Date(data["year"], data["month"], data["day"])
+    if name == "CypherTime":
+        tz = None
+        utc_offset_s = data.get("utc_offset_s")
+        if utc_offset_s is not None:
+            utc_offset_m = utc_offset_s // 60
+            if utc_offset_m * 60 != utc_offset_s:
+                raise ValueError("the used timezone library only supports "
+                                 "UTC offsets by minutes")
+            tz = pytz.FixedOffset(utc_offset_m)
+        return Time(data["hour"], data["minute"], data["second"],
+                    data["nanosecond"], tzinfo=tz)
+    if name == "CypherDateTime":
+        datetime = DateTime(
+            data["year"], data["month"], data["day"],
+            data["hour"], data["minute"], data["second"], data["nanosecond"]
+        )
+        utc_offset_s = data["utc_offset_s"]
+        timezone_id = data["timezone_id"]
+        if timezone_id is not None:
+            utc_offset = timedelta(seconds=utc_offset_s)
+            tz = pytz.timezone(timezone_id)
+            localized_datetime = tz.localize(datetime, is_dst=False)
+            if localized_datetime.utcoffset() == utc_offset:
+                return localized_datetime
+            localized_datetime = tz.localize(datetime, is_dst=True)
+            if localized_datetime.utcoffset() == utc_offset:
+                return localized_datetime
+            raise ValueError(
+                "cannot localize datetime %s to timezone %s with UTC "
+                "offset %s" % (datetime, timezone_id, utc_offset)
+            )
+        elif utc_offset_s is not None:
+            utc_offset_m = utc_offset_s // 60
+            if utc_offset_m * 60 != utc_offset_s:
+                raise ValueError("the used timezone library only supports "
+                                 "UTC offsets by minutes")
+            tz = pytz.FixedOffset(utc_offset_m)
+            return tz.localize(datetime)
+        return datetime
+    if name == "CypherDuration":
+        return Duration(
+            months=data["months"], days=data["days"],
+            seconds=data["seconds"], nanoseconds=data["nanoseconds"]
+        )
+    raise ValueError("Unknown param type " + name)

testkitbackend/test_config.json

@@ -32,8 +32,11 @@
     "Feature:API:Result.List": true,
     "Feature:API:Result.Peek": true,
     "Feature:API:Result.Single": true,
+    "Feature:API:Result.SingleOptional": true,
     "Feature:API:SSLConfig": true,
     "Feature:API:SSLSchemes": true,
+    "Feature:API:Type.Spatial":  true,
+    "Feature:API:Type.Temporal":  true,
     "Feature:Auth:Bearer": true,
     "Feature:Auth:Custom": true,
     "Feature:Auth:Kerberos": true,