piccolo 1.27.0__py3-none-any.whl → 1.28.0__py3-none-any.whl

tests/apps/migrations/auto/test_schema_differ.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import typing as t
 from unittest import TestCase
 from unittest.mock import MagicMock, call, patch
 
@@ -24,12 +23,12 @@ class TestSchemaDiffer(TestCase):
         """
         name_column = Varchar()
         name_column._meta.name = "name"
-        schema: t.List[DiffableTable] = [
+        schema: list[DiffableTable] = [
             DiffableTable(
                 class_name="Band", tablename="band", columns=[name_column]
             )
         ]
-        schema_snapshot: t.List[DiffableTable] = []
+        schema_snapshot: list[DiffableTable] = []
         schema_differ = SchemaDiffer(
             schema=schema, schema_snapshot=schema_snapshot, auto_input="y"
         )
@@ -52,8 +51,8 @@ class TestSchemaDiffer(TestCase):
         """
         Test dropping an existing table.
         """
-        schema: t.List[DiffableTable] = []
-        schema_snapshot: t.List[DiffableTable] = [
+        schema: list[DiffableTable] = []
+        schema_snapshot: list[DiffableTable] = [
             DiffableTable(class_name="Band", tablename="band", columns=[])
         ]
         schema_differ = SchemaDiffer(
@@ -73,12 +72,12 @@ class TestSchemaDiffer(TestCase):
         name_column = Varchar()
         name_column._meta.name = "name"
 
-        schema: t.List[DiffableTable] = [
+        schema: list[DiffableTable] = [
             DiffableTable(
                 class_name="Act", tablename="act", columns=[name_column]
             )
         ]
-        schema_snapshot: t.List[DiffableTable] = [
+        schema_snapshot: list[DiffableTable] = [
             DiffableTable(
                 class_name="Band", tablename="band", columns=[name_column]
             )
@@ -101,7 +100,7 @@ class TestSchemaDiffer(TestCase):
         """
         Testing changing the schema.
         """
-        schema: t.List[DiffableTable] = [
+        schema: list[DiffableTable] = [
             DiffableTable(
                 class_name="Band",
                 tablename="band",
@@ -109,7 +108,7 @@ class TestSchemaDiffer(TestCase):
                 schema="schema_1",
             )
         ]
-        schema_snapshot: t.List[DiffableTable] = [
+        schema_snapshot: list[DiffableTable] = [
             DiffableTable(
                 class_name="Band",
                 tablename="band",
@@ -142,14 +141,14 @@ class TestSchemaDiffer(TestCase):
         genre_column = Varchar()
         genre_column._meta.name = "genre"
 
-        schema: t.List[DiffableTable] = [
+        schema: list[DiffableTable] = [
             DiffableTable(
                 class_name="Band",
                 tablename="band",
                 columns=[name_column, genre_column],
             )
         ]
-        schema_snapshot: t.List[DiffableTable] = [
+        schema_snapshot: list[DiffableTable] = [
             DiffableTable(
                 class_name="Band",
                 tablename="band",
@@ -177,14 +176,14 @@ class TestSchemaDiffer(TestCase):
         genre_column = Varchar()
         genre_column._meta.name = "genre"
 
-        schema: t.List[DiffableTable] = [
+        schema: list[DiffableTable] = [
             DiffableTable(
                 class_name="Band",
                 tablename="band",
                 columns=[name_column],
             )
         ]
-        schema_snapshot: t.List[DiffableTable] = [
+        schema_snapshot: list[DiffableTable] = [
             DiffableTable(
                 class_name="Band",
                 tablename="band",
@@ -213,14 +212,14 @@ class TestSchemaDiffer(TestCase):
         title_column = Varchar()
         title_column._meta.name = "title"
 
-        schema_snapshot: t.List[DiffableTable] = [
+        schema_snapshot: list[DiffableTable] = [
             DiffableTable(
                 class_name="Band",
                 tablename="band",
                 columns=[title_column],
             )
         ]
-        schema: t.List[DiffableTable] = [
+        schema: list[DiffableTable] = [
             DiffableTable(
                 class_name="Band",
                 tablename="band",
@@ -278,14 +277,14 @@ class TestSchemaDiffer(TestCase):
         b2 = Varchar()
         b2._meta.name = "b2"
 
-        schema_snapshot: t.List[DiffableTable] = [
+        schema_snapshot: list[DiffableTable] = [
             DiffableTable(
                 class_name="Band",
                 tablename="band",
                 columns=[a1, b1],
             )
         ]
-        schema: t.List[DiffableTable] = [
+        schema: list[DiffableTable] = [
             DiffableTable(
                 class_name="Band",
                 tablename="band",
@@ -355,14 +354,14 @@ class TestSchemaDiffer(TestCase):
         b2 = Varchar()
         b2._meta.name = "b2"
 
-        schema_snapshot: t.List[DiffableTable] = [
+        schema_snapshot: list[DiffableTable] = [
             DiffableTable(
                 class_name="Band",
                 tablename="band",
                 columns=[a1, b1],
             )
         ]
-        schema: t.List[DiffableTable] = [
+        schema: list[DiffableTable] = [
             DiffableTable(
                 class_name="Band",
                 tablename="band",
@@ -425,14 +424,14 @@ class TestSchemaDiffer(TestCase):
         price_2 = Numeric(digits=(5, 2))
         price_2._meta.name = "price"
 
-        schema: t.List[DiffableTable] = [
+        schema: list[DiffableTable] = [
             DiffableTable(
                 class_name="Ticket",
                 tablename="ticket",
                 columns=[price_1],
             )
         ]
-        schema_snapshot: t.List[DiffableTable] = [
+        schema_snapshot: list[DiffableTable] = [
             DiffableTable(
                 class_name="Ticket",
                 tablename="ticket",
@@ -463,14 +462,14 @@ class TestSchemaDiffer(TestCase):
         price_2 = Numeric(digits=(5, 2), db_column_name="custom")
         price_2._meta.name = "price"
 
-        schema: t.List[DiffableTable] = [
+        schema: list[DiffableTable] = [
             DiffableTable(
                 class_name="Ticket",
                 tablename="ticket",
                 columns=[price_1],
             )
         ]
-        schema_snapshot: t.List[DiffableTable] = [
+        schema_snapshot: list[DiffableTable] = [
             DiffableTable(
                 class_name="Ticket",
                 tablename="ticket",

tests/apps/migrations/commands/test_forwards_backwards.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import sys
-import typing as t
+from typing import TYPE_CHECKING
 from unittest import TestCase
 from unittest.mock import MagicMock, call, patch
 
@@ -22,10 +22,10 @@ from tests.example_apps.music.tables import (
     Venue,
 )
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.table import Table
 
-TABLE_CLASSES: t.List[t.Type[Table]] = [
+TABLE_CLASSES: list[type[Table]] = [
     Manager,
     Band,
     Venue,

tests/columns/m2m/base.py

@@ -1,4 +1,4 @@
-import typing as t
+from typing import Optional
 
 from piccolo.columns.column_types import (
     ForeignKey,
@@ -41,7 +41,7 @@ class M2MBase:
     (public vs non-public).
     """
 
