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

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
 
 

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

@@ -1,11 +1,10 @@
-import asyncio
-import typing as t
+from typing import Any
 
 from hypercorn.middleware import DispatcherMiddleware
 from piccolo.engine import engine_finder
 from piccolo_admin.endpoints import create_admin
 from piccolo_api.crud.serializers import create_pydantic_model
-from sanic import Request, Sanic, json
+from sanic import NotFound, Request, Sanic, json
 from sanic_ext import openapi
 
 from home.endpoints import index
@@ -16,17 +15,24 @@ app = Sanic(__name__)
 app.static("/static/", "static")
 
 
-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:
+        raise NotFound(message="Record not found")
+    return result
+
+
 @app.get("/")
 @openapi.exclude()
 def home(request: Request):
@@ -43,6 +49,19 @@ async def tasks(request: Request):
     )
 
 
+@app.get("/tasks/<task_id:int>/")
+@openapi.tag("Task")
+@openapi.response(200, {"application/json": TaskModelOut.model_json_schema()})
+async def single_task(request: Request, task_id: int):
+    task = (
+        await Task.select()
+        .where(Task._meta.primary_key == task_id)
+        .first()
+        .callback(check_record_not_found)
+    )
+    return json(task, status=200)
+
+
 @app.post("/tasks/")
 @openapi.definition(
     body={"application/json": TaskModelIn.model_json_schema()},
@@ -62,9 +81,11 @@ async def create_task(request: Request):
 )
 @openapi.response(200, {"application/json": TaskModelOut.model_json_schema()})
 async def update_task(request: Request, task_id: int):
-    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 request.json.items():
         setattr(task, key, value)
 
@@ -75,9 +96,11 @@ async def update_task(request: Request, task_id: int):
 @app.delete("/tasks/<task_id:int>/")
 @openapi.tag("Task")
 async def delete_task(request: Request, task_id: int):
-    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)
+    )
     await task.remove()
     return json({}, status=200)
 

piccolo/apps/fixtures/commands/dump.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import typing as t
+from typing import Any, Optional
 
 from piccolo.apps.fixtures.commands.shared import (
     FixtureConfig,
@@ -11,8 +11,8 @@ from piccolo.table import sort_table_classes
 
 
 async def get_dump(
-    fixture_configs: t.List[FixtureConfig],
-) -> t.Dict[str, t.Any]:
+    fixture_configs: list[FixtureConfig],
+) -> dict[str, Any]:
     """
     Gets the data for each table specified and returns a data structure like:
 
@@ -32,7 +32,7 @@ async def get_dump(
     """
     finder = Finder()
 
-    output: t.Dict[str, t.Any] = {}
+    output: dict[str, Any] = {}
 
     for fixture_config in fixture_configs:
         app_config = finder.get_app_config(app_name=fixture_config.app_name)
