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

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_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_update.py

@@ -1,6 +1,6 @@
 import dataclasses
 import datetime
-import typing as t
+from typing import Any
 from unittest import TestCase
 
 import pytest
@@ -181,9 +181,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 = [

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/utils/test_pydantic.py

@@ -1,5 +1,5 @@
 import decimal
-import typing as t
+from typing import Optional, cast
 from unittest import TestCase
 
 import pydantic
@@ -138,7 +138,7 @@ class TestArrayColumn(TestCase):
 
         self.assertEqual(
             pydantic_model.model_fields["members"].annotation,
-            t.List[t.List[pydantic.constr(max_length=255)]],
+            list[list[pydantic.constr(max_length=255)]],
         )
 
         # Should not raise a validation error:
@@ -630,8 +630,8 @@ class TestNestedModel(TestCase):
 
         #######################################################################
 
-        ManagerModel = t.cast(
-            t.Type[pydantic.BaseModel],
+        ManagerModel = cast(
+            type[pydantic.BaseModel],
             BandModel.model_fields["manager"].annotation,
         )
         self.assertTrue(issubclass(ManagerModel, pydantic.BaseModel))
@@ -641,8 +641,8 @@ class TestNestedModel(TestCase):
 
         #######################################################################
 
-        CountryModel = t.cast(
-            t.Type[pydantic.BaseModel],
+        CountryModel = cast(
+            type[pydantic.BaseModel],
             ManagerModel.model_fields["country"].annotation,
         )
         self.assertTrue(issubclass(CountryModel, pydantic.BaseModel))
@@ -681,8 +681,8 @@ class TestNestedModel(TestCase):
 
         BandModel = create_pydantic_model(table=Band, nested=(Band.manager,))
 
-        ManagerModel = t.cast(
-            t.Type[pydantic.BaseModel],
+        ManagerModel = cast(
+            type[pydantic.BaseModel],
             BandModel.model_fields["manager"].annotation,
         )
         self.assertTrue(issubclass(ManagerModel, pydantic.BaseModel))
@@ -694,7 +694,7 @@ class TestNestedModel(TestCase):
         AssistantManagerType = BandModel.model_fields[
             "assistant_manager"
         ].annotation
-        self.assertIs(AssistantManagerType, t.Optional[int])
+        self.assertIs(AssistantManagerType, Optional[int])
 
         #######################################################################
         # Test two levels deep
@@ -703,8 +703,8 @@ class TestNestedModel(TestCase):
             table=Band, nested=(Band.manager._.country,)
         )
 
-        ManagerModel = t.cast(
-            t.Type[pydantic.BaseModel],
+        ManagerModel = cast(
+            type[pydantic.BaseModel],
             BandModel.model_fields["manager"].annotation,
         )
         self.assertTrue(issubclass(ManagerModel, pydantic.BaseModel))
@@ -713,14 +713,14 @@ class TestNestedModel(TestCase):
         )
         self.assertEqual(ManagerModel.__qualname__, "Band.manager")
 
-        AssistantManagerType = t.cast(
-            t.Type[pydantic.BaseModel],
+        AssistantManagerType = cast(
+            type[pydantic.BaseModel],
             BandModel.model_fields["assistant_manager"].annotation,
         )
-        self.assertIs(AssistantManagerType, t.Optional[int])
+        self.assertIs(AssistantManagerType, Optional[int])
 
-        CountryModel = t.cast(
-            t.Type[pydantic.BaseModel],
+        CountryModel = cast(
+            type[pydantic.BaseModel],
             ManagerModel.model_fields["country"].annotation,
         )
         self.assertTrue(issubclass(CountryModel, pydantic.BaseModel))
@@ -737,10 +737,10 @@ class TestNestedModel(TestCase):
         )
 
         VenueModel = ConcertModel.model_fields["venue"].annotation
-        self.assertIs(VenueModel, t.Optional[int])
+        self.assertIs(VenueModel, Optional[int])
 
-        BandModel = t.cast(
-            t.Type[pydantic.BaseModel],
+        BandModel = cast(
+            type[pydantic.BaseModel],
             ConcertModel.model_fields["band_1"].annotation,
         )
         self.assertTrue(issubclass(BandModel, pydantic.BaseModel))
@@ -750,8 +750,8 @@ class TestNestedModel(TestCase):
         )
         self.assertEqual(BandModel.__qualname__, "Concert.band_1")
 
-        ManagerModel = t.cast(
-            t.Type[pydantic.BaseModel],
+        ManagerModel = cast(
+            type[pydantic.BaseModel],
             BandModel.model_fields["manager"].annotation,
         )
         self.assertTrue(issubclass(ManagerModel, pydantic.BaseModel))
@@ -764,10 +764,10 @@ class TestNestedModel(TestCase):
         AssistantManagerType = BandModel.model_fields[
             "assistant_manager"
         ].annotation
-        self.assertIs(AssistantManagerType, t.Optional[int])
+        self.assertIs(AssistantManagerType, Optional[int])
 
         CountryModel = ManagerModel.model_fields["country"].annotation
-        self.assertIs(CountryModel, t.Optional[int])
+        self.assertIs(CountryModel, Optional[int])
 
         #######################################################################
         # Test with `model_name` arg
@@ -778,8 +778,8 @@ class TestNestedModel(TestCase):
             model_name="MyConcertModel",
         )
 
-        BandModel = t.cast(
-            t.Type[pydantic.BaseModel],
+        BandModel = cast(
+            type[pydantic.BaseModel],
             MyConcertModel.model_fields["band_1"].annotation,
         )
         self.assertEqual(BandModel.__qualname__, "MyConcertModel.band_1")
@@ -810,8 +810,8 @@ class TestNestedModel(TestCase):
             table=Band, nested=True, include_default_columns=True
         )
 
-        ManagerModel = t.cast(
-            t.Type[pydantic.BaseModel],
+        ManagerModel = cast(
+            type[pydantic.BaseModel],
             BandModel.model_fields["manager"].annotation,
         )
         self.assertTrue(issubclass(ManagerModel, pydantic.BaseModel))
@@ -820,8 +820,8 @@ class TestNestedModel(TestCase):
             ["id", "name", "country"],
         )
 
-        CountryModel = t.cast(
-            t.Type[pydantic.BaseModel],
+        CountryModel = cast(
+            type[pydantic.BaseModel],
             ManagerModel.model_fields["country"].annotation,
         )
         self.assertTrue(issubclass(CountryModel, pydantic.BaseModel))
@@ -855,27 +855,27 @@ class TestRecursionDepth(TestCase):
             table=Concert, nested=True, max_recursion_depth=2
         )
 
-        VenueModel = t.cast(
-            t.Type[pydantic.BaseModel],
+        VenueModel = cast(
+            type[pydantic.BaseModel],
             ConcertModel.model_fields["venue"].annotation,
         )
         self.assertTrue(issubclass(VenueModel, pydantic.BaseModel))
 
-        BandModel = t.cast(
-            t.Type[pydantic.BaseModel],
+        BandModel = cast(
+            type[pydantic.BaseModel],
             ConcertModel.model_fields["band"].annotation,
         )
         self.assertTrue(issubclass(BandModel, pydantic.BaseModel))
 
-        ManagerModel = t.cast(
-            t.Type[pydantic.BaseModel],
+        ManagerModel = cast(
+            type[pydantic.BaseModel],
             BandModel.model_fields["manager"].annotation,
         )
         self.assertTrue(issubclass(ManagerModel, pydantic.BaseModel))
 
         # We should have hit the recursion depth:
         CountryModel = ManagerModel.model_fields["country"].annotation
-        self.assertIs(CountryModel, t.Optional[int])
+        self.assertIs(CountryModel, Optional[int])
 
 
 class TestDBColumnName(TestCase):

tests/utils/test_table_reflection.py

@@ -1,4 +1,3 @@
-import typing as t
 from unittest import TestCase
 
 from piccolo.columns import Varchar
@@ -22,7 +21,7 @@ class TestTableStorage(TestCase):
             table_class.alter().drop_table(if_exists=True).run_sync()
 
     def _compare_table_columns(
-        self, table_1: t.Type[Table], table_2: t.Type[Table]
+        self, table_1: type[Table], table_2: type[Table]
     ):
         """
         Make sure that for each column in table_1, there is a corresponding