clickhouse-driver 0.2.4__cp38-cp38-musllinux_1_1_i686.whl → 0.2.8__cp38-cp38-musllinux_1_1_i686.whl

clickhouse_driver/connection.py

@@ -3,6 +3,7 @@ import socket
 import ssl
 from collections import deque
 from contextlib import contextmanager
+from sys import platform
 from time import time
 from urllib.parse import urlparse
 
@@ -19,11 +20,12 @@ from .log import log_block
 from .progress import Progress
 from .protocol import Compression, ClientPacketTypes, ServerPacketTypes
 from .queryprocessingstage import QueryProcessingStage
-from .reader import read_binary_str
+from .reader import read_binary_str, read_binary_uint64
 from .readhelpers import read_exception
-from .settings.writer import write_settings
+from .settings.writer import write_settings, SettingsFlags
 from .streams.native import BlockInputStream, BlockOutputStream
 from .util.compat import threading
+from .util.escape import escape_params
 from .varint import write_varint, read_varint
 from .writer import write_binary_str
 
@@ -44,7 +46,7 @@ class Packet(object):
 
 class ServerInfo(object):
     def __init__(self, name, version_major, version_minor, version_patch,
-                 revision, timezone, display_name):
+                 revision, timezone, display_name, used_revision):
         self.name = name
         self.version_major = version_major
         self.version_minor = version_minor
@@ -52,6 +54,7 @@ class ServerInfo(object):
         self.revision = revision
         self.timezone = timezone
         self.display_name = display_name
+        self.used_revision = used_revision
 
         super(ServerInfo, self).__init__()
 
@@ -66,6 +69,7 @@ class ServerInfo(object):
             ('name', self.name),
             ('version', version),
             ('revision', self.revision),
+            ('used revision', self.used_revision),
             ('timezone', self.timezone),
             ('display_name', self.display_name)
         ]
@@ -113,12 +117,26 @@ class Connection(object):
     :param ciphers: see :func:`ssl.wrap_socket` docs.
     :param keyfile: see :func:`ssl.wrap_socket` docs.
     :param certfile: see :func:`ssl.wrap_socket` docs.
+    :param server_hostname: Hostname to use in SSL Wrapper construction.
+                            Defaults to `None` which will send the passed
+                            host param during SSL initialization. This param
+                            may be used when connecting over an SSH tunnel
+                            to correctly identify the desired server via SNI.
     :param alt_hosts: list of alternative hosts for connection.
                       Example: alt_hosts=host1:port1,host2:port2.
     :param settings_is_important: ``False`` means unknown settings will be
                                   ignored, ``True`` means that the query will
                                   fail with UNKNOWN_SETTING error.
                                   Defaults to ``False``.
