clickhouse-orm 2.2.2__tar.gz → 3.0.1__tar.gz

clickhouse_orm-3.0.1/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: clickhouse_orm
+Version: 3.0.1
+Summary: A simple ORM for working with the Clickhouse database. Maintainance fork of infi.clickhouse_orm.
+Author-email: Oliver Margetts <oliver.margetts@gmail.com>
+Description-Content-Type: text/markdown
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Database
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: pytz
+Requires-Dist: docker==7.1.0 ; extra == "dev"
+Requires-Dist: pytest==9.0.2 ; extra == "dev"
+Requires-Dist: ruff==0.14.14 ; extra == "dev"
+Project-URL: Homepage, https://github.com/SuadeLabs/clickhouse_orm
+Project-URL: Repository, https://github.com/SuadeLabs/clickhouse_orm
+Provides-Extra: dev
+
+A fork of [infi.clikchouse_orm](https://github.com/Infinidat/infi.clickhouse_orm) aimed at more frequent maintenance and bugfixes.
+
+[![Tests](https://github.com/SuadeLabs/clickhouse_orm/actions/workflows/python-test.yml/badge.svg)](https://github.com/SuadeLabs/clickhouse_orm/actions/workflows/python-test.yml)
+![PyPI](https://img.shields.io/pypi/v/clickhouse_orm)
+
+Introduction
+============
+
+This project is simple ORM for working with the [ClickHouse database](https://clickhouse.yandex/).
+It allows you to define model classes whose instances can be written to the database and read from it.
+
+Let's jump right in with a simple example of monitoring CPU usage. First we need to define the model class,
+connect to the database and create a table for the model:
+
+```python
+from clickhouse_orm import Database, Model, DateTimeField, UInt16Field, Float32Field, Memory, F
+
+class CPUStats(Model):
+
+    timestamp = DateTimeField()
+    cpu_id = UInt16Field()
+    cpu_percent = Float32Field()
+
+    engine = Memory()
+
+db = Database('demo')
+db.create_table(CPUStats)
+```
+
+Now we can collect usage statistics per CPU, and write them to the database:
+
+```python
+import psutil, time, datetime
+
+psutil.cpu_percent(percpu=True) # first sample should be discarded
+while True:
+    time.sleep(1)
+    stats = psutil.cpu_percent(percpu=True)
+    timestamp = datetime.datetime.now()
+    db.insert([
+        CPUStats(timestamp=timestamp, cpu_id=cpu_id, cpu_percent=cpu_percent)
+        for cpu_id, cpu_percent in enumerate(stats)
+    ])
+```
+
+Querying the table is easy, using either the query builder or raw SQL:
+
+```python
+# Calculate what percentage of the time CPU 1 was over 95% busy
+queryset = CPUStats.objects_in(db)
+total = queryset.filter(CPUStats.cpu_id == 1).count()
+busy = queryset.filter(CPUStats.cpu_id == 1, CPUStats.cpu_percent > 95).count()
+print('CPU 1 was busy {:.2f}% of the time'.format(busy * 100.0 / total))
+
+# Calculate the average usage per CPU
+for row in queryset.aggregate(CPUStats.cpu_id, average=F.avg(CPUStats.cpu_percent)):
+    print('CPU {row.cpu_id}: {row.average:.2f}%'.format(row=row))
+```
+
+This and other examples can be found in the `examples` folder.
+
+To learn more please visit the [documentation](docs/toc.md).
+

clickhouse_orm-3.0.1/README.md

@@ -0,0 +1,62 @@
+A fork of [infi.clikchouse_orm](https://github.com/Infinidat/infi.clickhouse_orm) aimed at more frequent maintenance and bugfixes.
+
+[![Tests](https://github.com/SuadeLabs/clickhouse_orm/actions/workflows/python-test.yml/badge.svg)](https://github.com/SuadeLabs/clickhouse_orm/actions/workflows/python-test.yml)
+![PyPI](https://img.shields.io/pypi/v/clickhouse_orm)
+
+Introduction
+============
+
+This project is simple ORM for working with the [ClickHouse database](https://clickhouse.yandex/).
+It allows you to define model classes whose instances can be written to the database and read from it.
+
+Let's jump right in with a simple example of monitoring CPU usage. First we need to define the model class,
+connect to the database and create a table for the model:
+
+```python
+from clickhouse_orm import Database, Model, DateTimeField, UInt16Field, Float32Field, Memory, F
+
+class CPUStats(Model):
+
+    timestamp = DateTimeField()
+    cpu_id = UInt16Field()
+    cpu_percent = Float32Field()
+
+    engine = Memory()
+
+db = Database('demo')
+db.create_table(CPUStats)
+```
+
+Now we can collect usage statistics per CPU, and write them to the database:
+
+```python
+import psutil, time, datetime
+
+psutil.cpu_percent(percpu=True) # first sample should be discarded
+while True:
+    time.sleep(1)
+    stats = psutil.cpu_percent(percpu=True)
+    timestamp = datetime.datetime.now()
+    db.insert([
+        CPUStats(timestamp=timestamp, cpu_id=cpu_id, cpu_percent=cpu_percent)
+        for cpu_id, cpu_percent in enumerate(stats)
+    ])
+```
+
+Querying the table is easy, using either the query builder or raw SQL:
+
+```python
+# Calculate what percentage of the time CPU 1 was over 95% busy
+queryset = CPUStats.objects_in(db)
+total = queryset.filter(CPUStats.cpu_id == 1).count()
+busy = queryset.filter(CPUStats.cpu_id == 1, CPUStats.cpu_percent > 95).count()
+print('CPU 1 was busy {:.2f}% of the time'.format(busy * 100.0 / total))
+
+# Calculate the average usage per CPU
+for row in queryset.aggregate(CPUStats.cpu_id, average=F.avg(CPUStats.cpu_percent)):
+    print('CPU {row.cpu_id}: {row.average:.2f}%'.format(row=row))
+```
+
+This and other examples can be found in the `examples` folder.
+
+To learn more please visit the [documentation](docs/toc.md).

{clickhouse_orm-2.2.2 → clickhouse_orm-3.0.1}/clickhouse_orm/__init__.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from inspect import isclass
 
 from .database import *  # noqa: F401, F403

{clickhouse_orm-2.2.2 → clickhouse_orm-3.0.1}/clickhouse_orm/database.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import datetime
 import logging
 import re
@@ -13,13 +15,11 @@ from .utils import Page, import_submodules, parse_tsv
 logger = logging.getLogger("clickhouse_orm")
 
 
-class DatabaseException(Exception):
+class DatabaseException(Exception):  # noqa: N818
     """
     Raised when a database operation fails.
     """
 
-    pass
-
 
 class ServerError(DatabaseException):
     """
@@ -35,7 +35,7 @@ class ServerError(DatabaseException):
             # just skip custom init
             # if non-standard message format
             self.message = message
-            super(ServerError, self).__init__(message)
+            super().__init__(message)
 
     ERROR_PATTERNS = (
         # ClickHouse prior to v19.3.3
@@ -55,6 +55,14 @@ class ServerError(DatabaseException):
         """,
             re.VERBOSE | re.DOTALL,
         ),
+        # ClickHouse v21+
+        re.compile(
+            r"""
+            Code:\ (?P<code>\d+).
+            \ (?P<type1>[^ \n]+):\ (?P<msg>.+)
+        """,
+            re.VERBOSE | re.DOTALL,
+        ),
     )
 
     @classmethod
@@ -75,19 +83,21 @@ class ServerError(DatabaseException):
 
     def __str__(self):
         if self.code is not None:
-            return "{} ({})".format(self.message, self.code)
+            return f"{self.message} ({self.code})"
 
 
-class Database(object):
+class Database:
     """
     Database instances connect to a specific ClickHouse database for running queries,
     inserting data and other operations.
     """
 
+    _default_url = "http://localhost:8123/"
+
     def __init__(
         self,
         db_name,
-        db_url="http://localhost:8123/",
+        db_url=None,
         username=None,
         password=None,
         readonly=False,
@@ -111,7 +121,7 @@ class Database(object):
         - `log_statements`: when True, all database statements are logged.
         """
         self.db_name = db_name
-        self.db_url = db_url
+        self.db_url = db_url or self._default_url
         self.readonly = False
         self.timeout = timeout
         self.request_session = requests.Session()
@@ -432,7 +442,7 @@ class Database(object):
         except ServerError as e:
             logger.exception("Cannot determine server version (%s), assuming 1.1.0", e)
             ver = "1.1.0"
-        return tuple(int(n) for n in ver.split(".")) if as_tuple else ver
+        return tuple(int(n) for n in ver.split(".") if n.isdigit()) if as_tuple else ver
 
     def _is_existing_database(self):
         r = self._send("SELECT count() FROM system.databases WHERE name = '%s'" % self.db_name)

{clickhouse_orm-2.2.2 → clickhouse_orm-3.0.1}/clickhouse_orm/engines.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 
 from .utils import comma_join, get_subclass_names
@@ -5,7 +7,7 @@ from .utils import comma_join, get_subclass_names
 logger = logging.getLogger("clickhouse_orm")
 
 
-class Engine(object):
+class Engine:
     def create_table_sql(self, db):
         raise NotImplementedError()  # pragma: no cover
 
@@ -44,9 +46,9 @@ class MergeTree(Engine):
             list,
             tuple,
         ), "partition_key must be tuple or list if present"
-        assert (replica_table_path is None) == (
-            replica_name is None
-        ), "both replica_table_path and replica_name must be specified"
+        assert (replica_table_path is None) == (replica_name is None), (
+            "both replica_table_path and replica_name must be specified"
+        )
 
         # These values conflict with each other (old and new syntax of table engines.
         # So let's control only one of them is given.
@@ -145,7 +147,7 @@ class CollapsingMergeTree(MergeTree):
         partition_key=None,
         primary_key=None,
     ):
-        super(CollapsingMergeTree, self).__init__(
+        super().__init__(
             date_col,
             order_by,
             sampling_expr,
@@ -158,7 +160,7 @@ class CollapsingMergeTree(MergeTree):
         self.sign_col = sign_col
 
     def _build_sql_params(self, db):
-        params = super(CollapsingMergeTree, self)._build_sql_params(db)
+        params = super()._build_sql_params(db)
         params.append(self.sign_col)
         return params
 
@@ -176,7 +178,7 @@ class SummingMergeTree(MergeTree):
         partition_key=None,
         primary_key=None,
     ):
-        super(SummingMergeTree, self).__init__(
+        super().__init__(
             date_col,
             order_by,
             sampling_expr,
@@ -190,7 +192,7 @@ class SummingMergeTree(MergeTree):
         self.summing_cols = summing_cols
 
     def _build_sql_params(self, db):
-        params = super(SummingMergeTree, self)._build_sql_params(db)
+        params = super()._build_sql_params(db)
         if self.summing_cols:
             params.append("(%s)" % comma_join(self.summing_cols))
         return params
@@ -209,7 +211,7 @@ class ReplacingMergeTree(MergeTree):
         partition_key=None,
         primary_key=None,
     ):
-        super(ReplacingMergeTree, self).__init__(
+        super().__init__(
             date_col,
             order_by,
             sampling_expr,
@@ -222,7 +224,7 @@ class ReplacingMergeTree(MergeTree):
         self.ver_col = ver_col
 
     def _build_sql_params(self, db):
-        params = super(ReplacingMergeTree, self)._build_sql_params(db)
+        params = super()._build_sql_params(db)
         if self.ver_col:
             params.append(self.ver_col)
         return params
@@ -332,7 +334,7 @@ class Distributed(Engine):
 
     def _build_sql_params(self, db):
         if self.table_name is None:
-            raise ValueError("Cannot create {} engine: specify an underlying table".format(self.__class__.__name__))
+            raise ValueError(f"Cannot create {self.__class__.__name__} engine: specify an underlying table")
 
         params = ["`%s`" % p for p in [self.cluster, db.db_name, self.table_name]]
         if self.sharding_key:

{clickhouse_orm-2.2.2 → clickhouse_orm-3.0.1}/clickhouse_orm/fields.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import datetime
 from calendar import timegm
 from decimal import Decimal, localcontext
@@ -5,7 +7,6 @@ from ipaddress import IPv4Address, IPv6Address
 from logging import getLogger
 from uuid import UUID
 
-import iso8601
 import pytz
 from pytz import BaseTzInfo
 
@@ -27,12 +28,12 @@ class Field(FunctionOperatorsMixin):
     db_type = None  # should be overridden by concrete subclasses
 
     def __init__(self, default=None, alias=None, materialized=None, readonly=None, codec=None):
-        assert [default, alias, materialized].count(
-            None
-        ) >= 2, "Only one of default, alias and materialized parameters can be given"
-        assert (
-            alias is None or isinstance(alias, F) or isinstance(alias, str) and alias != ""
-        ), "Alias parameter must be a string or function object, if given"
+        assert [default, alias, materialized].count(None) >= 2, (
+            "Only one of default, alias and materialized parameters can be given"
+        )
+        assert alias is None or isinstance(alias, F) or isinstance(alias, str) and alias != "", (
+            "Alias parameter must be a string or function object, if given"
+        )
         assert (
             materialized is None or isinstance(materialized, F) or isinstance(materialized, str) and materialized != ""
         ), "Materialized parameter must be a string or function object, if given"
@@ -117,7 +118,7 @@ class Field(FunctionOperatorsMixin):
         elif self.default:
             default = self.to_db_string(self.default)
             sql += " DEFAULT %s" % default
-        if self.codec and db and db.has_codec_support:
+        if self.codec and db and db.has_codec_support and not self.alias:
             sql += " CODEC(%s)" % self.codec
         return sql
 
@@ -141,7 +142,6 @@ class Field(FunctionOperatorsMixin):
 
 
 class StringField(Field):
-
     class_default = ""
     db_type = "String"
 
@@ -157,10 +157,10 @@ class FixedStringField(StringField):
     def __init__(self, length, default=None, alias=None, materialized=None, readonly=None):
         self._length = length
         self.db_type = "FixedString(%d)" % length
-        super(FixedStringField, self).__init__(default, alias, materialized, readonly)
+        super().__init__(default, alias, materialized, readonly)
 
     def to_python(self, value, timezone_in_use):
-        value = super(FixedStringField, self).to_python(value, timezone_in_use)
+        value = super().to_python(value, timezone_in_use)
         return value.rstrip("\0")
 
     def validate(self, value):
@@ -171,7 +171,6 @@ class FixedStringField(StringField):
 
 
 class DateField(Field):
-
     min_value = datetime.date(1970, 1, 1)
     max_value = datetime.date(2105, 12, 31)
     class_default = min_value
@@ -198,7 +197,6 @@ class DateField(Field):
 
 
 class DateTimeField(Field):
-
     class_default = datetime.datetime.fromtimestamp(0, pytz.utc)
     db_type = "DateTime"
 
@@ -231,11 +229,8 @@ class DateTimeField(Field):
                     return datetime.datetime.utcfromtimestamp(value).replace(tzinfo=pytz.utc)
                 except ValueError:
                     pass
-            try:
-                # left the date naive in case of no tzinfo set
-                dt = iso8601.parse_date(value, default_timezone=None)
-            except iso8601.ParseError as e:
-                raise ValueError(str(e))
+            # left the date naive in case of no tzinfo set
+            dt = datetime.datetime.fromisoformat(value)
 
             # convert naive to aware
             if dt.tzinfo is None or dt.tzinfo.utcoffset(dt) is None:
@@ -316,58 +311,50 @@ class BaseIntField(Field):
 
 
 class UInt8Field(BaseIntField):
-
     min_value = 0
-    max_value = 2 ** 8 - 1
+    max_value = 2**8 - 1
     db_type = "UInt8"
 
 
 class UInt16Field(BaseIntField):
-
     min_value = 0
-    max_value = 2 ** 16 - 1
+    max_value = 2**16 - 1
     db_type = "UInt16"
 
 
 class UInt32Field(BaseIntField):
-
     min_value = 0
-    max_value = 2 ** 32 - 1
+    max_value = 2**32 - 1
     db_type = "UInt32"
 
 
 class UInt64Field(BaseIntField):
-
     min_value = 0
-    max_value = 2 ** 64 - 1
+    max_value = 2**64 - 1
     db_type = "UInt64"
 
 
 class Int8Field(BaseIntField):
-
-    min_value = -(2 ** 7)
-    max_value = 2 ** 7 - 1
+    min_value = -(2**7)
+    max_value = 2**7 - 1
     db_type = "Int8"
 
 
 class Int16Field(BaseIntField):
-
-    min_value = -(2 ** 15)
-    max_value = 2 ** 15 - 1
+    min_value = -(2**15)
+    max_value = 2**15 - 1
     db_type = "Int16"
 
 
 class Int32Field(BaseIntField):
-
-    min_value = -(2 ** 31)
-    max_value = 2 ** 31 - 1
+    min_value = -(2**31)
+    max_value = 2**31 - 1
     db_type = "Int32"
 
 
 class Int64Field(BaseIntField):
-
-    min_value = -(2 ** 63)
-    max_value = 2 ** 63 - 1
+    min_value = -(2**63)
+    max_value = 2**63 - 1
     db_type = "Int64"
 
 
@@ -389,12 +376,10 @@ class BaseFloatField(Field):
 
 
 class Float32Field(BaseFloatField):
-
     db_type = "Float32"
 
 
 class Float64Field(BaseFloatField):
-
     db_type = "Float64"
 
 
@@ -414,7 +399,7 @@ class DecimalField(Field):
             self.exp = Decimal(10) ** -self.scale  # for rounding to the required scale
             self.max_value = Decimal(10 ** (self.precision - self.scale)) - self.exp
             self.min_value = -self.max_value
-        super(DecimalField, self).__init__(default, alias, materialized, readonly)
+        super().__init__(default, alias, materialized, readonly)
 
     def to_python(self, value, timezone_in_use):
         if not isinstance(value, Decimal):
@@ -440,19 +425,19 @@ class DecimalField(Field):
 
 class Decimal32Field(DecimalField):
     def __init__(self, scale, default=None, alias=None, materialized=None, readonly=None):
-        super(Decimal32Field, self).__init__(9, scale, default, alias, materialized, readonly)
+        super().__init__(9, scale, default, alias, materialized, readonly)
         self.db_type = "Decimal32(%d)" % scale
 
 
 class Decimal64Field(DecimalField):
     def __init__(self, scale, default=None, alias=None, materialized=None, readonly=None):
-        super(Decimal64Field, self).__init__(18, scale, default, alias, materialized, readonly)
+        super().__init__(18, scale, default, alias, materialized, readonly)
         self.db_type = "Decimal64(%d)" % scale
 
 
 class Decimal128Field(DecimalField):
     def __init__(self, scale, default=None, alias=None, materialized=None, readonly=None):
-        super(Decimal128Field, self).__init__(38, scale, default, alias, materialized, readonly)
+        super().__init__(38, scale, default, alias, materialized, readonly)
         self.db_type = "Decimal128(%d)" % scale
 
 
@@ -465,7 +450,7 @@ class BaseEnumField(Field):
         self.enum_cls = enum_cls
         if default is None:
             default = list(enum_cls)[0]
-        super(BaseEnumField, self).__init__(default, alias, materialized, readonly, codec)
+        super().__init__(default, alias, materialized, readonly, codec)
 
     def to_python(self, value, timezone_in_use):
         if isinstance(value, self.enum_cls):
@@ -512,24 +497,21 @@ class BaseEnumField(Field):
 
 
 class Enum8Field(BaseEnumField):
-
     db_type = "Enum8"
 
 
 class Enum16Field(BaseEnumField):
-
     db_type = "Enum16"
 
 
 class ArrayField(Field):
-
     class_default = []
 
     def __init__(self, inner_field, default=None, alias=None, materialized=None, readonly=None, codec=None):
         assert isinstance(inner_field, Field), "The first argument of ArrayField must be a Field instance"
         assert not isinstance(inner_field, ArrayField), "Multidimensional array fields are not supported by the ORM"
         self.inner_field = inner_field
-        super(ArrayField, self).__init__(default, alias, materialized, readonly, codec)
+        super().__init__(default, alias, materialized, readonly, codec)
 
     def to_python(self, value, timezone_in_use):
         if isinstance(value, str):
@@ -556,7 +538,6 @@ class ArrayField(Field):
 
 
 class UUIDField(Field):
-
     class_default = UUID(int=0)
     db_type = "UUID"
 
@@ -579,7 +560,6 @@ class UUIDField(Field):
 
 
 class IPv4Field(Field):
-
     class_default = 0
     db_type = "IPv4"
 
@@ -596,7 +576,6 @@ class IPv4Field(Field):
 
 
 class IPv6Field(Field):
-
     class_default = 0
     db_type = "IPv6"
 
@@ -613,18 +592,17 @@ class IPv6Field(Field):
 
 
 class NullableField(Field):
-
     class_default = None
 
     def __init__(self, inner_field, default=None, alias=None, materialized=None, extra_null_values=None, codec=None):
-        assert isinstance(
-            inner_field, Field
-        ), "The first argument of NullableField must be a Field instance. Not: {}".format(inner_field)
+        assert isinstance(inner_field, Field), (
+            f"The first argument of NullableField must be a Field instance. Not: {inner_field}"
+        )
         self.inner_field = inner_field
         self._null_values = [None]
         if extra_null_values:
             self._null_values.extend(extra_null_values)
-        super(NullableField, self).__init__(default, alias, materialized, readonly=None, codec=codec)
+        super().__init__(default, alias, materialized, readonly=None, codec=codec)
 
     def to_python(self, value, timezone_in_use):
         if value == "\\N" or value in self._null_values:
@@ -648,18 +626,18 @@ class NullableField(Field):
 
 class LowCardinalityField(Field):
     def __init__(self, inner_field, default=None, alias=None, materialized=None, readonly=None, codec=None):
-        assert isinstance(
-            inner_field, Field
-        ), "The first argument of LowCardinalityField must be a Field instance. Not: {}".format(inner_field)
-        assert not isinstance(
-            inner_field, LowCardinalityField
-        ), "LowCardinality inner fields are not supported by the ORM"
-        assert not isinstance(
-            inner_field, ArrayField
-        ), "Array field inside LowCardinality are not supported by the ORM. Use Array(LowCardinality) instead"
+        assert isinstance(inner_field, Field), (
+            f"The first argument of LowCardinalityField must be a Field instance. Not: {inner_field}"
+        )
+        assert not isinstance(inner_field, LowCardinalityField), (
+            "LowCardinality inner fields are not supported by the ORM"
+        )
+        assert not isinstance(inner_field, ArrayField), (
+            "Array field inside LowCardinality are not supported by the ORM. Use Array(LowCardinality) instead"
+        )
         self.inner_field = inner_field
         self.class_default = self.inner_field.class_default
-        super(LowCardinalityField, self).__init__(default, alias, materialized, readonly, codec)
+        super().__init__(default, alias, materialized, readonly, codec)
 
     def to_python(self, value, timezone_in_use):
         return self.inner_field.to_python(value, timezone_in_use)
@@ -676,9 +654,7 @@ class LowCardinalityField(Field):
         else:
             sql = self.inner_field.get_sql(with_default_expression=False)
             logger.warning(
-                "LowCardinalityField not supported on clickhouse-server version < 19.0 using {} as fallback".format(
-                    self.inner_field.__class__.__name__
-                )
+                f"LowCardinalityField not supported on clickhouse-server version < 19.0 using {self.inner_field.__class__.__name__} as fallback"
             )
         if with_default_expression:
             sql += self._extra_params(db)

{clickhouse_orm-2.2.2 → clickhouse_orm-3.0.1}/clickhouse_orm/funcs.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from functools import wraps
 from inspect import Parameter, signature
 from types import FunctionType
@@ -86,7 +88,7 @@ def parametric(func):
     return wrapper
 
 
-class FunctionOperatorsMixin(object):
+class FunctionOperatorsMixin:
     """
     A mixin for implementing Python operators using F objects.
     """
@@ -186,7 +188,6 @@ class FunctionOperatorsMixin(object):
 
 
 class FMeta(type):
-
     FUNCTION_COMBINATORS = {
         "type_conversion": [
             {"suffix": "OrZero"},
@@ -409,7 +410,7 @@ class F(Cond, FunctionOperatorsMixin, metaclass=FMeta):
 
     @staticmethod
     def toQuarter(d, timezone=NO_VALUE):
-        return F("toQuarter", d, timezone)
+        return F("toQuarter", d, timezone) if timezone else F("toQuarter", d)
 
     @staticmethod
     def toMonth(d, timezone=NO_VALUE):
@@ -421,7 +422,7 @@ class F(Cond, FunctionOperatorsMixin, metaclass=FMeta):
 
     @staticmethod
     def toISOWeek(d, timezone=NO_VALUE):
-        return F("toISOWeek", d, timezone)
+        return F("toISOWeek", d, timezone) if timezone else F("toISOWeek", d)
 
     @staticmethod
     def toDayOfYear(d, timezone=NO_VALUE):
@@ -509,15 +510,15 @@ class F(Cond, FunctionOperatorsMixin, metaclass=FMeta):
 
     @staticmethod
     def toYYYYMM(dt, timezone=NO_VALUE):
-        return F("toYYYYMM", dt, timezone)
+        return F("toYYYYMM", dt, timezone) if timezone else F("toYYYYMM", dt)
 
     @staticmethod
     def toYYYYMMDD(dt, timezone=NO_VALUE):
-        return F("toYYYYMMDD", dt, timezone)
+        return F("toYYYYMMDD", dt, timezone) if timezone else F("toYYYYMMDD", dt)
 
     @staticmethod
     def toYYYYMMDDhhmmss(dt, timezone=NO_VALUE):
-        return F("toYYYYMMDDhhmmss", dt, timezone)
+        return F("toYYYYMMDDhhmmss", dt, timezone) if timezone else F("toYYYYMMDDhhmmss", dt)
 
     @staticmethod
     def toRelativeYearNum(d, timezone=NO_VALUE):
@@ -911,8 +912,6 @@ class F(Cond, FunctionOperatorsMixin, metaclass=FMeta):
     def replace(haystack, pattern, replacement):
         return F("replace", haystack, pattern, replacement)
 
-    replaceAll = replace
-
     @staticmethod
     def replaceAll(haystack, pattern, replacement):
         return F("replaceAll", haystack, pattern, replacement)
@@ -1649,6 +1648,16 @@ class F(Cond, FunctionOperatorsMixin, metaclass=FMeta):
     def varSamp(x):
         return F("varSamp", x)
 
+    @staticmethod
+    @aggregate
+    def stddevPop(expr):
+        return F("stddevPop", expr)
+
+    @staticmethod
+    @aggregate
+    def stddevSamp(expr):
+        return F("stddevSamp", expr)
+
     @staticmethod
     @aggregate
     @parametric

{clickhouse_orm-2.2.2 → clickhouse_orm-3.0.1}/clickhouse_orm/migrations.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 
 from .engines import MergeTree
@@ -84,10 +86,12 @@ class AlterTable(ModelOperation):
             is_regular_field = not (field.materialized or field.alias)
             if name not in table_fields:
                 logger.info("        Add column %s", name)
-                assert prev_name, "Cannot add a column to the beginning of the table"
                 cmd = "ADD COLUMN %s %s" % (name, field.get_sql(db=database))
                 if is_regular_field:
-                    cmd += " AFTER %s" % prev_name
+                    if prev_name:
+                        cmd += " AFTER %s" % prev_name
+                    else:
+                        cmd += " FIRST"
                 self._alter_table(database, cmd)
 
             if is_regular_field:
@@ -151,18 +155,18 @@ class AlterConstraints(ModelOperation):
     def apply(self, database):
         logger.info("    Alter constraints for %s", self.table_name)
         existing = self._get_constraint_names(database)
-        # Go over constraints in the model
+        no_longer_needed = existing - {c.name for c in self.model_class._constraints.values()}
+        # Drop old constraints first as they can conflict
+        for name in no_longer_needed:
+            logger.info("        Drop constraint %s", name)
+            self._alter_table(database, "DROP CONSTRAINT `%s`" % name)
+
+        # Add any new constraints
         for constraint in self.model_class._constraints.values():
             # Check if it's a new constraint
             if constraint.name not in existing:
                 logger.info("        Add constraint %s", constraint.name)
                 self._alter_table(database, "ADD %s" % constraint.create_table_sql())
-            else:
-                existing.remove(constraint.name)
-        # Remaining constraints in `existing` are obsolete
-        for name in existing:
-            logger.info("        Drop constraint %s", name)
-            self._alter_table(database, "DROP CONSTRAINT `%s`" % name)
 
     def _get_constraint_names(self, database):
         """

{clickhouse_orm-2.2.2 → clickhouse_orm-3.0.1}/clickhouse_orm/models.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import sys
 from collections import OrderedDict
 from itertools import chain
@@ -125,7 +127,6 @@ class ModelBase(type):
     ad_hoc_model_cache = {}
 
     def __new__(metacls, name, bases, attrs):
-
         # Collect fields, constraints and indexes from parent classes
         fields = {}
         constraints = {}
@@ -170,7 +171,7 @@ class ModelBase(type):
             _defaults=defaults,
             _has_funcs_as_defaults=has_funcs_as_defaults,
         )
-        model = super(ModelBase, metacls).__new__(metacls, str(name), bases, attrs)
+        model = super().__new__(metacls, str(name), bases, attrs)
 
         # Let each field, constraint and index know its parent and its own name
         for n, obj in chain(fields, constraints.items(), indexes.items()):
@@ -180,24 +181,24 @@ class ModelBase(type):
         return model
 
     @classmethod
-    def create_ad_hoc_model(metacls, fields, model_name="AdHocModel"):
+    def create_ad_hoc_model(cls, fields, model_name="AdHocModel"):
         # fields is a list of tuples (name, db_type)
         # Check if model exists in cache
         fields = list(fields)
         cache_key = model_name + " " + str(fields)
-        if cache_key in metacls.ad_hoc_model_cache:
-            return metacls.ad_hoc_model_cache[cache_key]
+        if cache_key in cls.ad_hoc_model_cache:
+            return cls.ad_hoc_model_cache[cache_key]
         # Create an ad hoc model class
         attrs = {}
         for name, db_type in fields:
-            attrs[name] = metacls.create_ad_hoc_field(db_type)
-        model_class = metacls.__new__(metacls, model_name, (Model,), attrs)
+            attrs[name] = cls.create_ad_hoc_field(db_type)
+        model_class = cls.__new__(cls, model_name, (Model,), attrs)
         # Add the model class to the cache
-        metacls.ad_hoc_model_cache[cache_key] = model_class
+        cls.ad_hoc_model_cache[cache_key] = model_class
         return model_class
 
     @classmethod
-    def create_ad_hoc_field(metacls, db_type):
+    def create_ad_hoc_field(cls, db_type):
         import clickhouse_orm.fields as orm_fields
 
         # Enums
@@ -215,13 +216,18 @@ class ModelBase(type):
             )
         # Arrays
         if db_type.startswith("Array"):
-            inner_field = metacls.create_ad_hoc_field(db_type[6:-1])
+            inner_field = cls.create_ad_hoc_field(db_type[6:-1])
             return orm_fields.ArrayField(inner_field)
         # Tuples (poor man's version - convert to array)
         if db_type.startswith("Tuple"):
             types = [s.strip() for s in db_type[6:-1].split(",")]
+            # newer versions are essentially "named tuples"
+            if any(" " in t for t in types):
+                assert all(" " in t for t in types), "Either all or none of the tuple types must be named - " + db_type
+                types = [t.split(" ", 1)[1] for t in types]
+
             assert len(set(types)) == 1, "No support for mixed types in tuples - " + db_type
-            inner_field = metacls.create_ad_hoc_field(types[0])
+            inner_field = cls.create_ad_hoc_field(types[0])
             return orm_fields.ArrayField(inner_field)
         # FixedString
         if db_type.startswith("FixedString"):
@@ -235,11 +241,11 @@ class ModelBase(type):
             return field_class(*args)
         # Nullable
         if db_type.startswith("Nullable"):
-            inner_field = metacls.create_ad_hoc_field(db_type[9:-1])
+            inner_field = cls.create_ad_hoc_field(db_type[9:-1])
             return orm_fields.NullableField(inner_field)
         # LowCardinality
         if db_type.startswith("LowCardinality"):
-            inner_field = metacls.create_ad_hoc_field(db_type[15:-1])
+            inner_field = cls.create_ad_hoc_field(db_type[15:-1])
             return orm_fields.LowCardinalityField(inner_field)
         # Simple fields
         name = db_type + "Field"
@@ -276,7 +282,7 @@ class Model(metaclass=ModelBase):
         invalid values will cause a `ValueError` to be raised.
         Unrecognized field names will cause an `AttributeError`.
         """
-        super(Model, self).__init__()
+        super().__init__()
         # Assign default values
         self.__dict__.update(self._defaults)
         # Assign field values from keyword arguments
@@ -299,9 +305,9 @@ class Model(metaclass=ModelBase):
                 field.validate(value)
             except ValueError:
                 tp, v, tb = sys.exc_info()
-                new_msg = "{} (field '{}')".format(v, name)
+                new_msg = f"{v} (field '{name}')"
                 raise tp.with_traceback(tp(new_msg), tb)
-        super(Model, self).__setattr__(name, value)
+        super().__setattr__(name, value)
 
     def set_database(self, db):
         """
@@ -535,7 +541,7 @@ class DistributedModel(Model):
         This is done automatically when the instance is read from the database or written to it.
         """
         assert isinstance(self.engine, Distributed), "engine must be an instance of engines.Distributed"
-        res = super(DistributedModel, self).set_database(db)
+        res = super().set_database(db)
         return res
 
     @classmethod
@@ -579,7 +585,7 @@ class DistributedModel(Model):
         storage_models = [b for b in cls.__bases__ if issubclass(b, Model) and not issubclass(b, DistributedModel)]
         if not storage_models:
             raise TypeError(
-                "When defining Distributed engine without the table_name " "ensure that your model has a parent model"
+                "When defining Distributed engine without the table_name ensure that your model has a parent model"
             )
 
         if len(storage_models) > 1:
@@ -601,9 +607,7 @@ class DistributedModel(Model):
         cls.fix_engine_table()
 
         parts = [
-            "CREATE TABLE IF NOT EXISTS `{0}`.`{1}` AS `{0}`.`{2}`".format(
-                db.db_name, cls.table_name(), cls.engine.table_name
-            ),
+            f"CREATE TABLE IF NOT EXISTS `{db.db_name}`.`{cls.table_name()}` AS `{db.db_name}`.`{cls.engine.table_name}`",
             "ENGINE = " + cls.engine.create_table_sql(db),
         ]
         return "\n".join(parts)

{clickhouse_orm-2.2.2 → clickhouse_orm-3.0.1}/clickhouse_orm/query.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from copy import copy, deepcopy
 from math import ceil
 
@@ -10,7 +12,7 @@ from .utils import Page, arg_to_sql, comma_join, string_or_func
 # - check that field names are valid
 
 
-class Operator(object):
+class Operator:
     """
     Base class for filtering operators.
     """
@@ -161,7 +163,7 @@ register_operator("iendswith", LikeOperator("%{}", False))
 register_operator("iexact", IExactOperator())
 
 
-class Cond(object):
+class Cond:
     """
     An abstract object for storing a single query condition Field + Operator + Value.
     """
@@ -193,8 +195,7 @@ class FieldCond(Cond):
         return res
 
 
-class Q(object):
-
+class Q:
     AND_MODE = "AND"
     OR_MODE = "OR"
 
@@ -217,7 +218,6 @@ class Q(object):
         if mode == l_child._mode and not l_child._negate:
             q = deepcopy(l_child)
             q._children.append(deepcopy(r_child))
-
         else:
             q = cls()
             q._children = [l_child, r_child]
@@ -249,7 +249,7 @@ class Q(object):
             sql = condition_sql[0]
         else:
             # Each condition must be enclosed in brackets, or order of operations may be wrong
-            sql = "(%s)" % ") {} (".format(self._mode).join(condition_sql)
+            sql = "(%s)" % f") {self._mode} (".join(condition_sql)
 
         if self._negate:
             sql = "NOT (%s)" % sql
@@ -288,7 +288,7 @@ class Q(object):
         return q
 
 
-class QuerySet(object):
+class QuerySet:
     """
     A queryset is an object that represents a database query using a specific `Model`.
     It is lazy, meaning that it does not hit the database until you iterate over its
@@ -300,6 +300,7 @@ class QuerySet(object):
         Initializer. It is possible to create a queryset like this, but the standard
         way is to use `MyModel.objects_in(database)`.
         """
+        self.model = model_cls
         self._model_cls = model_cls
         self._database = database
         self._order_by = []
@@ -343,7 +344,7 @@ class QuerySet(object):
             # Slice
             assert s.step in (None, 1), "step is not supported in slices"
             start = s.start or 0
-            stop = s.stop or 2 ** 63 - 1
+            stop = s.stop or 2**63 - 1
             assert start >= 0 and stop >= 0, "negative indexes are not supported"
             assert start <= stop, "start of slice cannot be smaller than its end"
             qs = copy(self)
@@ -626,7 +627,7 @@ class AggregateQuerySet(QuerySet):
         ```
         At least one calculated field is required.
         """
-        super(AggregateQuerySet, self).__init__(base_qs._model_cls, base_qs._database)
+        super().__init__(base_qs._model_cls, base_qs._database)
         assert calculated_fields, "No calculated fields specified for aggregation"
         self._fields = grouping_fields
         self._grouping_fields = grouping_fields

{clickhouse_orm-2.2.2 → clickhouse_orm-3.0.1}/clickhouse_orm/system_models.py

@@ -2,6 +2,9 @@
 This file contains system readonly models that can be got from the database
 https://clickhouse.tech/docs/en/system_tables/
 """
+
+from __future__ import annotations
+
 from .database import Database
 from .fields import DateTimeField, StringField, UInt8Field, UInt32Field, UInt64Field
 from .models import Model

{clickhouse_orm-2.2.2 → clickhouse_orm-3.0.1}/clickhouse_orm/utils.py

@@ -1,15 +1,27 @@
+from __future__ import annotations
+
 import codecs
 import importlib
 import pkgutil
 import re
-from collections import namedtuple
 from datetime import date, datetime, timedelta, tzinfo
 from inspect import isclass
-from types import ModuleType
-from typing import Any, Dict, Iterable, List, Optional, Type, Union
+from typing import TYPE_CHECKING, NamedTuple
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from types import ModuleType
+    from typing import Any
+
+
+class Page(NamedTuple):
+    """A simple data structure for paginated results."""
 
-Page = namedtuple("Page", "objects number_of_objects pages_total number page_size")
-Page.__doc__ += "\nA simple data structure for paginated results."
+    objects: list[Any]
+    number_of_objects: int
+    pages_total: int
+    number: int
+    page_size: int
 
 
 def escape(value: str, quote: bool = True) -> str:
@@ -25,7 +37,7 @@ def escape(value: str, quote: bool = True) -> str:
     return value
 
 
-def unescape(value: str) -> Optional[str]:
+def unescape(value: str) -> str | None:
     if value == "\\N":
         return None
     return codecs.escape_decode(value)[0].decode("utf-8")
@@ -70,7 +82,7 @@ def arg_to_sql(arg: Any) -> str:
     return str(arg)
 
 
-def parse_tsv(line: Union[bytes, str]) -> List[str]:
+def parse_tsv(line: bytes | str) -> list[str]:
     if isinstance(line, bytes):
         line = line.decode()
     if line and line[-1] == "\n":
@@ -78,7 +90,7 @@ def parse_tsv(line: Union[bytes, str]) -> List[str]:
     return [unescape(value) for value in line.split("\t")]
 
 
-def parse_array(array_string: str) -> List[Any]:
+def parse_array(array_string: str) -> list[Any]:
     """
     Parse an array or tuple string as returned by clickhouse. For example:
         "['hello', 'world']" ==> ["hello", "world"]
@@ -112,7 +124,7 @@ def parse_array(array_string: str) -> List[Any]:
             array_string = array_string[match.end() - 1 :]
 
 
-def import_submodules(package_name: str) -> Dict[str, ModuleType]:
+def import_submodules(package_name: str) -> dict[str, ModuleType]:
     """
     Import all submodules of a module.
     """
@@ -141,7 +153,7 @@ def is_iterable(obj: Any) -> bool:
         return False
 
 
-def get_subclass_names(locals: Dict[str, Any], base_class: Type):
+def get_subclass_names(locals: dict[str, Any], base_class: type):
     return [c.__name__ for c in locals.values() if isclass(c) and issubclass(c, base_class)]
 
 

clickhouse_orm-3.0.1/pyproject.toml

@@ -0,0 +1,95 @@
+[build-system]
+requires = ["flit_core >=3.2,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "clickhouse_orm"
+version = "3.0.1"
+readme = "README.md"
+description = "A simple ORM for working with the Clickhouse database. Maintainance fork of infi.clickhouse_orm."
+authors = [
+  {name = "Oliver Margetts", email = "oliver.margetts@gmail.com"}
+]
+license = { text = "BSD-3-Clause" }
+classifiers = [
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: BSD License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Database",
+]
+# requires_python = ">=3.11"
+dependencies = [
+    "requests",
+    "pytz",
+]
+
+[project.optional-dependencies]
+dev = [
+  "docker==7.1.0",
+  "pytest==9.0.2",
+  "ruff==0.14.14",
+]
+
+[project.urls]
+Homepage = "https://github.com/SuadeLabs/clickhouse_orm"
+Repository = "https://github.com/SuadeLabs/clickhouse_orm"
+
+[tool.ruff]
+line-length = 120
+target-version = "py311"
+# File Selection
+force-exclude = true  # don't check excluded files even if passed directly
+extend-exclude = ["./venv"]
+
+[tool.ruff.lint]
+# Rule Selection
+# to read about ruff rules check this: https://beta.ruff.rs/docs/rules/
+select = [
+  "E",
+  "W",       # pycodestyle: E, W
+  "F",       # pyflakes: F
+  "B",       # flake8-bugbear: B
+  "I",       # isort: I
+  "ISC",     # flake8-implicit-str-concat: ISC
+  "N",       # pep8-naming: N
+  "PYI",     # flake8-pyi: PYI
+  "RUF013",  # ruff: RUF (Specifically implicit-optional)
+  "RUF022",  # unsorted-dunder-all: https://docs.astral.sh/ruff/rules/unsorted-dunder-all/
+  "RUF023",  # unsorted-dunder-slots: https://docs.astral.sh/ruff/rules/unsorted-dunder-slots/
+  "RUF101",  # redirected-noqa: https://docs.astral.sh/ruff/rules/redirected-noqa/
+  "T10",     # flake8-debugger
+  "TC",      # flake8-type-checking
+  "UP",      # pyupgrade: U
+]
+
+ignore = [
+  "B904",   # raising without from clause
+  "B905",   # zip without strict parameter
+  "E501",   # line-too-long
+  "F403",   # from module import *
+  "F405",   # name defined from star imports
+  "N802",   # function names often mirror clickhouse function names
+  "N806",   # dynamically created classes
+  "N999",   # migration module names: 1234.py
+  "UP031",  # percent formatting
+]
+
+[tool.ruff.lint.isort]
+required-imports = ["from __future__ import annotations"]
+relative-imports-order = "closest-to-furthest"
+combine-as-imports = true
+split-on-trailing-comma = false
+section-order = [
+  "future",
+  "standard-library",
+  "third-party",
+  "first-party",
+  "local-folder",
+]

clickhouse_orm-2.2.2/PKG-INFO

@@ -1,26 +0,0 @@
-Metadata-Version: 2.1
-Name: clickhouse-orm
-Version: 2.2.2
-Summary: A simple ORM for working with the Clickhouse database. Maintainance fork of infi.clickhouse_orm.
-Home-page: https://github.com/SuadeLabs/clickhouse_orm
-License: BSD
-Author: olliemath
-Author-email: oliver.margetts@gmail.com
-Requires-Python: >=3.6.2,<4
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: System Administrators
-Classifier: License :: OSI Approved :: BSD License
-Classifier: License :: Other/Proprietary License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-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: Topic :: Database
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: iso8601
-Requires-Dist: pytz
-Requires-Dist: requests
-Project-URL: Repository, https://github.com/SuadeLabs/clickhouse_orm

clickhouse_orm-2.2.2/pyproject.toml

@@ -1,52 +0,0 @@
-[tool.black]
-line-length = 120
-
-[tool.isort]
-multi_line_output = 3
-include_trailing_comma = true
-force_grid_wrap = 0
-use_parentheses = true
-ensure_newline_before_comments = true
-line_length = 120
-
-[tool.poetry]
-name = "clickhouse_orm"
-version = "2.2.2"
-description = "A simple ORM for working with the Clickhouse database. Maintainance fork of infi.clickhouse_orm."
-authors = ["olliemath <oliver.margetts@gmail.com>"]
-license = "BSD"
-homepage = "https://github.com/SuadeLabs/clickhouse_orm"
-repository = "https://github.com/SuadeLabs/clickhouse_orm"
-classifiers = [
-    "Intended Audience :: Developers",
-    "Intended Audience :: System Administrators",
-    "License :: OSI Approved :: BSD License",
-    "Operating System :: OS Independent",
-    "Programming Language :: Python",
-    "Programming Language :: Python :: 3.6",
-    "Programming Language :: Python :: 3.7",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Topic :: Software Development :: Libraries :: Python Modules",
-    "Topic :: Database"
-]
-
-[tool.poetry.dependencies]
-python = ">=3.6.2,<4"
-requests = "*"
-pytz = "*"
-iso8601 = "*"
-
-[tool.poetry.dev-dependencies]
-flake8 = "^3.9.2"
-flake8-bugbear = "^21.4.3"
-pep8-naming = "^0.12.0"
-pytest = "^6.2.4"
-flake8-isort = "^4.0.0"
-black = {version = "^21.7b0", markers = "platform_python_implementation == 'CPython'"}
-isort = "^5.9.2"
-freezegun = "^1.1.0"
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"

clickhouse_orm-2.2.2/setup.py

@@ -1,30 +0,0 @@
-# -*- coding: utf-8 -*-
-from setuptools import setup
-
-packages = \
-['clickhouse_orm']
-
-package_data = \
-{'': ['*']}
-
-install_requires = \
-['iso8601', 'pytz', 'requests']
-
-setup_kwargs = {
-    'name': 'clickhouse-orm',
-    'version': '2.2.2',
-    'description': 'A simple ORM for working with the Clickhouse database. Maintainance fork of infi.clickhouse_orm.',
-    'long_description': None,
-    'author': 'olliemath',
-    'author_email': 'oliver.margetts@gmail.com',
-    'maintainer': None,
-    'maintainer_email': None,
-    'url': 'https://github.com/SuadeLabs/clickhouse_orm',
-    'packages': packages,
-    'package_data': package_data,
-    'install_requires': install_requires,
-    'python_requires': '>=3.6.2,<4',
-}
-
-
-setup(**setup_kwargs)