piccolo 1.21.0__tar.gz → 1.23.0__tar.gz

{piccolo-1.21.0 → piccolo-1.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: piccolo
-Version: 1.21.0
+Version: 1.23.0
 Summary: A fast, user friendly ORM and query builder which supports asyncio.
 Home-page: https://github.com/piccolo-orm/piccolo
 Author: Daniel Townsend
@@ -12,16 +12,16 @@ Project-URL: Tracker, https://github.com/piccolo-orm/piccolo/issues
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Framework :: AsyncIO
 Classifier: Typing :: Typed
 Classifier: Topic :: Database
-Requires-Python: >=3.8.0
+Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: black
@@ -36,7 +36,7 @@ Requires-Dist: orjson>=3.5.1; extra == "orjson"
 Provides-Extra: playground
 Requires-Dist: ipython; extra == "playground"
 Provides-Extra: postgres
-Requires-Dist: asyncpg>=0.21.0; extra == "postgres"
+Requires-Dist: asyncpg>=0.30.0; extra == "postgres"
 Provides-Extra: sqlite
 Requires-Dist: aiosqlite>=0.16.0; extra == "sqlite"
 Provides-Extra: uvloop
@@ -44,9 +44,21 @@ Requires-Dist: uvloop>=0.12.0; sys_platform != "win32" and extra == "uvloop"
 Provides-Extra: all
 Requires-Dist: orjson>=3.5.1; extra == "all"
 Requires-Dist: ipython; extra == "all"
-Requires-Dist: asyncpg>=0.21.0; extra == "all"
+Requires-Dist: asyncpg>=0.30.0; extra == "all"
 Requires-Dist: aiosqlite>=0.16.0; extra == "all"
 Requires-Dist: uvloop>=0.12.0; sys_platform != "win32" and extra == "all"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 ![Logo](https://raw.githubusercontent.com/piccolo-orm/piccolo/master/docs/logo_hero.png "Piccolo Logo")
 
@@ -144,7 +156,7 @@ Let Piccolo scaffold you an ASGI web app, using Piccolo as the ORM:
 piccolo asgi new
 ```
 
-[Starlette](https://www.starlette.io/), [FastAPI](https://fastapi.tiangolo.com/), [BlackSheep](https://www.neoteroi.dev/blacksheep/), [Litestar](https://litestar.dev/), [Esmerald](https://esmerald.dev/) and [Lilya](https://lilya.dev) are currently supported.
+[Starlette](https://www.starlette.io/), [FastAPI](https://fastapi.tiangolo.com/), [BlackSheep](https://www.neoteroi.dev/blacksheep/), [Litestar](https://litestar.dev/), [Esmerald](https://esmerald.dev/), [Lilya](https://lilya.dev), [Quart](https://quart.palletsprojects.com/en/latest/), [Falcon](https://falconframework.org/) and [Sanic](https://sanic.dev/en/) are currently supported.
 
 ## Are you a Django user?
 

{piccolo-1.21.0 → piccolo-1.23.0}/README.md

@@ -94,7 +94,7 @@ Let Piccolo scaffold you an ASGI web app, using Piccolo as the ORM:
 piccolo asgi new
 ```
 
-[Starlette](https://www.starlette.io/), [FastAPI](https://fastapi.tiangolo.com/), [BlackSheep](https://www.neoteroi.dev/blacksheep/), [Litestar](https://litestar.dev/), [Esmerald](https://esmerald.dev/) and [Lilya](https://lilya.dev) are currently supported.
+[Starlette](https://www.starlette.io/), [FastAPI](https://fastapi.tiangolo.com/), [BlackSheep](https://www.neoteroi.dev/blacksheep/), [Litestar](https://litestar.dev/), [Esmerald](https://esmerald.dev/), [Lilya](https://lilya.dev), [Quart](https://quart.palletsprojects.com/en/latest/), [Falcon](https://falconframework.org/) and [Sanic](https://sanic.dev/en/) are currently supported.
 
 ## Are you a Django user?
 

piccolo-1.23.0/piccolo/__init__.py

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

{piccolo-1.21.0 → piccolo-1.23.0}/piccolo/apps/asgi/commands/new.py

@@ -17,6 +17,9 @@ ROUTER_DEPENDENCIES = {
     "litestar": ["litestar"],
     "esmerald": ["esmerald"],
     "lilya": ["lilya"],
+    "quart": ["quart", "quart_schema"],
+    "falcon": ["falcon"],
+    "sanic": ["sanic", "sanic_ext"],
 }
 ROUTERS = list(ROUTER_DEPENDENCIES.keys())
 

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

@@ -0,0 +1,60 @@
+import os
+import typing as t
+
+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
+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")
+
+
+class LifespanMiddleware:
+    async def process_startup(
+        self, scope: t.Dict[str, t.Any], event: t.Dict[str, t.Any]
+    ) -> None:
+        await open_database_connection_pool()
+
+    async def process_shutdown(
+        self, scope: t.Dict[str, t.Any], event: t.Dict[str, t.Any]
+    ) -> None:
+        await close_database_connection_pool()
+
+
+app: t.Any = falcon.asgi.App(middleware=LifespanMiddleware())
+app.add_static_route("/static", directory=os.path.abspath("static"))
+app.add_route("/", HomeEndpoint())
+
+PICCOLO_CRUD: t.Any = PiccoloCRUD(table=Task)
+
+# enable the Admin and PiccoloCrud app using DispatcherMiddleware
+app = DispatcherMiddleware(  # type: ignore
+    {
+        "/admin": create_admin(
+            tables=APP_CONFIG.table_classes,
+            # Required when running under HTTPS:
+            # allowed_hosts=['my_site.com']
+        ),
+        "/tasks": PICCOLO_CRUD,
+        "": app,
+    }
+)

piccolo-1.23.0/piccolo/apps/asgi/commands/templates/app/_quart_app.py.jinja

@@ -0,0 +1,119 @@
+import typing as t
+from http import HTTPStatus
+
+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 quart import Quart
+from quart_schema import (
+    Info,
+    QuartSchema,
+    hide,
+    tag,
+    validate_request,
+    validate_response,
+)
+
+from home.endpoints import index
+from home.piccolo_app import APP_CONFIG
+from home.tables import Task
+
+
+app = Quart(__name__, static_folder="static")
+QuartSchema(app, info=Info(title="Quart API", version="0.1.0"))
+
+
+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",
+)
+
+
+@app.get("/")
+@hide
+def home():
+    return index()
+
+
+@app.get("/tasks/")
+@validate_response(t.List[TaskModelOut])
+@tag(["Task"])
+async def tasks():
+    return await Task.select().order_by(Task._meta.primary_key, ascending=False)
+
+
+@app.post("/tasks/")
+@validate_request(TaskModelIn)
+@validate_response(TaskModelOut)
+@tag(["Task"])
+async def create_task(data: TaskModelIn):
+    task = Task(**data.model_dump())
+    await task.save()
+    return task.to_dict(), HTTPStatus.CREATED
+
+
+@app.put("/tasks/<int:task_id>/")
+@validate_request(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
+
+    for key, value in data.model_dump().items():
+        setattr(task, key, value)
+
+    await task.save()
+
+    return 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
+
+    await task.remove()
+
+    return {}, HTTPStatus.OK
+
+
+@app.before_serving
+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.after_serving
+async def close_database_connection_pool():
+    try:
+        engine = engine_finder()
+        await engine.close_connection_pool()
+    except Exception:
+        print("Unable to connect to the database")
+
+
+# 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.23.0/piccolo/apps/asgi/commands/templates/app/_sanic_app.py.jinja

@@ -0,0 +1,121 @@
+import asyncio
+import typing as t
+
+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_ext import openapi
+
+from home.endpoints import index
+from home.piccolo_app import APP_CONFIG
+from home.tables import Task
+
+app = Sanic(__name__)
+app.static("/static/", "static")
+
+
+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",
+)
+
+
+@app.get("/")
+@openapi.exclude()
+def home(request: Request):
+    return index()
+
+
+@app.get("/tasks/")
+@openapi.tag("Task")
+@openapi.response(200, {"application/json": TaskModelOut.model_json_schema()})
+async def tasks(request: Request):
+    return json(
+        await Task.select().order_by(Task._meta.primary_key, ascending=False),
+        status=200,
+    )
+
+
+@app.post("/tasks/")
+@openapi.definition(
+    body={"application/json": TaskModelIn.model_json_schema()},
+    tag="Task",
+)
+@openapi.response(201, {"application/json": TaskModelOut.model_json_schema()})
+async def create_task(request: Request):
+    task = Task(**request.json)
+    await task.save()
+    return json(task.to_dict(), status=201)
+
+
+@app.put("/tasks/<task_id:int>/")
+@openapi.definition(
+    body={"application/json": TaskModelIn.model_json_schema()},
+    tag="Task",
+)
+@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)
+    for key, value in request.json.items():
+        setattr(task, key, value)
+
+    await task.save()
+    return json(task.to_dict(), status=200)
+
+
+@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)
+    await task.remove()
+    return json({}, status=200)
+
+
+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")
+
+
+@app.after_server_start
+async def startup(app, loop):
+    await open_database_connection_pool()
+
+
+@app.before_server_stop
+async def shutdown(app, loop):
+    await close_database_connection_pool()
+
+
+# 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.21.0 → piccolo-1.23.0}/piccolo/apps/asgi/commands/templates/app/app.py.jinja

@@ -10,4 +10,10 @@
     {% include '_esmerald_app.py.jinja' %}
 {% elif router == 'lilya' %}
     {% include '_lilya_app.py.jinja' %}
+{% elif router == 'quart' %}
+    {% include '_quart_app.py.jinja' %}
+{% elif router == 'falcon' %}
+    {% include '_falcon_app.py.jinja' %}
+{% elif router == 'sanic' %}
+    {% include '_sanic_app.py.jinja' %}
 {% endif %}

piccolo-1.23.0/piccolo/apps/asgi/commands/templates/app/home/_falcon_endpoints.py.jinja

@@ -0,0 +1,19 @@
+import os
+
+import falcon
+import jinja2
+
+ENVIRONMENT = jinja2.Environment(
+    loader=jinja2.FileSystemLoader(
+        searchpath=os.path.join(os.path.dirname(__file__), "templates")
+    )
+)
+
+
+class HomeEndpoint:
+    async def on_get(self, req, resp):
+        template = ENVIRONMENT.get_template("home.html.jinja")
+        content = template.render(title="Piccolo + ASGI",)
+        resp.status = falcon.HTTP_200
+        resp.content_type = "text/html"
+        resp.text = content

piccolo-1.23.0/piccolo/apps/asgi/commands/templates/app/home/_quart_endpoints.py.jinja

@@ -0,0 +1,18 @@
+import os
+
+import jinja2
+
+from quart import Response
+
+ENVIRONMENT = jinja2.Environment(
+    loader=jinja2.FileSystemLoader(
+        searchpath=os.path.join(os.path.dirname(__file__), "templates")
+    )
+)
+
+
+def index():
+    template = ENVIRONMENT.get_template("home.html.jinja")
+    content = template.render(title="Piccolo + ASGI")
+    return Response(content)
+    

piccolo-1.23.0/piccolo/apps/asgi/commands/templates/app/home/_sanic_endpoints.py.jinja

@@ -0,0 +1,17 @@
+import os
+
+import jinja2
+
+from sanic import HTTPResponse
+
+ENVIRONMENT = jinja2.Environment(
+    loader=jinja2.FileSystemLoader(
+        searchpath=os.path.join(os.path.dirname(__file__), "templates")
+    )
+)
+
+
+def index():
+    template = ENVIRONMENT.get_template("home.html.jinja")
+    content = template.render(title="Piccolo + ASGI")
+    return HTTPResponse(content)

{piccolo-1.21.0 → piccolo-1.23.0}/piccolo/apps/asgi/commands/templates/app/home/endpoints.py.jinja

@@ -8,4 +8,10 @@
     {% include '_esmerald_endpoints.py.jinja' %}
 {% elif router == 'lilya' %}
     {% include '_lilya_endpoints.py.jinja' %}
+{% elif router == 'quart' %}
+    {% include '_quart_endpoints.py.jinja' %}
+{% elif router == 'falcon' %}
+    {% include '_falcon_endpoints.py.jinja' %}
+{% elif router == 'sanic' %}
+    {% include '_sanic_endpoints.py.jinja' %}
 {% endif %}

{piccolo-1.21.0 → piccolo-1.23.0}/piccolo/apps/asgi/commands/templates/app/home/templates/home.html.jinja_raw

@@ -66,6 +66,21 @@
                 <li><a href="/admin/">Admin</a></li>
                 <li><a href="/tasks/">JSON endpoint</a></li>
             </ul>
+            <h3>Quart</h3>
+            <ul>
+                <li><a href="/admin/">Admin</a></li>
+                <li><a href="/docs">Swagger API</a></li>
+            </ul>
+            <h3>Falcon</h3>
+            <ul>
+                <li><a href="/admin/">Admin</a></li>
+                <li><a href="/tasks/">JSON endpoint</a></li>
+            </ul>
+            <h3>Sanic</h3>
+            <ul>
+                <li><a href="/admin/">Admin</a></li>
+                <li><a href="/docs/swagger">Swagger API</a></li>
+            </ul>
         </section>
     </div>
 {% endblock content %}

{piccolo-1.21.0 → piccolo-1.23.0}/piccolo/apps/playground/commands/run.py

@@ -233,6 +233,11 @@ def populate():
             RecordingStudio.facilities: {
                 "restaurant": True,
                 "mixing_desk": True,
+                "instruments": {"electric_guitars": 10, "drum_kits": 2},
+                "technicians": [
+                    {"name": "Alice Jones"},
+                    {"name": "Bob Williams"},
+                ],
             },
         }
     )
