Merge branch 'master' into user_model_enhancements

Author: dantownsend

CHANGES

@@ -1,6 +1,22 @@
 Changes
 =======
 
+0.18.4
+------
+ * Fixed a bug when multiple tables inherit from the same mixin (thanks to
+   @brnosouza).
+ * Added a ``log_queries`` option to ``PostgresEngine``, which is useful during
+   debugging.
+ * Added the `inflection` library for converting ``Table`` class names to
+   database table names. Previously, a class called ``TableA`` would wrongly
+   have a table called ``table`` instead of ``table_a``.
+ * Fixed a bug with ``SerialisedBuiltin.__hash__`` not returning a number,
+   which could break migrations (thanks to @sinisaos).
+
+0.18.3
+------
+Improved ``Array`` column serialisation - needed to fix auto migrations.
+
 0.18.2
 ------
 Added support for filtering ``Array`` columns.

piccolo/__init__.py

@@ -1 +1 @@
-__VERSION__ = "0.18.2"
+__VERSION__ = "0.18.4"

piccolo/apps/migrations/auto/migration_manager.py

@@ -609,7 +609,11 @@ async def _run_add_columns(self, backwards=False):
                 _Table._meta.tablename = add_columns[0].tablename
 
                 for add_column in add_columns:
-                    column = add_column.column
+                    # We fetch the column from the Table, as the metaclass
+                    # copies and sets it up properly.
+                    column = _Table._meta.get_column_by_name(
+                        add_column.column._meta.name
+                    )
                     await _Table.alter().add_column(
                         name=column._meta.name, column=column
                     ).run()

piccolo/apps/migrations/auto/serialisation.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+import builtins
 from copy import deepcopy
 from dataclasses import dataclass, field
 import datetime
@@ -8,6 +9,7 @@
 import typing as t
 import uuid
 
+from piccolo.columns import Column
 from piccolo.columns.defaults.base import Default
 from piccolo.columns.reference import LazyTableReference
 from piccolo.table import Table
@@ -17,7 +19,21 @@
 
 
 @dataclass
-class SerialisedClass:
+class SerialisedBuiltin:
+    builtin: t.Any
+
+    def __hash__(self):
+        return hash(self.builtin.__name__)
+
+    def __eq__(self, other):
+        return self.__hash__() == other.__hash__()
+
+    def __repr__(self):
+        return self.builtin.__name__
+
+
+@dataclass
+class SerialisedClassInstance:
     instance: object
 
     def __hash__(self):
@@ -26,19 +42,37 @@ def __hash__(self):
     def __eq__(self, other):
         return self.__hash__() == other.__hash__()
 
-    def _serialise_value(self, value):
-        return f"'{value}'" if isinstance(value, str) else value
-
     def __repr__(self):
         args = ", ".join(
             [
-                f"{key}={self._serialise_value(value)}"
+                f"{key}={value.__repr__()}"
                 for key, value in self.instance.__dict__.items()
             ]
         )
         return f"{self.instance.__class__.__name__}({args})"
 
 
+@dataclass
+class SerialisedColumnInstance:
+    instance: Column
+    serialised_params: SerialisedParams
+
+    def __hash__(self):
+        return self.instance.__hash__()
+
+    def __eq__(self, other):
+        return self.__hash__() == other.__hash__()
+
+    def __repr__(self):
+        args = ", ".join(
+            [
+                f"{key}={self.serialised_params.params.get(key).__repr__()}"  # noqa: E501
+                for key in self.instance._meta.params.keys()
+            ]
+        )
+        return f"{self.instance.__class__.__name__}({args})"
+
+
 @dataclass
 class SerialisedTableType:
     table_type: t.Type[Table]
@@ -127,9 +161,40 @@ def serialise_params(params: t.Dict[str, t.Any]) -> SerialisedParams:
 
     for key, value in params.items():
 
+        # Builtins, such as str, list and dict.
+        if (
+            hasattr(value, "__module__")
+            and value.__module__ == builtins.__name__
+        ):
+            params[key] = SerialisedBuiltin(builtin=value)
+            continue
+
+        # Column instances, which are used by Array definitions.
+        if isinstance(value, Column):
+            column: Column = value
+            serialised_params: SerialisedParams = serialise_params(
+                params=column._meta.params
+            )
+
+            # Include the extra imports and definitions required for the
+            # column params.
+            extra_imports.extend(serialised_params.extra_imports)
+            extra_definitions.extend(serialised_params.extra_definitions)
+
+            extra_imports.append(
+                Import(
+                    module=column.__class__.__module__,
+                    target=column.__class__.__name__,
+                )
+            )
+            params[key] = SerialisedColumnInstance(
+                instance=value, serialised_params=serialised_params
+            )
+            continue
+
         # Class instances
         if isinstance(value, Default):
