piccolo 1.19.0__tar.gz → 1.20.0__tar.gz

{piccolo-1.19.0 → piccolo-1.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.19.0
+Version: 1.20.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.20.0/piccolo/__init__.py

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

{piccolo-1.19.0 → piccolo-1.20.0}/piccolo/apps/asgi/commands/new.py

@@ -12,10 +12,10 @@ TEMPLATE_DIR = os.path.join(os.path.dirname(__file__), "templates/app/")
 SERVERS = ["uvicorn", "Hypercorn", "granian"]
 ROUTER_DEPENDENCIES = {
     "starlette": ["starlette"],
-    "fastapi": ["fastapi>=0.112.1"],
+    "fastapi": ["fastapi"],
     "blacksheep": ["blacksheep"],
     "litestar": ["litestar"],
-    "esmerald": ["esmerald==3.3.0"],
+    "esmerald": ["esmerald"],
     "lilya": ["lilya"],
 }
 ROUTERS = list(ROUTER_DEPENDENCIES.keys())

{piccolo-1.19.0 → piccolo-1.20.0}/piccolo/apps/asgi/commands/templates/app/_blacksheep_app.py.jinja

@@ -1,20 +1,18 @@
 import typing as t
 
-from piccolo_admin.endpoints import create_admin
-from piccolo_api.crud.serializers import create_pydantic_model
-from piccolo.engine import engine_finder
-
 from blacksheep.server import Application
 from blacksheep.server.bindings import FromJSON
-from blacksheep.server.responses import json
 from blacksheep.server.openapi.v3 import OpenAPIHandler
+from blacksheep.server.responses import json
 from openapidocs.v3 import Info
+from piccolo.engine import engine_finder
+from piccolo_admin.endpoints import create_admin
+from piccolo_api.crud.serializers import create_pydantic_model
 
 from home.endpoints import home
 from home.piccolo_app import APP_CONFIG
 from home.tables import Task
 
-
 app = Application()
 
 app.mount(
@@ -47,7 +45,7 @@ TaskModelPartial: t.Any = create_pydantic_model(
 
 @app.router.get("/tasks/")
 async def tasks() -> t.List[TaskModelOut]:
-    return await Task.select().order_by(Task.id)
+    return await Task.select().order_by(Task._meta.primary_key, ascending=False)
 
 
 @app.router.post("/tasks/")
@@ -58,10 +56,8 @@ async def create_task(task_model: FromJSON[TaskModelIn]) -> TaskModelOut:
 
 
 @app.router.put("/tasks/{task_id}/")
-async def put_task(
-    task_id: int, task_model: FromJSON[TaskModelIn]
-) -> TaskModelOut:
-    task = await Task.objects().get(Task.id == task_id)
+async def put_task(task_id: int, task_model: FromJSON[TaskModelIn]) -> TaskModelOut:
+    task = await Task.objects().get(Task._meta.primary_key == task_id)
     if not task:
         return json({}, status=404)
 
@@ -77,7 +73,7 @@ async def put_task(
 async def patch_task(
     task_id: int, task_model: FromJSON[TaskModelPartial]
 ) -> TaskModelOut:
-    task = await Task.objects().get(Task.id == task_id)
+    task = await Task.objects().get(Task._meta.primary_key == task_id)
     if not task:
         return json({}, status=404)
 
@@ -92,7 +88,7 @@ async def patch_task(
 
 @app.router.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 json({}, status=404)
 

{piccolo-1.19.0 → piccolo-1.20.0}/piccolo/apps/asgi/commands/templates/app/_esmerald_app.py.jinja

@@ -1,23 +1,21 @@
 import typing as t
-
 from pathlib import Path
 
-from piccolo.utils.pydantic import create_pydantic_model
-from piccolo.engine import engine_finder
-from piccolo_admin.endpoints import create_admin
-
 from esmerald import (
+    APIView,
     Esmerald,
-    Include,
     Gateway,
+    Include,
     JSONResponse,
-    APIView,
+    delete,
     get,
     post,
     put,
-    delete
 )
 from esmerald.config import StaticFilesConfig
+from piccolo.engine import engine_finder
+from piccolo.utils.pydantic import create_pydantic_model
+from piccolo_admin.endpoints import create_admin
 
 from home.endpoints import home
 from home.piccolo_app import APP_CONFIG
@@ -40,14 +38,9 @@ async def close_database_connection_pool():
         print("Unable to connect to the database")
 
 
-TaskModelIn: t.Any = create_pydantic_model(
-    table=Task,
-    model_name='TaskModelIn'
-)
+TaskModelIn: t.Any = create_pydantic_model(table=Task, 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"
 )
 
 
@@ -57,19 +50,17 @@ class TaskAPIView(APIView):
 
     @get("/")
     async def tasks(self) -> t.List[TaskModelOut]:
-        return await Task.select().order_by(Task.id)
-
+        return await Task.select().order_by(Task._meta.primary_key, ascending=False)
 
-    @post('/')
+    @post("/")
     async def create_task(self, payload: TaskModelIn) -> TaskModelOut:
         task = Task(**payload.dict())
         await task.save()
         return task.to_dict()
 
-
-    @put('/{task_id}')
+    @put("/{task_id}")
     async def update_task(self, payload: TaskModelIn, task_id: int) -> TaskModelOut:
-        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)
 
@@ -80,10 +71,9 @@ class TaskAPIView(APIView):
 
         return task.to_dict()
 
-
-    @delete('/{task_id}')
+    @delete("/{task_id}")
     async def delete_task(self, task_id: int) -> None:
-        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)
 

{piccolo-1.19.0 → piccolo-1.20.0}/piccolo/apps/asgi/commands/templates/app/_lilya_app.py.jinja

@@ -1,15 +1,14 @@
-from piccolo_admin.endpoints import create_admin
-from piccolo_api.crud.endpoints import PiccoloCRUD
-from piccolo.engine import engine_finder
-from lilya.routing import Path, Include
 from lilya.apps import Lilya
+from lilya.routing import Include, Path
 from lilya.staticfiles import StaticFiles
+from piccolo.engine import engine_finder
+from piccolo_admin.endpoints import create_admin
+from piccolo_api.crud.endpoints import PiccoloCRUD
 
 from home.endpoints import HomeController
 from home.piccolo_app import APP_CONFIG
 from home.tables import Task
 
-
 app = Lilya(
     routes=[
         Path("/", HomeController),
@@ -19,10 +18,10 @@ app = Lilya(
                 tables=APP_CONFIG.table_classes,
                 # Required when running under HTTPS:
                 # allowed_hosts=['my_site.com']
-            )
+            ),
         ),
         Include("/static/", StaticFiles(directory="static")),
-        Include("/tasks/", PiccoloCRUD(table=Task))
+        Include("/tasks/", PiccoloCRUD(table=Task)),
     ],
 )
 

{piccolo-1.19.0 → piccolo-1.20.0}/piccolo/apps/asgi/commands/templates/app/_litestar_app.py.jinja

@@ -1,8 +1,5 @@
 import typing as t
 
-from home.endpoints import home
-from home.piccolo_app import APP_CONFIG
-from home.tables import Task
 from litestar import Litestar, asgi, delete, get, patch, post
 from litestar.contrib.jinja import JinjaTemplateEngine
 from litestar.exceptions import NotFoundException
@@ -10,8 +7,19 @@ from litestar.static_files import StaticFilesConfig
 from litestar.template import TemplateConfig
 from litestar.types import Receive, Scope, Send
 from piccolo.engine import engine_finder
-from piccolo.utils.pydantic import create_pydantic_model
 from piccolo_admin.endpoints import create_admin
+from pydantic import BaseModel
+
+from home.endpoints import home
+from home.piccolo_app import APP_CONFIG
+from home.tables import Task
+
+"""
+NOTE: `create_pydantic_model` is not compatible with Litestar
+version higher than 2.11.0. If you are using Litestar<=2.11.0, 
+you can use `create_pydantic_model` as in other asgi templates
+
+from piccolo.utils.pydantic import create_pydantic_model
 
 TaskModelIn: t.Any = create_pydantic_model(
     table=Task,
@@ -22,6 +30,18 @@ TaskModelOut: t.Any = create_pydantic_model(
     include_default_columns=True,
     model_name="TaskModelOut",
 )
+"""
+
+
+class TaskModelIn(BaseModel):
+    name: str
+    completed: bool = False
+
+
+class TaskModelOut(BaseModel):
+    id: int
+    name: str
+    completed: bool = False
 
 
 # mounting Piccolo Admin
@@ -32,31 +52,32 @@ async def admin(scope: "Scope", receive: "Receive", send: "Send") -> None:
 
 @get("/tasks", tags=["Task"])
 async def tasks() -> t.List[TaskModelOut]:
-    return await Task.select().order_by(Task.id, ascending=False)
+    tasks = await Task.select().order_by(Task._meta.primary_key, ascending=False)
+    return [TaskModelOut(**task) for task in tasks]
 
 
 @post("/tasks", tags=["Task"])
 async def create_task(data: TaskModelIn) -> TaskModelOut:
-    task = Task(**data.dict())
+    task = Task(**data.model_dump())
     await task.save()
-    return task.to_dict()
+    return TaskModelOut(**task.to_dict())
 
 
 @patch("/tasks/{task_id:int}", tags=["Task"])
 async def update_task(task_id: int, data: TaskModelIn) -> TaskModelOut:
-    task = await Task.objects().get(Task.id == task_id)
+    task = await Task.objects().get(Task._meta.primary_key == task_id)
     if not task:
         raise NotFoundException("Task does not exist")
-    for key, value in data.dict().items():
+    for key, value in data.model_dump().items():
         setattr(task, key, value)
 
     await task.save()
-    return task.to_dict()
+    return TaskModelOut(**task.to_dict())
 
 
 @delete("/tasks/{task_id:int}", tags=["Task"])
 async def delete_task(task_id: int) -> None:
-    task = await Task.objects().get(Task.id == task_id)
+    task = await Task.objects().get(Task._meta.primary_key == task_id)
     if not task:
         raise NotFoundException("Task does not exist")
     await task.remove()

{piccolo-1.19.0 → piccolo-1.20.0}/piccolo/columns/m2m.py

@@ -384,8 +384,12 @@ class M2MGetRelated:
             .output(as_list=True)
         )
 
