package: allow to use without pandas and pytz

pandas and pytz packages are required to build a tarantool.Datetime
object. If user doesn't plan to work with datetimes, they still would
be installed. This patch makes this code dependency optional. If
packages are not provided, when Tarantool sends a Datetime object, its
encoded bytes data would be simply put to a `tarantool.DatetimeRaw`
object.

Part of #290

Author: DifferentialOrange

CHANGELOG.md

@@ -11,6 +11,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Migrate to built-in `Warning` instead of a custom one.
 - Migrate to built-in `RecursionError` instead of a custom one.
 - Collect full exception traceback.
+- Allow to use connector without `pandas` and `pytz`. In this case,
+  when Tarantool sends a Datetime object, its encoded bytes data would be simply put
+  to a `tarantool.DatetimeRaw` object (#290).
 
 ## 0.12.1 - 2023-02-28
 

tarantool/__init__.py

@@ -34,6 +34,7 @@
 
 from tarantool.msgpack_ext.types.datetime import (
     Datetime,
+    DatetimeRaw,
 )
 
 from tarantool.msgpack_ext.types.interval import (
@@ -141,5 +142,5 @@ def connectmesh(addrs=({'host': 'localhost', 'port': 3301},), user=None,
 
 __all__ = ['connect', 'Connection', 'connectmesh', 'MeshConnection', 'Schema',
            'Error', 'DatabaseError', 'NetworkError', 'NetworkWarning',
-           'SchemaError', 'dbapi', 'Datetime', 'Interval', 'IntervalAdjust',
-           'ConnectionPool', 'Mode', 'BoxError']
+           'SchemaError', 'dbapi', 'Datetime', 'DatetimeRaw', 'Interval',
+           'IntervalAdjust', 'ConnectionPool', 'Mode', 'BoxError']

tarantool/msgpack_ext/datetime.py

@@ -39,8 +39,10 @@
 """
 
 from tarantool.msgpack_ext.types.datetime import (
+    IS_DATETIME_SUPPORTED,
     NSEC_IN_SEC,
     Datetime,
+    DatetimeRaw,
 )
 import tarantool.msgpack_ext.types.timezones as tt_timezones
 
@@ -83,14 +85,17 @@ def encode(obj, _):
     Encode a datetime object.
 
     :param obj: Datetime to encode.
-    :type: :obj: :class:`tarantool.Datetime`
+    :type obj: :class:`tarantool.Datetime`, :class:`tarantool.DatetimeRaw`
 
     :return: Encoded datetime.
     :rtype: :obj:`bytes`
 
     :raise: :exc:`tarantool.Datetime.msgpack_encode` exceptions
     """
 
+    if isinstance(obj, DatetimeRaw):
+        return obj.data
+
     seconds = obj.value // NSEC_IN_SEC
     nsec = obj.nsec
     tzoffset = obj.tzoffset
@@ -142,13 +147,17 @@ def decode(data, _):
     :param obj: Datetime to decode.
     :type obj: :obj:`bytes`
 
-    :return: Decoded datetime.
-    :rtype: :class:`tarantool.Datetime`
+    :return: Decoded datetime. If :class:`tarantool.Datetime` is not
+        supported, :class:`tarantool.DatetimeRaw` returned instead.
+    :rtype: :class:`tarantool.Datetime`, :class:`tarantool.DatetimeRaw`
 
     :raise: :exc:`~tarantool.error.MsgpackError`,
         :exc:`tarantool.Datetime` exceptions
     """
 
+    if not IS_DATETIME_SUPPORTED:
+        return DatetimeRaw(data)
+
     cursor = 0
     seconds, cursor = get_bytes_as_int(data, cursor, SECONDS_SIZE_BYTES)
 

tarantool/msgpack_ext/packer.py

@@ -10,7 +10,7 @@
 from msgpack import ExtType
 
 from tarantool.types import BoxError
-from tarantool.msgpack_ext.types.datetime import Datetime
+from tarantool.msgpack_ext.types.datetime import Datetime, DatetimeRaw
 from tarantool.msgpack_ext.types.interval import Interval
 
 import tarantool.msgpack_ext.decimal as ext_decimal
@@ -24,6 +24,7 @@
     {'type': UUID, 'ext': ext_uuid},
     {'type': BoxError, 'ext': ext_error},
     {'type': Datetime, 'ext': ext_datetime},
+    {'type': DatetimeRaw, 'ext': ext_datetime},
     {'type': Interval, 'ext': ext_interval},
 ]
 
@@ -35,7 +36,7 @@ def default(obj, packer=None):
     :param obj: Object to encode.
     :type obj: :class:`decimal.Decimal` or :class:`uuid.UUID` or
          or :class:`tarantool.BoxError` or :class:`tarantool.Datetime`
-         or :class:`tarantool.Interval`
+         or :class:`tarantool.DatetimeRaw` or :class:`tarantool.Interval`
 
     :param packer: msgpack packer to work with common types
         (like dictionary in extended error payload)

tarantool/msgpack_ext/types/datetime.py

@@ -4,9 +4,14 @@
 # pylint: disable=line-too-long
 
 from copy import deepcopy
+from dataclasses import dataclass
 
-import pandas
-import pytz
+try:
+    import pandas
+    import pytz
+    IS_DATETIME_SUPPORTED = True
+except ImportError:
+    IS_DATETIME_SUPPORTED = False
 
 import tarantool.msgpack_ext.types.timezones as tt_timezones
 
@@ -267,6 +272,8 @@ def __init__(self, *, timestamp=None, year=None, month=None,
         """
         # pylint: disable=too-many-branches,too-many-locals
 
+        assert IS_DATETIME_SUPPORTED, "pandas and pytz are required"
+
         tzinfo = None
         if tz != '':
             if tz not in tt_timezones.timezoneToIndex:
@@ -638,3 +645,16 @@ def value(self):
         """
 
         return self._datetime.value
+
+
+@dataclass
+class DatetimeRaw():
+    """
+    Class representing Tarantool `datetime`_ info in raw format. Used when
+    :class:`pandas.Timestamp` or :class:`pytz` are unavailable.
+    """
+
+    data: bytes
+    """
+    :type: :obj:`bytes`
+    """

tarantool/msgpack_ext/unpacker.py

@@ -34,10 +34,11 @@ def ext_hook(code, data, unpacker=None):
         (like dictionary in extended error payload)
     :type unpacker: :class:`msgpack.Unpacker`, optional
 
-    :return: Decoded value.
+    :return: Decoded value. If :class:`tarantool.Datetime` is not
+        supported, :class:`tarantool.DatetimeRaw` returned instead.
     :rtype: :class:`decimal.Decimal` or :class:`uuid.UUID` or
-         or :class:`tarantool.BoxError` or :class:`tarantool.Datetime`
-         or :class:`tarantool.Interval`
+        or :class:`tarantool.BoxError` or :class:`tarantool.Datetime`
+        or :class:`tarantool.DatetimeRaw` or :class:`tarantool.Interval`
 
     :raise: :exc:`NotImplementedError`
     """

test/suites/test_datetime.py

@@ -13,10 +13,16 @@
 from tarantool.error import MsgpackError
 from tarantool.msgpack_ext.packer import default as packer_default
 from tarantool.msgpack_ext.unpacker import ext_hook as unpacker_ext_hook
+from tarantool.msgpack_ext.types.datetime import IS_DATETIME_SUPPORTED
 
 from .lib.tarantool_server import TarantoolServer
 from .lib.skip import skip_or_run_datetime_test
 
+# Workaround for matrix test cases build.
+if not IS_DATETIME_SUPPORTED:
+    ORIGINAL_DATETIME_IMPL = tarantool.Datetime
+    tarantool.Datetime = lambda *args, **kwars: None
+
 
 class TestSuiteDatetime(unittest.TestCase):
     @classmethod
@@ -69,6 +75,7 @@ def setUp(self):
 
         self.adm("box.space['test']:truncate()")
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     def test_datetime_class_api(self):
         datetime = tarantool.Datetime(year=2022, month=8, day=31, hour=18, minute=7, sec=54,
                                       nsec=308543321, tzoffset=180)
@@ -86,6 +93,7 @@ def test_datetime_class_api(self):
         self.assertEqual(datetime.tz, '')
         self.assertEqual(datetime.value, 1661958474308543321)
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     def test_datetime_class_api_wth_tz(self):
         datetime = tarantool.Datetime(year=2022, month=8, day=31, hour=18, minute=7, sec=54,
                                       nsec=308543321, tzoffset=123, tz='Europe/Moscow')
@@ -142,6 +150,7 @@ def test_datetime_class_api_wth_tz(self):
         },
     }
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     def test_datetime_class_invalid_init(self):
         # pylint: disable=cell-var-from-loop
 
