Convert the remaining classes to attrs

Since we now use `attrs` for some classes, let's use `attrs` for them all — at least those belonging to the same hierarchies.

This will ensure that all classes are slotted and will strictly check that we define attributes properly, especially in cases of multiple inheritance.

Except for Pydantic models and Python exceptions.

Despite the attrs classes are not frozen by default, we keep it explicitly stated, so that we see which classes were or were not frozen before the switch from runtype to attrs. We can later freeze more classes if/when it works (the stricter, the better). For this reason, we never unfreeze classes that were previously frozen.

Author: Sergey Vasilyev

data_diff/abcs/database_types.py

@@ -26,26 +26,32 @@ class PrecisionType(ColType):
     rounds: Union[bool, Unknown] = Unknown
 
 
+@attrs.define(frozen=True)
 class Boolean(ColType):
     precision = 0
 
 
+@attrs.define(frozen=True)
 class TemporalType(PrecisionType):
     pass
 
 
+@attrs.define(frozen=True)
 class Timestamp(TemporalType):
     pass
 
 
+@attrs.define(frozen=True)
 class TimestampTZ(TemporalType):
     pass
 
 
+@attrs.define(frozen=True)
 class Datetime(TemporalType):
     pass
 
 
+@attrs.define(frozen=True)
 class Date(TemporalType):
     pass
 
@@ -56,14 +62,17 @@ class NumericType(ColType):
     precision: int
 
 
+@attrs.define(frozen=True)
 class FractionalType(NumericType):
     pass
 
 
+@attrs.define(frozen=True)
 class Float(FractionalType):
     python_type = float
 
 
+@attrs.define(frozen=True)
 class IKey(ABC):
     "Interface for ColType, for using a column as a key in table."
 
@@ -76,6 +85,7 @@ def make_value(self, value):
         return self.python_type(value)
 
 
+@attrs.define(frozen=True)
 class Decimal(FractionalType, IKey):  # Snowflake may use Decimal as a key
     @property
     def python_type(self) -> type:
@@ -89,22 +99,27 @@ class StringType(ColType):
     python_type = str
 
 
+@attrs.define(frozen=True)
 class ColType_UUID(ColType, IKey):
     python_type = ArithUUID
 
 
+@attrs.define(frozen=True)
 class ColType_Alphanum(ColType, IKey):
     python_type = ArithAlphanumeric
 
 
+@attrs.define(frozen=True)
 class Native_UUID(ColType_UUID):
     pass
 
 
+@attrs.define(frozen=True)
 class String_UUID(ColType_UUID, StringType):
     pass
 
 
+@attrs.define(frozen=True)
 class String_Alphanum(ColType_Alphanum, StringType):
     @staticmethod
     def test_value(value: str) -> bool:
@@ -118,6 +133,7 @@ def make_value(self, value):
         return self.python_type(value)
 
 
+@attrs.define(frozen=True)
 class String_VaryingAlphanum(String_Alphanum):
     pass
 

data_diff/abcs/mixins.py

@@ -1,4 +1,7 @@
 from abc import ABC, abstractmethod
