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

piccolo/apps/migrations/auto/migration_manager.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 import inspect
 import logging
-import typing as t
+from collections.abc import Callable, Coroutine
 from dataclasses import dataclass, field
+from typing import Any, Optional, Union
 
 from piccolo.apps.migrations.auto.diffable_table import DiffableTable
 from piccolo.apps.migrations.auto.operations import (
@@ -32,19 +33,19 @@ class AddColumnClass:
     column: Column
     table_class_name: str
     tablename: str
-    schema: t.Optional[str]
+    schema: Optional[str]
 
 
 @dataclass
 class AddColumnCollection:
-    add_columns: t.List[AddColumnClass] = field(default_factory=list)
+    add_columns: list[AddColumnClass] = field(default_factory=list)
 
     def append(self, add_column: AddColumnClass):
         self.add_columns.append(add_column)
 
     def for_table_class_name(
         self, table_class_name: str
-    ) -> t.List[AddColumnClass]:
+    ) -> list[AddColumnClass]:
         return [
             i
             for i in self.add_columns
@@ -53,7 +54,7 @@ class AddColumnCollection:
 
     def columns_for_table_class_name(
         self, table_class_name: str
-    ) -> t.List[Column]:
+    ) -> list[Column]:
         return [
             i.column
             for i in self.add_columns
@@ -61,20 +62,18 @@ class AddColumnCollection:
         ]
 
     @property
-    def table_class_names(self) -> t.List[str]:
+    def table_class_names(self) -> list[str]:
         return list({i.table_class_name for i in self.add_columns})
 
 
 @dataclass
 class DropColumnCollection:
-    drop_columns: t.List[DropColumn] = field(default_factory=list)
+    drop_columns: list[DropColumn] = field(default_factory=list)
 
     def append(self, drop_column: DropColumn):
         self.drop_columns.append(drop_column)
 
-    def for_table_class_name(
-        self, table_class_name: str
-    ) -> t.List[DropColumn]:
+    def for_table_class_name(self, table_class_name: str) -> list[DropColumn]:
         return [
             i
             for i in self.drop_columns
@@ -82,20 +81,20 @@ class DropColumnCollection:
         ]
 
     @property
-    def table_class_names(self) -> t.List[str]:
+    def table_class_names(self) -> list[str]:
         return list({i.table_class_name for i in self.drop_columns})
 
 
 @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
@@ -103,20 +102,18 @@ class RenameColumnCollection:
         ]
 
     @property
-    def table_class_names(self) -> t.List[str]:
+    def table_class_names(self) -> list[str]:
         return list({i.table_class_name for i in self.rename_columns})
 
 
 @dataclass
 class AlterColumnCollection:
-    alter_columns: t.List[AlterColumn] = field(default_factory=list)
+    alter_columns: list[AlterColumn] = field(default_factory=list)
 
     def append(self, alter_column: AlterColumn):
         self.alter_columns.append(alter_column)
 
-    def for_table_class_name(
-        self, table_class_name: str
-    ) -> t.List[AlterColumn]:
+    def for_table_class_name(self, table_class_name: str) -> list[AlterColumn]:
         return [
             i
             for i in self.alter_columns
@@ -124,11 +121,11 @@ class AlterColumnCollection:
         ]
 
     @property
-    def table_class_names(self) -> t.List[str]:
+    def table_class_names(self) -> list[str]:
         return list({i.table_class_name for i in self.alter_columns})
 
 
-AsyncFunction = t.Callable[[], t.Coroutine]
+AsyncFunction = Callable[[], Coroutine]
 
 
 class SkippedTransaction:
@@ -158,12 +155,10 @@ class MigrationManager:
     app_name: str = ""
     description: str = ""
     preview: bool = False
-    add_tables: t.List[DiffableTable] = field(default_factory=list)
-    drop_tables: t.List[DiffableTable] = field(default_factory=list)
-    rename_tables: t.List[RenameTable] = field(default_factory=list)
-    change_table_schemas: t.List[ChangeTableSchema] = field(
-        default_factory=list
-    )
+    add_tables: list[DiffableTable] = field(default_factory=list)
+    drop_tables: list[DiffableTable] = field(default_factory=list)
+    rename_tables: list[RenameTable] = field(default_factory=list)
+    change_table_schemas: list[ChangeTableSchema] = field(default_factory=list)
     add_columns: AddColumnCollection = field(
         default_factory=AddColumnCollection
     )
