piccolo 1.11.0__tar.gz → 1.12.0__tar.gz

{piccolo-1.11.0 → piccolo-1.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.11.0
+Version: 1.12.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.12.0/piccolo/__init__.py

@@ -0,0 +1 @@
+__VERSION__ = "1.12.0"

{piccolo-1.11.0 → piccolo-1.12.0}/piccolo/apps/asgi/commands/templates/app/_fastapi_app.py.jinja

@@ -1,11 +1,12 @@
 import typing as t
+from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
 from fastapi.responses import JSONResponse
+from piccolo.engine import engine_finder
 from piccolo_admin.endpoints import create_admin
 from piccolo_api.crud.serializers import create_pydantic_model
-from piccolo.engine import engine_finder
-from starlette.routing import Route, Mount
+from starlette.routing import Mount, Route
 from starlette.staticfiles import StaticFiles
 
 from home.endpoints import HomeEndpoint
@@ -13,6 +14,29 @@ from home.piccolo_app import APP_CONFIG
 from home.tables import Task
 
 
+async def open_database_connection_pool():
+    try:
+        engine = engine_finder()
+        await engine.start_connection_pool()
+    except Exception:
+        print("Unable to connect to the database")
+
+
+async def close_database_connection_pool():
+    try:
+        engine = engine_finder()
+        await engine.close_connection_pool()
+    except Exception:
+        print("Unable to connect to the database")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await open_database_connection_pool()
+    yield
+    await close_database_connection_pool()
+
+
 app = FastAPI(
     routes=[
         Route("/", HomeEndpoint),
@@ -22,21 +46,20 @@ app = FastAPI(
                 tables=APP_CONFIG.table_classes,
                 # Required when running under HTTPS:
                 # allowed_hosts=['my_site.com']
-            )
+            ),
         ),
         Mount("/static/", StaticFiles(directory="static")),
     ],
+    lifespan=lifespan,
 )
 
 
 TaskModelIn: t.Any = create_pydantic_model(
     table=Task,
-    model_name='TaskModelIn'
+    model_name="TaskModelIn",
 )
 TaskModelOut: t.Any = create_pydantic_model(
-    table=Task,
-    include_default_columns=True,
-    model_name='TaskModelOut'
+    table=Task, include_default_columns=True, model_name="TaskModelOut"
 )
 
 
@@ -45,16 +68,16 @@ async def tasks():
     return await Task.select().order_by(Task.id)
 
 
-@app.post('/tasks/', response_model=TaskModelOut)
+@app.post("/tasks/", response_model=TaskModelOut)
 async def create_task(task_model: TaskModelIn):
     task = Task(**task_model.dict())
     await task.save()
     return task.to_dict()
 
 
-@app.put('/tasks/{task_id}/', response_model=TaskModelOut)
+@app.put("/tasks/{task_id}/", response_model=TaskModelOut)
 async def update_task(task_id: int, task_model: TaskModelIn):
-    task = await Task.objects().get(Task.id == task_id)
+    task = await Task.objects().get(Task._meta.primary_key == task_id)
     if not task:
         return JSONResponse({}, status_code=404)
 
@@ -66,30 +89,12 @@ async def update_task(task_id: int, task_model: TaskModelIn):
     return task.to_dict()
 
 
-@app.delete('/tasks/{task_id}/')
+@app.delete("/tasks/{task_id}/")
 async def delete_task(task_id: int):
-    task = await Task.objects().get(Task.id == task_id)
+    task = await Task.objects().get(Task._meta.primary_key == task_id)
     if not task:
         return JSONResponse({}, status_code=404)
 
     await task.remove()
 
     return JSONResponse({})
-
-
-@app.on_event("startup")
-async def open_database_connection_pool():
-    try:
-        engine = engine_finder()
-        await engine.start_connection_pool()
-    except Exception:
-        print("Unable to connect to the database")
-
-
-@app.on_event("shutdown")
-async def close_database_connection_pool():
-    try:
-        engine = engine_finder()
-        await engine.close_connection_pool()
-    except Exception:
-        print("Unable to connect to the database")

{piccolo-1.11.0 → piccolo-1.12.0}/piccolo/apps/asgi/commands/templates/app/_starlette_app.py.jinja

