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

piccolo/__init__.py

@@ -1 +1 @@
-__VERSION__ = "1.27.0"
+__VERSION__ = "1.28.0"

piccolo/apps/app/commands/new.py

@@ -5,7 +5,7 @@ import os
 import pathlib
 import string
 import sys
-import typing as t
+from typing import Any
 
 import black
 import jinja2
@@ -46,7 +46,7 @@ def validate_app_name(app_name: str):
 
     """
     for char in app_name:
-        if not char.lower() in APP_NAME_ALLOWED_CHARACTERS:
+        if char.lower() not in APP_NAME_ALLOWED_CHARACTERS:
             raise ValueError(
                 f"The app name contains a disallowed character: `{char}`. "
                 "It must only include a-z, 0-9, and _ characters."
@@ -81,7 +81,7 @@ def new_app(app_name: str, root: str = ".", register: bool = False):
     with open(os.path.join(app_root, "__init__.py"), "w"):
         pass
 
-    templates: t.Dict[str, t.Any] = {
+    templates: dict[str, Any] = {
         "piccolo_app.py": {"app_name": app_name},
         "tables.py": {},
     }

piccolo/apps/asgi/commands/new.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import os
 import shutil
-import typing as t
 
 import black
 import colorama
@@ -28,7 +27,7 @@ def print_instruction(message: str):
     print(f"{colorama.Fore.CYAN}{message}{colorama.Fore.RESET}")
 
 
-def get_options_string(options: t.List[str]):
+def get_options_string(options: list[str]):
     return ", ".join(f"{name} [{index}]" for index, name in enumerate(options))
 
 

piccolo/apps/fixtures/commands/dump.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import typing as t
+from typing import Any, Optional
 
 from piccolo.apps.fixtures.commands.shared import (
     FixtureConfig,
@@ -11,8 +11,8 @@ from piccolo.table import sort_table_classes
 
 
 async def get_dump(
-    fixture_configs: t.List[FixtureConfig],
-) -> t.Dict[str, t.Any]:
+    fixture_configs: list[FixtureConfig],
+) -> dict[str, Any]:
     """
     Gets the data for each table specified and returns a data structure like:
 