-        results = await secondary_table.objects().where(
-            secondary_table._meta.primary_key.is_in(ids)
+        results = (
+            await secondary_table.objects().where(
+                secondary_table._meta.primary_key.is_in(ids)
+            )
+            if len(ids) > 0
+            else []
         )
 
         return results

{piccolo-1.19.0 → piccolo-1.20.0}/piccolo/query/methods/objects.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import typing as t
 
-from piccolo.columns.column_types import ForeignKey
+from piccolo.columns.column_types import ForeignKey, ReferencedTable
 from piccolo.columns.combination import And, Where
 from piccolo.custom_types import Combinable, TableInstance
 from piccolo.engine.base import BaseBatch
@@ -231,6 +231,63 @@ class UpdateSelf:
         return run_sync(self.run(*args, **kwargs))
 
 
+class GetRelated(t.Generic[ReferencedTable]):
+
+    def __init__(self, row: Table, foreign_key: ForeignKey[ReferencedTable]):
+        self.row = row
+        self.foreign_key = foreign_key
+
+    async def run(
+        self,
+        node: t.Optional[str] = None,
+        in_pool: bool = True,
+    ) -> t.Optional[ReferencedTable]:
+        if not self.row._exists_in_db:
+            raise ValueError("The object doesn't exist in the database.")
+
+        root_table = self.row.__class__
+
+        data = (
+            await root_table.select(
+                *[
+                    i.as_alias(i._meta.name)
+                    for i in self.foreign_key.all_columns()
+                ]
+            )
+            .where(
+                root_table._meta.primary_key
+                == getattr(self.row, root_table._meta.primary_key._meta.name)
+            )
+            .first()
+            .run(node=node, in_pool=in_pool)
+        )
+
+        # Make sure that some values were returned:
+        if data is None or not any(data.values()):
+            return None
+
+        references = t.cast(
+            t.Type[ReferencedTable],
+            self.foreign_key._foreign_key_meta.resolved_references,
+        )
+
+        referenced_object = references(**data)
+        referenced_object._exists_in_db = True
+        return referenced_object
+
+    def __await__(
+        self,
+    ) -> t.Generator[None, None, t.Optional[ReferencedTable]]:
+        """
+        If the user doesn't explicity call .run(), proxy to it as a
+        convenience.
+        """
+        return self.run().__await__()
+
+    def run_sync(self, *args, **kwargs) -> t.Optional[ReferencedTable]:
+        return run_sync(self.run(*args, **kwargs))
+
+
 ###############################################################################
 
 

{piccolo-1.19.0 → piccolo-1.20.0}/piccolo/table.py

@@ -46,7 +46,7 @@ from piccolo.query import (
 )
 from piccolo.query.methods.create_index import CreateIndex
 from piccolo.query.methods.indexes import Indexes
-from piccolo.query.methods.objects import First, UpdateSelf
+from piccolo.query.methods.objects import GetRelated, UpdateSelf
 from piccolo.query.methods.refresh import Refresh
 from piccolo.querystring import QueryString
 from piccolo.utils import _camel_to_snake
@@ -612,14 +612,14 @@ class Table(metaclass=TableMetaclass):
     @t.overload
     def get_related(
         self, foreign_key: ForeignKey[ReferencedTable]
-    ) -> First[ReferencedTable]: ...
+    ) -> GetRelated[ReferencedTable]: ...
 
     @t.overload