@@ -1,8 +1,10 @@
+from contextlib import asynccontextmanager
+
+from piccolo.engine import engine_finder
 from piccolo_admin.endpoints import create_admin
 from piccolo_api.crud.endpoints import PiccoloCRUD
-from piccolo.engine import engine_finder
-from starlette.routing import Route, Mount
 from starlette.applications import Starlette
+from starlette.routing import Mount, Route
 from starlette.staticfiles import StaticFiles
 
 from home.endpoints import HomeEndpoint
@@ -10,24 +12,6 @@ from home.piccolo_app import APP_CONFIG
 from home.tables import Task
 
 
-app = Starlette(
-    routes=[
-        Route("/", HomeEndpoint),
-        Mount(
-            "/admin/",
-            create_admin(
-                tables=APP_CONFIG.table_classes,
-                # Required when running under HTTPS:
-                # allowed_hosts=['my_site.com']
-            )
-        ),
-        Mount("/static/", StaticFiles(directory="static")),
-        Mount("/tasks/", PiccoloCRUD(table=Task))
-    ],
-)
-
-
-@app.on_event("startup")
 async def open_database_connection_pool():
     try:
         engine = engine_finder()
@@ -36,10 +20,34 @@ async def open_database_connection_pool():
         print("Unable to connect to the database")
 
 
-@app.on_event("shutdown")
 async def close_database_connection_pool():
     try:
         engine = engine_finder()
         await engine.close_connection_pool()
     except Exception:
         print("Unable to connect to the database")
+
+
+@asynccontextmanager
+async def lifespan(app: Starlette):
+    await open_database_connection_pool()
+    yield
+    await close_database_connection_pool()
+
+
+app = Starlette(
+    routes=[
+        Route("/", HomeEndpoint),
+        Mount(
+            "/admin/",
+            create_admin(
+                tables=APP_CONFIG.table_classes,
+                # Required when running under HTTPS:
+                # allowed_hosts=['my_site.com']
+            ),
+        ),
+        Mount("/static/", StaticFiles(directory="static")),
+        Mount("/tasks/", PiccoloCRUD(table=Task)),
+    ],
+    lifespan=lifespan,
+)

{piccolo-1.11.0 → piccolo-1.12.0}/piccolo/apps/migrations/auto/migration_manager.py

@@ -165,6 +165,7 @@ class MigrationManager:
     raw_backwards: t.List[t.Union[t.Callable, AsyncFunction]] = field(
         default_factory=list
     )
