piccolo 1.28.0__tar.gz → 1.29.0__tar.gz

{piccolo-1.28.0 → piccolo-1.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: piccolo
-Version: 1.28.0
+Version: 1.29.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.29.0/piccolo/__init__.py

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

{piccolo-1.28.0 → piccolo-1.29.0}/piccolo/apps/asgi/commands/new.py

@@ -12,7 +12,7 @@ SERVERS = ["uvicorn", "Hypercorn", "granian"]
 ROUTER_DEPENDENCIES = {
     "starlette": ["starlette"],
     "fastapi": ["fastapi"],
-    "blacksheep": ["blacksheep"],
+    "blacksheep": ["blacksheep[full]"],
     "litestar": ["litestar"],
     "esmerald": ["esmerald"],
     "lilya": ["lilya"],

{piccolo-1.28.0 → piccolo-1.29.0}/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-1.28.0 → piccolo-1.29.0}/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-1.29.0/piccolo/apps/asgi/commands/templates/app/_falcon_app.py.jinja

@@ -0,0 +1,115 @@
+import os
+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 home.endpoints import HomeEndpoint
+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")
+
+
+# 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: dict[str, Any], event: dict[str, Any]
+    ) -> None:
+        await open_database_connection_pool()
+
+    async def process_shutdown(
+        self, scope: dict[str, Any], event: dict[str, Any]
+    ) -> None:
+        await close_database_connection_pool()
+
+
+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())
+
+
+# enable the admin application using DispatcherMiddleware
+app = DispatcherMiddleware(  # type: ignore
+    {
+        "/admin": create_admin(
+            tables=APP_CONFIG.table_classes,
+            # Required when running under HTTPS:
+            # allowed_hosts=['my_site.com']
+        ),
+        "": app,
+    }
+)

{piccolo-1.28.0 → piccolo-1.29.0}/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-1.28.0 → piccolo-1.29.0}/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,

{piccolo-1.28.0 → piccolo-1.29.0}/piccolo/apps/asgi/commands/templates/app/_quart_app.py.jinja

@@ -1,4 +1,4 @@
-import typing as t
+from typing import Any
 from http import HTTPStatus
 
 from hypercorn.middleware import DispatcherMiddleware
@@ -6,6 +6,7 @@ from piccolo.engine import engine_finder
 from piccolo_admin.endpoints import create_admin
 from piccolo_api.crud.serializers import create_pydantic_model
 from quart import Quart
+from quart.helpers import abort
 from quart_schema import (
     Info,
     QuartSchema,
@@ -24,17 +25,24 @@ app = Quart(__name__, static_folder="static")
 QuartSchema(app, info=Info(title="Quart API", version="0.1.0"))
 
 
-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",
 )
 
 
+# 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:
+        abort(code=HTTPStatus.NOT_FOUND)
+    return result
+
+
 @app.get("/")
 @hide
 def home():
@@ -42,10 +50,24 @@ def home():
 
 
 @app.get("/tasks/")
-@validate_response(t.List[TaskModelOut])
+@validate_response(list[TaskModelOut])
 @tag(["Task"])
 async def tasks():
-    return await Task.select().order_by(Task._meta.primary_key, ascending=False)
+    tasks = await Task.select().order_by(Task._meta.primary_key, ascending=False)
+    return [TaskModelOut(**task) for task in tasks], HTTPStatus.OK
+
+
+@app.get("/tasks/<int:task_id>/")
+@validate_response(TaskModelOut)
+@tag(["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 TaskModelOut(**task), HTTPStatus.OK
 
 
 @app.post("/tasks/")
@@ -63,28 +85,29 @@ async def create_task(data: TaskModelIn):
 @validate_response(TaskModelOut)
 @tag(["Task"])
 async def update_task(task_id: int, data: TaskModelIn):
-    task = await Task.objects().get(Task._meta.primary_key == task_id)
-    if not task:
-        return {}, HTTPStatus.NOT_FOUND
+    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)
 
     await task.save()
 
-    return task.to_dict(), HTTPStatus.OK
+    return TaskModelOut(**task.to_dict()), HTTPStatus.OK
 
 
 @app.delete("/tasks/<int:task_id>/")
-@validate_response(TaskModelOut)
 @tag(["Task"])
 async def delete_task(task_id: int):
-    task = await Task.objects().get(Task._meta.primary_key == task_id)
-    if not task:
-        return {}, HTTPStatus.NOT_FOUND
-
+    task = (
+        await Task.objects()
+        .get(Task._meta.primary_key == task_id)
+        .callback(check_record_not_found)
+    )
     await task.remove()
-
     return {}, HTTPStatus.OK