piccolo 1.10.0__tar.gz → 1.12.0__tar.gz

{piccolo-1.10.0 → piccolo-1.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.10.0
+Version: 1.12.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.12.0/piccolo/__init__.py

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

{piccolo-1.10.0 → piccolo-1.12.0}/piccolo/apps/asgi/commands/templates/app/_fastapi_app.py.jinja

@@ -1,11 +1,12 @@
 import typing as t
+from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
 from fastapi.responses import JSONResponse
+from piccolo.engine import engine_finder
 from piccolo_admin.endpoints import create_admin
 from piccolo_api.crud.serializers import create_pydantic_model
-from piccolo.engine import engine_finder
-from starlette.routing import Route, Mount
+from starlette.routing import Mount, Route
 from starlette.staticfiles import StaticFiles
 
 from home.endpoints import HomeEndpoint
@@ -13,6 +14,29 @@ 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")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await open_database_connection_pool()
+    yield
+    await close_database_connection_pool()
+
+
 app = FastAPI(
     routes=[
         Route("/", HomeEndpoint),
@@ -22,21 +46,20 @@ app = FastAPI(
                 tables=APP_CONFIG.table_classes,
                 # Required when running under HTTPS:
                 # allowed_hosts=['my_site.com']
-            )
+            ),
         ),
         Mount("/static/", StaticFiles(directory="static")),
     ],
+    lifespan=lifespan,
 )
 
 
 TaskModelIn: t.Any = create_pydantic_model(
     table=Task,
-    model_name='TaskModelIn'
+    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"
 )
 
 
@@ -45,16 +68,16 @@ async def tasks():
     return await Task.select().order_by(Task.id)
 
 
-@app.post('/tasks/', response_model=TaskModelOut)
+@app.post("/tasks/", response_model=TaskModelOut)
 async def create_task(task_model: TaskModelIn):
     task = Task(**task_model.dict())
     await task.save()
     return task.to_dict()
 
 
-@app.put('/tasks/{task_id}/', response_model=TaskModelOut)
+@app.put("/tasks/{task_id}/", response_model=TaskModelOut)
 async def update_task(task_id: int, task_model: TaskModelIn):
-    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)
 
@@ -66,30 +89,12 @@ async def update_task(task_id: int, task_model: TaskModelIn):
     return task.to_dict()
 
 
-@app.delete('/tasks/{task_id}/')
+@app.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 JSONResponse({}, status_code=404)
 
     await task.remove()
 
     return JSONResponse({})
-
-
-@app.on_event("startup")
-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.on_event("shutdown")
-async def close_database_connection_pool():
-    try:
-        engine = engine_finder()
-        await engine.close_connection_pool()
-    except Exception:
-        print("Unable to connect to the database")

{piccolo-1.10.0 → piccolo-1.12.0}/piccolo/apps/asgi/commands/templates/app/_starlette_app.py.jinja

@@ -1,8 +1,10 @@
+from contextlib import asynccontextmanager
+
+from piccolo.engine import engine_finder
 from piccolo_admin.endpoints import create_admin
 from piccolo_api.crud.endpoints import PiccoloCRUD
-from piccolo.engine import engine_finder
-from starlette.routing import Route, Mount
 from starlette.applications import Starlette
+from starlette.routing import Mount, Route
 from starlette.staticfiles import StaticFiles
 
 from home.endpoints import HomeEndpoint
@@ -10,24 +12,6 @@ from home.piccolo_app import APP_CONFIG
 from home.tables import Task
 
 
-app = Starlette(
-    routes=[
-        Route("/", HomeEndpoint),
-        Mount(
-            "/admin/",
-            create_admin(
-                tables=APP_CONFIG.table_classes,
-                # Required when running under HTTPS:
-                # allowed_hosts=['my_site.com']
-            )
-        ),
-        Mount("/static/", StaticFiles(directory="static")),
-        Mount("/tasks/", PiccoloCRUD(table=Task))
-    ],
-)
-
-
-@app.on_event("startup")
 async def open_database_connection_pool():
     try:
         engine = engine_finder()
@@ -36,10 +20,34 @@ async def open_database_connection_pool():
         print("Unable to connect to the database")
 
 
-@app.on_event("shutdown")
 async def close_database_connection_pool():
     try:
         engine = engine_finder()
         await engine.close_connection_pool()
     except Exception:
         print("Unable to connect to the database")