@@ -282,12 +291,14 @@ def test_datetime_class_invalid_init(self):
         },
     }
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     def test_msgpack_decode(self):
         for name, case in self.integration_cases.items():
             with self.subTest(msg=name):
                 self.assertEqual(unpacker_ext_hook(4, case['msgpack']),
                                  case['python'])
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     @skip_or_run_datetime_test
     def test_tarantool_decode(self):
         for name, case in self.integration_cases.items():
@@ -297,12 +308,14 @@ def test_tarantool_decode(self):
                 self.assertSequenceEqual(self.con.select('test', name),
                                          [[name, case['python'], 'field']])
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     def test_msgpack_encode(self):
         for name, case in self.integration_cases.items():
             with self.subTest(msg=name):
                 self.assertEqual(packer_default(case['python']),
                                  msgpack.ExtType(code=4, data=case['msgpack']))
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     @skip_or_run_datetime_test
     def test_tarantool_encode(self):
         for name, case in self.integration_cases.items():
@@ -325,12 +338,14 @@ def test_tarantool_encode(self):
 
                 self.assertSequenceEqual(self.adm(lua_eval), [True])
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     def test_msgpack_decode_unknown_tzindex(self):
         case = b'\x4a\x79\x0f\x63\x00\x00\x00\x00\x59\xff\x63\x12\xb4\x00\xff\xff'
         self.assertRaisesRegex(
             MsgpackError, 'Failed to decode datetime with unknown tzindex "-1"',
             lambda: unpacker_ext_hook(4, case))
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     def test_msgpack_decode_ambiguous_tzindex(self):
         case = b'\x4a\x79\x0f\x63\x00\x00\x00\x00\x59\xff\x63\x12\x00\x00\x82\x00'
         self.assertRaisesRegex(
@@ -364,11 +379,13 @@ def test_msgpack_decode_ambiguous_tzindex(self):
         },
     }
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     def test_python_datetime_subtraction(self):
         for name, case in self.datetime_subtraction_cases.items():
             with self.subTest(msg=name):
                 self.assertEqual(case['arg_1'] - case['arg_2'], case['res'])
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     @skip_or_run_datetime_test
     def test_tarantool_datetime_subtraction(self):
         for name, case in self.datetime_subtraction_cases.items():