+    :param tcp_keepalive: enables `TCP keepalive <https://tldp.org/HOWTO/
+                          TCP-Keepalive-HOWTO/overview.html>`_ on established
+                          connection. If is set to ``True``` system keepalive
+                          settings are used. You can also specify custom
+                          keepalive setting with tuple:
+                          ``(idle_time_sec, interval_sec, probes)``.
+                          Defaults to ``False``.
+    :param client_revision: can be used for client version downgrading.
+                          Defaults to ``None``.
     """
 
     def __init__(
@@ -135,8 +153,11 @@ class Connection(object):
             # Secure socket parameters.
             verify=True, ssl_version=None, ca_certs=None, ciphers=None,
             keyfile=None, certfile=None,
+            server_hostname=None,
             alt_hosts=None,
             settings_is_important=False,
+            tcp_keepalive=False,
+            client_revision=None
     ):
         if secure:
             default_port = defines.DEFAULT_SECURE_PORT
@@ -158,6 +179,10 @@ class Connection(object):
         self.send_receive_timeout = send_receive_timeout
         self.sync_request_timeout = sync_request_timeout
         self.settings_is_important = settings_is_important
+        self.tcp_keepalive = tcp_keepalive
+        self.client_revision = min(
+            client_revision or defines.CLIENT_REVISION, defines.CLIENT_REVISION
+        )
 
         self.secure_socket = secure
         self.verify_cert = verify
@@ -176,6 +201,8 @@ class Connection(object):
 
         self.ssl_options = ssl_options
 
+        self.server_hostname = server_hostname
+
         # Use LZ4 compression by default.
         if compression is True:
             compression = 'lz4'
@@ -209,6 +236,14 @@ class Connection(object):
 
         super(Connection, self).__init__()
 
+    def __repr__(self):
+        dsn = '%s://%s:***@%s:%s/%s' % (
+            'clickhouses' if self.secure_socket else 'clickhouse',
+            self.user, self.host, self.port, self.database
+        ) if self.connected else '(not connected)'
+
+        return '<Connection(dsn=%s, compression=%s)>' % (dsn, self.compression)
+
     def get_description(self):
         return '{}:{}'.format(self.host, self.port)
 
@@ -247,7 +282,8 @@ class Connection(object):
 
                 if self.secure_socket:
                     ssl_context = self._create_ssl_context(ssl_options)
-                    sock = ssl_context.wrap_socket(sock, server_hostname=host)
+                    sock = ssl_context.wrap_socket(
+                        sock, server_hostname=self.server_hostname or host)
 
                 sock.connect(sa)
                 return sock
@@ -267,6 +303,7 @@ class Connection(object):
 
         version = ssl_options.get('ssl_version', ssl.PROTOCOL_TLS)
         context = ssl.SSLContext(version)
+        context.check_hostname = self.verify_cert
 
         if 'ca_certs' in ssl_options:
             context.load_verify_locations(ssl_options['ca_certs'])
@@ -277,7 +314,7 @@ class Connection(object):
             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')
@@ -293,6 +330,8 @@ class Connection(object):
 
         # performance tweak
         self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        if self.tcp_keepalive:
+            self._set_keepalive()
 
         self.fin = BufferedSocketReader(self.socket, defines.BUFFER_SIZE)
         self.fout = BufferedSocketWriter(self.socket, defines.BUFFER_SIZE)
@@ -300,10 +339,42 @@ class Connection(object):
         self.send_hello()
         self.receive_hello()
 
+        revision = self.server_info.used_revision
+        if revision >= defines.DBMS_MIN_PROTOCOL_VERSION_WITH_ADDENDUM:
+            self.send_addendum()
+
         self.block_in = self.get_block_in_stream()
         self.block_in_raw = BlockInputStream(self.fin, self.context)
         self.block_out = self.get_block_out_stream()
 
+    def _set_keepalive(self):
+        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+
+        if not isinstance(self.tcp_keepalive, tuple):
+            return
+
+        idle_time_sec, interval_sec, probes = self.tcp_keepalive
+
+        if platform == 'linux' or platform == 'win32':
+            # This should also work for Windows
+            # starting with Windows 10, version 1709.
+            self.socket.setsockopt(
+                socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, idle_time_sec
+            )
+            self.socket.setsockopt(
+                socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, interval_sec
+            )
+            self.socket.setsockopt(
+                socket.IPPROTO_TCP, socket.TCP_KEEPCNT, probes
+            )
+
+        elif platform == 'darwin':
+            TCP_KEEPALIVE = 0x10
+            # Only interval is available in mac os.
+            self.socket.setsockopt(
+                socket.IPPROTO_TCP, TCP_KEEPALIVE, interval_sec
+            )
+
     def _format_connection_error(self, e, host, port):
         err = (e.strerror + ' ') if e.strerror else ''
         return err + '({}:{})'.format(host, port)
@@ -393,7 +464,7 @@ class Connection(object):
         write_varint(defines.CLIENT_VERSION_MINOR, self.fout)
         # NOTE For backward compatibility of the protocol,
         # client cannot send its version_patch.
-        write_varint(defines.CLIENT_REVISION, self.fout)
+        write_varint(self.client_revision, self.fout)
         write_binary_str(self.database, self.fout)
         write_binary_str(self.user, self.fout)
         write_binary_str(self.password, self.fout)
@@ -409,25 +480,38 @@ class Connection(object):
             server_version_minor = read_varint(self.fin)
             server_revision = read_varint(self.fin)
 
+            used_revision = min(self.client_revision, server_revision)
+
             server_timezone = None
-            if server_revision >= \
+            if used_revision >= \
                     defines.DBMS_MIN_REVISION_WITH_SERVER_TIMEZONE:
                 server_timezone = read_binary_str(self.fin)
 
             server_display_name = ''
-            if server_revision >= \
+            if used_revision >= \
                     defines.DBMS_MIN_REVISION_WITH_SERVER_DISPLAY_NAME:
                 server_display_name = read_binary_str(self.fin)
 
             server_version_patch = server_revision
-            if server_revision >= \
+            if used_revision >= \
                     defines.DBMS_MIN_REVISION_WITH_VERSION_PATCH:
                 server_version_patch = read_varint(self.fin)
 
+            if used_revision >= defines. \
+                    DBMS_MIN_PROTOCOL_VERSION_WITH_PASSWORD_COMPLEXITY_RULES:
+                rules_size = read_varint(self.fin)
+                for _i in range(rules_size):
+                    read_binary_str(self.fin)  # original_pattern
+                    read_binary_str(self.fin)  # exception_message
+
+            if used_revision >= defines. \
+                    DBMS_MIN_REVISION_WITH_INTERSERVER_SECRET_V2:
+                read_binary_uint64(self.fin)  # read_nonce
+
             self.server_info = ServerInfo(
                 server_name, server_version_major, server_version_minor,
                 server_version_patch, server_revision,
-                server_timezone, server_display_name
+                server_timezone, server_display_name, used_revision
             )
             self.context.server_info = self.server_info
 
@@ -446,6 +530,14 @@ class Connection(object):
             self.disconnect()
             raise errors.UnexpectedPacketFromServerError(message)
 
+    def send_addendum(self):
+        revision = self.server_info.used_revision
+
+        if revision >= defines.DBMS_MIN_PROTOCOL_VERSION_WITH_QUOTA_KEY:
+            write_binary_str(
+                self.context.client_settings['quota_key'], self.fout
+            )
+
     def ping(self):
         timeout = self.sync_request_timeout
 
@@ -550,7 +642,7 @@ class Connection(object):
             return BlockOutputStream(self.fout, self.context)
 
     def receive_data(self, may_be_compressed=True, may_be_use_numpy=False):
-        revision = self.server_info.revision
+        revision = self.server_info.used_revision
 
         if revision >= defines.DBMS_MIN_REVISION_WITH_TEMPORARY_TABLES:
             read_binary_str(self.fin)
@@ -564,7 +656,7 @@ class Connection(object):
 
     def receive_progress(self):
         progress = Progress()
-        progress.read(self.server_info.revision, self.fin)
+        progress.read(self.server_info, self.fin)
         return progress
 
     def receive_profile_info(self):
@@ -580,14 +672,14 @@ class Connection(object):
         start = time()
         write_varint(ClientPacketTypes.DATA, self.fout)
 
-        revision = self.server_info.revision
+        revision = self.server_info.used_revision
         if revision >= defines.DBMS_MIN_REVISION_WITH_TEMPORARY_TABLES:
             write_binary_str(table_name, self.fout)
 
         self.block_out.write(block)
         logger.debug('Block "%s" send time: %f', table_name, time() - start)
 
-    def send_query(self, query, query_id=None):
+    def send_query(self, query, query_id=None, params=None):
         if not self.connected:
             self.connect()
 
@@ -595,9 +687,10 @@ class Connection(object):
 
         write_binary_str(query_id or '', self.fout)
 
-        revision = self.server_info.revision
+        revision = self.server_info.used_revision
         if revision >= defines.DBMS_MIN_REVISION_WITH_CLIENT_INFO:
-            client_info = ClientInfo(self.client_name, self.context)
+            client_info = ClientInfo(self.client_name, self.context,
+                                     client_revision=self.client_revision)
             client_info.query_kind = ClientInfo.QueryKind.INITIAL_QUERY
 
             client_info.write(revision, self.fout)
@@ -606,8 +699,11 @@ class Connection(object):
             revision >= defines
             .DBMS_MIN_REVISION_WITH_SETTINGS_SERIALIZED_AS_STRINGS
         )
+        settings_flags = 0
+        if self.settings_is_important:
+            settings_flags |= SettingsFlags.IMPORTANT
         write_settings(self.context.settings, self.fout, settings_as_strings,
-                       self.settings_is_important)
+                       settings_flags)
 
         if revision >= defines.DBMS_MIN_REVISION_WITH_INTERSERVER_SECRET:
             write_binary_str('', self.fout)
@@ -617,6 +713,16 @@ class Connection(object):
 
         write_binary_str(query, self.fout)
 
+        if revision >= defines.DBMS_MIN_PROTOCOL_VERSION_WITH_PARAMETERS:
+            if self.context.client_settings['server_side_params']:
+                # Always settings_as_strings = True
+                escaped = escape_params(
+                    params or {}, self.context, for_server=True
+                )
+            else:
+                escaped = {}
+            write_settings(escaped, self.fout, True, SettingsFlags.CUSTOM)
+
         logger.debug('Query: %s', query)
 
         self.fout.flush()

clickhouse_driver/defines.py

@@ -25,6 +25,14 @@ DBMS_MIN_PROTOCOL_VERSION_WITH_DISTRIBUTED_DEPTH = 54448
 DBMS_MIN_PROTOCOL_VERSION_WITH_INITIAL_QUERY_START_TIME = 54449
 DBMS_MIN_PROTOCOL_VERSION_WITH_INCREMENTAL_PROFILE_EVENTS = 54451
 DBMS_MIN_REVISION_WITH_PARALLEL_REPLICAS = 54453
+DBMS_MIN_REVISION_WITH_CUSTOM_SERIALIZATION = 54454
+DBMS_MIN_PROTOCOL_VERSION_WITH_PROFILE_EVENTS_IN_INSERT = 54456
+DBMS_MIN_PROTOCOL_VERSION_WITH_ADDENDUM = 54458
+DBMS_MIN_PROTOCOL_VERSION_WITH_QUOTA_KEY = 54458
+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
 
 # Timeouts
 DBMS_DEFAULT_CONNECT_TIMEOUT_SEC = 10
@@ -40,7 +48,7 @@ CLIENT_NAME = 'python-driver'
 CLIENT_VERSION_MAJOR = 20
 CLIENT_VERSION_MINOR = 10
 CLIENT_VERSION_PATCH = 2
-CLIENT_REVISION = 54453
+CLIENT_REVISION = DBMS_MIN_REVISION_WITH_INTERSERVER_SECRET_V2
 
 BUFFER_SIZE = 1048576
 

clickhouse_driver/log.py

@@ -2,7 +2,8 @@ import logging
 
 logger = logging.getLogger(__name__)
 
-
+# Keep in sync with ClickHouse priorities
+# https://github.com/ClickHouse/ClickHouse/blob/master/src/Interpreters/InternalTextLogsQueue.cpp
 log_priorities = (
     'Unknown',
     'Fatal',
@@ -12,9 +13,12 @@ log_priorities = (
     'Notice',
     'Information',
     'Debug',
-    'Trace'
+    'Trace',
+    'Test',
 )
 
+num_priorities = len(log_priorities)
+
 
 def log_block(block):
     if block is None:
@@ -25,7 +29,7 @@ def log_block(block):
     for row in block.get_rows():
         row = dict(zip(column_names, row))
 
-        if 1 <= row['priority'] <= 8:
+        if 1 <= row['priority'] <= num_priorities:
             priority = log_priorities[row['priority']]
         else:
             priority = row[0]

clickhouse_driver/progress.py

@@ -9,14 +9,15 @@ class Progress(object):
         self.total_rows = 0
         self.written_rows = 0
         self.written_bytes = 0
+        self.elapsed_ns = 0
 
         super(Progress, self).__init__()
 
-    def read(self, server_revision, fin):
+    def read(self, server_info, fin):
         self.rows = read_varint(fin)
         self.bytes = read_varint(fin)
 
-        revision = server_revision
+        revision = server_info.used_revision
         if revision >= defines.DBMS_MIN_REVISION_WITH_TOTAL_ROWS_IN_PROGRESS:
             self.total_rows = read_varint(fin)
 
@@ -24,9 +25,14 @@ class Progress(object):
             self.written_rows = read_varint(fin)
             self.written_bytes = read_varint(fin)
 
+        if revision >= defines. \
+                DBMS_MIN_PROTOCOL_VERSION_WITH_SERVER_QUERY_TIME_IN_PROGRESS:
+            self.elapsed_ns = read_varint(fin)
+
     def increment(self, another_progress):
         self.rows += another_progress.rows
         self.bytes += another_progress.bytes
         self.total_rows += another_progress.total_rows
         self.written_rows += another_progress.written_rows
         self.written_bytes += another_progress.written_bytes
+        self.elapsed_ns += another_progress.elapsed_ns

clickhouse_driver/settings/writer.py

@@ -7,13 +7,18 @@ from .available import settings as available_settings
 logger = logging.getLogger(__name__)
 
 
-def write_settings(settings, buf, settings_as_strings, is_important=False):
+class SettingsFlags:
+    IMPORTANT = 0x1
+    CUSTOM = 0x2
+
+
+def write_settings(settings, buf, settings_as_strings, flags):
     for setting, value in (settings or {}).items():
         # If the server support settings as string we do not need to know
         # anything about them, so we can write any setting.
         if settings_as_strings:
             write_binary_str(setting, buf)
-            write_binary_uint8(int(is_important), buf)
+            write_binary_uint8(flags, buf)
             write_binary_str(str(value), buf)
 
         else:

clickhouse_driver/streams/native.py

@@ -1,8 +1,8 @@
 from ..block import ColumnOrientedBlock, BlockInfo
 from ..columns.service import read_column, write_column
-from ..reader import read_binary_str
+from ..reader import read_binary_str, read_binary_uint8
 from ..varint import write_varint, read_varint
-from ..writer import write_binary_str
+from ..writer import write_binary_str, write_binary_uint8
 from .. import defines
 
 
@@ -14,7 +14,7 @@ class BlockOutputStream(object):
         super(BlockOutputStream, self).__init__()
 
     def write(self, block):
-        revision = self.context.server_info.revision
+        revision = self.context.server_info.used_revision
         if revision >= defines.DBMS_MIN_REVISION_WITH_BLOCK_INFO:
             block.info.write(self.fout)
 
@@ -35,6 +35,11 @@ class BlockOutputStream(object):
                 except IndexError:
                     raise ValueError('Different rows length')
 
+                if revision >= \
+                        defines.DBMS_MIN_REVISION_WITH_CUSTOM_SERIALIZATION:
+                    # We write always sparse data without custom serialization.
+                    write_binary_uint8(0, self.fout)
+
                 write_column(self.context, col_name, col_type, items,
                              self.fout, types_check=block.types_check)
 
@@ -54,7 +59,7 @@ class BlockInputStream(object):
     def read(self, use_numpy=None):
         info = BlockInfo()
 
-        revision = self.context.server_info.revision
+        revision = self.context.server_info.used_revision
         if revision >= defines.DBMS_MIN_REVISION_WITH_BLOCK_INFO:
             info.read(self.fin)
 
@@ -70,9 +75,16 @@ class BlockInputStream(object):
             names.append(column_name)
             types.append(column_type)
 
+            has_custom_serialization = False
+            if revision >= defines.DBMS_MIN_REVISION_WITH_CUSTOM_SERIALIZATION:
+                has_custom_serialization = bool(read_binary_uint8(self.fin))
+
             if n_rows:
-                column = read_column(self.context, column_type, n_rows,
-                                     self.fin, use_numpy=use_numpy)
+                column = read_column(
+                    self.context, column_type, n_rows,
+                    self.fin, use_numpy=use_numpy,
+                    has_custom_serialization=has_custom_serialization
+                )
                 data.append(column)
 
         if self.context.client_settings['use_numpy']:

clickhouse_driver/util/compat.py

@@ -5,6 +5,18 @@ try:
 except ImportError:
     import dummy_threading as threading  # noqa: F401
 
+import json  # noqa: F401
+try:
+    import orjson as json  # noqa: F811
+except ImportError:
+    pass
+
+try:
+    import ujson as json  # noqa: F811,F401
+except ImportError:
+    pass
+
+
 try:
     # since tzlocal 4.0+
     # this will avoid warning for get_localzone().key

clickhouse_driver/util/escape.py

@@ -1,5 +1,6 @@
-from datetime import date, datetime
+from datetime import date, datetime, time
 from enum import Enum
+from functools import wraps
 from uuid import UUID
 
 from pytz import timezone
@@ -28,7 +29,24 @@ def escape_datetime(item, context):
     return "'%s'" % item.strftime('%Y-%m-%d %H:%M:%S')
 
 
-def escape_param(item, context):
+def maybe_enquote_for_server(f):
+    @wraps(f)
+    def wrapper(*args, **kwargs):
+        rv = f(*args, **kwargs)
+
+        if kwargs.get('for_server'):
+            is_str = isinstance(rv, str)
+
+            if not is_str or (is_str and not rv.startswith("'")):
+                rv = "'%s'" % rv
+
+        return rv
+
+    return wrapper
+
+
+@maybe_enquote_for_server
+def escape_param(item, context, for_server=False):
     if item is None:
         return 'NULL'
 
@@ -38,17 +56,27 @@ def escape_param(item, context):
     elif isinstance(item, date):
         return "'%s'" % item.strftime('%Y-%m-%d')
 
+    elif isinstance(item, time):
+        return "'%s'" % item.strftime('%H:%M:%S')
+
     elif isinstance(item, str):
+        # We need double escaping for server-side parameters.
+        if for_server:
+            item = ''.join(escape_chars_map.get(c, c) for c in item)
         return "'%s'" % ''.join(escape_chars_map.get(c, c) for c in item)
 
     elif isinstance(item, list):
-        return "[%s]" % ', '.join(str(escape_param(x, context)) for x in item)
+        return "[%s]" % ', '.join(
+            str(escape_param(x, context, for_server=for_server)) for x in item
+        )
 
     elif isinstance(item, tuple):
-        return "(%s)" % ', '.join(str(escape_param(x, context)) for x in item)
+        return "(%s)" % ', '.join(
+            str(escape_param(x, context, for_server=for_server)) for x in item
+        )
 
     elif isinstance(item, Enum):
-        return escape_param(item.value, context)
+        return escape_param(item.value, context, for_server=for_server)
 
     elif isinstance(item, UUID):
         return "'%s'" % str(item)
@@ -57,10 +85,10 @@ def escape_param(item, context):
         return item
 
 
-def escape_params(params, context):
+def escape_params(params, context, for_server=False):
     escaped = {}
 
     for key, value in params.items():
-        escaped[key] = escape_param(value, context)
+        escaped[key] = escape_param(value, context, for_server=for_server)
 
     return escaped

{clickhouse_driver-0.2.4.dist-info → clickhouse_driver-0.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clickhouse-driver
-Version: 0.2.4
+Version: 0.2.8
 Summary: Python driver with native interface for ClickHouse
 Home-page: https://github.com/mymarilyn/clickhouse-driver
 Author: Konstantin Lebedev
@@ -9,7 +9,6 @@ License: MIT
 Project-URL: Documentation, https://clickhouse-driver.readthedocs.io
 Project-URL: Changes, https://github.com/mymarilyn/clickhouse-driver/blob/master/CHANGELOG.md
 Keywords: ClickHouse db database cloud analytics
-Platform: UNKNOWN
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -18,12 +17,11 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: SQL
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
 Classifier: Programming Language :: Python :: 3.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 :: Implementation :: PyPy
 Classifier: Topic :: Database
 Classifier: Topic :: Software Development
@@ -31,21 +29,20 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Requires-Python: >=3.4, <4
+Requires-Python: >=3.7, <4
 License-File: LICENSE
 Requires-Dist: pytz
 Requires-Dist: tzlocal
-Requires-Dist: tzlocal (<2.1) ; python_version == "3.5"
 Provides-Extra: lz4
-Requires-Dist: clickhouse-cityhash (>=1.0.2.1) ; extra == 'lz4'
+Requires-Dist: clickhouse-cityhash >=1.0.2.1 ; extra == 'lz4'
 Requires-Dist: lz4 ; (implementation_name != "pypy") and extra == 'lz4'
-Requires-Dist: lz4 (<=3.0.1) ; (implementation_name == "pypy") and extra == 'lz4'
+Requires-Dist: lz4 <=3.0.1 ; (implementation_name == "pypy") and extra == 'lz4'
 Provides-Extra: numpy
-Requires-Dist: numpy (>=1.12.0) ; extra == 'numpy'
-Requires-Dist: pandas (>=0.24.0) ; extra == 'numpy'
+Requires-Dist: numpy >=1.12.0 ; extra == 'numpy'
+Requires-Dist: pandas >=0.24.0 ; extra == 'numpy'
 Provides-Extra: zstd
 Requires-Dist: zstd ; extra == 'zstd'
-Requires-Dist: clickhouse-cityhash (>=1.0.2.1) ; extra == 'zstd'
+Requires-Dist: clickhouse-cityhash >=1.0.2.1 ; extra == 'zstd'
 
 ClickHouse Python Driver
 ========================
@@ -202,5 +199,3 @@ License
 
 ClickHouse Python Driver is distributed under the `MIT license
 <http://www.opensource.org/licenses/mit-license.php>`_.
-
-