-    def _setUp(self, schema: t.Optional[str] = None):
+    def _setUp(self, schema: Optional[str] = None):
         self.schema = schema
 
         for table_class in (Band, Genre, GenreToBand):

tests/columns/test_array.py

@@ -186,7 +186,7 @@ class TestArray(TableTest):
     @pytest.mark.cockroach_array_slow
     def test_cat(self):
         """
-        Make sure values can be appended to an array.
+        Make sure values can be appended to an array and that we can concatenate two arrays.
 
         In CockroachDB <= v22.2.0 we had this error:
 
@@ -197,37 +197,47 @@ class TestArray(TableTest):
         * https://github.com/piccolo-orm/piccolo/issues/1005
 
         """  # noqa: E501
-        MyTable(value=[1, 1, 1]).save().run_sync()
+        MyTable(value=[5]).save().run_sync()
 
         MyTable.update(
-            {MyTable.value: MyTable.value.cat([2])}, force=True
+            {MyTable.value: MyTable.value.cat([6])}, force=True
         ).run_sync()
 
         self.assertEqual(
             MyTable.select(MyTable.value).run_sync(),
-            [{"value": [1, 1, 1, 2]}],
+            [{"value": [5, 6]}],
         )
 
-        # Try plus symbol
+        # Try plus symbol - add array to the end
 
         MyTable.update(
-            {MyTable.value: MyTable.value + [3]}, force=True
+            {MyTable.value: MyTable.value + [7]}, force=True
         ).run_sync()
 
         self.assertEqual(
             MyTable.select(MyTable.value).run_sync(),
-            [{"value": [1, 1, 1, 2, 3]}],
+            [{"value": [5, 6, 7]}],
         )
 
