piccolo 1.24.2__py3-none-any.whl → 1.26.0__py3-none-any.whl

piccolo/__init__.py

@@ -1 +1 @@
-__VERSION__ = "1.24.2"
+__VERSION__ = "1.26.0"

piccolo/apps/app/commands/new.py

@@ -2,12 +2,16 @@ from __future__ import annotations
 
 import importlib
 import os
+import pathlib
+import string
 import sys
 import typing as t
 
 import black
 import jinja2
 
+from piccolo.conf.apps import PiccoloConfUpdater
+
 TEMPLATE_DIRECTORY = os.path.join(
     os.path.dirname(os.path.abspath(__file__)), "templates"
 )
@@ -30,13 +34,36 @@ def module_exists(module_name: str) -> bool:
         return True
 
 
-def new_app(app_name: str, root: str = "."):
-    print(f"Creating {app_name} app ...")
+APP_NAME_ALLOWED_CHARACTERS = [*string.ascii_lowercase, *string.digits, "_"]
 
-    app_root = os.path.join(root, app_name)
 
-    if os.path.exists(app_root):
-        sys.exit("Folder already exists - exiting.")
+def validate_app_name(app_name: str):
+    """
+    Make sure the app name is something which is a valid Python package name.
+
+    :raises ValueError:
+        If ``app_name`` isn't valid.
+
+    """
+    for char in app_name:
+        if not char.lower() 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."
+            )
+
+
+def get_app_module(app_name: str, root: str) -> str:
+    return ".".join([*pathlib.Path(root).parts, app_name, "piccolo_app"])
+
+
+def new_app(app_name: str, root: str = ".", register: bool = False):
+    print(f"Creating {app_name} app ...")
+
+    try:
+        validate_app_name(app_name=app_name)
+    except ValueError as exception:
+        sys.exit(str(exception))
 
     if module_exists(app_name):
         sys.exit(
@@ -44,7 +71,12 @@ def new_app(app_name: str, root: str = "."):
             "Python module. Please choose a different name for your app."
         )
 
-    os.mkdir(app_root)
+    app_root = os.path.join(root, app_name)
+
+    if os.path.exists(app_root):
+        sys.exit("Folder already exists - exiting.")
+
+    os.makedirs(app_root)
 
     with open(os.path.join(app_root, "__init__.py"), "w"):
         pass
@@ -69,16 +101,22 @@ def new_app(app_name: str, root: str = "."):
     with open(os.path.join(migrations_folder_path, "__init__.py"), "w"):
         pass
 
+    if register:
+        app_module = get_app_module(app_name=app_name, root=root)
+        PiccoloConfUpdater().register_app(app_module=app_module)
+
 
-def new(app_name: str, root: str = "."):
+def new(app_name: str, root: str = ".", register: bool = False):
     """
     Creates a new Piccolo app.
 
     :param app_name:
         The name of the new app.
     :param root:
-        Where to create the app e.g. /my/folder. By default it creates the
+        Where to create the app e.g. ./my/folder. By default it creates the
         app in the current directory.
+    :param register:
+        If True, the app is registered automatically in piccolo_conf.py.
 
     """
-    new_app(app_name=app_name, root=root)
+    new_app(app_name=app_name, root=root, register=register)

piccolo/apps/app/commands/templates/piccolo_app.py.jinja

@@ -5,7 +5,7 @@ the APP_CONFIG.
 
 import os
 
-from piccolo.conf.apps import AppConfig, table_finder
+from piccolo.conf.apps import AppConfig, table_finder, get_package
 
 
 CURRENT_DIRECTORY = os.path.dirname(os.path.abspath(__file__))
@@ -18,7 +18,8 @@ APP_CONFIG = AppConfig(
         'piccolo_migrations'
     ),
     table_classes=table_finder(
-        modules=["{{ app_name }}.tables"],
+        modules=[".tables"],
+        package=get_package(__name__),
         exclude_imported=True
     ),
     migration_dependencies=[],

piccolo/apps/asgi/commands/templates/app/_esmerald_app.py.jinja

@@ -12,7 +12,7 @@ from esmerald import (
     post,
     put,
 )
-from esmerald.config import StaticFilesConfig
+from esmerald.core.config import StaticFilesConfig
 from piccolo.engine import engine_finder
 from piccolo.utils.pydantic import create_pydantic_model
 from piccolo_admin.endpoints import create_admin

piccolo/apps/migrations/auto/migration_manager.py

@@ -19,6 +19,7 @@ from piccolo.columns.column_types import ForeignKey, Serial
 from piccolo.engine import engine_finder
 from piccolo.query import Query
 from piccolo.query.base import DDL
+from piccolo.query.constraints import get_fk_constraint_name
 from piccolo.schema import SchemaDDLBase
 from piccolo.table import Table, create_table_class, sort_table_classes
 from piccolo.utils.warnings import colored_warning
@@ -423,8 +424,8 @@ class MigrationManager:
 
     async def _run_query(self, query: t.Union[DDL, Query, SchemaDDLBase]):
         """
-        If MigrationManager is not in the preview mode,
-         executes the queries. else, prints the query.
+        If MigrationManager is in preview mode then it just print the query
+        instead of executing it.
         """
         if self.preview:
             await self._print_query(query)
@@ -534,6 +535,39 @@ class MigrationManager:
 
                 ###############################################################
 