+
+import attrs
+
 from data_diff.abcs.database_types import (
     Array,
     TemporalType,
@@ -13,10 +16,12 @@
 from data_diff.abcs.compiler import Compilable
 
 
+@attrs.define(frozen=False)
 class AbstractMixin(ABC):
     "A mixin for a database dialect"
 
 
+@attrs.define(frozen=False)
 class AbstractMixin_NormalizeValue(AbstractMixin):
     @abstractmethod
     def to_comparable(self, value: str, coltype: ColType) -> str:
@@ -108,6 +113,7 @@ def normalize_value_by_type(self, value: str, coltype: ColType) -> str:
         return self.to_string(value)
 
 
+@attrs.define(frozen=False)
 class AbstractMixin_MD5(AbstractMixin):
     """Methods for calculating an MD6 hash as an integer."""
 
@@ -116,6 +122,7 @@ def md5_as_int(self, s: str) -> str:
         "Provide SQL for computing md5 and returning an int"
 
 
+@attrs.define(frozen=False)
 class AbstractMixin_Schema(AbstractMixin):
     """Methods for querying the database schema
 
@@ -134,6 +141,7 @@ def list_tables(self, table_schema: str, like: Compilable = None) -> Compilable:
         """
 
 
+@attrs.define(frozen=False)
 class AbstractMixin_RandomSample(AbstractMixin):
     @abstractmethod
     def random_sample_n(self, tbl: str, size: int) -> str:
@@ -151,6 +159,7 @@ def random_sample_ratio_approx(self, tbl: str, ratio: float) -> str:
     #     """
 
 
+@attrs.define(frozen=False)
 class AbstractMixin_TimeTravel(AbstractMixin):
     @abstractmethod
     def time_travel(
@@ -173,6 +182,7 @@ def time_travel(
         """
 
 
+@attrs.define(frozen=False)
 class AbstractMixin_OptimizerHints(AbstractMixin):
     @abstractmethod
     def optimizer_hints(self, optimizer_hints: str) -> str:

data_diff/databases/_connect.py

@@ -93,6 +93,7 @@ def match_path(self, dsn):
 }
 
 
+@attrs.define(frozen=False, init=False)
 class Connect:
     """Provides methods for connecting to a supported database using a URL or connection dict."""
 
@@ -288,6 +289,7 @@ def __make_cache_key(self, db_conf: Union[str, dict]) -> Hashable:
         return db_conf
 
 
+@attrs.define(frozen=False, init=False)
 class Connect_SetUTC(Connect):
     """Provides methods for connecting to a supported database using a URL or connection dict.
 

data_diff/databases/base.py

@@ -168,6 +168,7 @@ def _one(seq):
     return x
 
 
+@attrs.define(frozen=False)
 class ThreadLocalInterpreter:
     """An interpeter used to execute a sequence of queries within the same thread and cursor.
 
@@ -177,11 +178,6 @@ class ThreadLocalInterpreter:
     compiler: Compiler
     gen: Generator
 
-    def __init__(self, compiler: Compiler, gen: Generator):
-        super().__init__()
-        self.gen = gen
-        self.compiler = compiler
-
     def apply_queries(self, callback: Callable[[str], Any]):
         q: Expr = next(self.gen)
         while True:
@@ -205,6 +201,7 @@ def apply_query(callback: Callable[[str], Any], sql_code: Union[str, ThreadLocal
         return callback(sql_code)
 
 
+@attrs.define(frozen=False)
 class Mixin_Schema(AbstractMixin_Schema):
     def table_information(self) -> Compilable:
         return table("information_schema", "tables")
@@ -221,6 +218,7 @@ def list_tables(self, table_schema: str, like: Compilable = None) -> Compilable:
         )
 
 
+@attrs.define(frozen=False)
 class Mixin_RandomSample(AbstractMixin_RandomSample):
     def random_sample_n(self, tbl: ITable, size: int) -> ITable:
         # TODO use a more efficient algorithm, when the table count is known
@@ -230,15 +228,17 @@ def random_sample_ratio_approx(self, tbl: ITable, ratio: float) -> ITable:
         return tbl.where(Random() < ratio)
 
 
+@attrs.define(frozen=False)
 class Mixin_OptimizerHints(AbstractMixin_OptimizerHints):
     def optimizer_hints(self, hints: str) -> str:
         return f"/*+ {hints} */ "
 
 
+@attrs.define(frozen=False)
 class BaseDialect(abc.ABC):
     SUPPORTS_PRIMARY_KEY: ClassVar[bool] = False
     SUPPORTS_INDEXES: ClassVar[bool] = False
-    TYPE_CLASSES: ClassVar[Dict[str, type]] = {}
+    TYPE_CLASSES: ClassVar[Dict[str, Type[ColType]]] = {}
     MIXINS = frozenset()
 
     PLACEHOLDER_TABLE = None  # Used for Oracle
@@ -540,7 +540,7 @@ def render_select(self, parent_c: Compiler, elem: Select) -> str:
 
     def render_join(self, parent_c: Compiler, elem: Join) -> str:
         tables = [
-            t if isinstance(t, TableAlias) else TableAlias(source_table=t, name=parent_c.new_unique_name())
+            t if isinstance(t, TableAlias) else TableAlias(t, name=parent_c.new_unique_name())
             for t in elem.source_tables
         ]
         c = parent_c.add_table_context(*tables, in_join=True, in_select=False)
@@ -839,6 +839,7 @@ def __getitem__(self, i):
         return self.rows[i]
 
 
+@attrs.define(frozen=False)
 class Database(abc.ABC):
     """Base abstract class for databases.
 
@@ -1114,22 +1115,22 @@ def is_autocommit(self) -> bool:
         "Return whether the database autocommits changes. When false, COMMIT statements are skipped."
 
 
+@attrs.define(frozen=False)
 class ThreadedDatabase(Database):
     """Access the database through singleton threads.
 
     Used for database connectors that do not support sharing their connection between different threads.
     """
 
-    _init_error: Optional[Exception]
-    _queue: ThreadPoolExecutor
-    thread_local: threading.local
+    thread_count: int = 1
+
+    _init_error: Optional[Exception] = None
+    _queue: Optional[ThreadPoolExecutor] = None
+    thread_local: threading.local = attrs.field(factory=threading.local)
 
-    def __init__(self, thread_count=1):
-        super().__init__()
-        self._init_error = None
-        self._queue = ThreadPoolExecutor(thread_count, initializer=self.set_conn)
-        self.thread_local = threading.local()
-        logger.info(f"[{self.name}] Starting a threadpool, size={thread_count}.")
+    def __attrs_post_init__(self):
+        self._queue = ThreadPoolExecutor(self.thread_count, initializer=self.set_conn)
+        logger.info(f"[{self.name}] Starting a threadpool, size={self.thread_count}.")
 
     def set_conn(self):
         assert not hasattr(self.thread_local, "conn")

data_diff/databases/bigquery.py

@@ -1,5 +1,8 @@
 import re
 from typing import Any, List, Union
+
+import attrs
+
 from data_diff.abcs.database_types import (
     ColType,
     Array,
@@ -50,11 +53,13 @@ def import_bigquery_service_account():
     return service_account
 
 
+@attrs.define(frozen=False)
 class Mixin_MD5(AbstractMixin_MD5):
     def md5_as_int(self, s: str) -> str:
         return f"cast(cast( ('0x' || substr(TO_HEX(md5({s})), 18)) as int64) as numeric)"
 
 
+@attrs.define(frozen=False)
 class Mixin_NormalizeValue(AbstractMixin_NormalizeValue):
     def normalize_timestamp(self, value: str, coltype: TemporalType) -> str:
         if coltype.rounds:
@@ -99,6 +104,7 @@ def normalize_struct(self, value: str, _coltype: Struct) -> str:
         return f"to_json_string({value})"
 
 
+@attrs.define(frozen=False)
 class Mixin_Schema(AbstractMixin_Schema):
     def list_tables(self, table_schema: str, like: Compilable = None) -> Compilable:
         return (
@@ -112,6 +118,7 @@ def list_tables(self, table_schema: str, like: Compilable = None) -> Compilable:
         )
 
 
+@attrs.define(frozen=False)
 class Mixin_TimeTravel(AbstractMixin_TimeTravel):
     def time_travel(
         self,
@@ -139,6 +146,7 @@ def time_travel(
         )
 
 
+@attrs.define(frozen=False)
 class Dialect(
     BaseDialect, Mixin_Schema, Mixin_MD5, Mixin_NormalizeValue, AbstractMixin_MD5, AbstractMixin_NormalizeValue
 ):

data_diff/databases/clickhouse.py

@@ -1,5 +1,7 @@
 from typing import Optional, Type
 
+import attrs
+
 from data_diff.databases.base import (
     MD5_HEXDIGITS,
     CHECKSUM_HEXDIGITS,
@@ -35,12 +37,14 @@ def import_clickhouse():
     return clickhouse_driver
 
 
+@attrs.define(frozen=False)
 class Mixin_MD5(AbstractMixin_MD5):
     def md5_as_int(self, s: str) -> str:
         substr_idx = 1 + MD5_HEXDIGITS - CHECKSUM_HEXDIGITS
         return f"reinterpretAsUInt128(reverse(unhex(lowerUTF8(substr(hex(MD5({s})), {substr_idx})))))"
 
 
+@attrs.define(frozen=False)
 class Mixin_NormalizeValue(AbstractMixin_NormalizeValue):
     def normalize_number(self, value: str, coltype: FractionalType) -> str:
         # If a decimal value has trailing zeros in a fractional part, when casting to string they are dropped.
@@ -99,6 +103,7 @@ def normalize_timestamp(self, value: str, coltype: TemporalType) -> str:
         return f"rpad({value}, {TIMESTAMP_PRECISION_POS + 6}, '0')"
 
 
+@attrs.define(frozen=False)
 class Dialect(BaseDialect, Mixin_MD5, Mixin_NormalizeValue, AbstractMixin_MD5, AbstractMixin_NormalizeValue):
     name = "Clickhouse"
     ROUNDS_ON_PREC_LOSS = False
@@ -163,6 +168,7 @@ def current_timestamp(self) -> str:
         return "now()"
 
 
+@attrs.define(frozen=False)
 class Clickhouse(ThreadedDatabase):
     dialect = Dialect()
     CONNECT_URI_HELP = "clickhouse://<user>:<password>@<host>/<database>"