-        # Make sure non-list values work
+        # Add array to the start
+
+        MyTable.update(
+            {MyTable.value: [4] + MyTable.value}, force=True
+        ).run_sync()
+
+        self.assertEqual(
+            MyTable.select(MyTable.value).run_sync(),
+            [{"value": [4, 5, 6, 7]}],
+        )
 
+        # Add array to the start and end
         MyTable.update(
-            {MyTable.value: MyTable.value + 4}, force=True
+            {MyTable.value: [3] + MyTable.value + [8]}, force=True
         ).run_sync()
 
         self.assertEqual(
             MyTable.select(MyTable.value).run_sync(),
-            [{"value": [1, 1, 1, 2, 3, 4]}],
+            [{"value": [3, 4, 5, 6, 7, 8]}],
         )
 
     @sqlite_only
@@ -238,11 +248,167 @@ class TestArray(TableTest):
         with self.assertRaises(ValueError) as manager:
             MyTable.value.cat([2])
 
+        self.assertEqual(
+            str(manager.exception),
+            "Only Postgres and Cockroach support array concatenation.",
+        )
+
+    @engines_skip("sqlite")
+    @pytest.mark.cockroach_array_slow
+    def test_prepend(self):
+        """
+        Make sure values can be added to the beginning of the array.
+
+        In CockroachDB <= v22.2.0 we had this error:
+
+        * https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+
+        In newer CockroachDB versions, it runs but is very slow:
+
+        * https://github.com/piccolo-orm/piccolo/issues/1005
+
+        """  # noqa: E501
+        MyTable(value=[1, 1, 1]).save().run_sync()
+
+        MyTable.update(
+            {MyTable.value: MyTable.value.prepend(3)}, force=True
+        ).run_sync()
+
+        self.assertEqual(
+            MyTable.select(MyTable.value).run_sync(),
+            [{"value": [3, 1, 1, 1]}],
+        )
+
+    @sqlite_only
+    def test_prepend_sqlite(self):
+        """
+        If using SQLite then an exception should be raised currently.
+        """
+        with self.assertRaises(ValueError) as manager:
+            MyTable.value.prepend(2)
+
+        self.assertEqual(
+            str(manager.exception),
+            "Only Postgres and Cockroach support array prepending.",
+        )
+
+    @engines_skip("sqlite")
+    @pytest.mark.cockroach_array_slow
+    def test_append(self):
+        """
+        Make sure values can be appended to an array.
+
+        In CockroachDB <= v22.2.0 we had this error:
+
+        * https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+
+        In newer CockroachDB versions, it runs but is very slow:
+
+        * https://github.com/piccolo-orm/piccolo/issues/1005
+
+        """  # noqa: E501
+        MyTable(value=[1, 1, 1]).save().run_sync()
+
+        MyTable.update(
+            {MyTable.value: MyTable.value.append(3)}, force=True
+        ).run_sync()
+
+        self.assertEqual(
+            MyTable.select(MyTable.value).run_sync(),
+            [{"value": [1, 1, 1, 3]}],
+        )
+
+    @sqlite_only
+    def test_append_sqlite(self):
+        """
+        If using SQLite then an exception should be raised currently.
+        """
+        with self.assertRaises(ValueError) as manager:
+            MyTable.value.append(2)
+
         self.assertEqual(
             str(manager.exception),
             "Only Postgres and Cockroach support array appending.",
         )
 
+    @engines_skip("sqlite")
+    @pytest.mark.cockroach_array_slow
+    def test_replace(self):
+        """
+        Make sure values can be swapped in the array.
+
+        In CockroachDB <= v22.2.0 we had this error:
+
+        * https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+
+        In newer CockroachDB versions, it runs but is very slow:
+
+        * https://github.com/piccolo-orm/piccolo/issues/1005
+
+        """  # noqa: E501
+        MyTable(value=[1, 1, 1]).save().run_sync()
+
+        MyTable.update(
+            {MyTable.value: MyTable.value.replace(1, 2)}, force=True
+        ).run_sync()
+
+        self.assertEqual(
+            MyTable.select(MyTable.value).run_sync(),
+            [{"value": [2, 2, 2]}],
+        )
+
+    @sqlite_only
+    def test_replace_sqlite(self):
+        """
+        If using SQLite then an exception should be raised currently.
+        """
+        with self.assertRaises(ValueError) as manager:
+            MyTable.value.replace(1, 2)
+
+        self.assertEqual(
+            str(manager.exception),
+            "Only Postgres and Cockroach support array substitution.",
+        )
+
+    @engines_skip("sqlite")
+    @pytest.mark.cockroach_array_slow
+    def test_remove(self):
+        """
+        Make sure values can be removed from an array.
+
+        In CockroachDB <= v22.2.0 we had this error:
+
+        * https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+
+        In newer CockroachDB versions, it runs but is very slow:
+
+        * https://github.com/piccolo-orm/piccolo/issues/1005
+
+        """  # noqa: E501
+        MyTable(value=[1, 2, 3]).save().run_sync()
+
+        MyTable.update(
+            {MyTable.value: MyTable.value.remove(2)}, force=True
+        ).run_sync()
+
+        self.assertEqual(
+            MyTable.select(MyTable.value).run_sync(),
+            [{"value": [1, 3]}],
+        )
+
+    @sqlite_only
+    def test_remove_sqlite(self):
+        """
+        If using SQLite then an exception should be raised currently.
+        """
+        with self.assertRaises(ValueError) as manager:
+            MyTable.value.remove(2)
+
+        self.assertEqual(
+            str(manager.exception),
+            "Only Postgres and Cockroach support array removing.",
+        )
+
 
 ###############################################################################
 # Date and time arrays

