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

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
             )

piccolo/apps/migrations/commands/new.py

@@ -3,10 +3,10 @@ from __future__ import annotations
 import datetime
 import os
 import string
-import typing as t
 from dataclasses import dataclass
 from itertools import chain
 from types import ModuleType
+from typing import Optional
 
 import black
 import jinja2
@@ -33,7 +33,7 @@ JINJA_ENV = jinja2.Environment(
     loader=jinja2.FileSystemLoader(searchpath=TEMPLATE_DIRECTORY),
 )
 
-MIGRATION_MODULES: t.Dict[str, ModuleType] = {}
+MIGRATION_MODULES: dict[str, ModuleType] = {}
 
 VALID_PYTHON_MODULE_CHARACTERS = string.ascii_lowercase + string.digits + "_"
 
@@ -115,7 +115,7 @@ async def _create_new_migration(
     app_config: AppConfig,
     auto: bool = False,
     description: str = "",
-    auto_input: t.Optional[str] = None,
+    auto_input: Optional[str] = None,
 ) -> NewMigrationMeta:
     """
     Creates a new migration file on disk.
@@ -170,13 +170,13 @@ async def _create_new_migration(
 
 
 class AutoMigrationManager(BaseMigrationManager):
-    def __init__(self, auto_input: t.Optional[str] = None, *args, **kwargs):
+    def __init__(self, auto_input: Optional[str] = None, *args, **kwargs):
         self.auto_input = auto_input
         super().__init__(*args, **kwargs)
 
     async def get_alter_statements(
         self, app_config: AppConfig
-    ) -> t.List[AlterStatements]:
+    ) -> list[AlterStatements]:
         """
         Works out which alter statements are required.
         """
@@ -214,7 +214,7 @@ async def new(
     app_name: str,
     auto: bool = False,
     desc: str = "",
-    auto_input: t.Optional[str] = None,
+    auto_input: Optional[str] = None,
 ):
     """
     Creates a new migration file in the migrations folder.

piccolo/apps/migrations/tables.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import typing as t
+from typing import Optional
 
 from piccolo.columns import Timestamp, Varchar
 from piccolo.columns.defaults.timestamp import TimestampNow
@@ -14,8 +14,8 @@ class Migration(Table):
 
     @classmethod
     async def get_migrations_which_ran(
-        cls, app_name: t.Optional[str] = None
-    ) -> t.List[str]:
+        cls, app_name: Optional[str] = None
+    ) -> list[str]:
         """
         Returns the names of migrations which have already run, by inspecting
         the database.

piccolo/apps/playground/commands/run.py

@@ -8,15 +8,19 @@ import sys
 import uuid
 from decimal import Decimal
 from enum import Enum
+from typing import Optional
 
 from piccolo.columns import (
     JSON,
+    M2M,
     UUID,
+    Array,
     Boolean,
     Date,
     ForeignKey,
     Integer,
     Interval,
+    LazyTableReference,
     Numeric,
     Serial,
     Text,
@@ -24,7 +28,7 @@ from piccolo.columns import (
     Varchar,
 )
 from piccolo.columns.readable import Readable
-from piccolo.engine import PostgresEngine, SQLiteEngine
+from piccolo.engine import CockroachEngine, PostgresEngine, SQLiteEngine
 from piccolo.engine.base import Engine
 from piccolo.table import Table
 from piccolo.utils.warnings import colored_string
@@ -47,6 +51,7 @@ class Band(Table):
     name = Varchar(length=50)
     manager = ForeignKey(references=Manager, null=True)
     popularity = Integer()
+    genres = M2M(LazyTableReference("GenreToBand", module_path=__name__))
 
     @classmethod
     def get_readable(cls) -> Readable:
@@ -149,6 +154,7 @@ class Album(Table):
     band = ForeignKey(Band)
     release_date = Date()
     recorded_at = ForeignKey(RecordingStudio)
+    awards = Array(Varchar())
 
     @classmethod
     def get_readable(cls) -> Readable:
@@ -158,6 +164,26 @@ class Album(Table):
         )
 
 
+class Genre(Table):
+    id: Serial
+    name = Varchar()
+    bands = M2M(LazyTableReference("GenreToBand", module_path=__name__))
+
+    @classmethod
+    def get_readable(cls) -> Readable:
+        return Readable(
+            template="%s",
+            columns=[cls.name],
+        )
+
+
+class GenreToBand(Table):
+    id: Serial
+    band = ForeignKey(Band)
+    genre = ForeignKey(Genre)
+    reason = Text(null=True, default=None)
+
+
 TABLES = (
     Manager,
     Band,
@@ -168,6 +194,8 @@ TABLES = (
     DiscountCode,
     RecordingStudio,
     Album,
+    Genre,
+    GenreToBand,
 )
 
 
@@ -265,6 +293,7 @@ def populate():
                 Album.recorded_at: recording_studio_1,
                 Album.band: pythonistas,
                 Album.release_date: datetime.date(year=2021, month=1, day=1),
+                Album.awards: ["Grammy Award 2021"],
             }
         ),
         Album(
@@ -273,35 +302,55 @@ def populate():
                 Album.recorded_at: recording_studio_2,
                 Album.band: rustaceans,
                 Album.release_date: datetime.date(year=2022, month=2, day=2),
+                Album.awards: ["Mercury Prize 2022"],
             }
         ),
     ).run_sync()
 
+    genres = Genre.insert(
+        Genre(name="Rock"),
+        Genre(name="Classical"),
+        Genre(name="Folk"),
+    ).run_sync()
+
+    GenreToBand.insert(
+        GenreToBand(
+            band=pythonistas.id,
+            genre=genres[0]["id"],
+            reason="Because they rock.",
+        ),
+        GenreToBand(band=pythonistas.id, genre=genres[2]["id"]),
+        GenreToBand(band=rustaceans.id, genre=genres[2]["id"]),
+        GenreToBand(band=c_sharps.id, genre=genres[0]["id"]),
+        GenreToBand(band=c_sharps.id, genre=genres[1]["id"]),
+    ).run_sync()
+
 
 def run(
     engine: str = "sqlite",
-    user: str = "piccolo",
-    password: str = "piccolo",
+    user: Optional[str] = None,
+    password: Optional[str] = None,
     database: str = "piccolo_playground",
     host: str = "localhost",
-    port: int = 5432,
+    port: Optional[int] = None,
     ipython_profile: bool = False,
 ):
     """
     Creates a test database to play with.
 
     :param engine:
-        Which database engine to use - options are sqlite or postgres
+        Which database engine to use - options are sqlite, postgres or
+        cockroach
     :param user:
-        Postgres user
+        Database user (ignored for SQLite)
     :param password:
-        Postgres password
+        Database password (ignored for SQLite)
     :param database:
-        Postgres database
+        Database name (ignored for SQLite)
     :param host:
-        Postgres host
+        Database host (ignored for SQLite)
     :param port:
-        Postgres port
+        Database port (ignored for SQLite)
     :param ipython_profile:
         Set to true to use your own IPython profile. Located at ~/.ipython/.
         For more info see the IPython docs
@@ -320,9 +369,19 @@ def run(
             {
                 "host": host,
                 "database": database,
-                "user": user,
-                "password": password,
-                "port": port,
+                "user": user or "piccolo",
+                "password": password or "piccolo",
+                "port": port or 5432,
+            }
+        )
+    elif engine.upper() == "COCKROACH":
+        db = CockroachEngine(
+            {
+                "host": host,
+                "database": database,
+                "user": user or "root",
+                "password": password or "",
+                "port": port or 26257,
             }
         )
     else: