piccolo 1.27.1__py3-none-any.whl → 1.29.0__py3-none-any.whl

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):

tests/table/test_alter.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import typing as t
+from typing import Any, Union
 from unittest import TestCase
 
 import pytest
@@ -26,7 +26,7 @@ from tests.example_apps.music.tables import Band, Manager
 class TestRenameColumn(DBTestCase):
     def _test_rename(
         self,
-        existing_column: t.Union[Column, str],
+        existing_column: Union[Column, str],
         new_column_name: str = "rating",
     ):
         self.insert_row()
@@ -90,7 +90,7 @@ class TestDropColumn(DBTestCase):
     SQLite has very limited support for ALTER statements.
     """
 
-    def _test_drop(self, column: t.Union[str, Column]):
+    def _test_drop(self, column: Union[str, Column]):
         self.insert_row()
 
         Band.alter().drop_column(column).run_sync()
@@ -109,7 +109,7 @@ class TestDropColumn(DBTestCase):
 
 class TestAddColumn(DBTestCase):
     def _test_add_column(
-        self, column: Column, column_name: str, expected_value: t.Any
+        self, column: Column, column_name: str, expected_value: Any
     ):
         self.insert_row()
         Band.alter().add_column(column_name, column).run_sync()

tests/table/test_indexes.py

@@ -1,4 +1,3 @@
-import typing as t
 from unittest import TestCase
 
 from piccolo.columns.base import Column
@@ -52,7 +51,7 @@ class TestProblematicColumnName(TestCase):
         Make sure we can add an index to a column with a problematic name
         (which clashes with a SQL keyword).
         """
-        columns: t.List[Column] = [Concert.order]
+        columns: list[Column] = [Concert.order]
         Concert.create_index(columns=columns).run_sync()
         index_name = Concert._get_index_name([i._meta.name for i in columns])
 

tests/table/test_metaclass.py

@@ -1,13 +1,13 @@
 from unittest import TestCase
 from unittest.mock import MagicMock, patch
 
-from piccolo.columns import Secret
 from piccolo.columns.column_types import (
     JSON,
     JSONB,
     Array,
     Email,
     ForeignKey,
+    Secret,
     Varchar,
 )
 from piccolo.table import TABLENAME_WARNING, Table
@@ -99,14 +99,18 @@ class TestMetaClass(TestCase):
 
     def test_secret_columns(self):
         """
-        Make sure TableMeta.secret_columns are setup correctly.
+        Make sure TableMeta.secret_columns are setup correctly with the
+        ``secret=True`` argument and ``Secret`` column type.
         """
 
         class Classified(Table):
             top_secret = Secret()
+            confidential = Varchar(secret=True)
+            public = Varchar()
 
         self.assertEqual(
-            Classified._meta.secret_columns, [Classified.top_secret]
+            Classified._meta.secret_columns,
+            [Classified.top_secret, Classified.confidential],
         )
 
     def test_json_columns(self):

tests/table/test_refresh.py

@@ -1,4 +1,4 @@
-import typing as t
+from typing import cast
 
 from piccolo.testing.test_case import TableTest
 from tests.base import DBTestCase
@@ -293,6 +293,6 @@ class TestRefreshWithLoadJSON(TableTest):
         self.recording_studio.refresh(load_json=True).run_sync()
 
         self.assertDictEqual(
-            t.cast(dict, self.recording_studio.facilities),
+            cast(dict, self.recording_studio.facilities),
             {"electric piano": True},
         )

tests/table/test_select.py

@@ -258,6 +258,64 @@ class TestSelect(DBTestCase):
 
         self.assertEqual(response, [{"name": "Rustaceans"}])
 
+    def test_is_in(self):
+        self.insert_rows()
+
+        response = (
+            Band.select(Band.name)
+            .where(Band.manager._.name.is_in(["Guido"]))
+            .run_sync()
+        )
+
+        self.assertListEqual(response, [{"name": "Pythonistas"}])
+
+    def test_is_in_subquery(self):
+        self.insert_rows()
+
+        # This is a contrived example, just for testing.
+        response = (
+            Band.select(Band.name)
+            .where(
+                Band.manager.is_in(
+                    Manager.select(Manager.id).where(Manager.name == "Guido")
+                )
+            )
+            .run_sync()
+        )
+
+        self.assertListEqual(response, [{"name": "Pythonistas"}])
+
+    def test_not_in(self):
+        self.insert_rows()
+
+        response = (
+            Band.select(Band.name)
+            .where(Band.manager._.name.not_in(["Guido"]))
+            .run_sync()
+        )
+
+        self.assertListEqual(
+            response, [{"name": "Rustaceans"}, {"name": "CSharps"}]
+        )
+
+    def test_not_in_subquery(self):
+        self.insert_rows()
+
+        # This is a contrived example, just for testing.
+        response = (
+            Band.select(Band.name)
+            .where(
+                Band.manager.not_in(
+                    Manager.select(Manager.id).where(Manager.name == "Guido")
+                )
+            )
+            .run_sync()
+        )
+
+        self.assertListEqual(
+            response, [{"name": "Rustaceans"}, {"name": "CSharps"}]
+        )
+
     def test_where_is_null(self):
         self.insert_rows()
 

tests/table/test_str.py

@@ -1,30 +1,20 @@
 from unittest import TestCase
 
-from tests.base import engine_is
-from tests.example_apps.music.tables import Manager
+from piccolo.apps.playground.commands.run import Genre, Manager
 
 
 class TestTableStr(TestCase):
-    def test_str(self):
-        if engine_is("cockroach"):
-            self.assertEqual(
-                Manager._table_str(),
-                (
-                    "class Manager(Table, tablename='manager'):\n"
-                    "    id = Serial(null=False, primary_key=True, unique=False, index=False, index_method=IndexMethod.btree, choices=None, db_column_name='id', secret=False)\n"  # noqa: E501
-                    "    name = Varchar(length=50, default='', null=False, primary_key=False, unique=False, index=False, index_method=IndexMethod.btree, choices=None, db_column_name=None, secret=False)\n"  # noqa: E501
-                ),
-            )
-        else:
-            self.assertEqual(
-                Manager._table_str(),
-                (
-                    "class Manager(Table, tablename='manager'):\n"
-                    "    id = Serial(null=False, primary_key=True, unique=False, index=False, index_method=IndexMethod.btree, choices=None, db_column_name='id', secret=False)\n"  # noqa: E501
-                    "    name = Varchar(length=50, default='', null=False, primary_key=False, unique=False, index=False, index_method=IndexMethod.btree, choices=None, db_column_name=None, secret=False)\n"  # noqa: E501
-                ),
-            )
+    def test_all_attributes(self):
+        self.assertEqual(
+            Manager._table_str(),
+            (
+                "class Manager(Table, tablename='manager'):\n"
+                "    id = Serial(null=False, primary_key=True, unique=False, index=False, index_method=IndexMethod.btree, choices=None, db_column_name='id', secret=False)\n"  # noqa: E501
+                "    name = Varchar(length=50, default='', null=False, primary_key=False, unique=False, index=False, index_method=IndexMethod.btree, choices=None, db_column_name=None, secret=False)\n"  # noqa: E501
+            ),
+        )
 
+    def test_abbreviated(self):
         self.assertEqual(
             Manager._table_str(abbreviated=True),
             (
@@ -34,5 +24,23 @@ class TestTableStr(TestCase):
             ),
         )
 
-        # We should also be able to print it directly.
+    def test_m2m(self):
+        """
+        Make sure M2M relationships appear in the Table string.
+        """
+
+        self.assertEqual(
+            Genre._table_str(abbreviated=True),
+            (
+                "class Genre(Table):\n"
+                "    id = Serial()\n"
+                "    name = Varchar()\n"
+                "    bands = M2M(GenreToBand)\n"
+            ),
+        )
+
+    def test_print(self):
+        """
+        Make sure we can print it directly without any errors.
+        """
         print(Manager)

tests/table/test_update.py

@@ -1,6 +1,6 @@
 import dataclasses
 import datetime
-import typing as t
+from typing import Any
 from unittest import TestCase
 
 import pytest
@@ -158,6 +158,7 @@ class TestUpdate(DBTestCase):
 
 class MyTable(Table):
     integer = Integer(null=True)
+    other_integer = Integer(null=True, default=5)
     timestamp = Timestamp(null=True)
     timestamptz = Timestamptz(null=True)
     date = Date(null=True)
@@ -181,9 +182,9 @@ DATE_DELTA = datetime.timedelta(days=1)
 class OperatorTestCase:
     description: str
     column: Column
-    initial: t.Any
+    initial: Any
     querystring: QueryString
-    expected: t.Any
+    expected: Any
 
 
 TEST_CASES = [
@@ -295,6 +296,20 @@ TEST_CASES = [
         querystring=2000 - MyTable.integer,
         expected=1000,
     ),
+    OperatorTestCase(
+        description="Subtract Integer Columns",
+        column=MyTable.integer,
+        initial=1000,
+        querystring=MyTable.integer - MyTable.other_integer,
+        expected=995,
+    ),
+    OperatorTestCase(
+        description="Add Integer Columns",
+        column=MyTable.integer,
+        initial=1000,
+        querystring=MyTable.integer + MyTable.other_integer,
+        expected=1005,
+    ),
     OperatorTestCase(
         description="Multiply Integer",
         column=MyTable.integer,

tests/testing/test_model_builder.py

@@ -1,6 +1,5 @@
 import asyncio
 import json
-import typing as t
 import unittest
 
 from piccolo.columns import (
@@ -83,7 +82,7 @@ class TestModelBuilder(unittest.TestCase):
         drop_db_tables_sync(*TABLES)
 
     def test_async(self):
-        async def build_model(table_class: t.Type[Table]):
+        async def build_model(table_class: type[Table]):
             return await ModelBuilder.build(table_class)
 
         for table_class in TABLES:

tests/testing/test_random_builder.py

@@ -1,3 +1,4 @@
+import decimal
 import unittest
 from enum import Enum
 
@@ -35,6 +36,10 @@ class TestRandomBuilder(unittest.TestCase):
         random_float = RandomBuilder.next_float(maximum=1000)
         self.assertLessEqual(random_float, 1000)
 
+    def test_next_decimal(self):
+        random_decimal = RandomBuilder.next_decimal(precision=4, scale=2)
+        self.assertLessEqual(random_decimal, decimal.Decimal("99.99"))
+
     def test_next_int(self):
         random_int = RandomBuilder.next_int()
         self.assertLessEqual(random_int, 2147483647)