tests/columns/test_boolean.py

@@ -1,4 +1,4 @@
-import typing as t
+from typing import Any
 
 from piccolo.columns.column_types import Boolean
 from piccolo.table import Table
@@ -14,9 +14,7 @@ class TestBoolean(TableTest):
 
     def test_return_type(self) -> None:
         for value in (True, False, None, ...):
-            kwargs: t.Dict[str, t.Any] = (
-                {} if value is ... else {"boolean": value}
-            )
+            kwargs: dict[str, Any] = {} if value is ... else {"boolean": value}
             expected = MyTable.boolean.default if value is ... else value
 
             row = MyTable(**kwargs)

tests/columns/test_combination.py

@@ -1,6 +1,6 @@
 import unittest
 
-from tests.example_apps.music.tables import Band
+from tests.example_apps.music.tables import Band, Concert
 
 
 class TestWhere(unittest.TestCase):
@@ -29,6 +29,20 @@ class TestWhere(unittest.TestCase):
         with self.assertRaises(ValueError):
             Band.name.is_in([])
 
+    def test_is_in_subquery(self):
+        _where = Band.id.is_in(
+            Concert.select(Concert.band_1).where(Concert.band_1 == 1)
+        )
+        sql = _where.__str__()
+        self.assertEqual(
+            sql,
+            '"band"."id" IN (SELECT ALL "concert"."band_1" AS "band_1" FROM "concert" WHERE "concert"."band_1" = 1)',  # noqa: E501
+        )
+
+        # a sub select must only return a single column
+        with self.assertRaises(ValueError):
+            Band.id.is_in(Concert.select().where(Concert.band_1 == 1))
+
     def test_not_in(self):
         _where = Band.name.not_in(["CSharps"])
         sql = _where.__str__()
@@ -37,6 +51,20 @@ class TestWhere(unittest.TestCase):
         with self.assertRaises(ValueError):
             Band.name.not_in([])
 
+    def test_not_in_subquery(self):
+        _where = Band.id.not_in(
+            Concert.select(Concert.band_1).where(Concert.band_1 == 1)
+        )
+        sql = _where.__str__()
+        self.assertEqual(
+            sql,
+            '"band"."id" NOT IN (SELECT ALL "concert"."band_1" AS "band_1" FROM "concert" WHERE "concert"."band_1" = 1)',  # noqa: E501
+        )
+
+        # a sub select must only return a single column
+        with self.assertRaises(ValueError):
+            Band.id.not_in(Concert.select().where(Concert.band_1 == 1))
+
 
 class TestAnd(unittest.TestCase):
     def test_get_column_values(self):

tests/columns/test_db_column_name.py

@@ -1,4 +1,4 @@
-import typing as t
+from typing import Optional
 
 from piccolo.columns.column_types import ForeignKey, Integer, Serial, Varchar
 from piccolo.table import Table, create_db_tables_sync, drop_db_tables_sync
@@ -35,7 +35,7 @@ class TestDBColumnName(DBTestCase):
     def tearDown(self):
         drop_db_tables_sync(Band, Manager)
 
-    def insert_band(self, manager: t.Optional[Manager] = None) -> Band:
+    def insert_band(self, manager: Optional[Manager] = None) -> Band:
         band = Band(name="Pythonistas", popularity=1000, manager=manager)
         band.save().run_sync()
         return band