@@ -53,7 +53,7 @@ async def get_dump(
 
 
 async def dump_to_json_string(
-    fixture_configs: t.List[FixtureConfig],
+    fixture_configs: list[FixtureConfig],
 ) -> str:
     """
     Dumps all of the data for the given tables into a JSON string.
@@ -65,7 +65,7 @@ async def dump_to_json_string(
     return pydantic_model(**dump).model_dump_json(indent=4)
 
 
-def parse_args(apps: str, tables: str) -> t.List[FixtureConfig]:
+def parse_args(apps: str, tables: str) -> list[FixtureConfig]:
     """
     Works out which apps and tables the user is referring to.
     """
@@ -80,11 +80,11 @@ def parse_args(apps: str, tables: str) -> t.List[FixtureConfig]:
         # Must be a single app name
         app_names.append(apps)
 
-    table_class_names: t.Optional[t.List[str]] = None
+    table_class_names: Optional[list[str]] = None
 
     if tables != "all":
         table_class_names = tables.split(",") if "," in tables else [tables]
-    output: t.List[FixtureConfig] = []
+    output: list[FixtureConfig] = []
 
     for app_name in app_names:
         app_config = finder.get_app_config(app_name=app_name)

piccolo/apps/fixtures/commands/load.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import sys
-import typing as t
+from typing import Optional
 
 import typing_extensions
 
@@ -20,7 +20,7 @@ from piccolo.utils.list import batch
 async def load_json_string(
     json_string: str,
     chunk_size: int = 1000,
-    on_conflict_action: t.Optional[OnConflictAction] = None,
+    on_conflict_action: Optional[OnConflictAction] = None,
 ):
     """
     Parses the JSON string, and inserts the parsed data into the database.
@@ -55,7 +55,7 @@ async def load_json_string(
         raise Exception("Unable to find the engine.")
 
     # This is what we want to the insert into the database:
-    data: t.Dict[t.Type[Table], t.List[Table]] = {}
+    data: dict[type[Table], list[Table]] = {}
 
     for app_name in app_names:
         app_model = getattr(fixture_pydantic_model, app_name)
@@ -94,7 +94,7 @@ async def load_json_string(
 async def load(
     path: str = "fixture.json",
     chunk_size: int = 1000,
-    on_conflict: t.Optional[
+    on_conflict: Optional[
         typing_extensions.Literal["DO NOTHING", "DO UPDATE"]
     ] = None,
 ):
@@ -118,7 +118,7 @@ async def load(
     with open(path, "r") as f:
         contents = f.read()
 
-    on_conflict_action: t.Optional[OnConflictAction] = None
+    on_conflict_action: Optional[OnConflictAction] = None
 
     if on_conflict:
         try:

piccolo/apps/fixtures/commands/shared.py

@@ -1,42 +1,42 @@
 from __future__ import annotations
 
-import typing as t
 from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
 
 import pydantic
 
 from piccolo.conf.apps import Finder
 from piccolo.utils.pydantic import create_pydantic_model
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.table import Table
 
 
 @dataclass
 class FixtureConfig:
     app_name: str
-    table_class_names: t.List[str]
+    table_class_names: list[str]
 
 
-def create_pydantic_fixture_model(fixture_configs: t.List[FixtureConfig]):
+def create_pydantic_fixture_model(fixture_configs: list[FixtureConfig]):
     """
     Returns a nested Pydantic model for serialising and deserialising fixtures.
     """
-    columns: t.Dict[str, t.Any] = {}
+    columns: dict[str, Any] = {}
 
     finder = Finder()
 
     for fixture_config in fixture_configs:
 
-        app_columns: t.Dict[str, t.Any] = {}
+        app_columns: dict[str, Any] = {}
 
         for table_class_name in fixture_config.table_class_names:
-            table_class: t.Type[Table] = finder.get_table_with_name(
+            table_class: type[Table] = finder.get_table_with_name(
                 app_name=fixture_config.app_name,
                 table_class_name=table_class_name,
             )
             app_columns[table_class_name] = (
-                t.List[  # type: ignore
+                list[  # type: ignore
                     create_pydantic_model(
                         table_class, include_default_columns=True
                     )
@@ -44,7 +44,7 @@ def create_pydantic_fixture_model(fixture_configs: t.List[FixtureConfig]):
                 ...,
             )
 
-        app_model: t.Any = pydantic.create_model(
+        app_model: Any = pydantic.create_model(
             f"{fixture_config.app_name.title()}Model", **app_columns
         )
 

piccolo/apps/migrations/auto/diffable_table.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-import typing as t
 from dataclasses import dataclass, field
+from typing import Any, Optional
 
 from piccolo.apps.migrations.auto.operations import (
     AddColumn,
@@ -17,8 +17,8 @@ from piccolo.table import Table, create_table_class
 
 
 def compare_dicts(
-    dict_1: t.Dict[str, t.Any], dict_2: t.Dict[str, t.Any]
-) -> t.Dict[str, t.Any]:
+    dict_1: dict[str, Any], dict_2: dict[str, Any]
+) -> dict[str, Any]:
     """
     Returns a new dictionary which only contains key, value pairs which are in
     the first dictionary and not the second.
@@ -59,9 +59,9 @@ def compare_dicts(
 
 @dataclass
 class TableDelta:
-    add_columns: t.List[AddColumn] = field(default_factory=list)
-    drop_columns: t.List[DropColumn] = field(default_factory=list)
-    alter_columns: t.List[AlterColumn] = field(default_factory=list)
+    add_columns: list[AddColumn] = field(default_factory=list)
+    drop_columns: list[DropColumn] = field(default_factory=list)
+    alter_columns: list[AlterColumn] = field(default_factory=list)
 
     def __eq__(self, value: TableDelta) -> bool:  # type: ignore
         """
@@ -101,12 +101,12 @@ class DiffableTable:
 
     class_name: str
     tablename: str
-    schema: t.Optional[str] = None
-    columns: t.List[Column] = field(default_factory=list)
-    previous_class_name: t.Optional[str] = None
+    schema: Optional[str] = None
+    columns: list[Column] = field(default_factory=list)
+    previous_class_name: Optional[str] = None
 
     def __post_init__(self) -> None:
-        self.columns_map: t.Dict[str, Column] = {
+        self.columns_map: dict[str, Column] = {
             i._meta.name: i for i in self.columns
         }
 
@@ -163,7 +163,7 @@ class DiffableTable:
 
         #######################################################################
 
-        alter_columns: t.List[AlterColumn] = []
+        alter_columns: list[AlterColumn] = []
 
         for existing_column in value.columns:
             column = self.columns_map.get(existing_column._meta.name)
@@ -221,7 +221,7 @@ class DiffableTable:
     def __str__(self):
         return f"{self.class_name} - {self.tablename}"
 
-    def to_table_class(self) -> t.Type[Table]:
+    def to_table_class(self) -> type[Table]:
         """
         Converts the DiffableTable into a Table subclass.
         """