clickhouse-driver 0.2.7__tar.gz → 0.2.9__tar.gz

{clickhouse-driver-0.2.7/clickhouse_driver.egg-info → clickhouse-driver-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clickhouse-driver
-Version: 0.2.7
+Version: 0.2.9
 Summary: Python driver with native interface for ClickHouse
 Home-page: https://github.com/mymarilyn/clickhouse-driver
 Author: Konstantin Lebedev
@@ -179,6 +179,7 @@ Classifier: Programming Language :: Python :: 3.8
 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 :: Implementation :: PyPy
 Classifier: Topic :: Database
 Classifier: Topic :: Software Development

{clickhouse-driver-0.2.7 → clickhouse-driver-0.2.9}/clickhouse_driver/__init__.py

@@ -3,7 +3,7 @@ from .client import Client
 from .dbapi import connect
 
 
-VERSION = (0, 2, 7)
+VERSION = (0, 2, 9)
 __version__ = '.'.join(str(x) for x in VERSION)
 
 __all__ = ['Client', 'connect']

{clickhouse-driver-0.2.7 → clickhouse-driver-0.2.9}/clickhouse_driver/client.py

@@ -1,10 +1,9 @@
 import re
-import ssl
 from collections import deque
 from contextlib import contextmanager
 from time import time
 import types
-from urllib.parse import urlparse, parse_qs, unquote
+from urllib.parse import urlparse
 
 from . import errors, defines
 from .block import ColumnOrientedBlock, RowOrientedBlock
@@ -15,7 +14,7 @@ from .result import (
     IterQueryResult, ProgressQueryResult, QueryResult, QueryInfo
 )
 from .util.escape import escape_params
-from .util.helpers import column_chunks, chunks, asbool
+from .util.helpers import column_chunks, chunks, parse_url
 
 
 class Client(object):
@@ -312,6 +311,7 @@ class Client(object):
     def disconnect_on_error(self, query, settings):
         try:
             self.establish_connection(settings)
+            self.connection.server_info.session_timezone = None
 
             yield
 
@@ -746,9 +746,13 @@ class Client(object):
             elif packet.type == ServerPacketTypes.EXCEPTION:
                 raise packet.exception
 
+            elif packet.type == ServerPacketTypes.TIMEZONE_UPDATE:
+                pass
+
             else:
                 message = self.connection.unexpected_packet_message(
-                    'ProfileEvents, Progress, Log or Exception', packet.type
+                    'ProfileEvents, Progress, Log, Exception or '
+                    'TimezoneUpdate', packet.type
                 )
                 raise errors.UnexpectedPacketFromServerError(message)
 
@@ -796,101 +800,13 @@ class Client(object):
             clickhouses://[user:password]@localhost:9440/default
 
         Three URL schemes are supported:
-            clickhouse:// creates a normal TCP socket connection
-            clickhouses:// creates a SSL wrapped TCP socket connection
+
+            * clickhouse:// creates a normal TCP socket connection
+            * clickhouses:// creates a SSL wrapped TCP socket connection
 
         Any additional querystring arguments will be passed along to
         the Connection class's initializer.
         """
-        url = urlparse(url)
-
-        settings = {}
-        kwargs = {}
-
-        host = url.hostname
-
-        if url.port is not None:
-            kwargs['port'] = url.port
-
-        path = url.path.replace('/', '', 1)
-        if path:
-            kwargs['database'] = path
-
-        if url.username is not None:
-            kwargs['user'] = unquote(url.username)
-
-        if url.password is not None:
-            kwargs['password'] = unquote(url.password)
-
-        if url.scheme == 'clickhouses':
-            kwargs['secure'] = True
-
-        compression_algs = {'lz4', 'lz4hc', 'zstd'}
-        timeouts = {
-            'connect_timeout',
-            'send_receive_timeout',
-            'sync_request_timeout'
-        }
-
-        for name, value in parse_qs(url.query).items():
-            if not value or not len(value):
-                continue
-
-            value = value[0]
-
-            if name == 'compression':
-                value = value.lower()
-                if value in compression_algs:
-                    kwargs[name] = value
-                else:
-                    kwargs[name] = asbool(value)
-
-            elif name == 'secure':
-                kwargs[name] = asbool(value)
-
-            elif name == 'use_numpy':
-                settings[name] = asbool(value)
-
-            elif name == 'round_robin':
-                kwargs[name] = asbool(value)
-
-            elif name == 'client_name':
-                kwargs[name] = value
-
-            elif name in timeouts:
-                kwargs[name] = float(value)
-
-            elif name == 'compress_block_size':
-                kwargs[name] = int(value)
-
-            elif name == 'settings_is_important':
-                kwargs[name] = asbool(value)
-
-            elif name == 'tcp_keepalive':
-                try:
-                    kwargs[name] = asbool(value)
-                except ValueError:
-                    parts = value.split(',')
-                    kwargs[name] = (
-                        float(parts[0]), float(parts[1]), int(parts[2])
-                    )
-            elif name == 'client_revision':
-                kwargs[name] = int(value)
-
-            # ssl
-            elif name == 'verify':
-                kwargs[name] = asbool(value)
-            elif name == 'ssl_version':
-                kwargs[name] = getattr(ssl, value)
-            elif name in ['ca_certs', 'ciphers', 'keyfile', 'certfile',
-                          'server_hostname']:
-                kwargs[name] = value
-            elif name == 'alt_hosts':
-                kwargs['alt_hosts'] = value
-            else:
-                settings[name] = value
-
-        if settings:
-            kwargs['settings'] = settings
+        host, kwargs = parse_url(url)
 
         return cls(host, **kwargs)

clickhouse-driver-0.2.9/clickhouse_driver/columns/datecolumn.py

@@ -0,0 +1,108 @@
+from os import getenv
+from datetime import date, timedelta
+
+from .base import FormatColumn
+
+
+epoch_start = date(1970, 1, 1)
+epoch_end = date(2149, 6, 6)
+
+epoch_start_date32 = date(1900, 1, 1)
+epoch_end_date32 = date(2299, 12, 31)
+
+
+class LazyLUT(dict):
+    def __init__(self, *args, _factory, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._default_factory = _factory
+
+    def __missing__(self, key):
+        return self.setdefault(key, self._default_factory(key))
+
+
+def make_date_lut_range(date_start, date_end):
+    return range(
+        (date_start - epoch_start).days,
+        (date_end - epoch_start).days + 1,
+    )
+
+
+enable_lazy_date_lut = getenv('CLICKHOUSE_DRIVER_LASY_DATE_LUT', False)
+if enable_lazy_date_lut:
+    try:
+        start, end = enable_lazy_date_lut.split(':')
+        start_date = date.fromisoformat(start)
+        end_date = date.fromisoformat(end)
+
+        date_range = make_date_lut_range(start_date, end_date)
+    except ValueError:
+        date_range = ()
+
+    # Since we initialize lazy lut with some initially warmed values,
+    # we use iterator and not dict comprehension for memory & time optimization
+    _date_lut = LazyLUT(
+        ((x, epoch_start + timedelta(days=x)) for x in date_range),
+        _factory=lambda x: epoch_start + timedelta(days=x),
+    )
+    _date_lut_reverse = LazyLUT(
+        ((value, key) for key, value in _date_lut.items()),
+        _factory=lambda x: (x - epoch_start).days,
+    )
+else:
+    # If lazy lut is not enabled, we fallback to static dict initialization
+    # In both cases, we use same lut for both data types,
+    # since one encompasses the other and we can avoid duplicating overlap
+    date_range = make_date_lut_range(epoch_start_date32, epoch_end_date32)
+    _date_lut = {x: epoch_start + timedelta(days=x) for x in date_range}
+    _date_lut_reverse = {value: key for key, value in _date_lut.items()}
+
+
+class DateColumn(FormatColumn):
+    ch_type = 'Date'
+    py_types = (date, )
+    format = 'H'
+
+    min_value = epoch_start
+    max_value = epoch_end
+
+    date_lut = _date_lut
+    date_lut_reverse = _date_lut_reverse
+
+    def before_write_items(self, items, nulls_map=None):
+        null_value = self.null_value
+
+        date_lut_reverse = self.date_lut_reverse
+        min_value = self.min_value
+        max_value = self.max_value
+
+        for i, item in enumerate(items):
+            if nulls_map and nulls_map[i]:
+                items[i] = null_value
+                continue
+
+            if item is not date:
+                item = date(item.year, item.month, item.day)
+
+            if min_value <= item <= max_value:
+                items[i] = date_lut_reverse[item]
+            else:
+                items[i] = 0
+
+    def after_read_items(self, items, nulls_map=None):
+        date_lut = self.date_lut
+
+        if nulls_map is None:
+            return tuple(date_lut[item] for item in items)
+        else:
+            return tuple(
+                (None if is_null else date_lut[items[i]])
+                for i, is_null in enumerate(nulls_map)
+            )
+
+
+class Date32Column(DateColumn):
+    ch_type = 'Date32'
+    format = 'i'
+
+    min_value = epoch_start_date32
+    max_value = epoch_end_date32

{clickhouse-driver-0.2.7 → clickhouse-driver-0.2.9}/clickhouse_driver/columns/datetimecolumn.py

@@ -193,8 +193,9 @@ def create_datetime_column(spec, column_options):
     else:
         if not context.settings.get('use_client_time_zone', False):
             local_timezone = get_localzone_name_compat()
-            if local_timezone != context.server_info.timezone:
-                tz_name = context.server_info.timezone
+            remote_timezone = context.server_info.get_timezone()
+            if local_timezone != remote_timezone:
+                tz_name = remote_timezone
 
     if tz_name:
         timezone = get_timezone(tz_name)

{clickhouse-driver-0.2.7 → clickhouse-driver-0.2.9}/clickhouse_driver/columns/enumcolumn.py

@@ -1,20 +1,24 @@
 from enum import Enum
+from collections import OrderedDict
 
 from .. import errors
 from .intcolumn import IntColumn
 
+invalid_names_for_python_enum = frozenset(['mro', ''])
+
 
 class EnumColumn(IntColumn):
     py_types = (Enum, int, str)
 
-    def __init__(self, enum_cls, **kwargs):
-        self.enum_cls = enum_cls
+    def __init__(self, name_by_value, value_by_name, **kwargs):
+        self.name_by_value = name_by_value
+        self.value_by_name = value_by_name
         super(EnumColumn, self).__init__(**kwargs)
 
     def before_write_items(self, items, nulls_map=None):
         null_value = self.null_value
-
-        enum_cls = self.enum_cls
+        name_by_value = self.name_by_value
+        value_by_name = self.value_by_name
 
         for i, item in enumerate(items):
             if nulls_map and nulls_map[i]:
@@ -26,15 +30,15 @@ class EnumColumn(IntColumn):
             # Check real enum value
             try:
                 if isinstance(source_value, str):
-                    items[i] = enum_cls[source_value].value
+                    items[i] = value_by_name[source_value]
                 else:
-                    items[i] = enum_cls(source_value).value
+                    items[i] = value_by_name[name_by_value[source_value]]
             except (ValueError, KeyError):
                 choices = ', '.join(
-                    "'{}' = {}".format(x.name.replace("'", r"\'"), x.value)
-                    for x in enum_cls
+                    "'{}' = {}".format(name.replace("'", r"\'"), value)
+                    for name, value in value_by_name.items()
                 )
-                enum_str = '{}({})'.format(enum_cls.__name__, choices)
+                enum_str = '{}({})'.format(self.ch_type, choices)
 
                 raise errors.LogicalError(
                     "Unknown element '{}' for type {}"
@@ -42,13 +46,13 @@ class EnumColumn(IntColumn):
                 )
 
     def after_read_items(self, items, nulls_map=None):
-        enum_cls = self.enum_cls
+        name_by_value = self.name_by_value
 
         if nulls_map is None:
-            return tuple(enum_cls(item).name for item in items)
+            return tuple(name_by_value[item] for item in items)
         else:
             return tuple(
-                (None if is_null else enum_cls(items[i]).name)
+                (None if is_null else name_by_value[items[i]])
                 for i, is_null in enumerate(nulls_map)
             )
 
@@ -73,11 +77,13 @@ def create_enum_column(spec, column_options):
         params = spec[7:-1]
         cls = Enum16Column
 
-    return cls(Enum(cls.ch_type, _parse_options(params)), **column_options)
+    name_by_value, value_by_name = _parse_options(params)
+
+    return cls(name_by_value, value_by_name, **column_options)
 
 
 def _parse_options(option_string):
-    options = dict()
+    name_by_value, value_by_name = {}, OrderedDict()
     after_name = False
     escaped = False
     quote_character = None
@@ -93,7 +99,9 @@ def _parse_options(option_string):
             if ch in (' ', '='):
                 pass
             elif ch == ',':
-                options[name] = int(value)
+                value = int(value)
+                name_by_value[value] = name
+                value_by_name[name] = value
                 after_name = False
                 name = ''
                 value = ''  # reset before collecting new option
@@ -114,6 +122,8 @@ def _parse_options(option_string):
                 quote_character = ch
 
     if after_name:
-        options.setdefault(name, int(value))  # append word after last comma
+        value = int(value)
+        name_by_value[value] = name
+        value_by_name[name] = value
 
-    return options
+    return name_by_value, value_by_name

{clickhouse-driver-0.2.7 → clickhouse-driver-0.2.9}/clickhouse_driver/columns/mapcolumn.py

@@ -31,6 +31,9 @@ class MapColumn(Column):
         self.value_column.write_state_prefix(buf)
 
     def read_items(self, n_items, buf):
+        if not n_items:
+            return [{}]
+
         offsets = list(self.offset_column.read_items(n_items, buf))
         last_offset = offsets[-1]
         keys = self.key_column.read_data(last_offset, buf)

{clickhouse-driver-0.2.7 → clickhouse-driver-0.2.9}/clickhouse_driver/columns/numpy/datetimecolumn.py

@@ -33,7 +33,9 @@ class NumpyDateTimeColumnBase(NumpyColumn):
             ts = items
         else:
             timezone = self.timezone if self.timezone else self.local_timezone
-            ts = pd.to_datetime(items).tz_localize(timezone)
+            ts = pd.to_datetime(items)
+            if not getattr(ts.dtype, 'tz', None):
+                ts = ts.tz_localize(timezone)
 
         ts = ts.tz_convert('UTC')
         return ts.tz_localize(None).to_numpy(self.datetime_dtype)
@@ -133,8 +135,9 @@ def create_numpy_datetime_column(spec, column_options):
         offset_naive = False
     else:
         if not context.settings.get('use_client_time_zone', False):
-            if local_tz_name != context.server_info.timezone:
-                tz_name = context.server_info.timezone
+            remote_timezone = context.server_info.get_timezone()
+            if local_tz_name != remote_timezone:
+                tz_name = remote_timezone
 
     timezone = get_timezone(tz_name) if tz_name else None
     local_timezone = get_timezone(local_tz_name) if local_tz_name else None

{clickhouse-driver-0.2.7 → clickhouse-driver-0.2.9}/clickhouse_driver/columns/util.py

@@ -37,12 +37,13 @@ def get_inner_columns(spec):
 
 
 def get_inner_columns_with_types(spec):
+    spec = spec.strip()
     brackets = 0
     prev_comma = 0
     prev_space = 0
 
     columns = []
-    for i, x in enumerate(spec + ','):
+    for i, x in enumerate(spec.strip() + ','):
         if x == ',':
             if brackets == 0:
                 columns.append((

{clickhouse-driver-0.2.7 → clickhouse-driver-0.2.9}/clickhouse_driver/connection.py

@@ -53,11 +53,15 @@ class ServerInfo(object):
         self.version_patch = version_patch
         self.revision = revision
         self.timezone = timezone
+        self.session_timezone = None
         self.display_name = display_name
         self.used_revision = used_revision
 
         super(ServerInfo, self).__init__()
 
+    def get_timezone(self):
+        return self.session_timezone or self.timezone
+
     def version_tuple(self):
         return self.version_major, self.version_minor, self.version_patch
 
@@ -301,20 +305,19 @@ class Connection(object):
     def _create_ssl_context(self, ssl_options):
         purpose = ssl.Purpose.SERVER_AUTH
 
-        version = ssl_options.get('ssl_version', ssl.PROTOCOL_TLS)
+        version = ssl_options.get('ssl_version', ssl.PROTOCOL_TLS_CLIENT)
         context = ssl.SSLContext(version)
         context.check_hostname = self.verify_cert
 
         if 'ca_certs' in ssl_options:
             context.load_verify_locations(ssl_options['ca_certs'])
         elif ssl_options.get('cert_reqs') != ssl.CERT_NONE:
-            context.load_default_certs(purpose
-                                       )
+            context.load_default_certs(purpose)
         if 'ciphers' in ssl_options:
             context.set_ciphers(ssl_options['ciphers'])
 
         if 'cert_reqs' in ssl_options:
-            context.options = ssl_options['cert_reqs']
+            context.verify_mode = ssl_options['cert_reqs']
 
         if 'certfile' in ssl_options:
             keyfile = ssl_options.get('keyfile')
@@ -613,6 +616,12 @@ class Connection(object):
         elif packet_type == ServerPacketTypes.PROFILE_EVENTS:
             packet.block = self.receive_data(may_be_compressed=False)
 
+        elif packet_type == ServerPacketTypes.TIMEZONE_UPDATE:
+            timezone = read_binary_str(self.fin)
+            if timezone:
+                logger.info('Server timezone changed to %s', timezone)
+                self.server_info.session_timezone = timezone
+
         else:
             message = 'Unknown packet {} from server {}'.format(
                 packet_type, self.get_description()

{clickhouse-driver-0.2.7 → clickhouse-driver-0.2.9}/clickhouse_driver/defines.py

@@ -33,6 +33,9 @@ DBMS_MIN_PROTOCOL_VERSION_WITH_PARAMETERS = 54459
 DBMS_MIN_PROTOCOL_VERSION_WITH_SERVER_QUERY_TIME_IN_PROGRESS = 54460
 DBMS_MIN_PROTOCOL_VERSION_WITH_PASSWORD_COMPLEXITY_RULES = 54461
 DBMS_MIN_REVISION_WITH_INTERSERVER_SECRET_V2 = 54462
+DBMS_MIN_PROTOCOL_VERSION_WITH_TOTAL_BYTES_IN_PROGRESS = 54463
+DBMS_MIN_PROTOCOL_VERSION_WITH_TIMEZONE_UPDATES = 54464
+DBMS_MIN_REVISION_WITH_SYSTEM_KEYWORDS_TABLE = 54468
 
 # Timeouts
 DBMS_DEFAULT_CONNECT_TIMEOUT_SEC = 10
@@ -48,7 +51,7 @@ CLIENT_NAME = 'python-driver'
 CLIENT_VERSION_MAJOR = 20
 CLIENT_VERSION_MINOR = 10
 CLIENT_VERSION_PATCH = 2
-CLIENT_REVISION = DBMS_MIN_REVISION_WITH_INTERSERVER_SECRET_V2
+CLIENT_REVISION = DBMS_MIN_REVISION_WITH_SYSTEM_KEYWORDS_TABLE
 
 BUFFER_SIZE = 1048576
 

{clickhouse-driver-0.2.7 → clickhouse-driver-0.2.9}/clickhouse_driver/numpy/helpers.py

@@ -1,13 +1,16 @@
 import numpy as np
 import pandas as pd
+from pandas.core.arrays import ExtensionArray
 
 
 def column_chunks(columns, n):
     for column in columns:
-        if not isinstance(column, (np.ndarray, pd.DatetimeIndex)):
+        if not isinstance(
+            column, (np.ndarray, pd.DatetimeIndex, ExtensionArray)
+        ):
             raise TypeError(
                 'Unsupported column type: {}. '
-                'ndarray/DatetimeIndex is expected.'
+                'ndarray/DatetimeIndex/ExtensionArray is expected.'
                 .format(type(column))
             )
 

{clickhouse-driver-0.2.7 → clickhouse-driver-0.2.9}/clickhouse_driver/progress.py

@@ -6,7 +6,8 @@ class Progress(object):
     def __init__(self):
         self.rows = 0
         self.bytes = 0
-        self.total_rows = 0
+        self.total_rows = 0  # total_rows_to_read
+        self.total_bytes = 0  # total_bytes_to_read
         self.written_rows = 0
         self.written_bytes = 0
         self.elapsed_ns = 0
@@ -21,6 +22,10 @@ class Progress(object):
         if revision >= defines.DBMS_MIN_REVISION_WITH_TOTAL_ROWS_IN_PROGRESS:
             self.total_rows = read_varint(fin)
 
+        if revision >= defines. \
+                DBMS_MIN_PROTOCOL_VERSION_WITH_TOTAL_BYTES_IN_PROGRESS:
+            self.total_bytes = read_varint(fin)
+
         if revision >= defines.DBMS_MIN_REVISION_WITH_CLIENT_WRITE_INFO:
             self.written_rows = read_varint(fin)
             self.written_bytes = read_varint(fin)
@@ -33,6 +38,7 @@ class Progress(object):
         self.rows += another_progress.rows
         self.bytes += another_progress.bytes
         self.total_rows += another_progress.total_rows
+        self.total_bytes += another_progress.total_bytes
         self.written_rows += another_progress.written_rows
         self.written_bytes += another_progress.written_bytes
         self.elapsed_ns += another_progress.elapsed_ns

{clickhouse-driver-0.2.7 → clickhouse-driver-0.2.9}/clickhouse_driver/protocol.py

@@ -29,7 +29,10 @@ class ClientPacketTypes(object):
 
     @classmethod
     def to_str(cls, packet):
-        return 'Unknown packet' if packet > 5 else cls._types_str[packet]
+        try:
+            return cls._types_str[packet]
+        except IndexError:
+            return 'Unknown packet'
 
 
 class ServerPacketTypes(object):
@@ -81,15 +84,28 @@ class ServerPacketTypes(object):
     # Packet with profile events from server.
     PROFILE_EVENTS = 14
 
+    MERGE_TREE_ALL_RANGES_ANNOUNCEMENT = 15
+
+    # Request from a MergeTree replica to a coordinator
+    MERGE_TREE_READ_TASK_REQUEST = 16
+
+    # Receive server's (session-wide) default timezone
+    TIMEZONE_UPDATE = 17
+
     _types_str = [
         'Hello', 'Data', 'Exception', 'Progress', 'Pong', 'EndOfStream',
         'ProfileInfo', 'Totals', 'Extremes', 'TablesStatusResponse', 'Log',
-        'TableColumns', 'PartUUIDs', 'ReadTaskRequest', 'ProfileEvents'
+        'TableColumns', 'PartUUIDs', 'ReadTaskRequest', 'ProfileEvents',
+        'MergeTreeAllRangesAnnouncement', 'MergeTreeReadTaskRequest',
+        'TimezoneUpdate'
     ]
 
     @classmethod
     def to_str(cls, packet):
-        return 'Unknown packet' if packet > 14 else cls._types_str[packet]
+        try:
+            return cls._types_str[packet]
+        except IndexError:
+            return 'Unknown packet'
 
     @classmethod
     def strings_in_message(cls, packet):

{clickhouse-driver-0.2.7 → clickhouse-driver-0.2.9}/clickhouse_driver/streams/native.py

@@ -1,3 +1,5 @@
+import logging
+
 from ..block import ColumnOrientedBlock, BlockInfo
 from ..columns.service import read_column, write_column
 from ..reader import read_binary_str, read_binary_uint8
@@ -5,6 +7,8 @@ from ..varint import write_varint, read_varint
 from ..writer import write_binary_str, write_binary_uint8
 from .. import defines
 
+logger = logging.getLogger(__name__)
+
 
 class BlockOutputStream(object):
     def __init__(self, fout, context):
@@ -40,6 +44,7 @@ class BlockOutputStream(object):
                     # We write always sparse data without custom serialization.
                     write_binary_uint8(0, self.fout)
 
+                logger.debug('Writing column %s', col_name)
                 write_column(self.context, col_name, col_type, items,
                              self.fout, types_check=block.types_check)
 
@@ -80,6 +85,7 @@ class BlockInputStream(object):
                 has_custom_serialization = bool(read_binary_uint8(self.fin))
 
             if n_rows:
+                logger.debug('Reading column %s', column_name)
                 column = read_column(
                     self.context, column_type, n_rows,
                     self.fin, use_numpy=use_numpy,

{clickhouse-driver-0.2.7 → clickhouse-driver-0.2.9}/clickhouse_driver/util/escape.py

@@ -21,7 +21,7 @@ escape_chars_map = {
 
 
 def escape_datetime(item, context):
-    server_tz = timezone(context.server_info.timezone)
+    server_tz = timezone(context.server_info.get_timezone())
 
     if item.tzinfo is not None:
         item = item.astimezone(server_tz)