@@ -176,10 +171,8 @@ class MigrationManager:
     alter_columns: AlterColumnCollection = field(
         default_factory=AlterColumnCollection
     )
-    raw: t.List[t.Union[t.Callable, AsyncFunction]] = field(
-        default_factory=list
-    )
-    raw_backwards: t.List[t.Union[t.Callable, AsyncFunction]] = field(
+    raw: list[Union[Callable, AsyncFunction]] = field(default_factory=list)
+    raw_backwards: list[Union[Callable, AsyncFunction]] = field(
         default_factory=list
     )
     fake: bool = False
@@ -189,8 +182,8 @@ class MigrationManager:
         self,
         class_name: str,
         tablename: str,
-        schema: t.Optional[str] = None,
-        columns: t.Optional[t.List[Column]] = None,
+        schema: Optional[str] = None,
+        columns: Optional[list[Column]] = None,
     ):
         if not columns:
             columns = []
@@ -205,7 +198,7 @@ class MigrationManager:
         )
 
     def drop_table(
-        self, class_name: str, tablename: str, schema: t.Optional[str] = None
+        self, class_name: str, tablename: str, schema: Optional[str] = None
     ):
         self.drop_tables.append(
             DiffableTable(
@@ -217,8 +210,8 @@ class MigrationManager:
         self,
         class_name: str,
         tablename: str,
-        new_schema: t.Optional[str] = None,
-        old_schema: t.Optional[str] = None,
+        new_schema: Optional[str] = None,
+        old_schema: Optional[str] = None,
     ):
         self.change_table_schemas.append(
             ChangeTableSchema(
@@ -235,7 +228,7 @@ class MigrationManager:
         old_tablename: str,
         new_class_name: str,
         new_tablename: str,
-        schema: t.Optional[str] = None,
+        schema: Optional[str] = None,
     ):
         self.rename_tables.append(
             RenameTable(
@@ -252,11 +245,11 @@ class MigrationManager:
         table_class_name: str,
         tablename: str,
         column_name: str,
-        db_column_name: t.Optional[str] = None,
+        db_column_name: Optional[str] = None,
         column_class_name: str = "",
-        column_class: t.Optional[t.Type[Column]] = None,
-        params: t.Optional[t.Dict[str, t.Any]] = None,
-        schema: t.Optional[str] = None,
+        column_class: Optional[type[Column]] = None,
+        params: Optional[dict[str, Any]] = None,
+        schema: Optional[str] = None,
     ):
         """
         Add a new column to the table.
@@ -297,8 +290,8 @@ class MigrationManager:
         table_class_name: str,
         tablename: str,
         column_name: str,
-        db_column_name: t.Optional[str] = None,
-        schema: t.Optional[str] = None,
+        db_column_name: Optional[str] = None,
+        schema: Optional[str] = None,
     ):
         self.drop_columns.append(
             DropColumn(
@@ -316,9 +309,9 @@ class MigrationManager:
         tablename: str,
         old_column_name: str,
         new_column_name: str,
-        old_db_column_name: t.Optional[str] = None,
-        new_db_column_name: t.Optional[str] = None,
-        schema: t.Optional[str] = None,
+        old_db_column_name: Optional[str] = None,
+        new_db_column_name: Optional[str] = None,
+        schema: Optional[str] = None,
     ):
         self.rename_columns.append(
             RenameColumn(
@@ -337,12 +330,12 @@ class MigrationManager:
         table_class_name: str,
         tablename: str,
         column_name: str,
-        db_column_name: t.Optional[str] = None,
-        params: t.Optional[t.Dict[str, t.Any]] = None,
-        old_params: t.Optional[t.Dict[str, t.Any]] = None,
-        column_class: t.Optional[t.Type[Column]] = None,
-        old_column_class: t.Optional[t.Type[Column]] = None,
-        schema: t.Optional[str] = None,
+        db_column_name: Optional[str] = None,
+        params: Optional[dict[str, Any]] = None,
+        old_params: Optional[dict[str, Any]] = None,
+        column_class: Optional[type[Column]] = None,
+        old_column_class: Optional[type[Column]] = None,
+        schema: Optional[str] = None,
     ):
         """
         All possible alterations aren't currently supported.
@@ -365,14 +358,14 @@ class MigrationManager:
             )
         )
 
-    def add_raw(self, raw: t.Union[t.Callable, AsyncFunction]):
+    def add_raw(self, raw: Union[Callable, AsyncFunction]):
         """
         A migration manager can execute arbitrary functions or coroutines when
         run. This is useful if you want to execute raw SQL.
         """
         self.raw.append(raw)
 
-    def add_raw_backwards(self, raw: t.Union[t.Callable, AsyncFunction]):
+    def add_raw_backwards(self, raw: Union[Callable, AsyncFunction]):
         """
         When reversing a migration, you may want to run extra code to help
         clean up.
@@ -384,10 +377,10 @@ class MigrationManager:
     async def get_table_from_snapshot(
         self,
         table_class_name: str,
-        app_name: t.Optional[str],
+        app_name: Optional[str],
         offset: int = 0,
-        migration_id: t.Optional[str] = None,
-    ) -> t.Type[Table]:
+        migration_id: Optional[str] = None,
+    ) -> type[Table]:
         """
         Returns a Table subclass which can be used for modifying data within
         a migration.
@@ -416,13 +409,13 @@ class MigrationManager:
     ###########################################################################
 
     @staticmethod
-    async def _print_query(query: t.Union[DDL, Query, SchemaDDLBase]):
+    async def _print_query(query: Union[DDL, Query, SchemaDDLBase]):
         if isinstance(query, DDL):
             print("\n", ";".join(query.ddl) + ";")
         else:
             print(str(query))
 
-    async def _run_query(self, query: t.Union[DDL, Query, SchemaDDLBase]):
+    async def _run_query(self, query: Union[DDL, Query, SchemaDDLBase]):
         """
         If MigrationManager is in preview mode then it just print the query
         instead of executing it.
@@ -441,7 +434,7 @@ class MigrationManager:
             if not alter_columns:
                 continue
 
-            _Table: t.Type[Table] = create_table_class(
+            _Table: type[Table] = create_table_class(
                 class_name=table_class_name,
                 class_kwargs={
                     "tablename": alter_columns[0].tablename,
@@ -494,7 +487,7 @@ class MigrationManager:
                             alter_column.db_column_name
                         )
 
-                        using_expression: t.Optional[str] = None
+                        using_expression: Optional[str] = None
 
                         # Postgres won't automatically cast some types to
                         # others. We may as well try, as it will definitely
@@ -739,7 +732,7 @@ class MigrationManager:
                 else rename_table.new_tablename
             )
 
-            _Table: t.Type[Table] = create_table_class(
+            _Table: type[Table] = create_table_class(
                 class_name=class_name,
                 class_kwargs={
                     "tablename": tablename,
@@ -760,7 +753,7 @@ class MigrationManager:
             if not columns:
                 continue
 
-            _Table: t.Type[Table] = create_table_class(
+            _Table: type[Table] = create_table_class(
                 class_name=table_class_name,
                 class_kwargs={
                     "tablename": columns[0].tablename,
@@ -788,12 +781,12 @@ class MigrationManager:
                 )
 
     async def _run_add_tables(self, backwards: bool = False):
-        table_classes: t.List[t.Type[Table]] = []
+        table_classes: list[type[Table]] = []
         for add_table in self.add_tables:
-            add_columns: t.List[AddColumnClass] = (
+            add_columns: list[AddColumnClass] = (
                 self.add_columns.for_table_class_name(add_table.class_name)
             )
-            _Table: t.Type[Table] = create_table_class(
+            _Table: type[Table] = create_table_class(
                 class_name=add_table.class_name,
                 class_kwargs={
                     "tablename": add_table.tablename,
@@ -845,7 +838,7 @@ class MigrationManager:
                 if table_class_name in [i.class_name for i in self.add_tables]:
                     continue  # No need to add columns to new tables
 
-                add_columns: t.List[AddColumnClass] = (
+                add_columns: list[AddColumnClass] = (
                     self.add_columns.for_table_class_name(table_class_name)
                 )
 

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)