piccolo 1.5.1__tar.gz → 1.5.2__tar.gz

{piccolo-1.5.1 → piccolo-1.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.5.1
+Version: 1.5.2
 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.5.2/piccolo/__init__.py

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

{piccolo-1.5.1 → piccolo-1.5.2}/piccolo/apps/playground/commands/run.py

@@ -5,7 +5,6 @@ for interacting with the data using Piccolo.
 
 import datetime
 import sys
-import typing as t
 import uuid
 from decimal import Decimal
 from enum import Enum
@@ -14,10 +13,12 @@ from piccolo.columns import (
     JSON,
     UUID,
     Boolean,
+    Date,
     ForeignKey,
     Integer,
     Interval,
     Numeric,
+    Serial,
     Timestamp,
     Varchar,
 )
@@ -29,6 +30,7 @@ from piccolo.utils.warnings import colored_string
 
 
 class Manager(Table):
+    id: Serial
     name = Varchar(length=50)
 
     @classmethod
@@ -40,6 +42,7 @@ class Manager(Table):
 
 
 class Band(Table):
+    id: Serial
     name = Varchar(length=50)
     manager = ForeignKey(references=Manager, null=True)
     popularity = Integer()
@@ -53,6 +56,7 @@ class Band(Table):
 
 
 class Venue(Table):
+    id: Serial
     name = Varchar(length=100)
     capacity = Integer(default=0)
 
@@ -65,6 +69,7 @@ class Venue(Table):
 
 
 class Concert(Table):
+    id: Serial
     band_1 = ForeignKey(Band)
     band_2 = ForeignKey(Band)
     venue = ForeignKey(Venue)
@@ -89,6 +94,7 @@ class Ticket(Table):
         standing = "standing"
         premium = "premium"
 
+    id: Serial
     concert = ForeignKey(Concert)
     price = Numeric(digits=(5, 2))
     ticket_type = Varchar(choices=TicketType, default=TicketType.standing)
@@ -98,13 +104,14 @@ class Ticket(Table):
         return Readable(
             template="%s - %s",
             columns=[
-                t.cast(t.Type[Venue], cls.concert.venue).name,
+                cls.concert._.venue._.name,
                 cls.ticket_type,
             ],
         )
 
 
 class DiscountCode(Table):
+    id: Serial
     code = UUID()
     active = Boolean(default=True, null=True)
 
@@ -117,6 +124,7 @@ class DiscountCode(Table):
 
 
 class RecordingStudio(Table):
+    id: Serial
     name = Varchar(length=100)
     facilities = JSON(null=True)
 
@@ -128,7 +136,31 @@ class RecordingStudio(Table):
         )
 
 
-TABLES = (Manager, Band, Venue, Concert, Ticket, DiscountCode, RecordingStudio)
+class Album(Table):
+    id: Serial
+    name = Varchar()
+    band = ForeignKey(Band)
+    release_date = Date()
+    recorded_at = ForeignKey(RecordingStudio)
+
+    @classmethod
+    def get_readable(cls) -> Readable:
+        return Readable(
+            template="%s - %s",
+            columns=[cls.name, cls.band._.name],
+        )
+
+
+TABLES = (
+    Manager,
+    Band,
+    Venue,
+    Concert,
+    Ticket,
+    DiscountCode,
+    RecordingStudio,
+    Album,
+)
 
 
 def populate():
@@ -184,24 +216,44 @@ def populate():
         *[DiscountCode({DiscountCode.code: uuid.uuid4()}) for _ in range(5)]
     ).run_sync()
 