@@ -244,6 +249,10 @@ def populate():
             RecordingStudio.facilities: {
                 "restaurant": False,
                 "mixing_desk": True,
+                "instruments": {"electric_guitars": 6, "drum_kits": 3},
+                "technicians": [
+                    {"name": "Frank Smith"},
+                ],
             },
         },
     )

{piccolo-1.21.0 → piccolo-1.23.0}/piccolo/columns/column_types.py

@@ -70,6 +70,10 @@ from piccolo.utils.warnings import colored_warning
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from piccolo.columns.base import ColumnMeta
+    from piccolo.query.operators.json import (
+        GetChildElement,
+        GetElementFromPath,
+    )
     from piccolo.table import Table
 
 
@@ -2319,6 +2323,76 @@ class JSON(Column):
         else:
             return "JSON"
 
+    ###########################################################################
+
+    def arrow(self, key: t.Union[str, int, QueryString]) -> GetChildElement:
+        """
+        Allows a child element of the JSON structure to be returned - for
+        example::
+
+            >>> await RecordingStudio.select(
+            ...     RecordingStudio.facilities.arrow("restaurant")
+            ... )
+
+        """
+        from piccolo.query.operators.json import GetChildElement
+
+        alias = self._alias or self._meta.get_default_alias()
+        return GetChildElement(identifier=self, key=key, alias=alias)
+
+    def __getitem__(
+        self, value: t.Union[str, int, QueryString]
+    ) -> GetChildElement:
+        """
+        A shortcut for the ``arrow`` method, used for retrieving a child
+        element.
+
+        For example:
+
+        .. code-block:: python
+
+            >>> await RecordingStudio.select(
+            ...     RecordingStudio.facilities["restaurant"]
+            ... )
+
+        """
+        return self.arrow(key=value)
+
+    def from_path(
+        self,
+        path: t.List[t.Union[str, int]],
+    ) -> GetElementFromPath:
+        """
+        Allows an element of the JSON structure to be returned, which can be
+        arbitrarily deep. For example::
+
+            >>> await RecordingStudio.select(
+            ...     RecordingStudio.facilities.from_path([
+            ...         "technician",
+            ...         0,
+            ...         "first_name"
+            ...     ])
+            ... )
+
+        It's the same as calling ``arrow`` multiple times, but is more
+        efficient / convenient if extracting highly nested data::
+
+            >>> await RecordingStudio.select(
+            ...     RecordingStudio.facilities.arrow(
+            ...         "technician"
+            ...     ).arrow(
+            ...         0
+            ...     ).arrow(
+            ...         "first_name"
+            ...     )
+            ... )
+
+        """
+        from piccolo.query.operators.json import GetElementFromPath
+
+        alias = self._alias or self._meta.get_default_alias()
+        return GetElementFromPath(identifier=self, path=path, alias=alias)
+
     ###########################################################################
     # Descriptors
 