+
+
+@asynccontextmanager
+async def lifespan(app: Starlette):
+    await open_database_connection_pool()
+    yield
+    await close_database_connection_pool()
+
+
+app = Starlette(
+    routes=[
+        Route("/", HomeEndpoint),
+        Mount(
+            "/admin/",
+            create_admin(
+                tables=APP_CONFIG.table_classes,
+                # Required when running under HTTPS:
+                # allowed_hosts=['my_site.com']
+            ),
+        ),
+        Mount("/static/", StaticFiles(directory="static")),
+        Mount("/tasks/", PiccoloCRUD(table=Task)),
+    ],
+    lifespan=lifespan,
+)

{piccolo-1.10.0 → piccolo-1.12.0}/piccolo/apps/migrations/auto/migration_manager.py

@@ -165,6 +165,7 @@ class MigrationManager:
     raw_backwards: t.List[t.Union[t.Callable, AsyncFunction]] = field(
         default_factory=list
     )
+    fake: bool = False
 
     def add_table(
         self,

{piccolo-1.10.0 → piccolo-1.12.0}/piccolo/apps/migrations/commands/forwards.py

@@ -72,18 +72,19 @@ class ForwardsMigrationManager(BaseMigrationManager):
             print(f"🚀 Running {n} migration{'s' if n != 1 else ''}:")
 
             for _id in subset:
-                if self.fake:
-                    print(f"- {_id}: faked! ⏭️")
-                else:
-                    migration_module = migration_modules[_id]
-                    response = await migration_module.forwards()
+                migration_module = migration_modules[_id]
+                response = await migration_module.forwards()
 
-                    if isinstance(response, MigrationManager):
+                if isinstance(response, MigrationManager):
+                    if self.fake or response.fake:
+                        print(f"- {_id}: faked! ⏭️")
+                    else:
                         if self.preview:
                             response.preview = True
                         await response.run()
 
-                    print("ok! ✔️")
+                print("ok! ✔️")
+
                 if not self.preview:
                     await Migration.insert().add(
                         Migration(name=_id, app_name=app_config.app_name)

{piccolo-1.10.0 → piccolo-1.12.0}/piccolo/apps/playground/commands/run.py

@@ -19,6 +19,7 @@ from piccolo.columns import (
     Interval,
     Numeric,
     Serial,
+    Text,
     Timestamp,
     Varchar,
 )
@@ -55,6 +56,12 @@ class Band(Table):
         )
 
 
+class FanClub(Table):
+    id: Serial
+    address = Text()
+    band = ForeignKey(Band, unique=True)
+
+
 class Venue(Table):
     id: Serial
     name = Varchar(length=100)
@@ -154,6 +161,7 @@ class Album(Table):
 TABLES = (
     Manager,
     Band,
+    FanClub,
     Venue,
     Concert,
     Ticket,
@@ -185,6 +193,9 @@ def populate():
     pythonistas = Band(name="Pythonistas", manager=guido.id, popularity=1000)
     pythonistas.save().run_sync()
 
+    fan_club = FanClub(address="1 Flying Circus, UK", band=pythonistas)
+    fan_club.save().run_sync()
+
     graydon = Manager(name="Graydon")
     graydon.save().run_sync()
 

{piccolo-1.10.0 → piccolo-1.12.0}/piccolo/columns/column_types.py

@@ -86,47 +86,38 @@ class ConcatDelegate:
 
     def get_querystring(
         self,
-        column_name: str,
-        value: t.Union[str, Varchar, Text],
+        column: Column,
+        value: t.Union[str, Column, QueryString],
         reverse: bool = False,
     ) -> QueryString:
-        if isinstance(value, (Varchar, Text)):
-            column: Column = value
+        """
+        :param reverse:
+            By default the value is appended to the column's value. If
+            ``reverse=True`` then the value is prepended to the column's
+            value instead.
+
+        """
+        if isinstance(value, Column):
             if len(column._meta.call_chain) > 0:
                 raise ValueError(
                     "Adding values across joins isn't currently supported."
                 )
-            other_column_name = column._meta.db_column_name
-            if reverse:
-                return QueryString(
-                    Concat.template.format(
-                        value_1=other_column_name, value_2=column_name
-                    )
-                )
-            else:
-                return QueryString(
-                    Concat.template.format(
-                        value_1=column_name, value_2=other_column_name
-                    )
-                )
         elif isinstance(value, str):
-            if reverse:
-                value_1 = QueryString("CAST({} AS text)", value)
-                return QueryString(
-                    Concat.template.format(value_1="{}", value_2=column_name),
-                    value_1,
-                )
-            else:
-                value_2 = QueryString("CAST({} AS text)", value)
-                return QueryString(
-                    Concat.template.format(value_1=column_name, value_2="{}"),
-                    value_2,
-                )
-        else:
+            value = QueryString("CAST({} AS TEXT)", value)
+        elif not isinstance(value, QueryString):
             raise ValueError(
-                "Only str, Varchar columns, and Text columns can be added."
+                "Only str, Column and QueryString values can be added."
             )
 
+        args = [value, column] if reverse else [column, value]
+
+        # We use the concat operator instead of the concat function, because
+        # this is what we historically used, and they treat null values
+        # differently.
+        return QueryString(
+            Concat.template.format(value_1="{}", value_2="{}"), *args
+        )
+
 
 class MathDelegate:
     """
@@ -340,12 +331,13 @@ class Varchar(Column):
 
     def __add__(self, value: t.Union[str, Varchar, Text]) -> QueryString:
         return self.concat_delegate.get_querystring(
-            column_name=self._meta.db_column_name, value=value
+            column=self,
+            value=value,
         )
 
     def __radd__(self, value: t.Union[str, Varchar, Text]) -> QueryString:
         return self.concat_delegate.get_querystring(
-            column_name=self._meta.db_column_name,
+            column=self,
             value=value,
             reverse=True,
         )
@@ -442,12 +434,13 @@ class Text(Column):
 
     def __add__(self, value: t.Union[str, Varchar, Text]) -> QueryString:
         return self.concat_delegate.get_querystring(
-            column_name=self._meta.db_column_name, value=value
+            column=self,
+            value=value,
         )
 
     def __radd__(self, value: t.Union[str, Varchar, Text]) -> QueryString:
         return self.concat_delegate.get_querystring(
-            column_name=self._meta.db_column_name,
+            column=self,
             value=value,
             reverse=True,
         )
@@ -2023,6 +2016,61 @@ class ForeignKey(Column, t.Generic[ReferencedTable]):
             if column._meta.name not in excluded_column_names
         ]
 
+    def reverse(self) -> ForeignKey:
+        """
+        If there's a unique foreign key, this function reverses it.
+
+        .. code-block:: python
+
+            class Band(Table):
+                name = Varchar()
+
+            class FanClub(Table):
+                band = ForeignKey(Band, unique=True)
+                address = Text()
+
+            class Treasurer(Table):
+                fan_club = ForeignKey(FanClub, unique=True)
+                name = Varchar()
+
+        It's helpful with ``get_related``, for example:
+
+        .. code-block:: python
+
+            >>> band = await Band.objects().first()
+            >>> await band.get_related(FanClub.band.reverse())
+            <Fan Club: 1>
+
+        It works multiple levels deep:
+
+        .. code-block:: python
+
+            >>> await band.get_related(Treasurer.fan_club._.band.reverse())
+            <Treasurer: 1>
+
+        """
+        if not self._meta.unique or any(
+            not i._meta.unique for i in self._meta.call_chain
+        ):
+            raise ValueError("Only reverse unique foreign keys.")
+
+        foreign_keys = [*self._meta.call_chain, self]
+
+        root_foreign_key = foreign_keys[0]
+        target_column = (
+            root_foreign_key._foreign_key_meta.resolved_target_column
+        )
+        foreign_key = target_column.join_on(root_foreign_key)
+
+        call_chain = []
+        for fk in reversed(foreign_keys[1:]):
+            target_column = fk._foreign_key_meta.resolved_target_column
+            call_chain.append(target_column.join_on(fk))
+
+        foreign_key._meta.call_chain = call_chain
+
+        return foreign_key
+
     def all_related(
         self, exclude: t.Optional[t.List[t.Union[ForeignKey, str]]] = None
     ) -> t.List[ForeignKey]:

{piccolo-1.10.0 → piccolo-1.12.0}/piccolo/query/functions/__init__.py

@@ -1,6 +1,7 @@
 from .aggregate import Avg, Count, Max, Min, Sum
+from .datetime import Day, Extract, Hour, Month, Second, Strftime, Year
 from .math import Abs, Ceil, Floor, Round
-from .string import Length, Lower, Ltrim, Reverse, Rtrim, Upper
+from .string import Concat, Length, Lower, Ltrim, Reverse, Rtrim, Upper
 from .type_conversion import Cast
 
 __all__ = (
@@ -8,16 +9,25 @@ __all__ = (
     "Avg",
     "Cast",
     "Ceil",
+    "Concat",
     "Count",
+    "Day",
+    "Extract",
+    "Extract",
     "Floor",
+    "Hour",
     "Length",
     "Lower",
     "Ltrim",
     "Max",
     "Min",
+    "Month",
     "Reverse",
     "Round",
     "Rtrim",
+    "Second",
+    "Strftime",
     "Sum",
     "Upper",
+    "Year",
 )