+    fake: bool = False
 
     def add_table(
         self,

{piccolo-1.11.0 → piccolo-1.12.0}/piccolo/apps/migrations/commands/forwards.py

@@ -72,18 +72,19 @@ class ForwardsMigrationManager(BaseMigrationManager):
             print(f"🚀 Running {n} migration{'s' if n != 1 else ''}:")
 
             for _id in subset:
-                if self.fake:
-                    print(f"- {_id}: faked! ⏭️")
-                else:
-                    migration_module = migration_modules[_id]
-                    response = await migration_module.forwards()
+                migration_module = migration_modules[_id]
+                response = await migration_module.forwards()
 
-                    if isinstance(response, MigrationManager):
+                if isinstance(response, MigrationManager):
+                    if self.fake or response.fake:
+                        print(f"- {_id}: faked! ⏭️")
+                    else:
                         if self.preview:
                             response.preview = True
                         await response.run()
 
-                    print("ok! ✔️")
+                print("ok! ✔️")
+
                 if not self.preview:
                     await Migration.insert().add(
                         Migration(name=_id, app_name=app_config.app_name)

{piccolo-1.11.0 → piccolo-1.12.0}/piccolo/apps/playground/commands/run.py

@@ -19,6 +19,7 @@ from piccolo.columns import (
     Interval,
     Numeric,
     Serial,
+    Text,
     Timestamp,
     Varchar,
 )
@@ -55,6 +56,12 @@ class Band(Table):
         )
 
 
+class FanClub(Table):
+    id: Serial
+    address = Text()
+    band = ForeignKey(Band, unique=True)
+
+
 class Venue(Table):
     id: Serial
     name = Varchar(length=100)
@@ -154,6 +161,7 @@ class Album(Table):
 TABLES = (
     Manager,
     Band,
+    FanClub,
     Venue,
     Concert,
     Ticket,
@@ -185,6 +193,9 @@ def populate():
     pythonistas = Band(name="Pythonistas", manager=guido.id, popularity=1000)
     pythonistas.save().run_sync()
 
+    fan_club = FanClub(address="1 Flying Circus, UK", band=pythonistas)
+    fan_club.save().run_sync()
+
     graydon = Manager(name="Graydon")
     graydon.save().run_sync()
 

{piccolo-1.11.0 → piccolo-1.12.0}/piccolo/columns/column_types.py

@@ -2016,6 +2016,61 @@ class ForeignKey(Column, t.Generic[ReferencedTable]):
             if column._meta.name not in excluded_column_names
         ]
 
+    def reverse(self) -> ForeignKey:
+        """
+        If there's a unique foreign key, this function reverses it.
+
+        .. code-block:: python
+
+            class Band(Table):
+                name = Varchar()
+
+            class FanClub(Table):
+                band = ForeignKey(Band, unique=True)
+                address = Text()
+
+            class Treasurer(Table):
+                fan_club = ForeignKey(FanClub, unique=True)
+                name = Varchar()
+
+        It's helpful with ``get_related``, for example:
+
+        .. code-block:: python
+
+            >>> band = await Band.objects().first()
+            >>> await band.get_related(FanClub.band.reverse())
+            <Fan Club: 1>
+
+        It works multiple levels deep:
+
+        .. code-block:: python
+
+            >>> await band.get_related(Treasurer.fan_club._.band.reverse())
+            <Treasurer: 1>
+
+        """
+        if not self._meta.unique or any(
+            not i._meta.unique for i in self._meta.call_chain
+        ):
+            raise ValueError("Only reverse unique foreign keys.")
+
+        foreign_keys = [*self._meta.call_chain, self]
+
+        root_foreign_key = foreign_keys[0]
+        target_column = (
+            root_foreign_key._foreign_key_meta.resolved_target_column
+        )
+        foreign_key = target_column.join_on(root_foreign_key)
+
+        call_chain = []
+        for fk in reversed(foreign_keys[1:]):
+            target_column = fk._foreign_key_meta.resolved_target_column
+            call_chain.append(target_column.join_on(fk))
+
+        foreign_key._meta.call_chain = call_chain
+
+        return foreign_key
+
     def all_related(
         self, exclude: t.Optional[t.List[t.Union[ForeignKey, str]]] = None
     ) -> t.List[ForeignKey]:

{piccolo-1.11.0 → piccolo-1.12.0}/piccolo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.11.0
+Version: 1.12.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.11.0 → piccolo-1.12.0}/tests/apps/migrations/commands/test_forwards_backwards.py

@@ -192,7 +192,7 @@ class TestForwardsBackwards(TestCase):
     @engines_only("postgres")
     def test_forwards_fake(self):
         """
-        Test running the migrations if they've already run.
+        Make sure migrations can be faked on the command line.
         """
         run_sync(forwards(app_name="music", migration_id="all", fake=True))
 
@@ -214,9 +214,40 @@ class TestForwardsBackwards(TestCase):
                 "2021-09-06T13:58:23:024723",
                 "2021-11-13T14:01:46:114725",
                 "2024-05-28T23:15:41:018844",
+                "2024-06-19T18:11:05:793132",
             ],
         )
 