@@ -382,11 +399,13 @@ def test_tarantool_datetime_subtraction(self):
         'res': tarantool.Interval(day=1, hour=-21),
     }
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     def test_python_datetime_subtraction_different_timezones(self):
         case = self.datetime_subtraction_different_timezones_case
 
         self.assertEqual(case['arg_1'] - case['arg_2'], case['res'])
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     @skip_or_run_datetime_test
     @unittest.skip('See https://github.com/tarantool/tarantool/issues/7698')
     def test_tarantool_datetime_subtraction_different_timezones(self):
@@ -478,23 +497,27 @@ def test_tarantool_datetime_subtraction_different_timezones(self):
         },
     }
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     def test_python_interval_addition(self):
         for name, case in self.interval_arithmetic_cases.items():
             with self.subTest(msg=name):
                 self.assertEqual(case['arg_1'] + case['arg_2'], case['res_add'])
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     def test_python_interval_subtraction(self):
         for name, case in self.interval_arithmetic_cases.items():
             with self.subTest(msg=name):
                 self.assertEqual(case['arg_1'] - case['arg_2'], case['res_sub'])
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     @skip_or_run_datetime_test
     def test_tarantool_interval_addition(self):
         for name, case in self.interval_arithmetic_cases.items():
             with self.subTest(msg=name):
                 self.assertSequenceEqual(self.con.call('add', case['arg_1'], case['arg_2']),
                                          [case['res_add']])
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     @skip_or_run_datetime_test
     def test_tarantool_interval_subtraction(self):
         for name, case in self.interval_arithmetic_cases.items():
