piccolo 0.108.0__tar.gz → 0.110.0__tar.gz

{piccolo-0.108.0 → piccolo-0.110.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 0.108.0
+Version: 0.110.0
 Summary: A fast, user friendly ORM and query builder which supports asyncio.
 Home-page: https://github.com/piccolo-orm/piccolo
 Author: Daniel Townsend
@@ -105,7 +105,7 @@ Description: ![Logo](https://raw.githubusercontent.com/piccolo-orm/piccolo/maste
         piccolo asgi new
         ```
         
-        [Starlette](https://www.starlette.io/), [FastAPI](https://fastapi.tiangolo.com/), [BlackSheep](https://www.neoteroi.dev/blacksheep/), [Xpresso](https://xpresso-api.dev/) and [Starlite](https://starlite-api.github.io/starlite/) are currently supported.
+        [Starlette](https://www.starlette.io/), [FastAPI](https://fastapi.tiangolo.com/), [BlackSheep](https://www.neoteroi.dev/blacksheep/) and [Litestar](https://litestar.dev/) are currently supported.
         
         ## Are you a Django user?
         

{piccolo-0.108.0 → piccolo-0.110.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/), [Xpresso](https://xpresso-api.dev/) and [Starlite](https://starlite-api.github.io/starlite/) are currently supported.
+[Starlette](https://www.starlette.io/), [FastAPI](https://fastapi.tiangolo.com/), [BlackSheep](https://www.neoteroi.dev/blacksheep/) and [Litestar](https://litestar.dev/) are currently supported.
 
 ## Are you a Django user?
 

piccolo-0.110.0/piccolo/__init__.py

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

{piccolo-0.108.0 → piccolo-0.110.0}/piccolo/apps/asgi/commands/new.py

@@ -10,10 +10,9 @@ from jinja2 import Environment, FileSystemLoader
 
 TEMPLATE_DIR = os.path.join(os.path.dirname(__file__), "templates/app/")
 SERVERS = ["uvicorn", "Hypercorn"]
-ROUTERS = ["starlette", "fastapi", "blacksheep", "xpresso", "starlite"]
+ROUTERS = ["starlette", "fastapi", "blacksheep", "litestar"]
 ROUTER_DEPENDENCIES = {
-    "starlite": ["starlite>=1.46.0"],
-    "xpresso": ["xpresso==0.43.0", "di==0.72.1"],
+    "litestar": ["litestar>=2.0.0a3"],
 }
 
 

piccolo-0.108.0/piccolo/apps/asgi/commands/templates/app/_starlite_app.py.jinja → piccolo-0.110.0/piccolo/apps/asgi/commands/templates/app/_litestar_app.py.jinja

@@ -2,13 +2,13 @@ import typing as t
 
 from piccolo.engine import engine_finder
 from piccolo_admin.endpoints import create_admin
-from starlite import Starlite, asgi, delete, get, patch, post
-from starlite.config.static_files import StaticFilesConfig
-from starlite.config.template import TemplateConfig
-from starlite.contrib.jinja import JinjaTemplateEngine
-from starlite.exceptions import NotFoundException
-from starlite.plugins.piccolo_orm import PiccoloORMPlugin
-from starlite.types import Receive, Scope, Send
+from litestar import Litestar, asgi, delete, get, patch, post
+from litestar.static_files import StaticFilesConfig
+from litestar.template import TemplateConfig
+from litestar.contrib.jinja import JinjaTemplateEngine
+from litestar.contrib.piccolo_orm import PiccoloORMPlugin
+from litestar.exceptions import NotFoundException
+from litestar.types import Receive, Scope, Send
 
 from home.endpoints import home
 from home.piccolo_app import APP_CONFIG
@@ -71,7 +71,7 @@ async def close_database_connection_pool():
         print("Unable to connect to the database")
 
 
-app = Starlite(
+app = Litestar(
     route_handlers=[
         admin,
         home,

{piccolo-0.108.0 → piccolo-0.110.0}/piccolo/apps/asgi/commands/templates/app/app.py.jinja

@@ -4,8 +4,6 @@
     {% include '_starlette_app.py.jinja' %}
 {% elif router == 'blacksheep' %}
     {% include '_blacksheep_app.py.jinja' %}
-{% elif router == 'xpresso' %}
-    {% include '_xpresso_app.py.jinja' %}
-{% elif router == 'starlite' %}
-    {% include '_starlite_app.py.jinja' %}
+{% elif router == 'litestar' %}
+    {% include '_litestar_app.py.jinja' %}
 {% endif %}

piccolo-0.108.0/piccolo/apps/asgi/commands/templates/app/home/_starlite_endpoints.py.jinja → piccolo-0.110.0/piccolo/apps/asgi/commands/templates/app/home/_litestar_endpoints.py.jinja

@@ -1,7 +1,7 @@
 import os
 
 import jinja2
-from starlite import MediaType, Request, Response, get
+from litestar import MediaType, Request, Response, get
 
 ENVIRONMENT = jinja2.Environment(
     loader=jinja2.FileSystemLoader(
@@ -19,3 +19,4 @@ def home(request: Request) -> Response:
         media_type=MediaType.HTML,
         status_code=200,
     )
+

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

@@ -2,8 +2,6 @@
     {% include '_starlette_endpoints.py.jinja' %}
 {% elif router == 'blacksheep' %}
     {% include '_blacksheep_endpoints.py.jinja' %}
-{% elif router == 'xpresso' %}
-    {% include '_xpresso_endpoints.py.jinja' %}
-{% elif router == 'starlite' %}
-    {% include '_starlite_endpoints.py.jinja' %}
+{% elif router == 'litestar' %}
+    {% include '_litestar_endpoints.py.jinja' %}
 {% endif %}

{piccolo-0.108.0 → piccolo-0.110.0}/piccolo/apps/asgi/commands/templates/app/home/templates/home.html.jinja_raw

@@ -51,12 +51,7 @@
                 <li><a href="/admin/">Admin</a></li>
                 <li><a href="/docs/">Swagger API</a></li>
             </ul>
-            <h3>Xpresso</h3>
-            <ul>
-                <li><a href="/admin/">Admin</a></li>
-                <li><a href="/docs/">Swagger API</a></li>
-            </ul>
-            <h3>Starlite</h3>
+            <h3>Litestar</h3>
             <ul>
                 <li><a href="/admin/">Admin</a></li>
                 <li><a href="/schema/swagger">Swagger API</a></li>

{piccolo-0.108.0 → piccolo-0.110.0}/piccolo/apps/playground/commands/run.py

@@ -136,8 +136,7 @@ def populate():
     """
     for _table in reversed(TABLES):
         try:
-            if _table.table_exists().run_sync():
-                _table.alter().drop_table().run_sync()
+            _table.alter().drop_table(if_exists=True).run_sync()
         except Exception as e:
             print(e)
 
@@ -180,13 +179,30 @@ def populate():
     ticket = Ticket(concert=concert.id, price=Decimal("50.0"))
     ticket.save().run_sync()
 
-    discount_code = DiscountCode(code=uuid.uuid4())
-    discount_code.save().run_sync()
+    DiscountCode.insert(
+        *[DiscountCode({DiscountCode.code: uuid.uuid4()}) for _ in range(5)]
+    ).run_sync()
 
-    recording_studio = RecordingStudio(
-        name="Abbey Road", facilities={"restaurant": True, "mixing_desk": True}
-    )
-    recording_studio.save().run_sync()
+    RecordingStudio.insert(
+        RecordingStudio(
+            {
+                RecordingStudio.name: "Abbey Road",
+                RecordingStudio.facilities: {
+                    "restaurant": True,
+                    "mixing_desk": True,
+                },
+            }
+        ),
+        RecordingStudio(
+            {
+                RecordingStudio.name: "Electric Lady",
+                RecordingStudio.facilities: {
+                    "restaurant": False,
+                    "mixing_desk": True,
+                },
+            },
+        ),
+    ).run_sync()
 
 
 def run(

{piccolo-0.108.0 → piccolo-0.110.0}/piccolo/columns/base.py

@@ -759,6 +759,51 @@ class Column(Selectable):
         column._alias = name
         return column
 
+    def join_on(self, column: Column) -> ForeignKey:
+        """
+        Joins are typically performed via foreign key columns. For example,
+        here we get the band's name and the manager's name::
+
+            class Manager(Table):
+                name = Varchar()
+
+            class Band(Table):
+                name = Varchar()
+                manager = ForeignKey(Manager)
+
+            >>> await Band.select(Band.name, Band.manager.name)
+
+        The ``join_on`` method lets you join tables even when foreign keys
+        don't exist, by joining on a column in another table.
+
+        For example, here we want to get the manager's email, but no foreign
+        key exists::
+
+            class Manager(Table):
+                name = Varchar(unique=True)
+                email = Varchar()
+
+            class Band(Table):
+                name = Varchar()
+                manager_name = Varchar()
+
+            >>> await Band.select(
+            ...     Band.name,
+            ...     Band.manager_name.join_on(Manager.name).email
+            ... )
+
+        """
+        from piccolo.columns.column_types import ForeignKey
+
+        virtual_foreign_key = ForeignKey(
+            references=column._meta.table, target_column=column
+        )
+        virtual_foreign_key._meta._name = self._meta.name
+        virtual_foreign_key._meta.call_chain = [*self._meta.call_chain]
+        virtual_foreign_key._meta._table = self._meta.table
+        virtual_foreign_key.set_proxy_columns()
+        return virtual_foreign_key
+
     def get_default_value(self) -> t.Any:
         """
         If the column has a default attribute, return it. If it's callable,

{piccolo-0.108.0 → piccolo-0.110.0}/piccolo/columns/column_types.py

@@ -1784,7 +1784,7 @@ class ForeignKey(Column):
 
     :param on_update:
         Determines what the database should do when a row has it's primary key
-        updated. If set to ``OnDelete.cascade``, any rows referencing the
+        updated. If set to ``OnUpdate.cascade``, any rows referencing the
         updated row will have their references updated to point to the new
         primary key.
 
@@ -1800,7 +1800,7 @@ class ForeignKey(Column):
 
         .. code-block:: python
 
-            from piccolo.columns import OnDelete
+            from piccolo.columns import OnUpdate
 
             class Band(Table):
                 name = ForeignKey(

{piccolo-0.108.0 → piccolo-0.110.0}/piccolo/query/methods/select.py

@@ -353,8 +353,18 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
         self.columns_delegate.columns(*_columns)
         return self
 
-    def distinct(self: Self) -> Self:
-        self.distinct_delegate.distinct()
+    def distinct(
+        self: Self, *, on: t.Optional[t.Sequence[Column]] = None
+    ) -> Self:
+        if on is not None and self.engine_type not in (
+            "postgres",
+            "cockroach",
+        ):
+            raise ValueError(
+                "Only Postgres and Cockroach supports DISTINCT ON"
+            )
+
+        self.distinct_delegate.distinct(enabled=True, on=on)
         return self
 
     def group_by(self: Self, *columns: t.Union[Column, str]) -> Self:
@@ -722,17 +732,22 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
 
         #######################################################################
 
-        select = (
-            "SELECT DISTINCT" if self.distinct_delegate._distinct else "SELECT"
-        )
-        query = f"{select} {columns_str} FROM {self.table._meta.tablename}"
+        args: t.List[t.Any] = []
 
-        for join in joins:
-            query += f" {join}"
+        query = "SELECT"
 
-        #######################################################################
+        distinct = self.distinct_delegate._distinct
+        if distinct:
+            if distinct.on:
+                distinct.validate_on(self.order_by_delegate._order_by)
 
-        args: t.List[t.Any] = []
+            query += "{}"
+            args.append(distinct.querystring)
+
+        query += f" {columns_str} FROM {self.table._meta.tablename}"
+
+        for join in joins:
+            query += f" {join}"
 
         if self.as_of_delegate._as_of:
             query += "{}"

{piccolo-0.108.0 → piccolo-0.110.0}/piccolo/query/mixins.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import collections.abc
 import itertools
 import typing as t
 from dataclasses import dataclass, field
@@ -18,6 +19,70 @@ if t.TYPE_CHECKING:  # pragma: no cover
     from piccolo.table import Table  # noqa
 
 
+class DistinctOnError(ValueError):
+    """
+    Raised when ``DISTINCT ON`` queries are malformed.
+    """
+
+    pass
+
+
+@dataclass
+class Distinct:
+    __slots__ = ("enabled", "on")
+
+    enabled: bool
+    on: t.Optional[t.Sequence[Column]]
+
+    @property
+    def querystring(self) -> QueryString:
+        if self.enabled:
+            if self.on:
+                column_names = ", ".join(
+                    i._meta.get_full_name(with_alias=False) for i in self.on
+                )
+                return QueryString(f" DISTINCT ON ({column_names})")
+            else:
+                return QueryString(" DISTINCT")
+        else:
+            return QueryString(" ALL")
+
+    def validate_on(self, order_by: OrderBy):
+        """
+        When using the `on` argument, the first column must match the first
+        order by column.
+
+        :raises DistinctOnError:
+            If the columns don't match.
+
+        """
+        validated = True
+
+        try:
+            first_order_column = order_by.order_by_items[0].columns[0]
+        except IndexError:
+            validated = False
+        else:
+            if not self.on:
+                validated = False
+            elif isinstance(first_order_column, Column) and not self.on[
+                0
+            ]._equals(first_order_column):
+                validated = False
+
+        if not validated:
+            raise DistinctOnError(
+                "The first `order_by` column must match the first column "
+                "passed to `on`."
+            )
+
+    def __str__(self) -> str:
+        return self.querystring.__str__()
+
+    def copy(self) -> Distinct:
+        return self.__class__(enabled=self.enabled, on=self.on)
+
+
 @dataclass
 class Limit:
     __slots__ = ("number",)
@@ -259,10 +324,19 @@ class AsOfDelegate:
 @dataclass
 class DistinctDelegate:
 
-    _distinct: bool = False
+    _distinct: Distinct = field(
+        default_factory=lambda: Distinct(enabled=False, on=None)
+    )
+
+    def distinct(
+        self, enabled: bool, on: t.Optional[t.Sequence[Column]] = None
+    ):
+        if on and not isinstance(on, collections.abc.Sequence):
+            # Check a sequence is passed in, otherwise the user will get some
+            # unuseful errors later on.
+            raise ValueError("`on` must be a sequence of `Column` instances")
 
-    def distinct(self):
-        self._distinct = True
+        self._distinct = Distinct(enabled=enabled, on=on)
 
 
 @dataclass

{piccolo-0.108.0 → piccolo-0.110.0}/piccolo/testing/model_builder.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import json
 import typing as t
 from datetime import date, datetime, time, timedelta
@@ -5,7 +7,7 @@ from decimal import Decimal
 from uuid import UUID
 
 from piccolo.columns import Array, Column
-from piccolo.table import Table
+from piccolo.custom_types import TableInstance
 from piccolo.testing.random_builder import RandomBuilder
 from piccolo.utils.sync import run_sync
 
@@ -27,11 +29,11 @@ class ModelBuilder:
     @classmethod
     async def build(
         cls,
-        table_class: t.Type[Table],
+        table_class: t.Type[TableInstance],
         defaults: t.Dict[t.Union[Column, str], t.Any] = None,
         persist: bool = True,
         minimal: bool = False,
-    ) -> Table:
+    ) -> TableInstance:
         """
         Build a ``Table`` instance with random data and save async.
         If the ``Table`` has any foreign keys, then the related rows are also
@@ -78,11 +80,11 @@ class ModelBuilder:
     @classmethod
     def build_sync(
         cls,
-        table_class: t.Type[Table],
+        table_class: t.Type[TableInstance],
         defaults: t.Dict[t.Union[Column, str], t.Any] = None,
         persist: bool = True,
         minimal: bool = False,
-    ) -> Table:
+    ) -> TableInstance:
         """
         A sync wrapper around :meth:`build`.
         """
@@ -98,11 +100,11 @@ class ModelBuilder:
     @classmethod
     async def _build(
         cls,
-        table_class: t.Type[Table],
+        table_class: t.Type[TableInstance],
         defaults: t.Dict[t.Union[Column, str], t.Any] = None,
         minimal: bool = False,
         persist: bool = True,
-    ) -> Table:
+    ) -> TableInstance:
         model = table_class(_ignore_missing=True)
         defaults = {} if not defaults else defaults
 

{piccolo-0.108.0 → piccolo-0.110.0}/piccolo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 0.108.0
+Version: 0.110.0
 Summary: A fast, user friendly ORM and query builder which supports asyncio.
 Home-page: https://github.com/piccolo-orm/piccolo
 Author: Daniel Townsend
@@ -105,7 +105,7 @@ Description: ![Logo](https://raw.githubusercontent.com/piccolo-orm/piccolo/maste
         piccolo asgi new
         ```
         
-        [Starlette](https://www.starlette.io/), [FastAPI](https://fastapi.tiangolo.com/), [BlackSheep](https://www.neoteroi.dev/blacksheep/), [Xpresso](https://xpresso-api.dev/) and [Starlite](https://starlite-api.github.io/starlite/) are currently supported.
+        [Starlette](https://www.starlette.io/), [FastAPI](https://fastapi.tiangolo.com/), [BlackSheep](https://www.neoteroi.dev/blacksheep/) and [Litestar](https://litestar.dev/) are currently supported.
         
         ## Are you a Django user?
         

{piccolo-0.108.0 → piccolo-0.110.0}/piccolo.egg-info/SOURCES.txt

@@ -29,9 +29,8 @@ piccolo/apps/asgi/commands/new.py
 piccolo/apps/asgi/commands/templates/app/README.md.jinja
 piccolo/apps/asgi/commands/templates/app/_blacksheep_app.py.jinja
 piccolo/apps/asgi/commands/templates/app/_fastapi_app.py.jinja
+piccolo/apps/asgi/commands/templates/app/_litestar_app.py.jinja
 piccolo/apps/asgi/commands/templates/app/_starlette_app.py.jinja
-piccolo/apps/asgi/commands/templates/app/_starlite_app.py.jinja
-piccolo/apps/asgi/commands/templates/app/_xpresso_app.py.jinja
 piccolo/apps/asgi/commands/templates/app/app.py.jinja
 piccolo/apps/asgi/commands/templates/app/conftest.py.jinja
 piccolo/apps/asgi/commands/templates/app/main.py.jinja
@@ -40,9 +39,8 @@ piccolo/apps/asgi/commands/templates/app/piccolo_conf_test.py.jinja
 piccolo/apps/asgi/commands/templates/app/requirements.txt.jinja
 piccolo/apps/asgi/commands/templates/app/home/__init__.py.jinja
 piccolo/apps/asgi/commands/templates/app/home/_blacksheep_endpoints.py.jinja
+piccolo/apps/asgi/commands/templates/app/home/_litestar_endpoints.py.jinja
 piccolo/apps/asgi/commands/templates/app/home/_starlette_endpoints.py.jinja
-piccolo/apps/asgi/commands/templates/app/home/_starlite_endpoints.py.jinja
-piccolo/apps/asgi/commands/templates/app/home/_xpresso_endpoints.py.jinja
 piccolo/apps/asgi/commands/templates/app/home/endpoints.py.jinja
 piccolo/apps/asgi/commands/templates/app/home/piccolo_app.py.jinja
 piccolo/apps/asgi/commands/templates/app/home/tables.py.jinja
@@ -316,6 +314,7 @@ tests/table/test_indexes.py
 tests/table/test_inheritance.py
 tests/table/test_insert.py
 tests/table/test_join.py
+tests/table/test_join_on.py
 tests/table/test_metaclass.py
 tests/table/test_objects.py
 tests/table/test_output.py

piccolo-0.110.0/tests/table/test_join_on.py

@@ -0,0 +1,107 @@
+from unittest import TestCase
+
+from piccolo.columns import Varchar
+from piccolo.table import Table
+
+
+class Manager(Table):
+    name = Varchar(unique=True)
+    email = Varchar(unique=True)
+
+
+class Band(Table):
+    name = Varchar(unique=True)
+    manager_name = Varchar()
+
+
+class Concert(Table):
+    title = Varchar()
+    band_name = Varchar()
+
+
+class TestJoinOn(TestCase):
+
+    tables = [Manager, Band, Concert]
+
+    def setUp(self):
+        for table in self.tables:
+            table.create_table().run_sync()
+
+        Manager.insert(
+            Manager(name="Guido", email="guido@example.com"),
+            Manager(name="Maz", email="maz@example.com"),
+            Manager(name="Graydon", email="graydon@example.com"),
+        ).run_sync()
+
+        Band.insert(
+            Band(name="Pythonistas", manager_name="Guido"),
+            Band(name="Rustaceans", manager_name="Graydon"),
+        ).run_sync()
+
+        Concert.insert(
+            Concert(
+                title="Rockfest",
+                band_name="Pythonistas",
+            ),
+        ).run_sync()
+
+    def tearDown(self):
+        for table in self.tables:
+            table.alter().drop_table().run_sync()
+
+    def test_join_on(self):
+        """
+        Do a simple join between two tables.
+        """
+        query = Band.select(
+            Band.name,
+            Band.manager_name,
+            Band.manager_name.join_on(Manager.name).email.as_alias(
+                "manager_email"
+            ),
+        ).order_by(Band.id)
+
+        response = query.run_sync()
+
+        self.assertListEqual(
+            response,
+            [
+                {
+                    "name": "Pythonistas",
+                    "manager_name": "Guido",
+                    "manager_email": "guido@example.com",
+                },
+                {
+                    "name": "Rustaceans",
+                    "manager_name": "Graydon",
+                    "manager_email": "graydon@example.com",
+                },
+            ],
+        )
+
+    def test_deeper_join(self):
+        """
+        Do a join between three tables.
+        """
+        response = (
+            Concert.select(
+                Concert.title,
+                Concert.band_name,
+                Concert.band_name.join_on(Band.name)
+                .manager_name.join_on(Manager.name)
+                .email.as_alias("manager_email"),
+            )
+            .order_by(Concert.id)
+            .run_sync()
+        )
+
+        self.assertListEqual(
+            response,
+            [
+                {
+                    "title": "Rockfest",
+                    "band_name": "Pythonistas",
+                    "manager_email": "guido@example.com",
+                }
+            ],
+        )