@@ -32,7 +32,7 @@ async def get_dump(
     """
     finder = Finder()
 
-    output: t.Dict[str, t.Any] = {}
+    output: dict[str, Any] = {}
 
     for fixture_config in fixture_configs:
         app_config = finder.get_app_config(app_name=fixture_config.app_name)
@@ -53,7 +53,7 @@ async def get_dump(
 
 
 async def dump_to_json_string(
-    fixture_configs: t.List[FixtureConfig],
+    fixture_configs: list[FixtureConfig],
 ) -> str:
     """
     Dumps all of the data for the given tables into a JSON string.
@@ -65,7 +65,7 @@ async def dump_to_json_string(
     return pydantic_model(**dump).model_dump_json(indent=4)
 
 
-def parse_args(apps: str, tables: str) -> t.List[FixtureConfig]:
+def parse_args(apps: str, tables: str) -> list[FixtureConfig]:
     """
     Works out which apps and tables the user is referring to.
     """
@@ -80,11 +80,11 @@ def parse_args(apps: str, tables: str) -> t.List[FixtureConfig]:
         # Must be a single app name
         app_names.append(apps)
 
-    table_class_names: t.Optional[t.List[str]] = None
+    table_class_names: Optional[list[str]] = None
 
     if tables != "all":
         table_class_names = tables.split(",") if "," in tables else [tables]
-    output: t.List[FixtureConfig] = []
+    output: list[FixtureConfig] = []
 
     for app_name in app_names:
         app_config = finder.get_app_config(app_name=app_name)

piccolo/apps/fixtures/commands/load.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import sys
-import typing as t
+from typing import Optional
 
 import typing_extensions
 
@@ -20,7 +20,7 @@ from piccolo.utils.list import batch
 async def load_json_string(
     json_string: str,
     chunk_size: int = 1000,
-    on_conflict_action: t.Optional[OnConflictAction] = None,
+    on_conflict_action: Optional[OnConflictAction] = None,
 ):
     """
     Parses the JSON string, and inserts the parsed data into the database.
@@ -55,7 +55,7 @@ async def load_json_string(
         raise Exception("Unable to find the engine.")
 
     # This is what we want to the insert into the database:
-    data: t.Dict[t.Type[Table], t.List[Table]] = {}
+    data: dict[type[Table], list[Table]] = {}
 
     for app_name in app_names:
         app_model = getattr(fixture_pydantic_model, app_name)
@@ -94,7 +94,7 @@ async def load_json_string(
 async def load(
     path: str = "fixture.json",
     chunk_size: int = 1000,
-    on_conflict: t.Optional[
+    on_conflict: Optional[
         typing_extensions.Literal["DO NOTHING", "DO UPDATE"]
     ] = None,
 ):
@@ -118,7 +118,7 @@ async def load(
     with open(path, "r") as f:
         contents = f.read()
 
-    on_conflict_action: t.Optional[OnConflictAction] = None
+    on_conflict_action: Optional[OnConflictAction] = None
 
     if on_conflict:
         try:

piccolo/apps/fixtures/commands/shared.py

@@ -1,42 +1,42 @@
 from __future__ import annotations
 
-import typing as t
 from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
 
 import pydantic
 
 from piccolo.conf.apps import Finder
 from piccolo.utils.pydantic import create_pydantic_model
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.table import Table
 
 
 @dataclass
 class FixtureConfig:
     app_name: str
-    table_class_names: t.List[str]
+    table_class_names: list[str]
 
 
-def create_pydantic_fixture_model(fixture_configs: t.List[FixtureConfig]):
+def create_pydantic_fixture_model(fixture_configs: list[FixtureConfig]):
     """
     Returns a nested Pydantic model for serialising and deserialising fixtures.
     """
-    columns: t.Dict[str, t.Any] = {}
+    columns: dict[str, Any] = {}
 
     finder = Finder()
 
     for fixture_config in fixture_configs:
 
-        app_columns: t.Dict[str, t.Any] = {}
+        app_columns: dict[str, Any] = {}
 
         for table_class_name in fixture_config.table_class_names:
-            table_class: t.Type[Table] = finder.get_table_with_name(
+            table_class: type[Table] = finder.get_table_with_name(
                 app_name=fixture_config.app_name,
                 table_class_name=table_class_name,
             )
             app_columns[table_class_name] = (
-                t.List[  # type: ignore
+                list[  # type: ignore
                     create_pydantic_model(
                         table_class, include_default_columns=True
                     )
@@ -44,7 +44,7 @@ def create_pydantic_fixture_model(fixture_configs: t.List[FixtureConfig]):
                 ...,
             )
 
-        app_model: t.Any = pydantic.create_model(
+        app_model: Any = pydantic.create_model(
             f"{fixture_config.app_name.title()}Model", **app_columns
         )
 

piccolo/apps/migrations/auto/diffable_table.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-import typing as t
 from dataclasses import dataclass, field
+from typing import Any, Optional
 
 from piccolo.apps.migrations.auto.operations import (
     AddColumn,
@@ -17,8 +17,8 @@ from piccolo.table import Table, create_table_class
 
 
 def compare_dicts(
-    dict_1: t.Dict[str, t.Any], dict_2: t.Dict[str, t.Any]
-) -> t.Dict[str, t.Any]:
+    dict_1: dict[str, Any], dict_2: dict[str, Any]
+) -> dict[str, Any]:
     """
     Returns a new dictionary which only contains key, value pairs which are in
     the first dictionary and not the second.
@@ -59,9 +59,9 @@ def compare_dicts(
 
 @dataclass
 class TableDelta:
-    add_columns: t.List[AddColumn] = field(default_factory=list)
-    drop_columns: t.List[DropColumn] = field(default_factory=list)
-    alter_columns: t.List[AlterColumn] = field(default_factory=list)
+    add_columns: list[AddColumn] = field(default_factory=list)
+    drop_columns: list[DropColumn] = field(default_factory=list)
+    alter_columns: list[AlterColumn] = field(default_factory=list)
 
     def __eq__(self, value: TableDelta) -> bool:  # type: ignore
         """
@@ -101,12 +101,12 @@ class DiffableTable:
 
     class_name: str
     tablename: str
-    schema: t.Optional[str] = None
-    columns: t.List[Column] = field(default_factory=list)
-    previous_class_name: t.Optional[str] = None
+    schema: Optional[str] = None
+    columns: list[Column] = field(default_factory=list)
+    previous_class_name: Optional[str] = None
 
     def __post_init__(self) -> None:
-        self.columns_map: t.Dict[str, Column] = {
+        self.columns_map: dict[str, Column] = {
             i._meta.name: i for i in self.columns
         }
 
@@ -163,7 +163,7 @@ class DiffableTable:
 
         #######################################################################
 
-        alter_columns: t.List[AlterColumn] = []
+        alter_columns: list[AlterColumn] = []
 
         for existing_column in value.columns:
             column = self.columns_map.get(existing_column._meta.name)
@@ -221,7 +221,7 @@ class DiffableTable:
     def __str__(self):
         return f"{self.class_name} - {self.tablename}"
 
-    def to_table_class(self) -> t.Type[Table]:
+    def to_table_class(self) -> type[Table]:
         """
         Converts the DiffableTable into a Table subclass.
         """

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)
                 )