tests/engine/test_extra_nodes.py

@@ -1,4 +1,4 @@
-import typing as t
+from typing import cast
 from unittest import TestCase
 from unittest.mock import MagicMock
 
@@ -19,7 +19,7 @@ class TestExtraNodes(TestCase):
         test_engine = engine_finder()
         assert test_engine is not None
 
-        test_engine = t.cast(PostgresEngine, test_engine)
+        test_engine = cast(PostgresEngine, test_engine)
 
         EXTRA_NODE = MagicMock(spec=PostgresEngine(config=test_engine.config))
         EXTRA_NODE.run_querystring = AsyncMock(return_value=[])

tests/engine/test_pool.py

@@ -1,7 +1,7 @@
 import asyncio
 import os
 import tempfile
-import typing as t
+from typing import cast
 from unittest import TestCase
 from unittest.mock import call, patch
 
@@ -14,7 +14,7 @@ from tests.example_apps.music.tables import Manager
 @engines_only("postgres", "cockroach")
 class TestPool(DBTestCase):
     async def _create_pool(self) -> None:
-        engine = t.cast(PostgresEngine, Manager._meta.db)
+        engine = cast(PostgresEngine, Manager._meta.db)
 
         await engine.start_connection_pool()
         assert engine.pool is not None
@@ -72,7 +72,7 @@ class TestPool(DBTestCase):
 @engines_only("postgres", "cockroach")
 class TestPoolProxyMethods(DBTestCase):
     async def _create_pool(self) -> None:
-        engine = t.cast(PostgresEngine, Manager._meta.db)
+        engine = cast(PostgresEngine, Manager._meta.db)
 
         # Deliberate typo ('nnn'):
         await engine.start_connnection_pool()

tests/engine/test_transaction.py

@@ -1,5 +1,5 @@
 import asyncio
-import typing as t
+from typing import cast
 from unittest import TestCase
 
 import pytest
@@ -169,7 +169,7 @@ class TestTransactionExists(TestCase):
         """
         Make sure we can detect when code is within a transaction.
         """
-        engine = t.cast(SQLiteEngine, Manager._meta.db)
+        engine = cast(SQLiteEngine, Manager._meta.db)
 
         async def run_inside_transaction():
             async with engine.transaction():
@@ -198,7 +198,7 @@ class TestTransactionType(TestCase):
 
         https://github.com/piccolo-orm/piccolo/issues/687
         """
-        engine = t.cast(SQLiteEngine, Manager._meta.db)
+        engine = cast(SQLiteEngine, Manager._meta.db)
 
         async def run_transaction(name: str):
             async with engine.transaction(
@@ -234,7 +234,7 @@ class TestTransactionType(TestCase):
         """
         Similar to above, but with ``Atomic``.
         """
-        engine = t.cast(SQLiteEngine, Manager._meta.db)
+        engine = cast(SQLiteEngine, Manager._meta.db)
 
         async def run_atomic(name: str):
             atomic = engine.atomic(transaction_type=TransactionType.immediate)

tests/query/test_freeze.py

@@ -1,6 +1,6 @@
 import timeit
-import typing as t
 from dataclasses import dataclass
+from typing import Any, Union
 from unittest import mock
 
 from piccolo.columns import Integer, Varchar
@@ -12,8 +12,8 @@ from tests.example_apps.music.tables import Band
 
 @dataclass
 class QueryResponse:
-    query: t.Union[Query, FrozenQuery]
-    response: t.Any
+    query: Union[Query, FrozenQuery]
+    response: Any
 
 
 class TestFreeze(DBTestCase):
@@ -23,7 +23,7 @@ class TestFreeze(DBTestCase):
         """
         self.insert_rows()
 
-        query_responses: t.List[QueryResponse] = [
+        query_responses: list[QueryResponse] = [
             QueryResponse(
                 query=(
                     Band.select(Band.name)

tests/table/instance/test_get_related.py

@@ -1,4 +1,4 @@
-import typing as t
+from typing import cast
 
 from piccolo.testing.test_case import AsyncTableTest
 from tests.example_apps.music.tables import Band, Concert, Manager, Venue
@@ -52,7 +52,7 @@ class TestGetRelated(AsyncTableTest):
         """
         Make sure it also works using a string representation of a foreign key.
         """
-        manager = t.cast(Manager, await self.band.get_related("manager"))
+        manager = cast(Manager, await self.band.get_related("manager"))
         self.assertTrue(manager.id == self.manager.id)
 
     async def test_invalid_string(self):