-    def get_related(self, foreign_key: str) -> First[Table]: ...
+    def get_related(self, foreign_key: str) -> GetRelated[Table]: ...
 
     def get_related(
         self, foreign_key: t.Union[str, ForeignKey[ReferencedTable]]
-    ) -> t.Union[First[Table], First[ReferencedTable]]:
+    ) -> GetRelated[ReferencedTable]:
         """
         Used to fetch a ``Table`` instance, for the target of a foreign key.
 
@@ -630,8 +630,8 @@ class Table(metaclass=TableMetaclass):
             >>> print(manager.name)
             'Guido'
 
-        It can only follow foreign keys one level currently.
-        i.e. ``Band.manager``, but not ``Band.manager.x.y.z``.
+        It can only follow foreign keys multiple levels deep. For example,
+        ``Concert.band_1.manager``.
 
         """
         if isinstance(foreign_key, str):
@@ -645,18 +645,7 @@ class Table(metaclass=TableMetaclass):
                 "ForeignKey column."
             )
 
-        column_name = foreign_key._meta.name
-
-        references = foreign_key._foreign_key_meta.resolved_references
-
-        return (
-            references.objects()
-            .where(
-                foreign_key._foreign_key_meta.resolved_target_column
-                == getattr(self, column_name)
-            )
-            .first()
-        )
+        return GetRelated(foreign_key=foreign_key, row=self)
 
     def get_m2m(self, m2m: M2M) -> M2MGetRelated:
         """

{piccolo-1.19.0 → piccolo-1.20.0}/piccolo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.19.0
+Version: 1.20.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.19.0 → piccolo-1.20.0}/tests/columns/m2m/base.py

@@ -434,6 +434,22 @@ class M2MBase:
 
         self.assertEqual([i.name for i in genres], ["Rock", "Folk"])
 
+    def test_get_m2m_no_rows(self):
+        """
+        If there are no matching objects, then an empty list should be
+        returned.
+
+        https://github.com/piccolo-orm/piccolo/issues/1090
+
+        """
+        band = Band.objects().get(Band.name == "Pythonistas").run_sync()
+        assert band is not None
+
+        Genre.delete(force=True).run_sync()
+
+        genres = band.get_m2m(Band.genres).run_sync()
+        self.assertEqual(genres, [])
+
     def test_remove_m2m(self):
         """
         Make sure we can remove related items via the joining table.

piccolo-1.20.0/tests/table/instance/test_get_related.py

@@ -0,0 +1,98 @@
+import typing as t
+
+from piccolo.testing.test_case import AsyncTableTest
+from tests.example_apps.music.tables import Band, Concert, Manager, Venue
+
+
+class TestGetRelated(AsyncTableTest):
+    tables = [Manager, Band, Concert, Venue]
+
+    async def asyncSetUp(self):
+        await super().asyncSetUp()
+
+        # Setup two pairs of manager/band, so we can make sure the correct
+        # objects are returned.
+
+        self.manager = Manager(name="Guido")
+        await self.manager.save()
+
+        self.band = Band(
+            name="Pythonistas", manager=self.manager.id, popularity=100
+        )
+        await self.band.save()
+
+        self.manager_2 = Manager(name="Graydon")
+        await self.manager_2.save()
+
+        self.band_2 = Band(
+            name="Rustaceans", manager=self.manager_2.id, popularity=100
+        )
+        await self.band_2.save()
+
+    async def test_foreign_key(self) -> None:
+        """
+        Make sure you can get a related object from another object instance.
+        """
+        manager = await self.band.get_related(Band.manager)
+        assert manager is not None
+        self.assertTrue(manager.id == self.manager.id)
+
+        manager_2 = await self.band_2.get_related(Band.manager)
+        assert manager_2 is not None
+        self.assertTrue(manager_2.id == self.manager_2.id)
+
+    async def test_non_foreign_key(self):
+        """
+        Make sure that non-ForeignKey raise an exception.
+        """
+        with self.assertRaises(ValueError):
+            self.band.get_related(Band.name)  # type: ignore
+
+    async def test_string(self):
+        """
+        Make sure it also works using a string representation of a foreign key.
+        """
+        manager = t.cast(Manager, await self.band.get_related("manager"))
+        self.assertTrue(manager.id == self.manager.id)
+
+    async def test_invalid_string(self):
+        """
+        Make sure an exception is raised if the foreign key string is invalid.
+        """
+        with self.assertRaises(ValueError):
+            self.band.get_related("abc123")
+
+    async def test_multiple_levels(self):
+        """
+        Make sure ``get_related`` works multiple levels deep.
+        """
+        concert = Concert(band_1=self.band, band_2=self.band_2)
+        await concert.save()
+
+        manager = await concert.get_related(Concert.band_1._.manager)
+        assert manager is not None
+        self.assertTrue(manager.id == self.manager.id)
+
+        manager_2 = await concert.get_related(Concert.band_2._.manager)
+        assert manager_2 is not None
+        self.assertTrue(manager_2.id == self.manager_2.id)
+
+    async def test_no_match(self):
+        """
+        If not related object exists, make sure ``None`` is returned.
+        """
+        concert = Concert(band_1=self.band, band_2=None)
+        await concert.save()
+
+        manager_2 = await concert.get_related(Concert.band_2._.manager)
+        assert manager_2 is None
+
+    async def test_not_in_db(self):
+        """
+        If the object we're calling ``get_related`` on doesn't exist in the
+        database, then make sure an error is raised.
+        """
+        concert = Concert(band_1=self.band, band_2=self.band_2)
+
+        with self.assertRaises(ValueError):
+            await concert.get_related(Concert.band_1._.manager)