-    RecordingStudio.insert(
-        RecordingStudio(
+    recording_studio_1 = RecordingStudio(
+        {
+            RecordingStudio.name: "Abbey Road",
+            RecordingStudio.facilities: {
+                "restaurant": True,
+                "mixing_desk": True,
+            },
+        }
+    )
+    recording_studio_1.save().run_sync()
+
+    recording_studio_2 = RecordingStudio(
+        {
+            RecordingStudio.name: "Electric Lady",
+            RecordingStudio.facilities: {
+                "restaurant": False,
+                "mixing_desk": True,
+            },
+        },
+    )
+    recording_studio_2.save().run_sync()
+
+    Album.insert(
+        Album(
             {
-                RecordingStudio.name: "Abbey Road",
-                RecordingStudio.facilities: {
-                    "restaurant": True,
-                    "mixing_desk": True,
-                },
+                Album.name: "Awesome album 1",
+                Album.recorded_at: recording_studio_1,
+                Album.band: pythonistas,
+                Album.release_date: datetime.date(year=2021, month=1, day=1),
             }
         ),
-        RecordingStudio(
+        Album(
             {
-                RecordingStudio.name: "Electric Lady",
-                RecordingStudio.facilities: {
-                    "restaurant": False,
-                    "mixing_desk": True,
-                },
-            },
+                Album.name: "Awesome album 2",
+                Album.recorded_at: recording_studio_2,
+                Album.band: rustaceans,
+                Album.release_date: datetime.date(year=2022, month=2, day=2),
+            }
         ),
     ).run_sync()
 
@@ -278,7 +330,7 @@ def run(
 
     populate()
 
-    from IPython.core.interactiveshell import _asyncio_runner
+    from IPython.core.async_helpers import _asyncio_runner
 
     if ipython_profile:
         print(colored_string("Using your IPython profile\n"))

{piccolo-1.5.1 → piccolo-1.5.2}/piccolo/query/base.py

@@ -87,13 +87,9 @@ class Query(t.Generic[TableInstance, QueryResponseType]):
             for column in json_columns:
                 if column._alias is not None:
                     json_column_names.append(column._alias)
-                elif column.json_operator is not None:
-                    json_column_names.append(column._meta.name)
                 elif len(column._meta.call_chain) > 0:
                     json_column_names.append(
-                        column.get_select_string(
-                            engine_type=column._meta.engine_type
-                        )
+                        column._meta.get_default_alias().replace("$", ".")
                     )
                 else:
                     json_column_names.append(column._meta.name)

{piccolo-1.5.1 → piccolo-1.5.2}/piccolo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.5.1
+Version: 1.5.2
 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.5.1 → piccolo-1.5.2}/tests/apps/migrations/commands/test_forwards_backwards.py

@@ -13,6 +13,7 @@ from tests.base import engines_only
 from tests.example_apps.music.tables import (
     Band,
     Concert,
+    Instrument,
     Manager,
     Poster,
     RecordingStudio,
@@ -33,6 +34,7 @@ TABLE_CLASSES: t.List[t.Type[Table]] = [
     Poster,
     Shirt,
     RecordingStudio,
+    Instrument,
 ]
 
 
@@ -211,6 +213,7 @@ class TestForwardsBackwards(TestCase):
                 "2021-07-25T22:38:48:009306",
                 "2021-09-06T13:58:23:024723",
                 "2021-11-13T14:01:46:114725",
+                "2024-05-28T23:15:41:018844",
             ],
         )
 

{piccolo-1.5.1 → piccolo-1.5.2}/tests/apps/shell/commands/test_run.py

@@ -20,6 +20,7 @@ class TestRun(TestCase):
                 call("Importing music tables:"),
                 call("- Band"),
                 call("- Concert"),
+                call("- Instrument"),
                 call("- Manager"),
                 call("- Poster"),
                 call("- RecordingStudio"),

{piccolo-1.5.1 → piccolo-1.5.2}/tests/conf/test_apps.py

@@ -9,6 +9,7 @@ from tests.example_apps.mega.tables import MegaTable, SmallTable
 from tests.example_apps.music.tables import (
     Band,
     Concert,
+    Instrument,
     Manager,
     Poster,
     RecordingStudio,
@@ -113,6 +114,7 @@ class TestTableFinder(TestCase):
             [
                 "Band",
                 "Concert",
+                "Instrument",
                 "Manager",
                 "Poster",
                 "RecordingStudio",
@@ -139,6 +141,7 @@ class TestTableFinder(TestCase):
             [
                 "Band",
                 "Concert",
+                "Instrument",
                 "Manager",
                 "Poster",
                 "RecordingStudio",
@@ -182,6 +185,7 @@ class TestTableFinder(TestCase):
             [
                 "Band",
                 "Concert",
+                "Instrument",
                 "Manager",
                 "RecordingStudio",
                 "Shirt",
@@ -228,6 +232,7 @@ class TestFinder(TestCase):
             [
                 Band,
                 Concert,
+                Instrument,
                 Manager,
                 MegaTable,
                 Poster,
@@ -247,6 +252,7 @@ class TestFinder(TestCase):
             [
                 Band,
                 Concert,
+                Instrument,
                 Manager,
                 Poster,
                 RecordingStudio,

{piccolo-1.5.1 → piccolo-1.5.2}/tests/example_apps/music/tables.py

@@ -115,3 +115,13 @@ class RecordingStudio(Table):
     id: Serial
     facilities = JSON()
     facilities_b = JSONB()
+
+
+class Instrument(Table):
+    """
+    Used for testing foreign keys to a table with a JSON column.
+    """
+
+    id: Serial
+    name = Varchar()
+    recording_studio = ForeignKey(RecordingStudio)

piccolo-1.5.2/tests/table/test_output.py

@@ -0,0 +1,160 @@
+import json
+from unittest import TestCase
+
+from piccolo.table import create_db_tables_sync, drop_db_tables_sync
+from tests.base import DBTestCase
+from tests.example_apps.music.tables import Band, Instrument, RecordingStudio
+
+
+class TestOutputList(DBTestCase):
+    def test_output_as_list(self):
+        self.insert_row()
+
+        response = Band.select(Band.name).output(as_list=True).run_sync()
+        self.assertEqual(response, ["Pythonistas"])
+
+        # Make sure that if no rows are found, an empty list is returned.
+        empty_response = (
+            Band.select(Band.name)
+            .where(Band.name == "ABC123")
+            .output(as_list=True)
+            .run_sync()
+        )
+        self.assertEqual(empty_response, [])
+
+
+class TestOutputJSON(DBTestCase):
+    def test_output_as_json(self):
+        self.insert_row()
+
+        response = Band.select(Band.name).output(as_json=True).run_sync()
+
+        self.assertEqual(json.loads(response), [{"name": "Pythonistas"}])
+
+
+class TestOutputLoadJSON(TestCase):
+    tables = [RecordingStudio, Instrument]
+    json = {"a": 123}
+
+    def setUp(self):
+        create_db_tables_sync(*self.tables)
+
+        recording_studio = RecordingStudio(
+            {
+                RecordingStudio.facilities: self.json,
+                RecordingStudio.facilities_b: self.json,
+            }
+        )
+        recording_studio.save().run_sync()
+
+        instrument = Instrument(
+            {
+                Instrument.recording_studio: recording_studio,
+                Instrument.name: "Piccolo",
+            }
+        )
+        instrument.save().run_sync()
+
+    def tearDown(self):
+        drop_db_tables_sync(*self.tables)
+
+    def test_select(self):
+        results = (
+            RecordingStudio.select(
+                RecordingStudio.facilities, RecordingStudio.facilities_b
+            )
+            .output(load_json=True)
+            .run_sync()
+        )
+
+        self.assertEqual(
+            results,
+            [
+                {
+                    "facilities": self.json,
+                    "facilities_b": self.json,
+                }
+            ],
+        )
+
+    def test_join(self):
+        """
+        Make sure it works correctly when the JSON column is on a joined table.
+
+        https://github.com/piccolo-orm/piccolo/issues/1001
+
+        """
+        results = (
+            Instrument.select(
+                Instrument.name,
+                Instrument.recording_studio._.facilities,
+            )
+            .output(load_json=True)
+            .run_sync()
+        )
+
+        self.assertEqual(
+            results,
+            [
+                {
+                    "name": "Piccolo",
+                    "recording_studio.facilities": self.json,
+                }
+            ],
+        )
+
+    def test_join_with_alias(self):
+        results = (
+            Instrument.select(
+                Instrument.name,
+                Instrument.recording_studio._.facilities.as_alias(
+                    "facilities"
+                ),
+            )
+            .output(load_json=True)
+            .run_sync()
+        )
+
+        self.assertEqual(
+            results,
+            [
+                {
+                    "name": "Piccolo",
+                    "facilities": self.json,
+                }
+            ],
+        )
+
+    def test_objects(self):
+        results = RecordingStudio.objects().output(load_json=True).run_sync()
+        self.assertEqual(results[0].facilities, self.json)
+        self.assertEqual(results[0].facilities_b, self.json)
+
+
+class TestOutputNested(DBTestCase):
+    def test_output_nested(self):
+        self.insert_row()
+
+        response = (
+            Band.select(Band.name, Band.manager.name)
+            .output(nested=True)
+            .run_sync()
+        )
+        self.assertEqual(
+            response, [{"name": "Pythonistas", "manager": {"name": "Guido"}}]
+        )
+
+    def test_output_nested_with_first(self):
+        self.insert_row()
+
+        response = (
+            Band.select(Band.name, Band.manager.name)
+            .first()
+            .output(nested=True)
+            .run_sync()
+        )
+        assert response is not None
+        self.assertDictEqual(
+            response,  # type: ignore
+            {"name": "Pythonistas", "manager": {"name": "Guido"}},
+        )

piccolo-1.5.1/piccolo/__init__.py

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

piccolo-1.5.1/tests/table/test_output.py

@@ -1,108 +0,0 @@
-import json
-from unittest import TestCase
-
-from tests.base import DBTestCase, engine_is
-from tests.example_apps.music.tables import Band, RecordingStudio
-
-
-class TestOutputList(DBTestCase):
-    def test_output_as_list(self):
-        self.insert_row()
-
-        response = Band.select(Band.name).output(as_list=True).run_sync()
-        self.assertEqual(response, ["Pythonistas"])
-
-        # Make sure that if no rows are found, an empty list is returned.
-        empty_response = (
-            Band.select(Band.name)
-            .where(Band.name == "ABC123")
-            .output(as_list=True)
-            .run_sync()
-        )
-        self.assertEqual(empty_response, [])
-
-
-class TestOutputJSON(DBTestCase):
-    def test_output_as_json(self):
-        self.insert_row()
-
-        response = Band.select(Band.name).output(as_json=True).run_sync()
-
-        self.assertEqual(json.loads(response), [{"name": "Pythonistas"}])
-
-
-class TestOutputLoadJSON(TestCase):
-    def setUp(self):
-        RecordingStudio.create_table().run_sync()
-
-    def tearDown(self):
-        RecordingStudio.alter().drop_table().run_sync()
-
-    def test_select(self):
-        json = {"a": 123}
-
-        RecordingStudio(facilities=json, facilities_b=json).save().run_sync()
-
-        results = RecordingStudio.select().output(load_json=True).run_sync()
-
-        if engine_is("cockroach"):
-            self.assertEqual(
-                results,
-                [
-                    {
-                        "id": results[0]["id"],
-                        "facilities": {"a": 123},
-                        "facilities_b": {"a": 123},
-                    }
-                ],
-            )
-        else:
-            self.assertEqual(
-                results,
-                [
-                    {
-                        "id": 1,
-                        "facilities": {"a": 123},
-                        "facilities_b": {"a": 123},
-                    }
-                ],
-            )
-
-    def test_objects(self):
-        json = {"a": 123}
-
-        RecordingStudio(facilities=json, facilities_b=json).save().run_sync()
-
-        results = RecordingStudio.objects().output(load_json=True).run_sync()
-
-        self.assertEqual(results[0].facilities, json)
-        self.assertEqual(results[0].facilities_b, json)
-
-
-class TestOutputNested(DBTestCase):
-    def test_output_nested(self):
-        self.insert_row()
-
-        response = (
-            Band.select(Band.name, Band.manager.name)
-            .output(nested=True)
-            .run_sync()
-        )
-        self.assertEqual(
-            response, [{"name": "Pythonistas", "manager": {"name": "Guido"}}]
-        )
-
-    def test_output_nested_with_first(self):
-        self.insert_row()
-
-        response = (
-            Band.select(Band.name, Band.manager.name)
-            .first()
-            .output(nested=True)
-            .run_sync()
-        )
-        assert response is not None
-        self.assertDictEqual(
-            response,  # type: ignore
-            {"name": "Pythonistas", "manager": {"name": "Guido"}},
-        )