@@ -508,11 +531,13 @@ def test_tarantool_interval_subtraction(self):
         'res': tarantool.Datetime(year=2008, month=7, day=1, hour=12, tz='Europe/Moscow'),
     }
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     def test_python_datetime_addition_winter_time_switch(self):
         case = self.datetime_addition_winter_time_switch_case
 
         self.assertEqual(case['arg_1'] + case['arg_2'], case['res'])
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     @skip_or_run_datetime_test
     @unittest.skip('See https://github.com/tarantool/tarantool/issues/7700')
     def test_tarantool_datetime_addition_winter_time_switch(self):
@@ -521,13 +546,71 @@ def test_tarantool_datetime_addition_winter_time_switch(self):
         self.assertSequenceEqual(self.con.call('add', case['arg_1'], case['arg_2']),
                                  [case['res']])
 
+    @unittest.skipIf(not IS_DATETIME_SUPPORTED, "pandas or pytz not installed")
     @skip_or_run_datetime_test
     def test_primary_key(self):
         data = [tarantool.Datetime(year=1970, month=1, day=1), 'content']
 
         self.assertSequenceEqual(self.con.insert('test_pk', data), [data])
         self.assertSequenceEqual(self.con.select('test_pk', data[0]), [data])
 
+    integration_raw_case = {
+        'python': tarantool.DatetimeRaw(b'\x44\xa3\x0f\x63\x00\x00\x00\x00'),
+        'msgpack': (b'\x44\xa3\x0f\x63\x00\x00\x00\x00'),
+        'tarantool': r"datetime.new({year=2022, month=8, day=31, hour=18, min=7})",
+    }
+
+    @unittest.skipIf(IS_DATETIME_SUPPORTED, "pandas or pytz are installed")
+    def test_msgpack_decode_raw(self):
+        case = self.integration_raw_case
+        self.assertEqual(unpacker_ext_hook(4, case['msgpack']),
+                         case['python'])
+
+    @unittest.skipIf(IS_DATETIME_SUPPORTED, "pandas or pytz are installed")
+    @skip_or_run_datetime_test
+    def test_tarantool_decode_raw(self):
+        name = 'decode_raw'
+        case = self.integration_raw_case
+        self.adm(f"box.space['test']:replace{{'{name}', {case['tarantool']}, 'field'}}")
+
+        self.assertSequenceEqual(self.con.select('test', name),
+                                 [[name, case['python'], 'field']])
+
+    @unittest.skipIf(IS_DATETIME_SUPPORTED, "pandas or pytz are installed")
+    def test_msgpack_encode_raw(self):
+        case = self.integration_raw_case
+        self.assertEqual(packer_default(case['python']),
+                         msgpack.ExtType(code=4, data=case['msgpack']))
+
+    @unittest.skipIf(IS_DATETIME_SUPPORTED, "pandas or pytz are installed")
+    @skip_or_run_datetime_test
+    def test_tarantool_encode_raw(self):
+        name = 'encode_raw'
+        case = self.integration_raw_case
+        self.con.insert('test', [name, case['python'], 'field'])
+
+        lua_eval = f"""
+            local dt = {case['tarantool']}
+
+            local tuple = box.space['test']:get('{name}')
+            assert(tuple ~= nil)
+
+            if tuple[2] == dt then
+                return true
+            else
+                return nil, ('%s is not equal to expected %s'):format(
+                    tostring(tuple[2]), tostring(dt))
+            end
+        """
+
+        self.assertSequenceEqual(self.adm(lua_eval), [True])
+
+    @unittest.skipIf(IS_DATETIME_SUPPORTED, "pandas or pytz are installed")
+    def test_datetime_if_not_supported(self):
+        self.assertRaisesRegex(
+            AssertionError, "pandas and pytz are required",
+            lambda: ORIGINAL_DATETIME_IMPL(year=1970, month=1, day=1))
+
     @classmethod
     def tearDownClass(cls):
         cls.con.close()