@@ -2337,10 +2411,10 @@ class JSON(Column):
 
 class JSONB(JSON):
     """
-    Used for storing JSON strings - Postgres only. The data is stored in a
-    binary format, and can be queried. Insertion can be slower (as it needs to
-    be converted to the binary format). The benefits of JSONB generally
-    outweigh the downsides.
+    Used for storing JSON strings - Postgres / CochroachDB only. The data is
+    stored in a binary format, and can be queried more efficiently. Insertion
+    can be slower (as it needs to be converted to the binary format). The
+    benefits of JSONB generally outweigh the downsides.
 
     :param default:
         Either a JSON string can be provided, or a Python ``dict`` or ``list``
@@ -2352,41 +2426,6 @@ class JSONB(JSON):
     def column_type(self):
         return "JSONB"  # Must be defined, we override column_type() in JSON()
 
-    def arrow(self, key: str) -> JSONB:
-        """
-        Allows part of the JSON structure to be returned - for example,
-        for {"a": 1}, and a key value of "a", then 1 will be returned.
-        """
-        instance = t.cast(JSONB, self.copy())
-        instance.json_operator = f"-> '{key}'"
-        return instance
-
-    def get_select_string(
-        self, engine_type: str, with_alias: bool = True
-    ) -> QueryString:
-        select_string = self._meta.get_full_name(with_alias=False)
-
-        if self.json_operator is not None:
-            select_string += f" {self.json_operator}"
-
-        if with_alias:
-            alias = self._alias or self._meta.get_default_alias()
-            select_string += f' AS "{alias}"'
-
-        return QueryString(select_string)
-
-    def eq(self, value) -> Where:
-        """
-        See ``Boolean.eq`` for more details.
-        """
-        return self.__eq__(value)
-
-    def ne(self, value) -> Where:
-        """
-        See ``Boolean.ne`` for more details.
-        """
-        return self.__ne__(value)
-
     ###########################################################################
     # Descriptors
 

{piccolo-1.21.0 → piccolo-1.23.0}/piccolo/columns/defaults/timestamptz.py

@@ -73,6 +73,7 @@ TimestamptzArg = t.Union[
     Enum,
     None,
     datetime.datetime,
+    t.Callable[[], datetime.datetime],
 ]