+    @engines_only("postgres")
+    @patch("piccolo.apps.migrations.commands.forwards.print")
+    def test_hardcoded_fake_migrations(self, print_: MagicMock):
+        """
+        Make sure that migrations that have been hardcoded as fake aren't
+        executed, even without the ``--fake`` command line flag.
+
+        See tests/example_apps/music/piccolo_migrations/music_2024_06_19t18_11_05_793132.py
+
+        """  # noqa: E501
+        run_sync(forwards(app_name="music", migration_id="all"))
+
+        # The migration which is hardcoded as fake:
+        migration_name = "2024-06-19T18:11:05:793132"
+
+        self.assertTrue(
+            Migration.exists()
+            .where(Migration.name == migration_name)
+            .run_sync()
+        )
+
+        self.assertNotIn(
+            call("Running fake migration"),
+            print_.mock_calls,
+        )
+        self.assertIn(
+            call(f"- {migration_name}: faked! ⏭️"),
+            print_.mock_calls,
+        )
+
     def tearDown(self):
         for table_class in TABLE_CLASSES + [Migration]:
             table_class.alter().drop_table(

{piccolo-1.11.0 → piccolo-1.12.0}/tests/columns/test_array.py

@@ -14,7 +14,7 @@ from piccolo.columns.column_types import (
 )
 from piccolo.querystring import QueryString
 from piccolo.table import Table
-from tests.base import engines_only, engines_skip, sqlite_only
+from tests.base import TableTest, engines_only, engines_skip, sqlite_only
 
 
 class MyTable(Table):
@@ -32,16 +32,12 @@ class TestArrayDefault(TestCase):
         self.assertTrue(column.default is list)
 
 
-class TestArray(TestCase):
+class TestArray(TableTest):
     """
     Make sure an Array column can be created, and works correctly.
     """
 
-    def setUp(self):
-        MyTable.create_table().run_sync()
-
-    def tearDown(self):
-        MyTable.alter().drop_table().run_sync()
+    tables = [MyTable]
 
     @pytest.mark.cockroach_array_slow
     def test_storage(self):

{piccolo-1.11.0 → piccolo-1.12.0}/tests/columns/test_bigint.py

@@ -1,10 +1,8 @@
 import os
-from unittest import TestCase
 
 from piccolo.columns.column_types import BigInt
 from piccolo.table import Table
-
-from ..base import engines_only
+from tests.base import TableTest, engines_only
 
 
 class MyTable(Table):
@@ -12,16 +10,12 @@ class MyTable(Table):
 
 
 @engines_only("postgres", "cockroach")
-class TestBigIntPostgres(TestCase):
+class TestBigIntPostgres(TableTest):
     """
     Make sure a BigInt column in Postgres can store a large number.
     """
 
-    def setUp(self):
-        MyTable.create_table().run_sync()
-
-    def tearDown(self):
-        MyTable.alter().drop_table().run_sync()
+    tables = [MyTable]
 
     def _test_length(self):
         # Can store 8 bytes, but split between positive and negative values.

{piccolo-1.11.0 → piccolo-1.12.0}/tests/columns/test_boolean.py

@@ -1,20 +1,16 @@
 import typing as t
-from unittest import TestCase
 
 from piccolo.columns.column_types import Boolean
 from piccolo.table import Table
+from tests.base import TableTest
 
 
 class MyTable(Table):
     boolean = Boolean(boolean=False, null=True)
 
 
-class TestBoolean(TestCase):
-    def setUp(self):
-        MyTable.create_table().run_sync()
-
-    def tearDown(self):
-        MyTable.alter().drop_table().run_sync()
+class TestBoolean(TableTest):
+    tables = [MyTable]
 
     def test_return_type(self) -> None:
         for value in (True, False, None, ...):

{piccolo-1.11.0 → piccolo-1.12.0}/tests/columns/test_bytea.py

@@ -1,7 +1,6 @@
-from unittest import TestCase
-
 from piccolo.columns.column_types import Bytea
 from piccolo.table import Table
+from tests.base import TableTest
 
 
 class MyTable(Table):
@@ -19,12 +18,8 @@ class MyTableDefault(Table):
     token_none = Bytea(default=None, null=True)
 
 
-class TestBytea(TestCase):
-    def setUp(self):
-        MyTable.create_table().run_sync()
-
-    def tearDown(self):
-        MyTable.alter().drop_table().run_sync()
+class TestBytea(TableTest):
+    tables = [MyTable]
 
     def test_bytea(self):
         """
@@ -40,12 +35,8 @@ class TestBytea(TestCase):
         )
 
 
-class TestByteaDefault(TestCase):
-    def setUp(self):
-        MyTableDefault.create_table().run_sync()
-
-    def tearDown(self):
-        MyTableDefault.alter().drop_table().run_sync()
+class TestByteaDefault(TableTest):
+    tables = [MyTableDefault]
 
     def test_json_default(self):
         row = MyTableDefault()

{piccolo-1.11.0 → piccolo-1.12.0}/tests/columns/test_choices.py

@@ -1,18 +1,13 @@
 import enum
-from unittest import TestCase
 
 from piccolo.columns.column_types import Array, Varchar
 from piccolo.table import Table
-from tests.base import engines_only
+from tests.base import TableTest, engines_only
 from tests.example_apps.music.tables import Shirt
 
 
-class TestChoices(TestCase):
-    def setUp(self):
-        Shirt.create_table().run_sync()
-
-    def tearDown(self):
-        Shirt.alter().drop_table().run_sync()
+class TestChoices(TableTest):
+    tables = [Shirt]
 
     def _insert_shirts(self):
         Shirt.insert(
@@ -87,16 +82,12 @@ class Ticket(Table):
 
 
 @engines_only("postgres", "sqlite")
-class TestArrayChoices(TestCase):
+class TestArrayChoices(TableTest):
     """
     🐛 Cockroach bug: https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
     """  # noqa: E501
 
-    def setUp(self):
-        Ticket.create_table().run_sync()
-
-    def tearDown(self):
-        Ticket.alter().drop_table().run_sync()
+    tables = [Ticket]
 
     def test_string(self):
         """

{piccolo-1.11.0 → piccolo-1.12.0}/tests/columns/test_date.py

@@ -1,9 +1,9 @@
 import datetime
-from unittest import TestCase
 
 from piccolo.columns.column_types import Date
 from piccolo.columns.defaults.date import DateNow
 from piccolo.table import Table
+from tests.base import TableTest
 
 
 class MyTable(Table):
@@ -14,12 +14,8 @@ class MyTableDefault(Table):
     created_on = Date(default=DateNow())
 
 
-class TestDate(TestCase):
-    def setUp(self):
-        MyTable.create_table().run_sync()
-
-    def tearDown(self):
-        MyTable.alter().drop_table().run_sync()
+class TestDate(TableTest):
+    tables = [MyTable]
 
     def test_timestamp(self):
         created_on = datetime.datetime.now().date()
@@ -31,12 +27,8 @@ class TestDate(TestCase):
         self.assertEqual(result.created_on, created_on)
 
 
-class TestDateDefault(TestCase):
-    def setUp(self):
-        MyTableDefault.create_table().run_sync()
-
-    def tearDown(self):
-        MyTableDefault.alter().drop_table().run_sync()
+class TestDateDefault(TableTest):
+    tables = [MyTableDefault]
 
     def test_timestamp(self):
         created_on = datetime.datetime.now().date()

{piccolo-1.11.0 → piccolo-1.12.0}/tests/columns/test_double_precision.py

@@ -1,19 +1,14 @@
-from unittest import TestCase
-
 from piccolo.columns.column_types import DoublePrecision
 from piccolo.table import Table
+from tests.base import TableTest
 
 
 class MyTable(Table):
     column_a = DoublePrecision()
 
 
-class TestDoublePrecision(TestCase):
-    def setUp(self):
-        MyTable.create_table().run_sync()
-
-    def tearDown(self):
-        MyTable.alter().drop_table().run_sync()
+class TestDoublePrecision(TableTest):
+    tables = [MyTable]
 
     def test_creation(self):
         row = MyTable(column_a=1.23)

{piccolo-1.11.0 → piccolo-1.12.0}/tests/columns/test_interval.py

@@ -1,9 +1,9 @@
 import datetime
-from unittest import TestCase
 
 from piccolo.columns.column_types import Interval
 from piccolo.columns.defaults.interval import IntervalCustom
 from piccolo.table import Table
+from tests.base import TableTest
 
 
 class MyTable(Table):
@@ -14,12 +14,8 @@ class MyTableDefault(Table):
     interval = Interval(default=IntervalCustom(days=1))
 
 
-class TestInterval(TestCase):
-    def setUp(self):
-        MyTable.create_table().run_sync()
-
-    def tearDown(self):
-        MyTable.alter().drop_table().run_sync()
+class TestInterval(TableTest):
+    tables = [MyTable]
 
     def test_interval(self):
         # Test a range of different timedeltas
@@ -91,12 +87,8 @@ class TestInterval(TestCase):
         self.assertTrue(result)
 
 
-class TestIntervalDefault(TestCase):
-    def setUp(self):
-        MyTableDefault.create_table().run_sync()
-
-    def tearDown(self):
-        MyTableDefault.alter().drop_table().run_sync()
+class TestIntervalDefault(TableTest):
+    tables = [MyTableDefault]
 
     def test_interval(self):
         row = MyTableDefault()