Add datetime and timedelta conversion ,Add tests

Author: IdanHaim

pyravendb/data/document_convention.py

@@ -1,7 +1,9 @@
 from pyravendb.data.indexes import SortOptions
 from datetime import datetime, timedelta
+from pyravendb.tools.utils import Utils
 from enum import Enum
 from inflector import Inflector
+import sys
 
 
 class Failover(Enum):
@@ -68,9 +70,9 @@ def __init__(self):
     @staticmethod
     def json_default(o):
         if isinstance(o, datetime):
-            return str(0)
+            return Utils.datetime_to_string(o)
         elif isinstance(o, timedelta):
-            return str(0)
+            return Utils.timedelta_to_str(o)
         elif getattr(o, "__dict__"):
             return o.__dict__
         else:
@@ -104,9 +106,13 @@ def try_get_type_from_metadata(metadata):
     def uses_range_type(obj):
         if obj is None:
             return False
-
-        if isinstance(obj, int) or isinstance(obj, long) or isinstance(obj, float):
-            return True
+        if sys.version_info.major > 2:
+            if isinstance(obj, int) or isinstance(obj, float):
+                return True
+        else:
+            if isinstance(obj, int) or isinstance(obj, float) or isinstance(obj, long):
+                return True
+        return False
 
     @staticmethod
     def get_default_sort_option(type_name):

pyravendb/store/session_query.py

@@ -2,6 +2,8 @@
 from pyravendb.custom_exceptions.exceptions import ErrorResponseException
 from pyravendb.data.indexes import IndexQuery
 from pyravendb.tools.utils import Utils
+from datetime import timedelta
+import sys
 import time
 
 