+                on_delete = params.get("on_delete")
+                on_update = params.get("on_update")
+                if on_delete is not None or on_update is not None:
+                    existing_table = await self.get_table_from_snapshot(
+                        table_class_name=table_class_name,
+                        app_name=self.app_name,
+                    )
+
+                    fk_column = existing_table._meta.get_column_by_name(
+                        alter_column.column_name
+                    )
+
+                    assert isinstance(fk_column, ForeignKey)
+
+                    # First drop the existing foreign key constraint
+                    constraint_name = await get_fk_constraint_name(
+                        column=fk_column
+                    )
+                    await self._run_query(
+                        _Table.alter().drop_constraint(
+                            constraint_name=constraint_name
+                        )
+                    )
+
+                    # Then add a new foreign key constraint
+                    await self._run_query(
+                        _Table.alter().add_foreign_key_constraint(
+                            column=fk_column,
+                            on_delete=on_delete,
+                            on_update=on_update,
+                        )
+                    )
+
                 null = params.get("null")
                 if null is not None:
                     await self._run_query(

piccolo/apps/schema/commands/generate.py

@@ -501,6 +501,8 @@ async def get_fk_triggers(
         Any Table subclass - just used to execute raw queries on the database.
 
     """
+    # TODO - Move this query to `piccolo.query.constraints` or use:
+    # `piccolo.query.constraints.referential_constraints`
     triggers = await table_class.raw(
         (
             "SELECT tc.constraint_name, "
@@ -537,23 +539,6 @@ async def get_fk_triggers(
     )
 
 
-ONDELETE_MAP = {
-    "NO ACTION": OnDelete.no_action,
-    "RESTRICT": OnDelete.restrict,
-    "CASCADE": OnDelete.cascade,
-    "SET NULL": OnDelete.set_null,
-    "SET DEFAULT": OnDelete.set_default,
-}
-
-ONUPDATE_MAP = {
-    "NO ACTION": OnUpdate.no_action,
-    "RESTRICT": OnUpdate.restrict,
-    "CASCADE": OnUpdate.cascade,
-    "SET NULL": OnUpdate.set_null,
-    "SET DEFAULT": OnUpdate.set_default,
-}
-
-
 async def get_constraints(
     table_class: t.Type[Table], tablename: str, schema_name: str = "public"
 ) -> TableConstraints:
@@ -765,8 +750,8 @@ async def create_table_class_from_db(
                     column_name, constraint_table.name
                 )
                 if trigger:
-                    kwargs["on_update"] = ONUPDATE_MAP[trigger.on_update]
-                    kwargs["on_delete"] = ONDELETE_MAP[trigger.on_delete]
+                    kwargs["on_update"] = OnUpdate(trigger.on_update)
+                    kwargs["on_delete"] = OnDelete(trigger.on_delete)
                 else:
                     output_schema.trigger_warnings.append(
                         f"{tablename}.{column_name}"

piccolo/conf/apps.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import ast
 import inspect
 import itertools
 import os
@@ -11,6 +12,8 @@ from dataclasses import dataclass, field
 from importlib import import_module
 from types import ModuleType
 
+import black
+
 from piccolo.apps.migrations.auto.migration_manager import MigrationManager
 from piccolo.engine.base import Engine
 from piccolo.table import Table
@@ -32,8 +35,18 @@ class PiccoloAppModule(ModuleType):
     APP_CONFIG: AppConfig
 
 
+def get_package(name: str) -> str:
+    """
+    :param name:
+        The __name__ variable from a Python file.
+
+    """
+    return ".".join(name.split(".")[:-1])
+
+
 def table_finder(
     modules: t.Sequence[str],
+    package: t.Optional[str] = None,
     include_tags: t.Optional[t.Sequence[str]] = None,
     exclude_tags: t.Optional[t.Sequence[str]] = None,
     exclude_imported: bool = False,
@@ -46,8 +59,10 @@ def table_finder(
 
     :param modules:
         The module paths to check for ``Table`` subclasses. For example,
-        ``['blog.tables']``. The path should be from the root of your project,
-        not a relative path.
+        ``['blog.tables']``.
+    :param package:
+        This must be passed in if the modules are relative paths (e.g.
+        if ``modules=['.tables']`` then ``package='blog'``).
     :param include_tags:
         If the ``Table`` subclass has one of these tags, it will be
         imported. The special tag ``'__all__'`` will import all ``Table``
@@ -83,10 +98,19 @@ def table_finder(
     table_subclasses: t.List[t.Type[Table]] = []
 
     for module_path in modules:
+        full_module_path = (
+            ".".join([package, module_path.lstrip(".")])
+            if package
+            else module_path
+        )
+
         try:
-            module = import_module(module_path)
+            module = import_module(
+                module_path,
+                package=package,
+            )
         except ImportError as exception:
-            print(f"Unable to import {module_path}")
+            print(f"Unable to import {full_module_path}")
             raise exception from exception
 
         object_names = [i for i in dir(module) if not i.startswith("_")]
@@ -100,7 +124,7 @@ def table_finder(
             ):
                 table: Table = _object  # type: ignore
 
-                if exclude_imported and table.__module__ != module_path:
+                if exclude_imported and table.__module__ != full_module_path:
                     continue
 
                 if exclude_tags and set(table._meta.tags).intersection(
@@ -416,6 +440,17 @@ class Finder:
         else:
             return module
 
+    def get_piccolo_conf_path(self) -> str:
+        piccolo_conf_module = self.get_piccolo_conf_module()
+
+        if piccolo_conf_module is None:
+            raise ModuleNotFoundError("piccolo_conf.py not found.")
+
+        module_file_path = piccolo_conf_module.__file__
+        assert module_file_path
+
+        return module_file_path
+
     def get_app_registry(self) -> AppRegistry:
         """
         Returns the ``AppRegistry`` instance within piccolo_conf.
@@ -562,3 +597,88 @@ class Finder:
             tables.extend(app_config.table_classes)
 
         return tables
+
+
+###############################################################################
+
+
+class PiccoloConfUpdater:
+
+    def __init__(self, piccolo_conf_path: t.Optional[str] = None):
+        """
+        :param piccolo_conf_path:
+            The path to the piccolo_conf.py (e.g. `./piccolo_conf.py`). If not
+            passed in, we use our ``Finder`` class to get it.
+        """
+        self.piccolo_conf_path = (
+            piccolo_conf_path or Finder().get_piccolo_conf_path()
+        )
+
+    def _modify_app_registry_src(self, src: str, app_module: str) -> str:
+        """
+        :param src:
+            The contents of the ``piccolo_conf.py`` file.
+        :param app_module:
+            The app to add to the registry e.g. ``'music.piccolo_app'``.
+        :returns:
+            Updated Python source code string.
+
+        """
+        ast_root = ast.parse(src)
+
+        parsing_successful = False
+
+        for node in ast.walk(ast_root):
+            if isinstance(node, ast.Call):
+                if (
+                    isinstance(node.func, ast.Name)
+                    and node.func.id == "AppRegistry"
+                ):
+                    if len(node.keywords) > 0:
+                        keyword = node.keywords[0]
+                        if keyword.arg == "apps":
+                            apps = keyword.value
+                            if isinstance(apps, ast.List):
+                                apps.elts.append(
+                                    ast.Constant(app_module, kind="str")
+                                )
+                                parsing_successful = True
+                                break
+
+        if not parsing_successful:
+            raise SyntaxError(
+                "Unable to parse piccolo_conf.py - `AppRegistry(apps=...)` "
+                "not found)."
+            )
+
+        new_contents = ast.unparse(ast_root)
+
+        formatted_contents = black.format_str(
+            new_contents, mode=black.FileMode(line_length=80)
+        )
+
+        return formatted_contents
+
+    def register_app(self, app_module: str):
+        """
+        Adds the given app to the ``AppRegistry`` in ``piccolo_conf.py``.
+
+        This is used by command line tools like:
+
+        .. code-block:: bash
+
+            piccolo app new my_app --register
+
+        :param app_module:
+            The module of the app, e.g. ``'music.piccolo_app'``.
+
+        """
+        with open(self.piccolo_conf_path) as f:
+            piccolo_conf_src = f.read()
+
+        new_contents = self._modify_app_registry_src(
+            src=piccolo_conf_src, app_module=app_module
+        )
+
+        with open(self.piccolo_conf_path, "wt") as f:
+            f.write(new_contents)

piccolo/query/constraints.py

@@ -0,0 +1,92 @@
+from dataclasses import dataclass
+
+from piccolo.columns import ForeignKey
+from piccolo.columns.base import OnDelete, OnUpdate
+
+
+async def get_fk_constraint_name(column: ForeignKey) -> str:
+    """
+    Checks what the foreign key constraint is called in the database.
+    """
+
+    table = column._meta.table
+
+    if table._meta.db.engine_type == "sqlite":
+        # TODO - add the query for SQLite
+        raise ValueError("SQLite isn't currently supported.")
+
+    schema = table._meta.schema or "public"
+    table_name = table._meta.tablename
+    column_name = column._meta.db_column_name
+
+    constraints = await table.raw(
+        """
+        SELECT
+            kcu.constraint_name AS fk_constraint_name
+        FROM
+            information_schema.referential_constraints AS rc
+        INNER JOIN
+            information_schema.key_column_usage AS kcu
+            ON kcu.constraint_catalog = rc.constraint_catalog
+            AND kcu.constraint_schema = rc.constraint_schema
+            AND kcu.constraint_name = rc.constraint_name
+        WHERE
+            kcu.table_schema = {} AND
+            kcu.table_name = {} AND
+            kcu.column_name = {}
+        """,
+        schema,
+        table_name,
+        column_name,
+    )
+
+    return constraints[0]["fk_constraint_name"]
+
+
+@dataclass
+class ConstraintRules:
+    on_delete: OnDelete
+    on_update: OnUpdate
+
+
+async def get_fk_constraint_rules(column: ForeignKey) -> ConstraintRules:
+    """
+    Checks the constraint rules for this foreign key in the database.
+    """
+    table = column._meta.table
+
+    if table._meta.db.engine_type == "sqlite":
+        # TODO - add the query for SQLite
+        raise ValueError("SQLite isn't currently supported.")
+
+    schema = table._meta.schema or "public"
+    table_name = table._meta.tablename
+    column_name = column._meta.db_column_name
+
+    constraints = await table.raw(
+        """
+        SELECT
+            kcu.constraint_name,
+            kcu.table_name,
+            kcu.column_name,
+            rc.update_rule,
+            rc.delete_rule
+        FROM
+            information_schema.key_column_usage AS kcu
+        INNER JOIN
+            information_schema.referential_constraints AS rc
+            ON kcu.constraint_name = rc.constraint_name
+        WHERE
+            kcu.table_schema = {} AND
+            kcu.table_name = {} AND
+            kcu.column_name = {}
+        """,
+        schema,
+        table_name,
+        column_name,
+    )
+
+    return ConstraintRules(
+        on_delete=OnDelete(constraints[0]["delete_rule"]),
+        on_update=OnUpdate(constraints[0]["update_rule"]),
+    )

piccolo/query/methods/alter.py

@@ -36,6 +36,18 @@ class RenameTable(AlterStatement):
         return f"RENAME TO {self.new_name}"
 
 
+@dataclass
+class RenameConstraint(AlterStatement):
+    __slots__ = ("old_name", "new_name")
+
+    old_name: str
+    new_name: str
+
+    @property
+    def ddl(self) -> str:
+        return f"RENAME CONSTRAINT {self.old_name} TO {self.new_name}"
+
+
 @dataclass
 class AlterColumnStatement(AlterStatement):
     __slots__ = ("column",)
@@ -194,6 +206,7 @@ class AddForeignKeyConstraint(AlterStatement):
         "constraint_name",
         "foreign_key_column_name",
         "referenced_table_name",
+        "referenced_column_name",
         "on_delete",
         "on_update",
     )
@@ -201,9 +214,9 @@ class AddForeignKeyConstraint(AlterStatement):
     constraint_name: str
     foreign_key_column_name: str
     referenced_table_name: str
+    referenced_column_name: str
     on_delete: t.Optional[OnDelete]
     on_update: t.Optional[OnUpdate]
-    referenced_column_name: str = "id"
 
     @property
     def ddl(self) -> str:
@@ -273,8 +286,8 @@ class DropTable:
 
 class Alter(DDL):
     __slots__ = (
-        "_add_foreign_key_constraint",
         "_add",
+        "_add_foreign_key_constraint",
         "_drop_constraint",
         "_drop_default",
         "_drop_table",
@@ -288,6 +301,7 @@ class Alter(DDL):
         "_set_null",
         "_set_schema",
         "_set_unique",
+        "_rename_constraint",
     )
 
     def __init__(self, table: t.Type[Table], **kwargs):
@@ -307,6 +321,7 @@ class Alter(DDL):
         self._set_null: t.List[SetNull] = []
         self._set_schema: t.List[SetSchema] = []
         self._set_unique: t.List[SetUnique] = []
+        self._rename_constraint: t.List[RenameConstraint] = []
 
     def add_column(self: Self, name: str, column: Column) -> Self:
         """
@@ -372,6 +387,24 @@ class Alter(DDL):
         self._rename_table = [RenameTable(new_name=new_name)]
         return self
 
+    def rename_constraint(self, old_name: str, new_name: str) -> Alter:
+        """
+        Rename a constraint on the table::
+
+            >>> await Band.alter().rename_constraint(
+            ...     'old_constraint_name',
+            ...     'new_constraint_name',
+            ... )
+
+        """
+        self._rename_constraint = [
+            RenameConstraint(
+                old_name=old_name,
+                new_name=new_name,
+            )
+        ]
+        return self
+
     def rename_column(
         self, column: t.Union[str, Column], new_name: str
     ) -> Alter:
@@ -488,7 +521,7 @@ class Alter(DDL):
     def _get_constraint_name(self, column: t.Union[str, ForeignKey]) -> str:
         column_name = AlterColumnStatement(column=column).column_name
         tablename = self.table._meta.tablename
-        return f"{tablename}_{column_name}_fk"
+        return f"{tablename}_{column_name}_fkey"
 
     def drop_constraint(self, constraint_name: str) -> Alter:
         self._drop_constraint.append(
@@ -500,37 +533,58 @@ class Alter(DDL):
         self, column: t.Union[str, ForeignKey]
     ) -> Alter:
         constraint_name = self._get_constraint_name(column=column)
-        return self.drop_constraint(constraint_name=constraint_name)
+        self._drop_constraint.append(
+            DropConstraint(constraint_name=constraint_name)
+        )
+        return self
 
     def add_foreign_key_constraint(
         self,
         column: t.Union[str, ForeignKey],
-        referenced_table_name: str,
+        referenced_table_name: t.Optional[str] = None,
+        referenced_column_name: t.Optional[str] = None,
+        constraint_name: t.Optional[str] = None,
         on_delete: t.Optional[OnDelete] = None,
         on_update: t.Optional[OnUpdate] = None,
-        referenced_column_name: str = "id",
     ) -> Alter:
         """
         Add a new foreign key constraint::
 
             >>> await Band.alter().add_foreign_key_constraint(
             ...     Band.manager,
-            ...     referenced_table_name='manager',
             ...     on_delete=OnDelete.cascade
             ... )
 
         """
-        constraint_name = self._get_constraint_name(column=column)
+        constraint_name = constraint_name or self._get_constraint_name(
+            column=column
+        )
         column_name = AlterColumnStatement(column=column).column_name
 
+        if referenced_column_name is None:
+            if isinstance(column, ForeignKey):
+                referenced_column_name = (
+                    column._foreign_key_meta.resolved_target_column._meta.db_column_name  # noqa: E501
+                )
+            else:
+                raise ValueError("Please pass in `referenced_column_name`.")
+
+        if referenced_table_name is None:
+            if isinstance(column, ForeignKey):
+                referenced_table_name = (
+                    column._foreign_key_meta.resolved_references._meta.tablename  # noqa: E501
+                )
+            else:
+                raise ValueError("Please pass in `referenced_table_name`.")
+
         self._add_foreign_key_constraint.append(
             AddForeignKeyConstraint(
                 constraint_name=constraint_name,
                 foreign_key_column_name=column_name,
                 referenced_table_name=referenced_table_name,
+                referenced_column_name=referenced_column_name,
                 on_delete=on_delete,
                 on_update=on_update,
-                referenced_column_name=referenced_column_name,
             )
         )
         return self
@@ -579,9 +633,12 @@ class Alter(DDL):
             i.ddl
             for i in itertools.chain(
                 self._add,
+                self._add_foreign_key_constraint,
                 self._rename_columns,
                 self._rename_table,
+                self._rename_constraint,
                 self._drop,
+                self._drop_constraint,
                 self._drop_default,
                 self._set_column_type,
                 self._set_unique,

piccolo/table.py

@@ -573,6 +573,8 @@ class Table(metaclass=TableMetaclass):
 
         setattr(self, self._meta.primary_key._meta.name, None)
 
+        self._exists_in_db = False
+
         return self.__class__.delete().where(
             self.__class__._meta.primary_key == primary_key_value
         )

piccolo/utils/sync.py

@@ -2,10 +2,14 @@ from __future__ import annotations
 
 import asyncio
 import typing as t
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import Future, ThreadPoolExecutor
 
+ReturnType = t.TypeVar("ReturnType")
 
-def run_sync(coroutine: t.Coroutine):
+
+def run_sync(
+    coroutine: t.Coroutine[t.Any, t.Any, ReturnType],
+) -> ReturnType:
     """
     Run the coroutine synchronously - trying to accommodate as many edge cases
     as possible.
@@ -20,5 +24,5 @@ def run_sync(coroutine: t.Coroutine):
     except RuntimeError:
         # An event loop already exists.
         with ThreadPoolExecutor(max_workers=1) as executor:
-            future = executor.submit(asyncio.run, coroutine)
+            future: Future = executor.submit(asyncio.run, coroutine)
             return future.result()

{piccolo-1.24.2.dist-info → piccolo-1.26.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: piccolo
-Version: 1.24.2
+Version: 1.26.0
 Summary: A fast, user friendly ORM and query builder which supports asyncio.
 Home-page: https://github.com/piccolo-orm/piccolo
 Author: Daniel Townsend

{piccolo-1.24.2.dist-info → piccolo-1.26.0.dist-info}/RECORD

@@ -1,18 +1,18 @@
-piccolo/__init__.py,sha256=53bY15Zwtb-mVcNomjadBbUceria081xCDSw7iTXiZM,23
+piccolo/__init__.py,sha256=ZVRfjDuz3xhQA4e78KxBcezkGjqcWBkBGlP0bm-NFD8,23
 piccolo/custom_types.py,sha256=7HMQAze-5mieNLfbQ5QgbRQgR2abR7ol0qehv2SqROY,604
 piccolo/main.py,sha256=1VsFV67FWTUikPTysp64Fmgd9QBVa_9wcwKfwj2UCEA,5117
 piccolo/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/querystring.py,sha256=kb7RYTvQZEyPsC4GH8vR2b_w35wnM-ita242S0_eyvQ,10013
 piccolo/schema.py,sha256=qNNy4tG_HqnXR9t3hHMgYXtGxHabwQAhUpc6RKLJ_gE,7960
-piccolo/table.py,sha256=UvEbagMYRkTbyFHTUwUshZlL_dC4UKDP7vUOwF8OXmg,50593
+piccolo/table.py,sha256=vA4H5oebvpIsUYUpAIOFMqAG8wtNBWmu18zEmbfen0I,50629
 piccolo/table_reflection.py,sha256=02baOSLX6f2LEo0kruFZYF_nPPTbIvaCTH_KPGe0DKw,7540
 piccolo/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/app/piccolo_app.py,sha256=8z2ITpxQQ-McxSYwQ5H_vyEnRXbY6cyAh2JSqhiylYk,340
 piccolo/apps/app/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-piccolo/apps/app/commands/new.py,sha256=odvFHBiKmbgmlfDXxMcU-0qlX8LumRdvPGzfX-SkMWI,2187
+piccolo/apps/app/commands/new.py,sha256=XzcVBBHiEezIt0VvyNezLDSgcSRDn5rmefdVulReCSk,3382
 piccolo/apps/app/commands/show_all.py,sha256=46Hv3SipMT0YeMgAobU62O0mR7xvN1pn7xjU9Y2spKM,252
-piccolo/apps/app/commands/templates/piccolo_app.py.jinja,sha256=Wl11z0J0EiT5kDFJ_3Xps0dn-qndloDmAs1U_7UB1BY,554
+piccolo/apps/app/commands/templates/piccolo_app.py.jinja,sha256=QjaBEQucryT-vCv37Qm47I2hdirGxYE725WUGqF2WR0,592
 piccolo/apps/app/commands/templates/tables.py.jinja,sha256=revzdrvDDwe78VedBKz0zYSwcsxyv2IURun6q6qmV1Y,32
 piccolo/apps/asgi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/asgi/piccolo_app.py,sha256=7VUvqQJbB-ScO0A62S6MiJmQL9F5DS-SdlqlDLbAblE,217
@@ -20,7 +20,7 @@ piccolo/apps/asgi/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJ
 piccolo/apps/asgi/commands/new.py,sha256=718mXx7XdDTN0CKK0ZB1WVMkOrQtVfqT5bqO1kDKnRk,4335
 piccolo/apps/asgi/commands/templates/app/README.md.jinja,sha256=As3gNEZt9qcRmTVkjCzNtXJ8r4-3g0fCSe7Q-P39ezI,214
 piccolo/apps/asgi/commands/templates/app/_blacksheep_app.py.jinja,sha256=IKOql1G5wrEKm5qErlizOmrwYKlnxkm-d8NY5uVg9KA,3186
-piccolo/apps/asgi/commands/templates/app/_esmerald_app.py.jinja,sha256=nTzXc5IJLl_al1FuzG5AnaA1vSn-ipMurpPK7BibmB8,2710
+piccolo/apps/asgi/commands/templates/app/_esmerald_app.py.jinja,sha256=fIbD106Us4j2DBv_41PimvFRVw2FuZhOfc3xFPkNjuY,2715
 piccolo/apps/asgi/commands/templates/app/_falcon_app.py.jinja,sha256=LOn3auJFeXNW48rtHzRbH3MzxWbRNhFib6Fm6wDS53E,1684
 piccolo/apps/asgi/commands/templates/app/_fastapi_app.py.jinja,sha256=mKnYfUOnYyWJA1jFoRLCUOGQlK6imaxx_1qaauGjeeQ,2627
 piccolo/apps/asgi/commands/templates/app/_lilya_app.py.jinja,sha256=PUph5Jj_AXVpxXZmpUzzHXogUchU8vjKBL_7WvgrfCU,1260
@@ -66,7 +66,7 @@ piccolo/apps/migrations/piccolo_app.py,sha256=1EcS2ComBPCaMCC2C3WaPR_GqLwt3XiIJN
 piccolo/apps/migrations/tables.py,sha256=jqBnK-Rk545v1Eu6GaLHTVz7-uwBTUnz2m58OA-mxTc,799
 piccolo/apps/migrations/auto/__init__.py,sha256=eYb1rZQaalumv_bhbcEe6x3dUglmpFtw7Egg6k7597U,316
 piccolo/apps/migrations/auto/diffable_table.py,sha256=1HdqGeWFUYVJ2cJg6DZWOCh67SbgCxFVc554uD7N71A,7405
-piccolo/apps/migrations/auto/migration_manager.py,sha256=tyAE1Xk6Xb58igbuHw3FGHhKkVjv_Vr5qBH4AbvVb8k,35856
+piccolo/apps/migrations/auto/migration_manager.py,sha256=5M2_01_FsZj6zIGXLEwkyEAPF2e-ICNB2_ZcBWwifCQ,37267
 piccolo/apps/migrations/auto/operations.py,sha256=169IrCLR3FtTRxHsEHNg6dTG45lcEM7Aoyy3SwgX_hU,1329
 piccolo/apps/migrations/auto/schema_differ.py,sha256=VA1rK-_wNSdyZZgfA3ZOlpVGJCcvLyouKtT9k2YKhiA,26266
 piccolo/apps/migrations/auto/schema_snapshot.py,sha256=ZqUg4NpChOeoACKF2gkhqsz1BW3wOWFnzJCccq-CNNQ,4719
@@ -93,7 +93,7 @@ piccolo/apps/schema/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 piccolo/apps/schema/piccolo_app.py,sha256=De9eujzB6zWsP6J1gHYUk_f5_DpjvTZVXJsQ3eXBgnA,432
 piccolo/apps/schema/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/schema/commands/exceptions.py,sha256=ZOGL3iV-xtWbWsImXObrXNaKtNPY_Qk1OmaOMOV6Ps0,236
-piccolo/apps/schema/commands/generate.py,sha256=_niW_UxZ-x29-xjDIVdjHdDyKAaXn4HUDVtVjsXgBD0,30700
+piccolo/apps/schema/commands/generate.py,sha256=xYRz9P4cdahSHzAIiXhXBzg6eUqV0WB2THSRZH7uPhU,30415
 piccolo/apps/schema/commands/graph.py,sha256=FuQUPavUXpr-Y_11XRr11DbVLsgK8uG0IN8uBZIe5G4,3190
 piccolo/apps/schema/commands/templates/graphviz.dot.jinja,sha256=-legygtsueOC70aboX35ZJpbCAXcv3E8RXXvFDQTeIY,1443
 piccolo/apps/shell/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -143,7 +143,7 @@ piccolo/columns/operators/comparison.py,sha256=G7bI_O-EXqun_zHwbNcZ9z9gsY8OK-0oB
 piccolo/columns/operators/math.py,sha256=knsUZzYOVdsFn3bTS0XC0ZzfNObeJcMvZ8Q_QwmGxjU,325
 piccolo/columns/operators/string.py,sha256=M5ifxHP-ttJaE_wYCl23W5sJof4i5S5_QDIOv34VxDM,142
 piccolo/conf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-piccolo/conf/apps.py,sha256=AlgOM2ePl9NQjME5AQxcZ5RbuQpjRywFCj5uHUsCIZU,19040
+piccolo/conf/apps.py,sha256=t5_Wn9A8_NRgSKmkkXqnq36yi-qucnpll41_XeX9nYE,22590
 piccolo/engine/__init__.py,sha256=Z0QR5NAA9jTFenY7pEJv1C8jZXBaFZojBUR3z3nx1cw,283
 piccolo/engine/base.py,sha256=4NISWRuvgp5ShqJbOEK6g8ok8Ijqtp2gzuM9J6o_wSU,6444
 piccolo/engine/cockroach.py,sha256=gGnihplotMZMWqHwRnZYnnbKU3jFrwttwOlNtktoeLE,1522
@@ -153,6 +153,7 @@ piccolo/engine/postgres.py,sha256=DekL3KafCdzSAEQ6_EgOiUB1ERXh2xpePYwI9QvmN-c,18
 piccolo/engine/sqlite.py,sha256=Oe0GBrIUSUkutvk5LoXGWC6HFQzKeusfql5-NMssH_s,25735
 piccolo/query/__init__.py,sha256=bcsMV4813rMRAIqGv4DxI4eyO4FmpXkDv9dfTk5pt3A,699
 piccolo/query/base.py,sha256=sO5VyicbWjgYaQukr6jqUqUUrOctL6QJ1MjcsgDKHXM,14912
+piccolo/query/constraints.py,sha256=menFcqLKSM4697OSvMRZPsTgxHfR9GTvZZMrGDk2PrA,2601
 piccolo/query/mixins.py,sha256=X9HEYnj6uOjgTkGr4vgqTwN_dokJPzVagwbFx385atQ,24468
 piccolo/query/proxy.py,sha256=Yq4jNc7IWJvdeO3u7_7iPyRy2WhVj8KsIUcIYHBIi9Q,1839
 piccolo/query/functions/__init__.py,sha256=pZkzOIh7Sg9HPNOeegOwAS46Oxt31ATlSVmwn-lxCbc,605
@@ -163,7 +164,7 @@ piccolo/query/functions/math.py,sha256=2Wapq0lpXZh77z0uzXUhnOfmUkbkM0xjQ4tiyuCsb
 piccolo/query/functions/string.py,sha256=X3g_4qomJJCkYOcKcK-zZEqC6qJBrS4VTogPp9Xw4Cs,2506
 piccolo/query/functions/type_conversion.py,sha256=OYbZc6TEk6b5yTwCMw2rmZ-UiQiUiWZOyxwMLzUjXwE,2583
 piccolo/query/methods/__init__.py,sha256=tm4gLeV_obDqpgnouVjFbGubbaoJcqm_cbNd4LPo48Q,622
-piccolo/query/methods/alter.py,sha256=AI9YkJeip2EitrWJN_TDExXhA8HGAG3XuDz1NR-KirQ,16728
+piccolo/query/methods/alter.py,sha256=tL8IIuEldBwegQOZM5N4IaoO2fH0tYLk8R7ra6PLD3s,18519
 piccolo/query/methods/count.py,sha256=Vxn_7Ry-rleC6OGRxh-cLbuEMsy1DNjAZJThGED-_do,1748
 piccolo/query/methods/create.py,sha256=hJ-6VVsWczzKDH6fQRN1WmYhcitixuXJ-eNOuCo_JgM,2742
 piccolo/query/methods/create_index.py,sha256=gip_cRXZkLfpJqCL7KHk2l_7HLptoa-Ae8qu6I5d5c8,2224
@@ -195,17 +196,17 @@ piccolo/utils/printing.py,sha256=5VWNSfOrIGPh1VM-7fd4K18RGCYk0FQ5o-D4aLhzXZE,174
 piccolo/utils/pydantic.py,sha256=RhoQZ7ddmFmepVcslHXMqmynbSVch7XLKUSgJkLuQS0,12327
 piccolo/utils/repr.py,sha256=K3w-TAP9WPx8tbAIB2XDab_C4PHsPrB9TzwWfOHa4cc,787
 piccolo/utils/sql_values.py,sha256=pGXmVTw6pWr8q7QA4xs7NiKSwjBzhN--3HXVjQv2SQQ,1749
-piccolo/utils/sync.py,sha256=j9Abkxn5HHS6HyvfpMzb1zV_teTkFHVhaIxu9rrSwSU,819
+piccolo/utils/sync.py,sha256=irmdTsYtURZNEBmIP6i2v2PyjgE-gK4t6VSxnBZ75Qo,920
 piccolo/utils/warnings.py,sha256=ONrurw3HVCClUuHnpenMjg45dcFesrXqMgG9ifgP4_8,1247
 piccolo/utils/graphlib/__init__.py,sha256=SUJ5Yh7LiRun3nkBuLUSVmGNHF6fANrxSoYan0mtYB0,200
 piccolo/utils/graphlib/_graphlib.py,sha256=9FNGDSmTIEAk86FktniCe_J2yXjSE_sRZHDBAJJAUOw,9677
-piccolo-1.24.2.dist-info/licenses/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
+piccolo-1.26.0.dist-info/licenses/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
 profiling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 profiling/run_profile.py,sha256=264qsSFu93NTpExePnKQ9GkcN5fiuRBQ72WOSt0ZHck,829
 tests/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/apps/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/apps/app/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/apps/app/commands/test_new.py,sha256=GxVAgyqEtbuHCUWaLhTzTUOxfqQ1daFq8SgdIcWjr_8,1187
+tests/apps/app/commands/test_new.py,sha256=Z4Vt3G60sVw6Ab7npn3PS5daq5BTWEzlHu7LcZIorfg,2194
 tests/apps/app/commands/test_show_all.py,sha256=ca1afRhePYyVw-x2swxnoj659_qdu53uY8sVGIqBuNg,551
 tests/apps/asgi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/apps/asgi/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -221,7 +222,7 @@ tests/apps/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 tests/apps/migrations/test_migration.py,sha256=JmPLtf2BCWX3Yofe0GQe40m8I_yWa_-3vk1lDfFDfIo,308
 tests/apps/migrations/auto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/apps/migrations/auto/test_diffable_table.py,sha256=p0cKDkfhmu96-rB9bonOlg5bmfQ7U9S2kRppOt4YxyU,3338
-tests/apps/migrations/auto/test_migration_manager.py,sha256=L2raSuhZybRyK-BEh-G-nDndAgl4sLynekHQFqyrteY,35719
+tests/apps/migrations/auto/test_migration_manager.py,sha256=qzYHC8nKm4pRtsgIyPDSZdXEWLOl2UDgTv6Mv8QO49k,37362
 tests/apps/migrations/auto/test_schema_differ.py,sha256=UdsaZisA02j15wr1bXkXD6Cqu3p0A23NwFQLXsJdQL4,19391
 tests/apps/migrations/auto/test_schema_snapshot.py,sha256=ZyvGZqn3N3cwd-3S-FME5AJ8buDSHesw7yPIvY6mE5k,6196
 tests/apps/migrations/auto/test_serialisation.py,sha256=EFkhES1w9h51UCamWrhxs3mf4I718ggeP7Yl5J_UID4,13548
@@ -288,7 +289,7 @@ tests/columns/m2m/test_m2m.py,sha256=0ObmIHUJF6CZoNBznc5xXVr5_BbGBqOmWwtpg8IcPt4
 tests/columns/m2m/test_m2m_schema.py,sha256=oxu7eAjFFpDjnq9Eq-5OTNmlnsEIMFWx18OItfpVs-s,339
 tests/conf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/conf/example.py,sha256=K8sTttLpEac8rQlOLDY500IGkHj3P3NoyFbCMnT1EqY,347
-tests/conf/test_apps.py,sha256=Ovdp4v55iC-epS25sKntyYAw2ki9svcyCNOj5rOzE-E,8632
+tests/conf/test_apps.py,sha256=5Cl9zL_nJr5NDS7KiTIIne219RGSouxP2gWhQK99F7A,9925
 tests/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/engine/test_extra_nodes.py,sha256=xW5gflHzM6ou26DqRSAZoaAbYVzF1IuMkW3vzNmB954,1298
 tests/engine/test_logging.py,sha256=VLf9A3QuoV7OhV8lttLDB4gzZemnG63kSr-Uyan005U,1287
@@ -361,7 +362,7 @@ tests/table/instance/test_create.py,sha256=JD0l7L9dDK1FKPhUs6WC_B2bruPR1qQ8aIqXp
 tests/table/instance/test_get_related.py,sha256=eracFunh4Qlj5BEkI7OsrOyefRZM0rxrXnFX92VL1ZE,3285
 tests/table/instance/test_get_related_readable.py,sha256=QDMMZykxPsTWcsl8ZIZtmQVLwSGCw7QBilLepAAAnWg,4694
 tests/table/instance/test_instantiate.py,sha256=jvtaqSa_zN1lHQiykN4EnwitZqkWAbXle5IJtyhKuHY,958
-tests/table/instance/test_remove.py,sha256=Zv22ZZqot61rjCVWL1PHDf1oxELcBnmMXx1gsST6j80,648
+tests/table/instance/test_remove.py,sha256=P-8wWodlA2PukdWhaj8x2HYZI1U8Q7oIuFBe2sAkcdo,757
 tests/table/instance/test_save.py,sha256=ccdDz-bR3aYDa16_RGQP7JTXprgm1mT6-NpF1y3RXyo,4388
 tests/table/instance/test_to_dict.py,sha256=gkiYkmcI5qcy5E-ERWWmO-Q8uyVSFfcpJ8d53LlzCuI,3442
 tests/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -380,8 +381,8 @@ tests/utils/test_sql_values.py,sha256=vzxRmy16FfLZPH-sAQexBvsF9MXB8n4smr14qoEOS5
 tests/utils/test_sync.py,sha256=9ytVo56y2vPQePvTeIi9lHIouEhWJbodl1TmzkGFrSo,799
 tests/utils/test_table_reflection.py,sha256=SIzuat-IpcVj1GCFyOWKShI8YkhdOPPFH7qVrvfyPNE,3794
 tests/utils/test_warnings.py,sha256=NvSC_cvJ6uZcwAGf1m-hLzETXCqprXELL8zg3TNLVMw,269
-piccolo-1.24.2.dist-info/METADATA,sha256=zrjcB9J7oo9wGk6Z19Xgpm6Iupa_8VymJ9OOpIUMvA8,5531
-piccolo-1.24.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-piccolo-1.24.2.dist-info/entry_points.txt,sha256=SJPHET4Fi1bN5F3WqcKkv9SClK3_F1I7m4eQjk6AFh0,46
-piccolo-1.24.2.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
-piccolo-1.24.2.dist-info/RECORD,,
+piccolo-1.26.0.dist-info/METADATA,sha256=UE7oErMiVueu8PQJLKAzHWoVIaXJtA2r9d1VZsOzwbU,5531
+piccolo-1.26.0.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+piccolo-1.26.0.dist-info/entry_points.txt,sha256=SJPHET4Fi1bN5F3WqcKkv9SClK3_F1I7m4eQjk6AFh0,46
+piccolo-1.26.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
+piccolo-1.26.0.dist-info/RECORD,,

{piccolo-1.24.2.dist-info → piccolo-1.26.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.4.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tests/apps/app/commands/test_new.py

@@ -3,7 +3,12 @@ import shutil
 import tempfile
 from unittest import TestCase
 
-from piccolo.apps.app.commands.new import module_exists, new
+from piccolo.apps.app.commands.new import (
+    get_app_module,
+    module_exists,
+    new,
+    validate_app_name,
+)
 
 
 class TestModuleExists(TestCase):
@@ -43,3 +48,37 @@ class TestNewApp(TestCase):
                 "A module called sys already exists"
             )
         )
+
+
+class TestValidateAppName(TestCase):
+
+    def test_validate_app_name(self):
+        """
+        Make sure only app names which work as valid Python package names are
+        allowed.
+        """
+        # Should be rejected:
+        for app_name in ("MY APP", "app/my_app", "my.app"):
+            with self.assertRaises(ValueError):
+                validate_app_name(app_name=app_name)
+
+        # Should work fine:
+        validate_app_name(app_name="music")
+
+
+class TestGetAppIdentifier(TestCase):
+
+    def test_get_app_module(self):
+        """
+        Make sure the the ``root`` argument is handled correctly.
+        """
+        self.assertEqual(
+            get_app_module(app_name="music", root="."),
+            "music.piccolo_app",
+        )
+
+        for root in ("apps", "./apps", "./apps/"):
+            self.assertEqual(
+                get_app_module(app_name="music", root=root),
+                "apps.music.piccolo_app",
+            )

tests/apps/migrations/auto/test_migration_manager.py

@@ -12,8 +12,10 @@ from piccolo.columns.base import OnDelete, OnUpdate
 from piccolo.columns.column_types import ForeignKey
 from piccolo.conf.apps import AppConfig
 from piccolo.engine import engine_finder
+from piccolo.query.constraints import get_fk_constraint_rules
 from piccolo.table import Table, sort_table_classes
 from piccolo.utils.lazy_loader import LazyLoader
+from piccolo.utils.sync import run_sync
 from tests.base import AsyncMock, DBTestCase, engine_is, engines_only
 from tests.example_apps.music.tables import Band, Concert, Manager, Venue
 
@@ -618,6 +620,54 @@ class TestMigrationManager(DBTestCase):
             response = self.run_sync("SELECT * FROM manager;")
             self.assertEqual(response, [{"id": id[0]["id"], "name": "Dave"}])
 
+    @engines_only("postgres", "cockroach")
+    def test_alter_fk_on_delete_on_update(self):
+        """
+        Test altering OnDelete and OnUpdate with MigrationManager.
+        """
+        # before performing migrations - OnDelete.no_action
+        self.assertEqual(
+            run_sync(get_fk_constraint_rules(column=Band.manager)).on_delete,
+            OnDelete.no_action,
+        )
+
+        manager = MigrationManager(app_name="music")
+        manager.alter_column(
+            table_class_name="Band",
+            tablename="band",
+            column_name="manager",
+            db_column_name="manager",
+            params={
+                "on_delete": OnDelete.set_null,
+                "on_update": OnUpdate.set_null,
+            },
+            old_params={
+                "on_delete": OnDelete.no_action,
+                "on_update": OnUpdate.no_action,
+            },
+            column_class=ForeignKey,
+            old_column_class=ForeignKey,
+            schema=None,
+        )
+
+        asyncio.run(manager.run())
+
+        # after performing migrations - OnDelete.set_null
+        self.assertEqual(
+            run_sync(get_fk_constraint_rules(column=Band.manager)).on_delete,
+            OnDelete.set_null,
+        )
+
+        # Reverse
+        asyncio.run(manager.run(backwards=True))
+
+        # after performing reverse migrations we have
+        # OnDelete.no_action again
+        self.assertEqual(
+            run_sync(get_fk_constraint_rules(column=Band.manager)).on_delete,
+            OnDelete.no_action,
+        )
+
     @engines_only("postgres")
     def test_alter_column_unique(self):
         """

tests/conf/test_apps.py

@@ -1,10 +1,17 @@
 from __future__ import annotations
 
 import pathlib
+import tempfile
 from unittest import TestCase
 
 from piccolo.apps.user.tables import BaseUser
-from piccolo.conf.apps import AppConfig, AppRegistry, Finder, table_finder
+from piccolo.conf.apps import (
+    AppConfig,
+    AppRegistry,
+    Finder,
+    PiccoloConfUpdater,
+    table_finder,
+)
 from tests.example_apps.mega.tables import MegaTable, SmallTable
 from tests.example_apps.music.tables import (
     Band,
@@ -310,3 +317,44 @@ class TestFinder(TestCase):
         self.assertListEqual(
             [i.app_name for i in sorted_app_configs], ["app_2", "app_1"]
         )
+
+
+class TestPiccoloConfUpdater(TestCase):
+
+    def test_modify_app_registry_src(self):
+        """
+        Make sure the `piccolo_conf.py` source code can be modified
+        successfully.
+        """
+        updater = PiccoloConfUpdater()
+
+        new_src = updater._modify_app_registry_src(
+            src="APP_REGISTRY = AppRegistry(apps=[])",
+            app_module="music.piccolo_app",
+        )
+        self.assertEqual(
+            new_src.strip(),
+            'APP_REGISTRY = AppRegistry(apps=["music.piccolo_app"])',
+        )
+
+    def test_register_app(self):
+        """
+        Make sure the new contents get written to disk.
+        """
+        temp_dir = tempfile.gettempdir()
+        piccolo_conf_path = pathlib.Path(temp_dir) / "piccolo_conf.py"
+
+        src = "APP_REGISTRY = AppRegistry(apps=[])"
+
+        with open(piccolo_conf_path, "wt") as f:
+            f.write(src)
+
+        updater = PiccoloConfUpdater(piccolo_conf_path=str(piccolo_conf_path))
+        updater.register_app(app_module="music.piccolo_app")
+
+        with open(piccolo_conf_path) as f:
+            contents = f.read().strip()
+
+        self.assertEqual(
+            contents, 'APP_REGISTRY = AppRegistry(apps=["music.piccolo_app"])'
+        )

tests/table/instance/test_remove.py

@@ -17,9 +17,11 @@ class TestRemove(TestCase):
             "Maz"
             in Manager.select(Manager.name).output(as_list=True).run_sync()
         )
+        self.assertEqual(manager._exists_in_db, True)
 
         manager.remove().run_sync()
         self.assertTrue(
             "Maz"
             not in Manager.select(Manager.name).output(as_list=True).run_sync()
         )
+        self.assertEqual(manager._exists_in_db, False)