piccolo-1.19.0/piccolo/__init__.py

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

piccolo-1.19.0/tests/table/instance/test_get_related.py

@@ -1,42 +0,0 @@
-import typing as t
-from unittest import TestCase
-
-from tests.example_apps.music.tables import Band, Manager
-
-TABLES = [Manager, Band]
-
-
-class TestGetRelated(TestCase):
-    def setUp(self):
-        for table in TABLES:
-            table.create_table().run_sync()
-
-    def tearDown(self):
-        for table in reversed(TABLES):
-            table.alter().drop_table().run_sync()
-
-    def test_get_related(self) -> None:
-        """
-        Make sure you can get a related object from another object instance.
-        """
-        manager = Manager(name="Guido")
-        manager.save().run_sync()
-
-        band = Band(name="Pythonistas", manager=manager.id, popularity=100)
-        band.save().run_sync()
-
-        _manager = band.get_related(Band.manager).run_sync()
-        assert _manager is not None
-        self.assertTrue(_manager.name == "Guido")
-
-        # Test non-ForeignKey
-        with self.assertRaises(ValueError):
-            band.get_related(Band.name)  # type: ignore
-
-        # Make sure it also works using a string
-        _manager_2 = t.cast(Manager, band.get_related("manager").run_sync())
-        self.assertTrue(_manager_2.name == "Guido")
-
-        # Test an invalid string
-        with self.assertRaises(ValueError):
-            band.get_related("abc123")