@@ -42,9 +44,6 @@ def __call__(self, object_type=None, index_name=None, using_default_operator=Non
         self._with_statistics = with_statistics
         return self
 
-    def __iter__(self):
-        return self._execute_query().__iter__()
-
     def _lucene_builder(self, value, action=None):
         lucene_text = Utils.to_lucene(value, action=action)
 
@@ -56,6 +55,9 @@ def _lucene_builder(self, value, action=None):
 
         return lucene_text
 
+    def __iter__(self):
+        return self._execute_query().__iter__()
+
     def where_equals(self, field_name, value):
         """
         To get all the document that equal to the value in the given field_name
@@ -70,6 +72,10 @@ def where_equals(self, field_name, value):
         if value is not None and not isinstance(value, str) and field_name is not None:
             sort_hint = self.session.conventions.get_default_sort_option(type(value).__name__)
             if sort_hint:
+                field_name = "{0}_Range".format(field_name)
+                if sys.version_info.major > 2:
+                    if value > sys.maxsize:
+                        sort_hint = self.session.conventions.get_default_sort_option("long")
                 self._sort_hints.add("SortHint-{0}={1}".format(field_name, sort_hint))
 
         lucene_text = self._lucene_builder(value, action="equal")
@@ -106,6 +112,10 @@ def where_ends_with(self, field_name, value):
         if value is not None and not isinstance(value, str) and field_name is not None:
             sort_hint = self.session.conventions.get_default_sort_option(type(value).__name__)
             if sort_hint:
+                field_name = "{0}_Range".format(field_name)
+                if sys.version_info.major > 2:
+                    if value > sys.maxsize:
+                        sort_hint = self.session.conventions.get_default_sort_option("long")
                 self._sort_hints.add("SortHint-{0}={1}".format(field_name, sort_hint))
 
         lucene_text = self._lucene_builder(value, action="end_with")
@@ -127,6 +137,10 @@ def where_starts_with(self, field_name, value):
         if value is not None and not isinstance(value, str) and field_name is not None:
             sort_hint = self.session.conventions.get_default_sort_option(type(value).__name__)
             if sort_hint:
+                field_name = "{0}_Range".format(field_name)
+                if sys.version_info.major > 2:
+                    if value > sys.maxsize:
+                        sort_hint = self.session.conventions.get_default_sort_option("long")
                 self._sort_hints.add("SortHint-{0}={1}".format(field_name, sort_hint))
 
         lucene_text = self._lucene_builder(value, action="end_with")
@@ -152,23 +166,40 @@ def where_in(self, field_name, values):
         return self
 
     def where_between(self, field_name, start, end):
+        if isinstance(start, timedelta):
+            start = Utils.timedelta_tick(start)
+        if isinstance(end, timedelta):
+            end = Utils.timedelta_tick(end)
+
         value = start or end
         if self.session.conventions.uses_range_type(value) and not field_name.endswith("_Range"):
             sort_hint = self.session.conventions.get_default_sort_option(type(value).__name__)
             if sort_hint:
+                field_name = "{0}_Range".format(field_name)
+                if sys.version_info.major > 2:
+                    if value > sys.maxsize:
+                        sort_hint = self.session.conventions.get_default_sort_option("long")
                 self._sort_hints.add("SortHint-{0}={1}".format(field_name, sort_hint))
-            field_name = "{0}_Range".format(field_name)
+
         lucene_text = self._lucene_builder([start, end], action="between")
         self.query_builder += "{0}:{1}".format(field_name, lucene_text)
         return self
 
     def where_between_or_equal(self, field_name, start, end):
+        if isinstance(start, timedelta):
+            start = Utils.timedelta_tick(start)
+        if isinstance(end, timedelta):
+            end = Utils.timedelta_tick(end)
+
         value = start or end
         if self.session.conventions.uses_range_type(value) and not field_name.endswith("_Range"):
             sort_hint = self.session.conventions.get_default_sort_option(type(value).__name__)
             if sort_hint:
+                field_name = "{0}_Range".format(field_name)
+                if sys.version_info.major > 2:
+                    if value > sys.maxsize:
+                        sort_hint = self.session.conventions.get_default_sort_option("long")
                 self._sort_hints.add("SortHint-{0}={1}".format(field_name, sort_hint))
-            field_name = "{0}_Range".format(field_name)
         lucene_text = self._lucene_builder([start, end], action="equal_between")
         self.query_builder += "{0}:{1}".format(field_name, lucene_text)
         return self

pyravendb/tests/session_tests/conversion_test.py

@@ -0,0 +1,63 @@
+from pyravendb.tests.test_base import TestBase
+from pyravendb.store.document_store import documentstore
+from datetime import datetime, timedelta
+from pyravendb.tools.utils import Utils
+import unittest
+
+
+class Time(object):
+    def __init__(self, td, dt):
+        self.td = td
+        self.dt = dt
+
+
+class TestConversion(TestBase):
+    @classmethod
+    def setUpClass(cls):
+        super(TestConversion, cls).setUpClass()
+
+        cls.db.put("times/3",
+                   {"td": Utils.timedelta_to_str(timedelta(days=20, minutes=23, seconds=59, milliseconds=254)),
+                    "dt": Utils.datetime_to_string(datetime.now())}, {"Raven-Entity-Name": "Times"})
+
+        cls.db.put("times/4",
+                   {"td": Utils.timedelta_to_str(timedelta(minutes=23, seconds=59, milliseconds=254)),
+                    "dt": Utils.datetime_to_string(datetime.now())}, {"Raven-Entity-Name": "Times"})
+
+        cls.document_store = documentstore(cls.default_url, cls.default_database)
+        cls.document_store.initialize()
+
+    def test_load_timedelta_and_datetime(self):
+        with self.document_store.open_session() as session:
+            times = session.load("times/3", object_type=Time, nested_object_types={"td": timedelta, "dt": datetime})
+            self.assertTrue(isinstance(times.td, timedelta) and isinstance(times.dt, datetime))
+
+    def test_store_conversion(self):
+        with self.document_store.open_session() as session:
+            times = Time(timedelta(days=1, hours=1), datetime.now())
+            session.store(times)
+            key = session.advanced.get_document_id(times)
+            session.save_changes()
+
+        with self.document_store.open_session() as session:
+            times = session.load(key, object_type=Time, nested_object_types={"td": timedelta, "dt": datetime})
+            self.assertTrue(isinstance(times.td, timedelta) and isinstance(times.dt, datetime))
+
+    def test_query_conversion(self):
+        with self.document_store.open_session() as session:
+            query = list(session.query(object_type=Time, nested_object_types={"td": timedelta,
+                                                                              "dt": datetime}).where_greater_than_or_equal(
+                "td", timedelta(days=9)))
+
+            not_working = False
+            if len(query) < 1:
+                not_working = True
+            for item in query:
+                if not isinstance(item.td, timedelta):
+                    not_working = True
+
+            self.assertFalse(not_working)
+
+
+if __name__ == "__main__":
+    unittest.main()

pyravendb/tests/session_tests/load_test.py

@@ -21,6 +21,11 @@ def __init__(self, name, key):
         self.key = key
 
 
+class Time(object):
+    def __init__(self, td):
+        self.td = td
+
+
 class TestLoad(TestBase):
     @classmethod
     def setUpClass(cls):

pyravendb/tools/utils.py

@@ -1,6 +1,7 @@
 from pyravendb.data.operations import BulkOperationOption
 from pyravendb.data.indexes import IndexQuery
 from pyravendb.custom_exceptions import exceptions
+from datetime import datetime, timedelta
 import urllib
 import inspect
 import sys
@@ -113,8 +114,13 @@ def convert_to_entity(document, object_type, conventions, nested_object_types=No
                 attr = getattr(entity, key)
                 if attr:
                     try:
-                        setattr(entity, key, nested_object_types[key](
-                            **Utils.make_initialize_dict(attr, nested_object_types[key].__init__)))
+                        if nested_object_types[key] is datetime:
+                            setattr(entity, key, Utils.string_to_datetime(attr))
+                        elif nested_object_types[key] is timedelta:
+                            setattr(entity, key, Utils.string_to_timedelta(attr))
+                        else:
+                            setattr(entity, key, nested_object_types[key](
+                                **Utils.make_initialize_dict(attr, nested_object_types[key].__init__)))
                     except TypeError:
                         pass
 
@@ -188,11 +194,15 @@ def numeric_to_lucene_syntax(value):
         elif not value:
             value = "[[EMPTY_STRING]]"
 
-        if isinstance(value, float) or isinstance(value, int):
+        python_version = sys.version_info.major
+
+        if (python_version > 2 and value > sys.maxsize and isinstance(value,int)) \
+                or python_version <= 2 and isinstance(value, long):
+            value = "Lx{0}".format(int(value))
+
+        elif isinstance(value, float) or isinstance(value, int):
             value = "Dx{0}".format(value)
 
-        elif isinstance(value, long):
-            value = "Lx{0}".format(value)
         return value
 
     @staticmethod
@@ -203,3 +213,53 @@ def dict_to_string(dictionary):
                 dictionary[item] = dictionary[item].decode('utf-8')
             builder.append('{0}={1}'.format(item, dictionary[item]))
         return ','.join(item for item in builder)
+
+    @staticmethod
+    def datetime_to_string(datetime_obj):
+        return datetime_obj.strftime("%Y-%m-%dT%H:%M:%S.%f0")
+
+    @staticmethod
+    def string_to_datetime(datetime_str):
+        try:
+            datetime_s = datetime.strptime(datetime_str, "%Y-%m-%dT%H:%M:%S.%f")
+        except ValueError:
+            datetime_s = datetime.strptime(datetime_str[:-1], "%Y-%m-%dT%H:%M:%S.%f")
+
+        return datetime_s
+
+    @staticmethod
+    def timedelta_tick(td):
+        return int(td.total_seconds() * 10000000)
+
+    @staticmethod
+    def string_to_timedelta(timedelta_str):
+        pattern = r'(?:(-?\d+)[.])?(\d{2}):(\d{2}):(\d{2})(?:.(\d+))?'
+        timedelta_initialize = None
+        m = re.match(pattern, timedelta_str, re.IGNORECASE)
+        if m:
+            timedelta_initialize = {"days": 0 if m.group(1) is None else int(m.group(1)),
+                                    "hours": 0 if m.group(2) is None else int(m.group(2)),
+                                    "minutes": 0 if m.group(3) is None else int(m.group(3)),
+                                    "seconds": 0 if m.group(4) is None else int(m.group(4)),
+                                    "microseconds": 0 if m.group(5) is None else int(m.group(5))
+                                    }
+        if timedelta_initialize:
+            return timedelta(**timedelta_initialize)
+        return None
+
+    @staticmethod
+    def timedelta_to_str(timedelta_obj):
+        timedelta_str = ""
+        if isinstance(timedelta_obj, timedelta):
+            total_seconds = timedelta_obj.seconds
+            days = timedelta_obj.days
+            hours = total_seconds // 3600
+            minutes = (total_seconds // 60) % 60
+            seconds = (total_seconds % 3600) % 60
+            microseconds = timedelta_obj.microseconds
+            if days > 0:
+                timedelta_str += "{0}.".format(days)
+            timedelta_str += "{:02}:{:02}:{:02}".format(hours, minutes, seconds)
+            if microseconds > 0:
+                timedelta_str += ".{0}".format(microseconds)
+        return timedelta_str

setup.py

@@ -3,7 +3,7 @@
 setup(
     name='pyravendb',
     packages=find_packages(),
-    version='1.1.0',
+    version='1.1.1',
     description='This is the official python client for RavenDB document database',
     author='Idan Haim Shalom',
     author_email='haimdude@gmail.com',