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

piccolo/__init__.py

@@ -1 +1 @@
-__VERSION__ = "1.9.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/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

@@ -18,7 +18,7 @@ class Default(ABC):
         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:

piccolo/engine/postgres.py

@@ -4,7 +4,15 @@ import contextvars
 import typing as t
 from dataclasses import dataclass
 
-from piccolo.engine.base import Batch, Engine, validate_savepoint_name
+from typing_extensions import Self
+
+from piccolo.engine.base import (
+    BaseAtomic,
+    BaseBatch,
+    BaseTransaction,
+    Engine,
+    validate_savepoint_name,
+)
 from piccolo.engine.exceptions import TransactionError
 from piccolo.query.base import DDL, Query
 from piccolo.querystring import QueryString
@@ -18,16 +26,17 @@ if t.TYPE_CHECKING:  # pragma: no cover
     from asyncpg.connection import Connection
     from asyncpg.cursor import Cursor
     from asyncpg.pool import Pool
+    from asyncpg.transaction import Transaction
 
 
 @dataclass
-class AsyncBatch(Batch):
+class AsyncBatch(BaseBatch):
     connection: Connection
     query: Query
     batch_size: int
 
     # Set internally
-    _transaction = None
+    _transaction: t.Optional[Transaction] = None
     _cursor: t.Optional[Cursor] = None
 
     @property
@@ -36,20 +45,26 @@ class AsyncBatch(Batch):
             raise ValueError("_cursor not set")
         return self._cursor
 
+    @property
+    def transaction(self) -> Transaction:
+        if not self._transaction:
+            raise ValueError("The transaction can't be found.")
+        return self._transaction
+
     async def next(self) -> t.List[t.Dict]:
         data = await self.cursor.fetch(self.batch_size)
         return await self.query._process_results(data)
 
-    def __aiter__(self):
+    def __aiter__(self: Self) -> Self:
         return self
 
-    async def __anext__(self):
+    async def __anext__(self) -> t.List[t.Dict]:
         response = await self.next()
         if response == []:
             raise StopAsyncIteration()
         return response
 
-    async def __aenter__(self):
+    async def __aenter__(self: Self) -> Self:
         self._transaction = self.connection.transaction()
         await self._transaction.start()
         querystring = self.query.querystrings[0]
@@ -60,9 +75,9 @@ class AsyncBatch(Batch):
 
     async def __aexit__(self, exception_type, exception, traceback):
         if exception:
-            await self._transaction.rollback()
+            await self.transaction.rollback()
         else:
-            await self._transaction.commit()
+            await self.transaction.commit()
 
         await self.connection.close()
 
@@ -72,7 +87,7 @@ class AsyncBatch(Batch):
 ###############################################################################
 
 
-class Atomic:
+class Atomic(BaseAtomic):
     """
     This is useful if you want to build up a transaction programatically, by
     adding queries to it.
@@ -140,7 +155,7 @@ class Savepoint:
         )
 
 
-class PostgresTransaction:
+class PostgresTransaction(BaseTransaction):
     """
     Used for wrapping queries in a transaction, using a context manager.
     Currently it's async only.
@@ -243,7 +258,7 @@ class PostgresTransaction:
 
     ###########################################################################
 
-    async def __aexit__(self, exception_type, exception, traceback):
+    async def __aexit__(self, exception_type, exception, traceback) -> bool:
         if self._parent:
             return exception is None
 
@@ -269,7 +284,7 @@ class PostgresTransaction:
 ###############################################################################
 
 
-class PostgresEngine(Engine[t.Optional[PostgresTransaction]]):
+class PostgresEngine(Engine[PostgresTransaction]):
     """
     Used to connect to PostgreSQL.
 
@@ -331,16 +346,10 @@ class PostgresEngine(Engine[t.Optional[PostgresTransaction]]):
     __slots__ = (
         "config",
         "extensions",
-        "log_queries",
-        "log_responses",
         "extra_nodes",
         "pool",
-        "current_transaction",
     )
 
-    engine_type = "postgres"
-    min_version_number = 10
-
     def __init__(
         self,
         config: t.Dict[str, t.Any],
@@ -362,7 +371,12 @@ class PostgresEngine(Engine[t.Optional[PostgresTransaction]]):
         self.current_transaction = contextvars.ContextVar(
             f"pg_current_transaction_{database_name}", default=None
         )
-        super().__init__()
+        super().__init__(
+            engine_type="postgres",
+            log_queries=log_queries,
+            log_responses=log_responses,
+            min_version_number=10,
+        )
 
     @staticmethod
     def _parse_raw_version_string(version_string: str) -> float: