piccolo 1.9.0__py3-none-any.whl → 1.11.0__py3-none-any.whl

tests/query/functions/test_datetime.py

@@ -0,0 +1,114 @@
+import datetime
+
+from piccolo.columns import Timestamp
+from piccolo.query.functions.datetime import (
+    Day,
+    Extract,
+    Hour,
+    Minute,
+    Month,
+    Second,
+    Strftime,
+    Year,
+)
+from piccolo.table import Table
+from tests.base import engines_only, sqlite_only
+
+from .base import FunctionTest
+
+
+class Concert(Table):
+    starts = Timestamp()
+
+
+class DatetimeTest(FunctionTest):
+    tables = [Concert]
+
+    def setUp(self) -> None:
+        super().setUp()
+        self.concert = Concert(
+            {
+                Concert.starts: datetime.datetime(
+                    year=2024, month=6, day=14, hour=23, minute=46, second=10
+                )
+            }
+        )
+        self.concert.save().run_sync()
+
+
+@engines_only("postgres", "cockroach")
+class TestExtract(DatetimeTest):
+    def test_extract(self):
+        self.assertEqual(
+            Concert.select(
+                Extract(Concert.starts, "year", alias="starts_year")
+            ).run_sync(),
+            [{"starts_year": self.concert.starts.year}],
+        )
+
+    def test_invalid_format(self):
+        with self.assertRaises(ValueError):
+            Extract(
+                Concert.starts,
+                "abc123",  # type: ignore
+                alias="starts_year",
+            )
+
+
+@sqlite_only
+class TestStrftime(DatetimeTest):
+    def test_strftime(self):
+        self.assertEqual(
+            Concert.select(
+                Strftime(Concert.starts, "%Y", alias="starts_year")
+            ).run_sync(),
+            [{"starts_year": str(self.concert.starts.year)}],
+        )
+
+
+class TestDatabaseAgnostic(DatetimeTest):
+    def test_year(self):
+        self.assertEqual(
+            Concert.select(
+                Year(Concert.starts, alias="starts_year")
+            ).run_sync(),
+            [{"starts_year": self.concert.starts.year}],
+        )
+
+    def test_month(self):
+        self.assertEqual(
+            Concert.select(
+                Month(Concert.starts, alias="starts_month")
+            ).run_sync(),
+            [{"starts_month": self.concert.starts.month}],
+        )
+
+    def test_day(self):
+        self.assertEqual(
+            Concert.select(Day(Concert.starts, alias="starts_day")).run_sync(),
+            [{"starts_day": self.concert.starts.day}],
+        )
+
+    def test_hour(self):
+        self.assertEqual(
+            Concert.select(
+                Hour(Concert.starts, alias="starts_hour")
+            ).run_sync(),
+            [{"starts_hour": self.concert.starts.hour}],
+        )
+
+    def test_minute(self):
+        self.assertEqual(
+            Concert.select(
+                Minute(Concert.starts, alias="starts_minute")
+            ).run_sync(),
+            [{"starts_minute": self.concert.starts.minute}],
+        )
+
+    def test_second(self):
+        self.assertEqual(
+            Concert.select(
+                Second(Concert.starts, alias="starts_second")
+            ).run_sync(),
+            [{"starts_second": self.concert.starts.second}],
+        )

tests/query/functions/test_string.py

@@ -1,10 +1,13 @@
-from piccolo.query.functions.string import Upper
+import pytest
+
+from piccolo.query.functions.string import Concat, Upper
+from tests.base import engine_version_lt, is_running_sqlite
 from tests.example_apps.music.tables import Band
 
 from .base import BandTest
 
 
-class TestUpperFunction(BandTest):
+class TestUpper(BandTest):
 
     def test_column(self):
         """
@@ -23,3 +26,32 @@ class TestUpperFunction(BandTest):
         """
         response = Band.select(Upper(Band.manager._.name)).run_sync()
         self.assertListEqual(response, [{"upper": "GUIDO"}])
+
+
+@pytest.mark.skipif(
+    is_running_sqlite() and engine_version_lt(3.44),
+    reason="SQLite version not supported",
+)
+class TestConcat(BandTest):
+
+    def test_column_and_string(self):
+        response = Band.select(
+            Concat(Band.name, "!!!", alias="name")
+        ).run_sync()
+        self.assertListEqual(response, [{"name": "Pythonistas!!!"}])
+
+    def test_column_and_column(self):
+        response = Band.select(
+            Concat(Band.name, Band.popularity, alias="name")
+        ).run_sync()
+        self.assertListEqual(response, [{"name": "Pythonistas1000"}])
+
+    def test_join(self):
+        response = Band.select(
+            Concat(Band.name, "-", Band.manager._.name, alias="name")
+        ).run_sync()
+        self.assertListEqual(response, [{"name": "Pythonistas-Guido"}])
+
+    def test_min_args(self):
+        with self.assertRaises(ValueError):
+            Concat()

tests/table/test_indexes.py

@@ -1,5 +1,7 @@
+import typing as t
 from unittest import TestCase
 
+from piccolo.columns.base import Column
 from piccolo.columns.column_types import Integer
 from piccolo.table import Table
 from tests.example_apps.music.tables import Manager
@@ -45,12 +47,12 @@ class TestProblematicColumnName(TestCase):
     def tearDown(self):
         Concert.alter().drop_table().run_sync()
 
-    def test_problematic_name(self):
+    def test_problematic_name(self) -> None:
         """
         Make sure we can add an index to a column with a problematic name
         (which clashes with a SQL keyword).
         """
-        columns = [Concert.order]
+        columns: t.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/utils/test_pydantic.py

@@ -274,6 +274,7 @@ class TestUUIDColumn(TestCase):
         # We'll also fetch it from the DB in case the database adapter's UUID
         # is used.
         ticket_from_db = Ticket.objects().first().run_sync()
+        assert ticket_from_db is not None
 
         for ticket_ in (ticket, ticket_from_db):
             json = pydantic_model(**ticket_.to_dict()).model_dump_json()
@@ -368,8 +369,8 @@ class TestJSONColumn(TestCase):
         json_string = '{"code": 12345}'
 
         model_instance = pydantic_model(meta=json_string, meta_b=json_string)
-        self.assertEqual(model_instance.meta, json_string)
-        self.assertEqual(model_instance.meta_b, json_string)
+        self.assertEqual(model_instance.meta, json_string)  # type: ignore
+        self.assertEqual(model_instance.meta_b, json_string)  # type: ignore
 
     def test_deserialize_json(self):
         class Movie(Table):
@@ -384,8 +385,8 @@ class TestJSONColumn(TestCase):
         output = {"code": 12345}
 
         model_instance = pydantic_model(meta=json_string, meta_b=json_string)
-        self.assertEqual(model_instance.meta, output)
-        self.assertEqual(model_instance.meta_b, output)
+        self.assertEqual(model_instance.meta, output)  # type: ignore
+        self.assertEqual(model_instance.meta_b, output)  # type: ignore
 
     def test_validation(self):
         class Movie(Table):
@@ -428,8 +429,8 @@ class TestJSONColumn(TestCase):
         pydantic_model = create_pydantic_model(table=Movie)
         movie = pydantic_model(meta=None, meta_b=None)
 
-        self.assertIsNone(movie.meta)
-        self.assertIsNone(movie.meta_b)
+        self.assertIsNone(movie.meta)  # type: ignore
+        self.assertIsNone(movie.meta_b)  # type: ignore
 
 
 class TestExcludeColumns(TestCase):
@@ -490,7 +491,7 @@ class TestExcludeColumns(TestCase):
         with self.assertRaises(ValueError):
             create_pydantic_model(
                 Computer,
-                exclude_columns=("CPU",),
+                exclude_columns=("CPU",),  # type: ignore
             )
 
     def test_invalid_column_different_table(self):
@@ -629,7 +630,10 @@ class TestNestedModel(TestCase):
 
         #######################################################################
 
-        ManagerModel = BandModel.model_fields["manager"].annotation
+        ManagerModel = t.cast(
+            t.Type[pydantic.BaseModel],
+            BandModel.model_fields["manager"].annotation,
+        )
         self.assertTrue(issubclass(ManagerModel, pydantic.BaseModel))
         self.assertEqual(
             [i for i in ManagerModel.model_fields.keys()], ["name", "country"]
@@ -637,7 +641,10 @@ class TestNestedModel(TestCase):
 
         #######################################################################
 
-        CountryModel = ManagerModel.model_fields["country"].annotation
+        CountryModel = t.cast(
+            t.Type[pydantic.BaseModel],
+            ManagerModel.model_fields["country"].annotation,
+        )
         self.assertTrue(issubclass(CountryModel, pydantic.BaseModel))
         self.assertEqual(
             [i for i in CountryModel.model_fields.keys()], ["name"]
@@ -674,7 +681,10 @@ class TestNestedModel(TestCase):
 
         BandModel = create_pydantic_model(table=Band, nested=(Band.manager,))
 
-        ManagerModel = BandModel.model_fields["manager"].annotation
+        ManagerModel = t.cast(
+            t.Type[pydantic.BaseModel],
+            BandModel.model_fields["manager"].annotation,
+        )
         self.assertTrue(issubclass(ManagerModel, pydantic.BaseModel))
         self.assertEqual(
             [i for i in ManagerModel.model_fields.keys()], ["name", "country"]
@@ -690,22 +700,29 @@ class TestNestedModel(TestCase):
         # Test two levels deep
 
         BandModel = create_pydantic_model(
-            table=Band, nested=(Band.manager.country,)
+            table=Band, nested=(Band.manager._.country,)
         )
 
-        ManagerModel = BandModel.model_fields["manager"].annotation
+        ManagerModel = t.cast(
+            t.Type[pydantic.BaseModel],
+            BandModel.model_fields["manager"].annotation,
+        )
         self.assertTrue(issubclass(ManagerModel, pydantic.BaseModel))
         self.assertEqual(
             [i for i in ManagerModel.model_fields.keys()], ["name", "country"]
         )
         self.assertEqual(ManagerModel.__qualname__, "Band.manager")
 
-        AssistantManagerType = BandModel.model_fields[
-            "assistant_manager"
-        ].annotation
+        AssistantManagerType = t.cast(
+            t.Type[pydantic.BaseModel],
+            BandModel.model_fields["assistant_manager"].annotation,
+        )
         self.assertIs(AssistantManagerType, t.Optional[int])
 
-        CountryModel = ManagerModel.model_fields["country"].annotation
+        CountryModel = t.cast(
+            t.Type[pydantic.BaseModel],
+            ManagerModel.model_fields["country"].annotation,
+        )
         self.assertTrue(issubclass(CountryModel, pydantic.BaseModel))
         self.assertEqual(
             [i for i in CountryModel.model_fields.keys()], ["name"]
@@ -716,13 +733,16 @@ class TestNestedModel(TestCase):
         # Test three levels deep
 
         ConcertModel = create_pydantic_model(
-            Concert, nested=(Concert.band_1.manager,)
+            Concert, nested=(Concert.band_1._.manager,)
         )
 
         VenueModel = ConcertModel.model_fields["venue"].annotation
         self.assertIs(VenueModel, t.Optional[int])
 
-        BandModel = ConcertModel.model_fields["band_1"].annotation
+        BandModel = t.cast(
+            t.Type[pydantic.BaseModel],
+            ConcertModel.model_fields["band_1"].annotation,
+        )
         self.assertTrue(issubclass(BandModel, pydantic.BaseModel))
         self.assertEqual(
             [i for i in BandModel.model_fields.keys()],
@@ -730,7 +750,10 @@ class TestNestedModel(TestCase):
         )
         self.assertEqual(BandModel.__qualname__, "Concert.band_1")
 
-        ManagerModel = BandModel.model_fields["manager"].annotation
+        ManagerModel = t.cast(
+            t.Type[pydantic.BaseModel],
+            BandModel.model_fields["manager"].annotation,
+        )
         self.assertTrue(issubclass(ManagerModel, pydantic.BaseModel))
         self.assertEqual(
             [i for i in ManagerModel.model_fields.keys()],
@@ -751,11 +774,14 @@ class TestNestedModel(TestCase):
 
         MyConcertModel = create_pydantic_model(
             Concert,
-            nested=(Concert.band_1.manager,),
+            nested=(Concert.band_1._.manager,),
             model_name="MyConcertModel",
         )
 
-        BandModel = MyConcertModel.model_fields["band_1"].annotation
+        BandModel = t.cast(
+            t.Type[pydantic.BaseModel],
+            MyConcertModel.model_fields["band_1"].annotation,
+        )
         self.assertEqual(BandModel.__qualname__, "MyConcertModel.band_1")
 
         ManagerModel = BandModel.model_fields["manager"].annotation
@@ -763,7 +789,7 @@ class TestNestedModel(TestCase):
             ManagerModel.__qualname__, "MyConcertModel.band_1.manager"
         )
 
-    def test_cascaded_args(self):
+    def test_cascaded_args(self) -> None:
         """
         Make sure that arguments passed to ``create_pydantic_model`` are
         cascaded to nested models.
@@ -784,14 +810,20 @@ class TestNestedModel(TestCase):
             table=Band, nested=True, include_default_columns=True
         )
 
-        ManagerModel = BandModel.model_fields["manager"].annotation
+        ManagerModel = t.cast(
+            t.Type[pydantic.BaseModel],
+            BandModel.model_fields["manager"].annotation,
+        )
         self.assertTrue(issubclass(ManagerModel, pydantic.BaseModel))
         self.assertEqual(
             [i for i in ManagerModel.model_fields.keys()],
             ["id", "name", "country"],
         )
 
-        CountryModel = ManagerModel.model_fields["country"].annotation
+        CountryModel = t.cast(
+            t.Type[pydantic.BaseModel],
+            ManagerModel.model_fields["country"].annotation,
+        )
         self.assertTrue(issubclass(CountryModel, pydantic.BaseModel))
         self.assertEqual(
             [i for i in CountryModel.model_fields.keys()], ["id", "name"]
@@ -823,13 +855,22 @@ class TestRecursionDepth(TestCase):
             table=Concert, nested=True, max_recursion_depth=2
         )
 
-        VenueModel = ConcertModel.model_fields["venue"].annotation
+        VenueModel = t.cast(
+            t.Type[pydantic.BaseModel],
+            ConcertModel.model_fields["venue"].annotation,
+        )
         self.assertTrue(issubclass(VenueModel, pydantic.BaseModel))
 
-        BandModel = ConcertModel.model_fields["band"].annotation
+        BandModel = t.cast(
+            t.Type[pydantic.BaseModel],
+            ConcertModel.model_fields["band"].annotation,
+        )
         self.assertTrue(issubclass(BandModel, pydantic.BaseModel))
 
-        ManagerModel = BandModel.model_fields["manager"].annotation
+        ManagerModel = t.cast(
+            t.Type[pydantic.BaseModel],
+            BandModel.model_fields["manager"].annotation,
+        )
         self.assertTrue(issubclass(ManagerModel, pydantic.BaseModel))
 
         # We should have hit the recursion depth:
@@ -851,7 +892,7 @@ class TestDBColumnName(TestCase):
 
         model = BandModel(regrettable_column_name="test")
 
-        self.assertEqual(model.name, "test")
+        self.assertEqual(model.name, "test")  # type: ignore
 
 
 class TestJSONSchemaExtra(TestCase):
@@ -885,7 +926,7 @@ class TestPydanticExtraFields(TestCase):
         config: pydantic.config.ConfigDict = {"extra": "forbid"}
         model = create_pydantic_model(Band, pydantic_config=config)
 
-        self.assertEqual(model.model_config["extra"], "forbid")
+        self.assertEqual(model.model_config.get("extra"), "forbid")
 
     def test_pydantic_invalid_extra_fields(self) -> None:
         """