piccolo 1.8.0__py3-none-any.whl → 1.10.0__py3-none-any.whl

piccolo/__init__.py

@@ -1 +1 @@
-__VERSION__ = "1.8.0"
+__VERSION__ = "1.10.0"

piccolo/apps/fixtures/commands/load.py

@@ -51,7 +51,7 @@ async def load_json_string(
     finder = Finder()
     engine = engine_finder()
 
-    if not engine:
+    if engine is None:
         raise Exception("Unable to find the engine.")
 
     # This is what we want to the insert into the database:

piccolo/apps/migrations/auto/__init__.py

@@ -2,3 +2,11 @@ from .diffable_table import DiffableTable
 from .migration_manager import MigrationManager
 from .schema_differ import AlterStatements, SchemaDiffer
 from .schema_snapshot import SchemaSnapshot
+
+__all__ = [
+    "DiffableTable",
+    "MigrationManager",
+    "AlterStatements",
+    "SchemaDiffer",
+    "SchemaSnapshot",
+]

piccolo/apps/migrations/auto/migration_manager.py

@@ -261,7 +261,8 @@ class MigrationManager:
         cleaned_params = deserialise_params(params=params)
         column = column_class(**cleaned_params)
         column._meta.name = column_name
-        column._meta.db_column_name = db_column_name
+        if db_column_name:
+            column._meta.db_column_name = db_column_name
 
         self.add_columns.append(
             AddColumnClass(

piccolo/apps/migrations/commands/backwards.py

@@ -32,7 +32,9 @@ class BackwardsMigrationManager(BaseMigrationManager):
 
     async def run_migrations_backwards(self, app_config: AppConfig):
         migration_modules: t.Dict[str, MigrationModule] = (
-            self.get_migration_modules(app_config.migrations_folder_path)
+            self.get_migration_modules(
+                app_config.resolved_migrations_folder_path
+            )
         )
 
         ran_migration_ids = await Migration.get_migrations_which_ran(

piccolo/apps/migrations/commands/base.py

@@ -86,7 +86,7 @@ class BaseMigrationManager(Finder):
         """
         migration_managers: t.List[MigrationManager] = []
 
-        migrations_folder = app_config.migrations_folder_path
+        migrations_folder = app_config.resolved_migrations_folder_path
 
         migration_modules: t.Dict[str, MigrationModule] = (
             self.get_migration_modules(migrations_folder)

piccolo/apps/migrations/commands/check.py

@@ -36,7 +36,7 @@ class CheckMigrationManager(BaseMigrationManager):
                 continue
 
             migration_modules = self.get_migration_modules(
-                app_config.migrations_folder_path
+                app_config.resolved_migrations_folder_path
             )
             ids = self.get_migration_ids(migration_modules)
             for _id in ids:

piccolo/apps/migrations/commands/clean.py

@@ -20,7 +20,7 @@ class CleanMigrationManager(BaseMigrationManager):
         app_config = self.get_app_config(app_name=self.app_name)
 
         migration_module_dict = self.get_migration_modules(
-            folder_path=app_config.migrations_folder_path
+            folder_path=app_config.resolved_migrations_folder_path
         )
 
         # The migration IDs which are in migration modules.

piccolo/apps/migrations/commands/forwards.py

@@ -33,7 +33,9 @@ class ForwardsMigrationManager(BaseMigrationManager):
         )
 
         migration_modules: t.Dict[str, MigrationModule] = (
-            self.get_migration_modules(app_config.migrations_folder_path)
+            self.get_migration_modules(
+                app_config.resolved_migrations_folder_path
+            )
         )
 
         ids = self.get_migration_ids(migration_modules)

piccolo/apps/migrations/commands/new.py

@@ -98,7 +98,9 @@ def _generate_migration_meta(app_config: AppConfig) -> NewMigrationMeta:
 
     filename = f"{cleaned_app_name}_{cleaned_id}"
 
-    path = os.path.join(app_config.migrations_folder_path, f"{filename}.py")
+    path = os.path.join(
+        app_config.resolved_migrations_folder_path, f"{filename}.py"
+    )
 
     return NewMigrationMeta(
         migration_id=_id, migration_filename=filename, migration_path=path
@@ -255,7 +257,7 @@ async def new(
 
         app_config = Finder().get_app_config(app_name=app_name)
 
-        _create_migrations_folder(app_config.migrations_folder_path)
+        _create_migrations_folder(app_config.resolved_migrations_folder_path)
 
         try:
             await _create_new_migration(

piccolo/apps/schema/commands/generate.py

@@ -313,7 +313,7 @@ COLUMN_TYPE_MAP_COCKROACH: t.Dict[str, t.Type[Column]] = {
     **{"integer": BigInt, "json": JSONB},
 }
 
-COLUMN_DEFAULT_PARSER = {
+COLUMN_DEFAULT_PARSER: t.Dict[t.Type[Column], t.Any] = {
     BigInt: re.compile(r"^'?(?P<value>-?[0-9]\d*)'?(?:::bigint)?$"),
     Boolean: re.compile(r"^(?P<value>true|false)$"),
     Bytea: re.compile(r"'(?P<value>.*)'::bytea$"),
@@ -373,7 +373,7 @@ COLUMN_DEFAULT_PARSER = {
 }
 
 # Re-map for Cockroach compatibility.
-COLUMN_DEFAULT_PARSER_COCKROACH = {
+COLUMN_DEFAULT_PARSER_COCKROACH: t.Dict[t.Type[Column], t.Any] = {
     **COLUMN_DEFAULT_PARSER,
     BigInt: re.compile(r"^(?P<value>-?\d+)$"),
 }

piccolo/apps/shell/commands/run.py

@@ -24,7 +24,7 @@ def start_ipython_shell(**tables: t.Type[Table]):  # pragma: no cover
         if table_class_name not in existing_global_names:
             globals()[table_class_name] = table_class
 
-    IPython.embed(using=_asyncio_runner, colors="neutral")
+    IPython.embed(using=_asyncio_runner, colors="neutral")  # type: ignore
 
 
 def run() -> None:

piccolo/columns/base.py

@@ -830,7 +830,11 @@ class Column(Selectable):
             engine_type=engine_type, with_alias=False
         )
 
-    def get_sql_value(self, value: t.Any) -> t.Any:
+    def get_sql_value(
+        self,
+        value: t.Any,
+        delimiter: str = "'",
+    ) -> str:
         """
         When using DDL statements, we can't parameterise the values. An example
         is when setting the default for a column. So we have to convert from
@@ -839,11 +843,18 @@ class Column(Selectable):
 
         :param value:
             The Python value to convert to a string usable in a DDL statement
-            e.g. 1.
+            e.g. ``1``.
+        :param delimiter:
+            The string returned by this function is wrapped in delimiters,
+            ready to be added to a DDL statement. For example:
+            ``'hello world'``.
         :returns:
-            The string usable in the DDL statement e.g. '1'.
+            The string usable in the DDL statement e.g. ``'1'``.
 
         """
+        from piccolo.engine.sqlite import ADAPTERS as sqlite_adapters
+
+        # Common across all DB engines
         if isinstance(value, Default):
             return getattr(value, self._meta.engine_type)
         elif value is None:
@@ -851,37 +862,52 @@ class Column(Selectable):
         elif isinstance(value, (float, decimal.Decimal)):
             return str(value)
         elif isinstance(value, str):
-            return f"'{value}'"
+            return f"{delimiter}{value}{delimiter}"
         elif isinstance(value, bool):
             return str(value).lower()
-        elif isinstance(value, datetime.datetime):
-            return f"'{value.isoformat().replace('T', ' ')}'"
-        elif isinstance(value, datetime.date):
-            return f"'{value.isoformat()}'"
-        elif isinstance(value, datetime.time):
-            return f"'{value.isoformat()}'"
-        elif isinstance(value, datetime.timedelta):
-            interval = IntervalCustom.from_timedelta(value)
-            return getattr(interval, self._meta.engine_type)
         elif isinstance(value, bytes):
-            return f"'{value.hex()}'"
-        elif isinstance(value, uuid.UUID):
-            return f"'{value}'"
-        elif isinstance(value, list):
-            # Convert to the array syntax.
-            return (
-                "'{"
-                + ", ".join(
-                    (
-                        f'"{i}"'
-                        if isinstance(i, str)
-                        else str(self.get_sql_value(i))
+            return f"{delimiter}{value.hex()}{delimiter}"
+
+        # SQLite specific
+        if self._meta.engine_type == "sqlite":
+            if adapter := sqlite_adapters.get(type(value)):
+                sqlite_value = adapter(value)
+                return (
+                    f"{delimiter}{sqlite_value}{delimiter}"
+                    if isinstance(sqlite_value, str)
+                    else sqlite_value
+                )
+
+        # Postgres and Cockroach
+        if self._meta.engine_type in ["postgres", "cockroach"]:
+            if isinstance(value, datetime.datetime):
+                return f"{delimiter}{value.isoformat().replace('T', ' ')}{delimiter}"  # noqa: E501
+            elif isinstance(value, datetime.date):
+                return f"{delimiter}{value.isoformat()}{delimiter}"
+            elif isinstance(value, datetime.time):
+                return f"{delimiter}{value.isoformat()}{delimiter}"
+            elif isinstance(value, datetime.timedelta):
+                interval = IntervalCustom.from_timedelta(value)
+                return getattr(interval, self._meta.engine_type)
+            elif isinstance(value, uuid.UUID):
+                return f"{delimiter}{value}{delimiter}"
+            elif isinstance(value, list):
+                # Convert to the array syntax.
+                return (
+                    delimiter
+                    + "{"
+                    + ",".join(
+                        self.get_sql_value(
+                            i,
+                            delimiter="" if isinstance(i, list) else '"',
+                        )
+                        for i in value
                     )
-                    for i in value
+                    + "}"
+                    + delimiter
                 )
-            ) + "}'"
-        else:
-            return value
+
+        return str(value)
 
     @property
     def column_type(self):

piccolo/columns/column_types.py

@@ -57,7 +57,11 @@ from piccolo.columns.defaults.timestamptz import (
     TimestamptzNow,
 )
 from piccolo.columns.defaults.uuid import UUID4, UUIDArg
-from piccolo.columns.operators.comparison import ArrayAll, ArrayAny
+from piccolo.columns.operators.comparison import (
+    ArrayAll,
+    ArrayAny,
+    ArrayNotAny,
+)
 from piccolo.columns.operators.string import Concat
 from piccolo.columns.reference import LazyTableReference
 from piccolo.querystring import QueryString
@@ -1952,7 +1956,9 @@ class ForeignKey(Column, t.Generic[ReferencedTable]):
 
         if is_table_class:
             # Record the reverse relationship on the target table.
-            references._meta._foreign_key_references.append(self)
+            t.cast(
+                t.Type[Table], references
+            )._meta._foreign_key_references.append(self)
 
             # Allow columns on the referenced table to be accessed via
             # auto completion.
@@ -2670,6 +2676,24 @@ class Array(Column):
         else:
             raise ValueError("Unrecognised engine type")
 
+    def not_any(self, value: t.Any) -> Where:
+        """
+        Check if the given value isn't in the array.
+
+        .. code-block:: python
+
+            >>> await Ticket.select().where(Ticket.seat_numbers.not_any(510))
+
+        """
+        engine_type = self._meta.engine_type
+
+        if engine_type in ("postgres", "cockroach"):
+            return Where(column=self, value=value, operator=ArrayNotAny)
+        elif engine_type == "sqlite":
+            return self.not_like(f"%{value}%")
+        else:
+            raise ValueError("Unrecognised engine type")
+
     def all(self, value: t.Any) -> Where:
         """
         Check if all of the items in the array match the given value.
@@ -2688,7 +2712,7 @@ class Array(Column):
         else:
             raise ValueError("Unrecognised engine type")
 
-    def cat(self, value: t.List[t.Any]) -> QueryString:
+    def cat(self, value: t.Union[t.Any, t.List[t.Any]]) -> QueryString:
         """
         Used in an ``update`` query to append items to an array.
 
@@ -2719,7 +2743,7 @@ class Array(Column):
         db_column_name = self._meta.db_column_name
         return QueryString(f'array_cat("{db_column_name}", {{}})', value)
 
-    def __add__(self, value: t.List[t.Any]) -> QueryString:
+    def __add__(self, value: t.Union[t.Any, t.List[t.Any]]) -> QueryString:
         return self.cat(value)
 
     ###########################################################################

piccolo/columns/defaults/base.py

@@ -1,22 +1,24 @@
 from __future__ import annotations
 
 import typing as t
-from abc import ABC, abstractmethod, abstractproperty
+from abc import ABC, abstractmethod
 
 from piccolo.utils.repr import repr_class_instance
 
 
 class Default(ABC):
-    @abstractproperty
+    @property
+    @abstractmethod
     def postgres(self) -> str:
         pass
 
-    @abstractproperty
+    @property
+    @abstractmethod
     def sqlite(self) -> str:
         pass
 
     @abstractmethod
-    def python(self):
+    def python(self) -> t.Any:
         pass
 
     def get_postgres_interval_string(self, attributes: t.List[str]) -> str:

piccolo/columns/defaults/date.py

@@ -102,7 +102,15 @@ class DateCustom(Default):
 
 
 # Might add an enum back which encapsulates all of the options.
-DateArg = t.Union[DateOffset, DateCustom, DateNow, Enum, None, datetime.date]
+DateArg = t.Union[
+    DateOffset,
+    DateCustom,
+    DateNow,
+    Enum,
+    None,
+    datetime.date,
+    t.Callable[[], datetime.date],
+]
 
 
 __all__ = ["DateArg", "DateOffset", "DateCustom", "DateNow"]

piccolo/columns/defaults/interval.py

@@ -80,6 +80,7 @@ IntervalArg = t.Union[
     Enum,
     None,
     datetime.timedelta,
+    t.Callable[[], datetime.timedelta],
 ]
 
 

piccolo/columns/defaults/time.py

@@ -89,7 +89,15 @@ class TimeCustom(Default):
         )
 
 
-TimeArg = t.Union[TimeCustom, TimeNow, TimeOffset, Enum, None, datetime.time]
+TimeArg = t.Union[
+    TimeCustom,
+    TimeNow,
+    TimeOffset,
+    Enum,
+    None,
+    datetime.time,
+    t.Callable[[], datetime.time],
+]
 
 
 __all__ = ["TimeArg", "TimeCustom", "TimeNow", "TimeOffset"]

piccolo/columns/defaults/timestamp.py

@@ -138,6 +138,7 @@ TimestampArg = t.Union[
     None,
     datetime.datetime,
     DatetimeDefault,
+    t.Callable[[], datetime.datetime],
 ]
 
 

piccolo/columns/defaults/uuid.py

@@ -22,7 +22,7 @@ class UUID4(Default):
         return uuid.uuid4()
 
 
-UUIDArg = t.Union[UUID4, uuid.UUID, str, Enum, None]
+UUIDArg = t.Union[UUID4, uuid.UUID, str, Enum, None, t.Callable[[], uuid.UUID]]
 
 
 __all__ = ["UUIDArg", "UUID4"]

piccolo/columns/m2m.py

@@ -131,6 +131,7 @@ class M2MSelect(Selectable):
             if len(self.columns) > 1 or not self.serialisation_safe:
                 column_name = table_2_pk_name
             else:
+                assert len(self.columns) > 0
                 column_name = self.columns[0]._meta.db_column_name
 
             return QueryString(
@@ -256,15 +257,14 @@ class M2MMeta:
 
 @dataclass
 class M2MAddRelated:
-
     target_row: Table
     m2m: M2M
     rows: t.Sequence[Table]
     extra_column_values: t.Dict[t.Union[Column, str], t.Any]
 
-    def __post_init__(self) -> None:
-        # Normalise `extra_column_values`, so we just have the column names.
-        self.extra_column_values: t.Dict[str, t.Any] = {
+    @property
+    def resolved_extra_column_values(self) -> t.Dict[str, t.Any]:
+        return {
             i._meta.name if isinstance(i, Column) else i: j
             for i, j in self.extra_column_values.items()
         }
@@ -281,7 +281,9 @@ class M2MAddRelated:
         joining_table_rows = []
 
         for row in rows:
-            joining_table_row = joining_table(**self.extra_column_values)
+            joining_table_row = joining_table(
+                **self.resolved_extra_column_values
+            )
             setattr(
                 joining_table_row,
                 self.m2m._meta.primary_foreign_key._meta.name,
@@ -323,7 +325,6 @@ class M2MAddRelated:
 
 @dataclass
 class M2MRemoveRelated:
-
     target_row: Table
     m2m: M2M
     rows: t.Sequence[Table]
@@ -363,7 +364,6 @@ class M2MRemoveRelated:
 
 @dataclass
 class M2MGetRelated:
-
     row: Table
     m2m: M2M
 

piccolo/columns/operators/comparison.py

@@ -62,5 +62,9 @@ class ArrayAny(ComparisonOperator):
     template = "{value} = ANY ({name})"
 
 
+class ArrayNotAny(ComparisonOperator):
+    template = "NOT {value} = ANY ({name})"
+
+
 class ArrayAll(ComparisonOperator):
     template = "{value} = ALL ({name})"

piccolo/conf/apps.py

@@ -157,17 +157,22 @@ class AppConfig:
     """
 
     app_name: str
-    migrations_folder_path: str
+    migrations_folder_path: t.Union[str, pathlib.Path]
     table_classes: t.List[t.Type[Table]] = field(default_factory=list)
     migration_dependencies: t.List[str] = field(default_factory=list)
     commands: t.List[t.Union[t.Callable, Command]] = field(
         default_factory=list
     )
 
-    def __post_init__(self) -> None:
-        if isinstance(self.migrations_folder_path, pathlib.Path):
-            self.migrations_folder_path = str(self.migrations_folder_path)
+    @property
+    def resolved_migrations_folder_path(self) -> str:
+        return (
+            str(self.migrations_folder_path)
+            if isinstance(self.migrations_folder_path, pathlib.Path)
+            else self.migrations_folder_path
+        )
 
+    def __post_init__(self) -> None:
         self._migration_dependency_app_configs: t.Optional[
             t.List[AppConfig]
         ] = None

piccolo/engine/base.py

@@ -7,12 +7,14 @@ import string
 import typing as t
 from abc import ABCMeta, abstractmethod
 
+from typing_extensions import Self
+
 from piccolo.querystring import QueryString
 from piccolo.utils.sync import run_sync
 from piccolo.utils.warnings import Level, colored_string, colored_warning
 
 if t.TYPE_CHECKING:  # pragma: no cover
-    from piccolo.query.base import Query
+    from piccolo.query.base import DDL, Query
 
 
 logger = logging.getLogger(__name__)
@@ -32,31 +34,76 @@ def validate_savepoint_name(savepoint_name: str) -> None:
         )
 
 
-class Batch:
-    pass
+class BaseBatch(metaclass=ABCMeta):
+    @abstractmethod
+    async def __aenter__(self: Self, *args, **kwargs) -> Self: ...
 
+    @abstractmethod
+    async def __aexit__(self, *args, **kwargs): ...
 
-TransactionClass = t.TypeVar("TransactionClass")
+    @abstractmethod
+    def __aiter__(self: Self) -> Self: ...
 
+    @abstractmethod
+    async def __anext__(self) -> t.List[t.Dict]: ...
 
-class Engine(t.Generic[TransactionClass], metaclass=ABCMeta):
 
-    __slots__ = ("query_id",)
+class BaseTransaction(metaclass=ABCMeta):
 
-    def __init__(self):
-        run_sync(self.check_version())
-        run_sync(self.prep_database())
-        self.query_id = 0
+    __slots__: t.Tuple[str, ...] = tuple()
 
-    @property
     @abstractmethod
-    def engine_type(self) -> str:
-        pass
+    async def __aenter__(self, *args, **kwargs): ...
 
-    @property
     @abstractmethod
-    def min_version_number(self) -> float:
-        pass
+    async def __aexit__(self, *args, **kwargs) -> bool: ...
+
+
+class BaseAtomic(metaclass=ABCMeta):
+
+    __slots__: t.Tuple[str, ...] = tuple()
+
+    @abstractmethod
+    def add(self, *query: t.Union[Query, DDL]): ...
+
+    @abstractmethod
+    async def run(self): ...
+
+    @abstractmethod
+    def run_sync(self): ...
+
+    @abstractmethod
+    def __await__(self): ...
+
+
+TransactionClass = t.TypeVar("TransactionClass", bound=BaseTransaction)
+
+
+class Engine(t.Generic[TransactionClass], metaclass=ABCMeta):
+    __slots__ = (
+        "query_id",
+        "log_queries",
+        "log_responses",
+        "engine_type",
+        "min_version_number",
+        "current_transaction",
+    )
+
+    def __init__(
+        self,
+        engine_type: str,
+        min_version_number: t.Union[int, float],
+        log_queries: bool = False,
+        log_responses: bool = False,
+    ):
+        self.log_queries = log_queries
+        self.log_responses = log_responses
+        self.engine_type = engine_type
+        self.min_version_number = min_version_number
+
+        run_sync(self.check_version())
+        run_sync(self.prep_database())
+        self.query_id = 0
 
     @abstractmethod
     async def get_version(self) -> float:
@@ -76,11 +123,13 @@ class Engine(t.Generic[TransactionClass], metaclass=ABCMeta):
         query: Query,
         batch_size: int = 100,
         node: t.Optional[str] = None,
-    ) -> Batch:
+    ) -> BaseBatch:
         pass
 
     @abstractmethod
-    async def run_querystring(self, querystring: QueryString, in_pool: bool):
+    async def run_querystring(
+        self, querystring: QueryString, in_pool: bool = True
+    ):
         pass
 
     @abstractmethod
@@ -88,11 +137,11 @@ class Engine(t.Generic[TransactionClass], metaclass=ABCMeta):
         pass
 
     @abstractmethod
-    def transaction(self):
+    def transaction(self, *args, **kwargs) -> TransactionClass:
         pass
 
     @abstractmethod
-    def atomic(self):
+    def atomic(self) -> BaseAtomic:
         pass
 
     async def check_version(self):

piccolo/engine/cockroach.py

@@ -16,9 +16,6 @@ class CockroachEngine(PostgresEngine):
     :class:`PostgresEngine <piccolo.engine.postgres.PostgresEngine>`.
     """
 
-    engine_type = "cockroach"
-    min_version_number = 0  # Doesn't seem to work with cockroach versioning.
-
     def __init__(
         self,
         config: t.Dict[str, t.Any],
@@ -34,6 +31,8 @@ class CockroachEngine(PostgresEngine):
             log_responses=log_responses,
             extra_nodes=extra_nodes,
         )
+        self.engine_type = "cockroach"
+        self.min_version_number = 0
 
     async def prep_database(self):
         try: