piccolo 1.27.1__py3-none-any.whl → 1.28.0__py3-none-any.whl

piccolo/apps/migrations/auto/operations.py

@@ -1,5 +1,5 @@
-import typing as t
 from dataclasses import dataclass
+from typing import Any, Optional
 
 from piccolo.columns.base import Column
 
@@ -10,15 +10,15 @@ class RenameTable:
     old_tablename: str
     new_class_name: str
     new_tablename: str
-    schema: t.Optional[str] = None
+    schema: Optional[str] = None
 
 
 @dataclass
 class ChangeTableSchema:
     class_name: str
     tablename: str
-    old_schema: t.Optional[str]
-    new_schema: t.Optional[str]
+    old_schema: Optional[str]
+    new_schema: Optional[str]
 
 
 @dataclass
@@ -29,7 +29,7 @@ class RenameColumn:
     new_column_name: str
     old_db_column_name: str
     new_db_column_name: str
-    schema: t.Optional[str] = None
+    schema: Optional[str] = None
 
 
 @dataclass
@@ -38,11 +38,11 @@ class AlterColumn:
     column_name: str
     db_column_name: str
     tablename: str
-    params: t.Dict[str, t.Any]
-    old_params: t.Dict[str, t.Any]
-    column_class: t.Optional[t.Type[Column]] = None
-    old_column_class: t.Optional[t.Type[Column]] = None
-    schema: t.Optional[str] = None
+    params: dict[str, Any]
+    old_params: dict[str, Any]
+    column_class: Optional[type[Column]] = None
+    old_column_class: Optional[type[Column]] = None
+    schema: Optional[str] = None
 
 
 @dataclass
@@ -51,7 +51,7 @@ class DropColumn:
     column_name: str
     db_column_name: str
     tablename: str
-    schema: t.Optional[str] = None
+    schema: Optional[str] = None
 
 
 @dataclass
@@ -60,6 +60,6 @@ class AddColumn:
     column_name: str
     db_column_name: str
     column_class_name: str
-    column_class: t.Type[Column]
-    params: t.Dict[str, t.Any]
-    schema: t.Optional[str] = None
+    column_class: type[Column]
+    params: dict[str, Any]
+    schema: Optional[str] = None

piccolo/apps/migrations/auto/schema_differ.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
 import inspect
-import typing as t
+from collections.abc import Callable
 from copy import deepcopy
 from dataclasses import dataclass, field
+from typing import Any, Optional
 
 from piccolo.apps.migrations.auto.diffable_table import (
     DiffableTable,
@@ -26,7 +27,7 @@ from piccolo.utils.printing import get_fixed_length_string
 
 @dataclass
 class RenameTableCollection:
-    rename_tables: t.List[RenameTable] = field(default_factory=list)
+    rename_tables: list[RenameTable] = field(default_factory=list)
 
     def append(self, renamed_table: RenameTable):
         self.rename_tables.append(renamed_table)
@@ -48,7 +49,7 @@ class RenameTableCollection:
                 return True
         return False
 
-    def renamed_from(self, new_class_name: str) -> t.Optional[str]:
+    def renamed_from(self, new_class_name: str) -> Optional[str]:
         """
         Returns the old class name, if it exists.
         """
@@ -60,7 +61,7 @@ class RenameTableCollection:
 
 @dataclass
 class ChangeTableSchemaCollection:
-    collection: t.List[ChangeTableSchema] = field(default_factory=list)
+    collection: list[ChangeTableSchema] = field(default_factory=list)
 
     def append(self, change_table_schema: ChangeTableSchema):
         self.collection.append(change_table_schema)
@@ -68,14 +69,14 @@ class ChangeTableSchemaCollection:
 
 @dataclass
 class RenameColumnCollection:
-    rename_columns: t.List[RenameColumn] = field(default_factory=list)
+    rename_columns: list[RenameColumn] = field(default_factory=list)
 
     def append(self, rename_column: RenameColumn):
         self.rename_columns.append(rename_column)
 
     def for_table_class_name(
         self, table_class_name: str
-    ) -> t.List[RenameColumn]:
+    ) -> list[RenameColumn]:
         return [
             i
             for i in self.rename_columns
@@ -93,9 +94,9 @@ class RenameColumnCollection:
 
 @dataclass
 class AlterStatements:
-    statements: t.List[str] = field(default_factory=list)
-    extra_imports: t.List[Import] = field(default_factory=list)
-    extra_definitions: t.List[Definition] = field(default_factory=list)
+    statements: list[str] = field(default_factory=list)
+    extra_imports: list[Import] = field(default_factory=list)
+    extra_definitions: list[Definition] = field(default_factory=list)
 
     def extend(self, alter_statements: AlterStatements):
         self.statements.extend(alter_statements.statements)
@@ -112,19 +113,19 @@ class SchemaDiffer:
     sure - for example, whether a column was renamed.
     """
 
-    schema: t.List[DiffableTable]
-    schema_snapshot: t.List[DiffableTable]
+    schema: list[DiffableTable]
+    schema_snapshot: list[DiffableTable]
 
     # Sometimes the SchemaDiffer requires input from a user - for example,
     # asking if a table was renamed or not. When running in non-interactive
     # mode (like in a unittest), we can set a default to be used instead, like
     # 'y'.
-    auto_input: t.Optional[str] = None
+    auto_input: Optional[str] = None
 
     ###########################################################################
 
     def __post_init__(self) -> None:
-        self.schema_snapshot_map: t.Dict[str, DiffableTable] = {
+        self.schema_snapshot_map: dict[str, DiffableTable] = {
             i.class_name: i for i in self.schema_snapshot
         }
         self.table_schema_changes_collection = (
@@ -137,11 +138,11 @@ class SchemaDiffer:
         """
         Work out whether any of the tables were renamed.
         """
-        drop_tables: t.List[DiffableTable] = list(
+        drop_tables: list[DiffableTable] = list(
             set(self.schema_snapshot) - set(self.schema)
         )
 
-        new_tables: t.List[DiffableTable] = list(
+        new_tables: list[DiffableTable] = list(
             set(self.schema) - set(self.schema_snapshot)
         )
 
@@ -267,7 +268,7 @@ class SchemaDiffer:
             # We track which dropped columns have already been identified by
             # the user as renames, so we don't ask them if another column
             # was also renamed from it.
-            used_drop_column_names: t.List[str] = []
+            used_drop_column_names: list[str] = []
 
             for add_column in delta.add_columns:
                 for drop_column in delta.drop_columns:
@@ -300,9 +301,9 @@ class SchemaDiffer:
 
     def _stringify_func(
         self,
-        func: t.Callable,
-        params: t.Dict[str, t.Any],
-        prefix: t.Optional[str] = None,
+        func: Callable,
+        params: dict[str, Any],
+        prefix: Optional[str] = None,
     ) -> AlterStatements:
         """
         Generates a string representing how to call the given function with the
@@ -348,7 +349,7 @@ class SchemaDiffer:
 
     @property
     def create_tables(self) -> AlterStatements:
-        new_tables: t.List[DiffableTable] = list(
+        new_tables: list[DiffableTable] = list(
             set(self.schema) - set(self.schema_snapshot)
         )
 
@@ -379,7 +380,7 @@ class SchemaDiffer:
 
     @property
     def drop_tables(self) -> AlterStatements:
-        drop_tables: t.List[DiffableTable] = list(
+        drop_tables: list[DiffableTable] = list(
             set(self.schema_snapshot) - set(self.schema)
         )
 
@@ -442,7 +443,7 @@ class SchemaDiffer:
 
     def _get_snapshot_table(
         self, table_class_name: str
-    ) -> t.Optional[DiffableTable]:
+    ) -> Optional[DiffableTable]:
         snapshot_table = self.schema_snapshot_map.get(table_class_name, None)
         if snapshot_table:
             return snapshot_table
@@ -463,9 +464,9 @@ class SchemaDiffer:
 
     @property
     def alter_columns(self) -> AlterStatements:
-        response: t.List[str] = []
-        extra_imports: t.List[Import] = []
-        extra_definitions: t.List[Definition] = []
+        response: list[str] = []
+        extra_imports: list[Import] = []
+        extra_definitions: list[Definition] = []
         for table in self.schema:
             snapshot_table = self._get_snapshot_table(table.class_name)
             if snapshot_table:
@@ -563,9 +564,9 @@ class SchemaDiffer:
 
     @property
     def add_columns(self) -> AlterStatements:
-        response: t.List[str] = []
-        extra_imports: t.List[Import] = []
-        extra_definitions: t.List[Definition] = []
+        response: list[str] = []
+        extra_imports: list[Import] = []
+        extra_definitions: list[Definition] = []
         for table in self.schema:
             snapshot_table = self._get_snapshot_table(table.class_name)
             if snapshot_table:
@@ -632,13 +633,13 @@ class SchemaDiffer:
 
     @property
     def new_table_columns(self) -> AlterStatements:
-        new_tables: t.List[DiffableTable] = list(
+        new_tables: list[DiffableTable] = list(
             set(self.schema) - set(self.schema_snapshot)
         )
 
-        response: t.List[str] = []
-        extra_imports: t.List[Import] = []
-        extra_definitions: t.List[Definition] = []
+        response: list[str] = []
+        extra_imports: list[Import] = []
+        extra_definitions: list[Definition] = []
         for table in new_tables:
             if (
                 table.class_name
@@ -681,11 +682,11 @@ class SchemaDiffer:
 
     ###########################################################################
 
-    def get_alter_statements(self) -> t.List[AlterStatements]:
+    def get_alter_statements(self) -> list[AlterStatements]:
         """
         Call to execute the necessary alter commands on the database.
         """
-        alter_statements: t.Dict[str, AlterStatements] = {
+        alter_statements: dict[str, AlterStatements] = {
             "Created tables": self.create_tables,
             "Dropped tables": self.drop_tables,
             "Renamed tables": self.rename_tables,

piccolo/apps/migrations/auto/schema_snapshot.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import typing as t
 from dataclasses import dataclass, field
 
 from piccolo.apps.migrations.auto.diffable_table import DiffableTable
@@ -15,7 +14,7 @@ class SchemaSnapshot:
     """
 
     # In ascending order of date created.
-    managers: t.List[MigrationManager] = field(default_factory=list)
+    managers: list[MigrationManager] = field(default_factory=list)
 
     ###########################################################################
 
@@ -28,8 +27,8 @@ class SchemaSnapshot:
 
     ###########################################################################
 
-    def get_snapshot(self) -> t.List[DiffableTable]:
-        tables: t.List[DiffableTable] = []
+    def get_snapshot(self) -> list[DiffableTable]:
+        tables: list[DiffableTable] = []
 
         # Make sure the managers are sorted correctly:
         sorted_managers = sorted(self.managers, key=lambda x: x.migration_id)

piccolo/apps/migrations/auto/serialisation.py

@@ -5,12 +5,13 @@ import builtins
 import datetime
 import decimal
 import inspect
-import typing as t
 import uuid
 import warnings
+from collections.abc import Callable, Iterable
 from copy import deepcopy
 from dataclasses import dataclass, field
 from enum import Enum
+from typing import Any, Optional
 
 from piccolo.columns import Column
 from piccolo.columns.defaults.base import Default
@@ -61,8 +62,8 @@ class UniqueGlobalNamesMeta(type):
 
     @staticmethod
     def get_unique_class_attribute_values(
-        class_attributes: t.Dict[str, t.Any],
-    ) -> t.Set[t.Any]:
+        class_attributes: dict[str, Any],
+    ) -> set[Any]:
         """
         Return class attribute values.
 
@@ -87,9 +88,9 @@ class UniqueGlobalNamesMeta(type):
 
     @staticmethod
     def merge_class_attributes(
-        class_attributes1: t.Dict[str, t.Any],
-        class_attributes2: t.Dict[str, t.Any],
-    ) -> t.Dict[str, t.Any]:
+        class_attributes1: dict[str, Any],
+        class_attributes2: dict[str, Any],
+    ) -> dict[str, Any]:
         """
         Merges two class attribute dictionaries.
 
@@ -104,12 +105,12 @@ class UniqueGlobalNamesMeta(type):
         return dict(**class_attributes1, **class_attributes2)
 
     @staticmethod
-    def get_column_class_attributes() -> t.Dict[str, str]:
+    def get_column_class_attributes() -> dict[str, str]:
         """Automatically generates global names for each column type."""
 
         import piccolo.columns.column_types
 
-        class_attributes: t.Dict[str, str] = {}
+        class_attributes: dict[str, str] = {}
         for module_global in piccolo.columns.column_types.__dict__.values():
             try:
                 if module_global is not Column and issubclass(
@@ -150,7 +151,7 @@ class UniqueGlobalNames(metaclass=UniqueGlobalNamesMeta):
     EXTERNAL_UUID = f"{EXTERNAL_MODULE_UUID}.{uuid.UUID.__name__}"
 
     # This attribute is set in metaclass
-    unique_names: t.Set[str]
+    unique_names: set[str]
 
     @classmethod
     def warn_if_is_conflicting_name(
@@ -172,7 +173,7 @@ class UniqueGlobalNames(metaclass=UniqueGlobalNamesMeta):
 
     @staticmethod
     def warn_if_are_conflicting_objects(
-        objects: t.Iterable[CanConflictWithGlobalNames],
+        objects: Iterable[CanConflictWithGlobalNames],
     ) -> None:
         """
         Call each object's ``raise_if_is_conflicting_with_global_name`` method.
@@ -192,8 +193,8 @@ class UniqueGlobalNameConflictWarning(UserWarning):
 @dataclass
 class Import(CanConflictWithGlobalNames):
     module: str
-    target: t.Optional[str] = None
-    expect_conflict_with_global_name: t.Optional[str] = None
+    target: Optional[str] = None
+    expect_conflict_with_global_name: Optional[str] = None
 
     def __post_init__(self) -> None:
         if (
@@ -256,9 +257,9 @@ class Definition(CanConflictWithGlobalNames, abc.ABC):
 
 @dataclass
 class SerialisedParams:
-    params: t.Dict[str, t.Any]
-    extra_imports: t.List[Import]
-    extra_definitions: t.List[Definition] = field(default_factory=list)
+    params: dict[str, Any]
+    extra_imports: list[Import]
+    extra_definitions: list[Definition] = field(default_factory=list)
 
 
 ###############################################################################
@@ -273,7 +274,7 @@ def check_equality(self, other):
 
 @dataclass
 class SerialisedBuiltin:
-    builtin: t.Any
+    builtin: Any
 
     def __hash__(self):
         return hash(self.builtin.__name__)
@@ -335,7 +336,7 @@ class SerialisedEnumInstance:
 
 @dataclass
 class SerialisedTableType(Definition):
-    table_type: t.Type[Table]
+    table_type: type[Table]
 
     def __hash__(self):
         return hash(
@@ -361,7 +362,7 @@ class SerialisedTableType(Definition):
 
         # When creating a ForeignKey, the user can specify a column other than
         # the primary key to reference.
-        serialised_target_columns: t.Set[SerialisedColumnInstance] = set()
+        serialised_target_columns: set[SerialisedColumnInstance] = set()
 
         for fk_column in self.table_type._meta._foreign_key_references:
             target_column = fk_column._foreign_key_meta.target_column
@@ -426,7 +427,7 @@ class SerialisedTableType(Definition):
 
 @dataclass
 class SerialisedEnumType:
-    enum_type: t.Type[Enum]
+    enum_type: type[Enum]
 
     def __hash__(self):
         return hash(self.__repr__())
@@ -442,7 +443,7 @@ class SerialisedEnumType:
 
 @dataclass
 class SerialisedCallable:
-    callable_: t.Callable
+    callable_: Callable
 
     def __hash__(self):
         return hash(self.callable_.__name__)
@@ -487,14 +488,14 @@ class SerialisedDecimal:
 ###############################################################################
 
 
-def serialise_params(params: t.Dict[str, t.Any]) -> SerialisedParams:
+def serialise_params(params: dict[str, Any]) -> SerialisedParams:
     """
     When writing column params to a migration file, we need to serialise some
     of the values.
     """
     params = deepcopy(params)
-    extra_imports: t.List[Import] = []
-    extra_definitions: t.List[Definition] = []
+    extra_imports: list[Import] = []
+    extra_definitions: list[Definition] = []
 
     for key, value in params.items():
         # Builtins, such as str, list and dict.
@@ -725,7 +726,7 @@ def serialise_params(params: t.Dict[str, t.Any]) -> SerialisedParams:
     )
 
 
-def deserialise_params(params: t.Dict[str, t.Any]) -> t.Dict[str, t.Any]:
+def deserialise_params(params: dict[str, Any]) -> dict[str, Any]:
     """
     When reading column params from a migration file, we need to convert
     them from their serialised form.
@@ -737,6 +738,8 @@ 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, SerialisedColumnInstance):
+            params[key] = value.instance
         elif isinstance(value, SerialisedClassInstance):
             params[key] = value.instance
         elif isinstance(value, SerialisedUUID):

piccolo/apps/migrations/auto/serialisation_legacy.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 import datetime
-import typing as t
+from typing import Any
 
 from piccolo.columns.column_types import OnDelete, OnUpdate
 from piccolo.columns.defaults.timestamp import TimestampNow
 from piccolo.table import create_table_class
 
 
-def deserialise_legacy_params(name: str, value: str) -> t.Any:
+def deserialise_legacy_params(name: str, value: str) -> Any:
     """
     Earlier versions of Piccolo serialised parameters differently. This is
     here purely for backwards compatibility.

piccolo/apps/migrations/commands/backwards.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import os
 import sys
-import typing as t
 
 from piccolo.apps.migrations.auto.migration_manager import MigrationManager
 from piccolo.apps.migrations.commands.base import (
@@ -31,7 +30,7 @@ class BackwardsMigrationManager(BaseMigrationManager):
         super().__init__()
 
     async def run_migrations_backwards(self, app_config: AppConfig):
-        migration_modules: t.Dict[str, MigrationModule] = (
+        migration_modules: dict[str, MigrationModule] = (
             self.get_migration_modules(
                 app_config.resolved_migrations_folder_path
             )

piccolo/apps/migrations/commands/base.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 import importlib
 import os
 import sys
-import typing as t
 from dataclasses import dataclass
+from typing import Optional, cast
 
 from piccolo.apps.migrations.auto.diffable_table import DiffableTable
 from piccolo.apps.migrations.auto.migration_manager import MigrationManager
@@ -16,7 +16,7 @@ from piccolo.conf.apps import AppConfig, Finder, MigrationModule
 @dataclass
 class MigrationResult:
     success: bool
-    message: t.Optional[str] = None
+    message: Optional[str] = None
 
 
 class BaseMigrationManager(Finder):
@@ -32,7 +32,7 @@ class BaseMigrationManager(Finder):
 
     def get_migration_modules(
         self, folder_path: str
-    ) -> t.Dict[str, MigrationModule]:
+    ) -> dict[str, MigrationModule]:
         """
         Imports the migration modules in the given folder path, and returns
         a mapping of migration ID to the corresponding migration module.
@@ -50,8 +50,8 @@ class BaseMigrationManager(Finder):
             if ((i not in excluded) and i.endswith(".py"))
         ]
 
-        modules: t.List[MigrationModule] = [
-            t.cast(MigrationModule, importlib.import_module(name))
+        modules: list[MigrationModule] = [
+            cast(MigrationModule, importlib.import_module(name))
             for name in migration_names
         ]
         for m in modules:
@@ -62,8 +62,8 @@ class BaseMigrationManager(Finder):
         return migration_modules
 
     def get_migration_ids(
-        self, migration_module_dict: t.Dict[str, MigrationModule]
-    ) -> t.List[str]:
+        self, migration_module_dict: dict[str, MigrationModule]
+    ) -> list[str]:
         """
         Returns a list of migration IDs, from the Python migration files.
         """
@@ -72,9 +72,9 @@ class BaseMigrationManager(Finder):
     async def get_migration_managers(
         self,
         app_config: AppConfig,
-        max_migration_id: t.Optional[str] = None,
+        max_migration_id: Optional[str] = None,
         offset: int = 0,
-    ) -> t.List[MigrationManager]:
+    ) -> list[MigrationManager]:
         """
         Call the forwards coroutine in each migration module. Each one should
         return a `MigrationManger`. Combine all of the results, and return in
@@ -84,11 +84,11 @@ class BaseMigrationManager(Finder):
             If set, only MigrationManagers up to and including the given
             migration ID will be returned.
         """
-        migration_managers: t.List[MigrationManager] = []
+        migration_managers: list[MigrationManager] = []
 
         migrations_folder = app_config.resolved_migrations_folder_path
 
-        migration_modules: t.Dict[str, MigrationModule] = (
+        migration_modules: dict[str, MigrationModule] = (
             self.get_migration_modules(migrations_folder)
         )
 
@@ -118,7 +118,7 @@ class BaseMigrationManager(Finder):
         self,
         app_name: str,
         table_class_name: str,
-        max_migration_id: t.Optional[str] = None,
+        max_migration_id: Optional[str] = None,
         offset: int = 0,
     ) -> DiffableTable:
         """

piccolo/apps/migrations/commands/check.py

@@ -1,5 +1,4 @@
 import dataclasses
-import typing as t
 
 from piccolo.apps.migrations.commands.base import BaseMigrationManager
 from piccolo.apps.migrations.tables import Migration
@@ -19,11 +18,11 @@ class CheckMigrationManager(BaseMigrationManager):
         self.app_name = app_name
         super().__init__()
 
-    async def get_migration_statuses(self) -> t.List[MigrationStatus]:
+    async def get_migration_statuses(self) -> list[MigrationStatus]:
         # Make sure the migration table exists, otherwise we'll get an error.
         await self.create_migration_table()
 
-        migration_statuses: t.List[MigrationStatus] = []
+        migration_statuses: list[MigrationStatus] = []
 
         app_modules = self.get_app_modules()
 

piccolo/apps/migrations/commands/clean.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import typing as t
+from typing import cast
 
 from piccolo.apps.migrations.commands.base import BaseMigrationManager
 from piccolo.apps.migrations.tables import Migration
@@ -12,7 +12,7 @@ class CleanMigrationManager(BaseMigrationManager):
         self.auto_agree = auto_agree
         super().__init__()
 
-    def get_migration_ids_to_remove(self) -> t.List[str]:
+    def get_migration_ids_to_remove(self) -> list[str]:
         """
         Returns a list of migration ID strings, which are rows in the table,
         but don't have a corresponding migration module on disk.
@@ -37,7 +37,7 @@ class CleanMigrationManager(BaseMigrationManager):
         if len(migration_ids) > 0:
             query = query.where(Migration.name.not_in(migration_ids))
 
-        return t.cast(t.List[str], query.run_sync())
+        return cast(list[str], query.run_sync())
 
     async def run(self):
         print("Checking the migration table ...")

piccolo/apps/migrations/commands/forwards.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import sys
-import typing as t
 
 from piccolo.apps.migrations.auto.migration_manager import MigrationManager
 from piccolo.apps.migrations.commands.base import (
@@ -32,7 +31,7 @@ class ForwardsMigrationManager(BaseMigrationManager):
             app_name=app_config.app_name
         )
 
-        migration_modules: t.Dict[str, MigrationModule] = (
+        migration_modules: dict[str, MigrationModule] = (
             self.get_migration_modules(
                 app_config.resolved_migrations_folder_path
             )