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

piccolo/__init__.py

@@ -1 +1 @@
-__VERSION__ = "1.27.1"
+__VERSION__ = "1.29.0"

piccolo/apps/app/commands/new.py

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

piccolo/apps/asgi/commands/new.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import os
 import shutil
-import typing as t
 
 import black
 import colorama
@@ -13,7 +12,7 @@ SERVERS = ["uvicorn", "Hypercorn", "granian"]
 ROUTER_DEPENDENCIES = {
     "starlette": ["starlette"],
     "fastapi": ["fastapi"],
-    "blacksheep": ["blacksheep"],
+    "blacksheep": ["blacksheep[full]"],
     "litestar": ["litestar"],
     "esmerald": ["esmerald"],
     "lilya": ["lilya"],
@@ -28,7 +27,7 @@ def print_instruction(message: str):
     print(f"{colorama.Fore.CYAN}{message}{colorama.Fore.RESET}")
 
 
-def get_options_string(options: t.List[str]):
+def get_options_string(options: list[str]):
     return ", ".join(f"{name} [{index}]" for index, name in enumerate(options))
 
 

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

@@ -1,10 +1,9 @@
-import typing as t
+from typing import Any
 
+from blacksheep.exceptions import HTTPException
 from blacksheep.server import Application
 from blacksheep.server.bindings import FromJSON
-from blacksheep.server.openapi.v3 import OpenAPIHandler
-from blacksheep.server.responses import json
-from openapidocs.v3 import Info
+from blacksheep.server.openapi.v3 import OpenAPIHandler, Info
 from piccolo.engine import engine_finder
 from piccolo_admin.endpoints import create_admin
 from piccolo_api.crud.serializers import create_pydantic_model
@@ -34,38 +33,67 @@ app.serve_files("static", root_path="/static")
 app.router.add_get("/", home)
 
 
-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"
+TaskModelIn: Any = create_pydantic_model(
+    table=Task,
+    model_name="TaskModelIn",
 )
-TaskModelPartial: t.Any = create_pydantic_model(
-    table=Task, model_name="TaskModelPartial", all_optional=True
+TaskModelOut: Any = create_pydantic_model(
+    table=Task,
+    include_default_columns=True,
+    model_name="TaskModelOut",
 )
+TaskModelPartial: Any = (
+    create_pydantic_model(
+        table=Task,
+        model_name="TaskModelPartial",
+        all_optional=True,
+    ),
+)
+
+
+# Check if the record is None. Use for query callback
+def check_record_not_found(result: dict[str, Any]) -> dict[str, Any]:
+    if result is None:
+        raise HTTPException(status=404)
+    return result
 
 
 @app.router.get("/tasks/")
-async def tasks() -> t.List[TaskModelOut]:
-    return await Task.select().order_by(Task._meta.primary_key, ascending=False)
+async def tasks() -> list[TaskModelOut]:
+    tasks = await Task.select().order_by(Task._meta.primary_key, ascending=False)
+    return [TaskModelOut(**task) for task in tasks]
+
+
+@app.router.get("/tasks/{task_id}/")
+async def single_task(task_id: int) -> TaskModelOut:
+    task = (
+        await Task.select()
+        .where(Task._meta.primary_key == task_id)
+        .first()
+        .callback(check_record_not_found)
+    )
+    return TaskModelOut(**task)
 
 
 @app.router.post("/tasks/")
 async def create_task(task_model: FromJSON[TaskModelIn]) -> TaskModelOut:
-    task = Task(**task_model.value.dict())
+    task = Task(**task_model.value.model_dump())
     await task.save()
     return TaskModelOut(**task.to_dict())
 
 
 @app.router.put("/tasks/{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)
+    task = (
+        await Task.objects()
+        .get(Task._meta.primary_key == task_id)
+        .callback(check_record_not_found)
+    )
 
-    for key, value in task_model.value.dict().items():
+    for key, value in task_model.value.model_dump().items():
         setattr(task, key, value)
 
     await task.save()
-
     return TaskModelOut(**task.to_dict())
 
 
@@ -73,29 +101,29 @@ async def put_task(task_id: int, task_model: FromJSON[TaskModelIn]) -> TaskModel
 async def patch_task(
     task_id: int, task_model: FromJSON[TaskModelPartial]
 ) -> TaskModelOut:
-    task = await Task.objects().get(Task._meta.primary_key == task_id)
-    if not task:
-        return json({}, status=404)
+    task = (
+        await Task.objects()
+        .get(Task._meta.primary_key == task_id)
+        .callback(check_record_not_found)
+    )
 
-    for key, value in task_model.value.dict().items():
+    for key, value in task_model.value.model_dump().items():
         if value is not None:
             setattr(task, key, value)
 
     await task.save()
-
     return TaskModelOut(**task.to_dict())
 
 
 @app.router.delete("/tasks/{task_id}/")
-async def delete_task(task_id: int):
-    task = await Task.objects().get(Task._meta.primary_key == task_id)
-    if not task:
-        return json({}, status=404)
-
+async def delete_task(task_id: int) -> None:
+    task = (
+        await Task.objects()
+        .get(Task._meta.primary_key == task_id)
+        .callback(check_record_not_found)
+    )
     await task.remove()
 
-    return json({})
-
 
 async def open_database_connection_pool(application):
     try:

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

@@ -1,12 +1,12 @@
-import typing as t
+from typing import Any
 from pathlib import Path
 
 from esmerald import (
     APIView,
     Esmerald,
     Gateway,
+    HTTPException,
     Include,
-    JSONResponse,
     delete,
     get,
     post,
@@ -38,45 +38,72 @@ async def close_database_connection_pool():
         print("Unable to connect to the database")
 
 
-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"
+TaskModelIn: Any = create_pydantic_model(
+    table=Task,
+    model_name="TaskModelIn",
 )
+TaskModelOut: Any = create_pydantic_model(
+    table=Task,
+    include_default_columns=True,
+    model_name="TaskModelOut",
+)
+
+
+# Check if the record is None. Use for query callback
+def check_record_not_found(result: dict[str, Any]) -> dict[str, Any]:
+    if result is None:
+        raise HTTPException(
+            detail="Record not found",
+            status_code=404,
+        )
+    return result
 
 
 class TaskAPIView(APIView):
     path: str = "/"
-    tags: str = ["Task"]
+    tags: list[str] = ["Task"]
 
     @get("/")
-    async def tasks(self) -> t.List[TaskModelOut]:
-        return await Task.select().order_by(Task._meta.primary_key, ascending=False)
+    async def tasks(self) -> list[TaskModelOut]:
+        tasks = await Task.select().order_by(Task._meta.primary_key, ascending=False)
+        return [TaskModelOut(**task) for task in tasks]
+
+    @get("/{task_id}")
+    async def single_task(self, task_id: int) -> TaskModelOut:
+        task = (
+            await Task.select()
+            .where(Task._meta.primary_key == task_id)
+            .first()
+            .callback(check_record_not_found)
+        )
+        return TaskModelOut(**task)
 
     @post("/")
     async def create_task(self, payload: TaskModelIn) -> TaskModelOut:
-        task = Task(**payload.dict())
+        task = Task(**payload.model_dump())
         await task.save()
-        return task.to_dict()
+        return TaskModelOut(**task.to_dict())
 
     @put("/{task_id}")
     async def update_task(self, payload: TaskModelIn, task_id: int) -> TaskModelOut:
-        task = await Task.objects().get(Task._meta.primary_key == task_id)
-        if not task:
-            return JSONResponse({}, status_code=404)
-
-        for key, value in payload.dict().items():
+        task = (
+            await Task.objects()
+            .get(Task._meta.primary_key == task_id)
+            .callback(check_record_not_found)
+        )
+        for key, value in payload.model_dump().items():
             setattr(task, key, value)
 
         await task.save()
-
-        return task.to_dict()
+        return TaskModelOut(**task.to_dict())
 
     @delete("/{task_id}")
     async def delete_task(self, task_id: int) -> None:
-        task = await Task.objects().get(Task._meta.primary_key == task_id)
-        if not task:
-            return JSONResponse({}, status_code=404)
-
+        task = (
+            await Task.objects()
+            .get(Task._meta.primary_key == task_id)
+            .callback(check_record_not_found)
+        )
         await task.remove()
 
 

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

@@ -1,11 +1,10 @@
 import os
-import typing as t
+from typing import Any
 
 import falcon.asgi
 from hypercorn.middleware import DispatcherMiddleware
 from piccolo.engine import engine_finder
 from piccolo_admin.endpoints import create_admin
-from piccolo_api.crud.endpoints import PiccoloCRUD
 
 from home.endpoints import HomeEndpoint
 from home.piccolo_app import APP_CONFIG
@@ -28,25 +27,82 @@ async def close_database_connection_pool():
         print("Unable to connect to the database")
 
 
+# Check if the record is None. Use for query callback
+def check_record_not_found(result: dict[str, Any]) -> dict[str, Any]:
+    if result is None:
+        raise falcon.HTTPNotFound()
+    return result
+
+
 class LifespanMiddleware:
     async def process_startup(
-        self, scope: t.Dict[str, t.Any], event: t.Dict[str, t.Any]
+        self, scope: dict[str, Any], event: dict[str, Any]
     ) -> None:
         await open_database_connection_pool()
 
     async def process_shutdown(
-        self, scope: t.Dict[str, t.Any], event: t.Dict[str, t.Any]
+        self, scope: dict[str, Any], event: dict[str, Any]
     ) -> None:
         await close_database_connection_pool()
 
 
-app: t.Any = falcon.asgi.App(middleware=LifespanMiddleware())
+class TaskCollectionResource:
+    async def on_get(self, req, resp):
+        tasks = await Task.select().order_by(Task._meta.primary_key, ascending=False)
+        resp.media = tasks
+
+    async def on_post(self, req, resp):
+        data = await req.media
+        task = Task(**data)
+        await task.save()
+        resp.status = falcon.HTTP_201
+        resp.media = task.to_dict()
+
+
+class TaskItemResource:
+    async def on_get(self, req, resp, task_id):
+        task = (
+            await Task.select()
+            .where(Task._meta.primary_key == task_id)
+            .first()
+            .callback(check_record_not_found)
+        )
+        resp.status = falcon.HTTP_200
+        resp.media = task
+
+    async def on_put(self, req, resp, task_id):
+        task = (
+            await Task.objects()
+            .get(Task._meta.primary_key == task_id)
+            .callback(check_record_not_found)
+        )
+
+        data = await req.media
+        for key, value in data.items():
+            setattr(task, key, value)
+
+        await task.save()
+        resp.status = falcon.HTTP_200
+        resp.media = task.to_dict()
+
+    async def on_delete(self, req, resp, task_id):
+        task = (
+            await Task.objects()
+            .get(Task._meta.primary_key == task_id)
+            .callback(check_record_not_found)
+        )
+        resp.status = falcon.HTTP_204
+        await task.remove()
+
+
+app: Any = falcon.asgi.App(middleware=LifespanMiddleware())
 app.add_static_route("/static", directory=os.path.abspath("static"))
 app.add_route("/", HomeEndpoint())
+app.add_route("/tasks/", TaskCollectionResource())
+app.add_route("/tasks/{task_id:int}", TaskItemResource())
 
-PICCOLO_CRUD: t.Any = PiccoloCRUD(table=Task)
 
-# enable the Admin and PiccoloCrud app using DispatcherMiddleware
+# enable the admin application using DispatcherMiddleware
 app = DispatcherMiddleware(  # type: ignore
     {
         "/admin": create_admin(
@@ -54,7 +110,6 @@ app = DispatcherMiddleware(  # type: ignore
             # Required when running under HTTPS:
             # allowed_hosts=['my_site.com']
         ),
-        "/tasks": PICCOLO_CRUD,
         "": app,
     }
 )

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

@@ -1,8 +1,8 @@
-import typing as t
 from contextlib import asynccontextmanager
+from typing import Any
 
-from fastapi import FastAPI
-from fastapi.responses import JSONResponse
+from fastapi import FastAPI, status
+from fastapi.exceptions import HTTPException
 from piccolo.engine import engine_finder
 from piccolo_admin.endpoints import create_admin
 from piccolo_api.crud.serializers import create_pydantic_model
@@ -54,47 +54,74 @@ app = FastAPI(
 )
 
 
-TaskModelIn: t.Any = create_pydantic_model(
+TaskModelIn: Any = create_pydantic_model(
     table=Task,
     model_name="TaskModelIn",
 )
-TaskModelOut: t.Any = create_pydantic_model(
-    table=Task, include_default_columns=True, model_name="TaskModelOut"
+
+TaskModelOut: Any = create_pydantic_model(
+    table=Task,
+    include_default_columns=True,
+    model_name="TaskModelOut",
 )
 
 
-@app.get("/tasks/", response_model=t.List[TaskModelOut])
+# Check if the record is None. Use for query callback
+def check_record_not_found(result: dict[str, Any]) -> dict[str, Any]:
+    if result is None:
+        raise HTTPException(
+            detail="Record not found",
+            status_code=status.HTTP_404_NOT_FOUND,
+        )
+    return result
+
+
+@app.get("/tasks/", response_model=list[TaskModelOut], tags=["Task"])
 async def tasks():
-    return await Task.select().order_by(Task.id)
+    return await Task.select().order_by(Task._meta.primary_key, ascending=False)
+
+
+@app.get("/tasks/{task_id}/", response_model=TaskModelOut, tags=["Task"])
+async def single_task(task_id: int):
+    task = (
+        await Task.select()
+        .where(Task._meta.primary_key == task_id)
+        .first()
+        .callback(check_record_not_found)
+    )
+    return task
 
 
-@app.post("/tasks/", response_model=TaskModelOut)
+@app.post("/tasks/", response_model=TaskModelOut, tags=["Task"])
 async def create_task(task_model: TaskModelIn):
-    task = Task(**task_model.dict())
+    task = Task(**task_model.model_dump())
     await task.save()
     return task.to_dict()
 
 
-@app.put("/tasks/{task_id}/", response_model=TaskModelOut)
+@app.put("/tasks/{task_id}/", response_model=TaskModelOut, tags=["Task"])
 async def update_task(task_id: int, task_model: TaskModelIn):
-    task = await Task.objects().get(Task._meta.primary_key == task_id)
-    if not task:
-        return JSONResponse({}, status_code=404)
-
-    for key, value in task_model.dict().items():
+    task = (
+        await Task.objects()
+        .get(Task._meta.primary_key == task_id)
+        .callback(check_record_not_found)
+    )
+    for key, value in task_model.model_dump().items():
         setattr(task, key, value)
 
     await task.save()
-
     return task.to_dict()
 
 
-@app.delete("/tasks/{task_id}/")
+@app.delete(
+    "/tasks/{task_id}/",
+    status_code=status.HTTP_204_NO_CONTENT,
+    tags=["Task"],
+)
 async def delete_task(task_id: int):
-    task = await Task.objects().get(Task._meta.primary_key == task_id)
-    if not task:
-        return JSONResponse({}, status_code=404)
-
+    task = (
+        await Task.objects()
+        .get(Task._meta.primary_key == task_id)
+        .callback(check_record_not_found)
+    )
     await task.remove()
-
-    return JSONResponse({})

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

@@ -1,4 +1,4 @@
-import typing as t
+from typing import Any
 
 from litestar import Litestar, asgi, delete, get, patch, post
 from litestar.contrib.jinja import JinjaTemplateEngine
@@ -21,11 +21,11 @@ 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(
+TaskModelIn: Any = create_pydantic_model(
     table=Task,
     model_name="TaskModelIn",
 )
-TaskModelOut: t.Any = create_pydantic_model(
+TaskModelOut: Any = create_pydantic_model(
     table=Task,
     include_default_columns=True,
     model_name="TaskModelOut",
@@ -50,12 +50,30 @@ async def admin(scope: "Scope", receive: "Receive", send: "Send") -> None:
     await create_admin(tables=APP_CONFIG.table_classes)(scope, receive, send)
 
 
+# Check if the record is None. Use for query callback
+def check_record_not_found(result: dict[str, Any]) -> dict[str, Any]:
+    if result is None:
+        raise NotFoundException(detail="Record not found")
+    return result
+
+
 @get("/tasks", tags=["Task"])
-async def tasks() -> t.List[TaskModelOut]:
+async def tasks() -> list[TaskModelOut]:
     tasks = await Task.select().order_by(Task._meta.primary_key, ascending=False)
     return [TaskModelOut(**task) for task in tasks]
 
 
+@get("/tasks/{task_id:int}", tags=["Task"])
+async def single_task(task_id: int) -> TaskModelOut:
+    task = (
+        await Task.select()
+        .where(Task._meta.primary_key == task_id)
+        .first()
+        .callback(check_record_not_found)
+    )
+    return TaskModelOut(**task)
+
+
 @post("/tasks", tags=["Task"])
 async def create_task(data: TaskModelIn) -> TaskModelOut:
     task = Task(**data.model_dump())
@@ -65,9 +83,12 @@ async def create_task(data: TaskModelIn) -> TaskModelOut:
 
 @patch("/tasks/{task_id:int}", tags=["Task"])
 async def update_task(task_id: int, data: TaskModelIn) -> TaskModelOut:
-    task = await Task.objects().get(Task._meta.primary_key == task_id)
-    if not task:
-        raise NotFoundException("Task does not exist")
+    task = (
+        await Task.objects()
+        .get(Task._meta.primary_key == task_id)
+        .callback(check_record_not_found)
+    )
+
     for key, value in data.model_dump().items():
         setattr(task, key, value)
 
@@ -77,9 +98,11 @@ async def update_task(task_id: int, data: TaskModelIn) -> TaskModelOut:
 
 @delete("/tasks/{task_id:int}", tags=["Task"])
 async def delete_task(task_id: int) -> None:
-    task = await Task.objects().get(Task._meta.primary_key == task_id)
-    if not task:
-        raise NotFoundException("Task does not exist")
+    task = (
+        await Task.objects()
+        .get(Task._meta.primary_key == task_id)
+        .callback(check_record_not_found)
+    )
     await task.remove()
 
 
@@ -104,6 +127,7 @@ app = Litestar(
         admin,
         home,
         tasks,
+        single_task,
         create_task,
         update_task,
         delete_task,