-            params[key] = SerialisedClass(instance=value)
+            params[key] = SerialisedClassInstance(instance=value)
             extra_imports.append(
                 Import(
                     module=value.__class__.__module__,
@@ -227,7 +292,7 @@ def deserialise_params(params: t.Dict[str, t.Any]) -> t.Dict[str, t.Any]:
         if isinstance(value, str) and not isinstance(value, Enum):
             if value != "self":
                 params[key] = deserialise_legacy_params(name=key, value=value)
-        elif isinstance(value, SerialisedClass):
+        elif isinstance(value, SerialisedClassInstance):
             params[key] = value.instance
         elif isinstance(value, SerialisedUUID):
             params[key] = value.instance

piccolo/columns/column_types.py

@@ -1384,6 +1384,10 @@ def __init__(
 
         self._validate_default(default, (list, None))
 
+        # Usually columns are given a name by the Table metaclass, but in this
+        # case we have to assign one manually.
+        base_column._meta._name = base_column.__class__.__name__
+
         self.base_column = base_column
         self.default = default
         self.index: t.Optional[int] = None

piccolo/engine/postgres.py

@@ -215,6 +215,10 @@ class PostgresEngine(Engine):
         When the engine starts, it will try and create these extensions
         in Postgres.
 
+    :param log_queries:
+        If True, all SQL and DDL statements are printed out before being run.
+        Useful for debugging.
+
     """  # noqa: E501
 
     __slots__ = ("config", "extensions", "pool", "transaction_connection")
@@ -226,9 +230,11 @@ def __init__(
         self,
         config: t.Dict[str, t.Any],
         extensions: t.Sequence[str] = ["uuid-ossp"],
+        log_queries: bool = False,
     ) -> None:
         self.config = config
         self.extensions = extensions
+        self.log_queries = log_queries
         self.pool: t.Optional[Pool] = None
         database_name = config.get("database", "Unknown")
         self.transaction_connection = contextvars.ContextVar(
@@ -367,6 +373,9 @@ async def run_querystring(
             engine_type=self.engine_type
         )
 
+        if self.log_queries:
+            print(querystring)
+
         # If running inside a transaction:
         connection = self.transaction_connection.get()
         if connection:

piccolo/table.py

@@ -172,7 +172,12 @@ def __init_subclass__(
 
             attribute = getattr(cls, attribute_name)
             if isinstance(attribute, Column):
-                column = attribute
+                # We have to copy, then override the existing column
+                # definition, in case this column is inheritted from a mixin.
+                # Otherwise, when we set attributes on that column, it will
+                # effect all other users of that mixin.
+                column = attribute.copy()
+                setattr(cls, attribute_name, column)
 
                 if isinstance(column, PrimaryKey):
                     # We want it at the start.
@@ -185,8 +190,8 @@ def __init_subclass__(
                 column._meta._name = attribute_name
                 column._meta._table = cls
 
-            if isinstance(column, ForeignKey):
-                foreign_key_columns.append(column)
+                if isinstance(column, ForeignKey):
+                    foreign_key_columns.append(column)
 
         cls._meta = TableMeta(
             tablename=tablename,

piccolo/utils/naming.py

@@ -1,14 +1,8 @@
-import re
+import inflection
 
 
-_camel_words = re.compile(r"([A-Z][a-z0-9_]+)")
-
-
-def _camel_to_snake(s):
-    """ Convert CamelCase to snake_case.
+def _camel_to_snake(string: str):
+    """
+    Convert CamelCase to snake_case.
     """
-    return "_".join(
-        [
-            i.lower() for i in _camel_words.split(s)[1::2]
-        ]
-    )
+    return inflection.underscore(string)

requirements.txt

@@ -4,3 +4,4 @@ black
 colorama>=0.4.0
 Jinja2>=2.11.0
 targ>=0.1.0
+inflection>=0.5.1

tests/apps/migrations/auto/test_migration_manager.py

@@ -1,4 +1,5 @@
 import asyncio
+from piccolo.columns.column_types import ForeignKey
 from unittest.mock import patch, MagicMock
 
 from asyncpg.exceptions import UniqueViolationError
@@ -119,6 +120,7 @@ def test_add_column(self):
             table_class_name="Manager",
             tablename="manager",
             column_name="email",
+            column_class=Varchar,
             column_class_name="Varchar",
             params={
                 "length": 100,
@@ -156,6 +158,7 @@ def test_add_column_with_index(self):
             table_class_name="Manager",
             tablename="manager",
             column_name="email",
+            column_class=Varchar,
             column_class_name="Varchar",
             params={
                 "length": 100,
@@ -187,6 +190,7 @@ def test_add_foreign_key_self_column(self):
             table_class_name="Manager",
             tablename="manager",
             column_name="advisor",
+            column_class=ForeignKey,
             column_class_name="ForeignKey",
             params={
                 "references": "self",
@@ -235,6 +239,7 @@ def test_add_non_nullable_column(self):
             table_class_name="Manager",
             tablename="manager",
             column_name="email",
+            column_class=Varchar,
             column_class_name="Varchar",
             params={
                 "length": 100,