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

piccolo/columns/combination.py

@@ -1,17 +1,17 @@
 from __future__ import annotations
 
-import typing as t
+from typing import TYPE_CHECKING, Any, Union
 
 from piccolo.columns.operators.comparison import (
     ComparisonOperator,
     Equal,
     IsNull,
 )
-from piccolo.custom_types import Combinable, Iterable
+from piccolo.custom_types import Combinable, CustomIterable
 from piccolo.querystring import QueryString
 from piccolo.utils.sql_values import convert_to_sql_value
 
-if t.TYPE_CHECKING:
+if TYPE_CHECKING:
     from piccolo.columns.base import Column
 
 
@@ -59,7 +59,7 @@ class Combination(CombinableMixin):
 class And(Combination):
     operator = "AND"
 
-    def get_column_values(self) -> t.Dict[Column, t.Any]:
+    def get_column_values(self) -> dict[Column, Any]:
         """
         This is used by `get_or_create` to know which values to assign if
         the row doesn't exist in the database.
@@ -109,7 +109,7 @@ UNDEFINED = Undefined()
 class WhereRaw(CombinableMixin):
     __slots__ = ("querystring",)
 
-    def __init__(self, sql: str, *args: t.Any) -> None:
+    def __init__(self, sql: str, *args: Any) -> None:
         """
         Execute raw SQL queries in your where clause. Use with caution!
 
@@ -145,9 +145,9 @@ class Where(CombinableMixin):
     def __init__(
         self,
         column: Column,
-        value: t.Any = UNDEFINED,
-        values: t.Union[Iterable, Undefined] = UNDEFINED,
-        operator: t.Type[ComparisonOperator] = ComparisonOperator,
+        value: Any = UNDEFINED,
+        values: Union[CustomIterable, Undefined, QueryString] = UNDEFINED,
+        operator: type[ComparisonOperator] = ComparisonOperator,
     ) -> None:
         """
         We use the UNDEFINED value to show the value was deliberately
@@ -156,14 +156,14 @@ class Where(CombinableMixin):
         self.column = column
 
         self.value = value if value == UNDEFINED else self.clean_value(value)
-        if values == UNDEFINED:
+        if (values == UNDEFINED) or isinstance(values, QueryString):
             self.values = values
         else:
             self.values = [self.clean_value(i) for i in values]  # type: ignore
 
         self.operator = operator
 
-    def clean_value(self, value: t.Any) -> t.Any:
+    def clean_value(self, value: Any) -> Any:
         """
         If a where clause contains a ``Table`` instance, we should convert that
         to a column reference. For example:
@@ -192,6 +192,9 @@ class Where(CombinableMixin):
     def values_querystring(self) -> QueryString:
         values = self.values
 
+        if isinstance(values, QueryString):
+            return values
+
         if isinstance(values, Undefined):
             raise ValueError("values is undefined")
 
@@ -200,7 +203,7 @@ class Where(CombinableMixin):
 
     @property
     def querystring(self) -> QueryString:
-        args: t.List[t.Any] = []
+        args: list[Any] = []
         if self.value != UNDEFINED:
             args.append(self.value)
 
@@ -219,7 +222,7 @@ class Where(CombinableMixin):
 
     @property
     def querystring_for_update_and_delete(self) -> QueryString:
-        args: t.List[t.Any] = []
+        args: list[Any] = []
         if self.value != UNDEFINED:
             args.append(self.value)
 

piccolo/columns/defaults/base.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-import typing as t
 from abc import ABC, abstractmethod
+from typing import Any
 
 from piccolo.utils.repr import repr_class_instance
 
@@ -18,10 +18,10 @@ class Default(ABC):
         pass
 
     @abstractmethod
-    def python(self) -> t.Any:
+    def python(self) -> Any:
         pass
 
-    def get_postgres_interval_string(self, attributes: t.List[str]) -> str:
+    def get_postgres_interval_string(self, attributes: list[str]) -> str:
         """
         Returns a string usable as an interval argument in Postgres e.g.
         "1 day 2 hour".
@@ -39,7 +39,7 @@ class Default(ABC):
 
         return " ".join(interval_components)
 
-    def get_sqlite_interval_string(self, attributes: t.List[str]) -> str:
+    def get_sqlite_interval_string(self, attributes: list[str]) -> str:
         """
         Returns a string usable as an interval argument in SQLite e.g.
         "'-2 hours', '1 days'".

piccolo/columns/defaults/date.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import datetime
-import typing as t
+from collections.abc import Callable
 from enum import Enum
+from typing import Union
 
 from .base import Default
 
@@ -102,14 +103,14 @@ class DateCustom(Default):
 
 
 # Might add an enum back which encapsulates all of the options.
-DateArg = t.Union[
+DateArg = Union[
     DateOffset,
     DateCustom,
     DateNow,
     Enum,
     None,
     datetime.date,
-    t.Callable[[], datetime.date],
+    Callable[[], datetime.date],
 ]
 
 

piccolo/columns/defaults/interval.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import datetime
-import typing as t
+from collections.abc import Callable
 from enum import Enum
+from typing import Union
 
 from .base import Default
 
@@ -75,12 +76,12 @@ class IntervalCustom(Default):
 
 ###############################################################################
 
-IntervalArg = t.Union[
+IntervalArg = Union[
     IntervalCustom,
     Enum,
     None,
     datetime.timedelta,
-    t.Callable[[], datetime.timedelta],
+    Callable[[], datetime.timedelta],
 ]
 
 

piccolo/columns/defaults/time.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import datetime
-import typing as t
+from collections.abc import Callable
 from enum import Enum
+from typing import Union
 
 from .base import Default
 
@@ -89,14 +90,14 @@ class TimeCustom(Default):
         )
 
 
-TimeArg = t.Union[
+TimeArg = Union[
     TimeCustom,
     TimeNow,
     TimeOffset,
     Enum,
     None,
     datetime.time,
-    t.Callable[[], datetime.time],
+    Callable[[], datetime.time],
 ]
 
 

piccolo/columns/defaults/timestamp.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import datetime
-import typing as t
+from collections.abc import Callable
 from enum import Enum
+from typing import Union
 
 from .base import Default
 
@@ -134,7 +135,7 @@ class DatetimeDefault:
 
 ###############################################################################
 
-TimestampArg = t.Union[
+TimestampArg = Union[
     TimestampCustom,
     TimestampNow,
     TimestampOffset,
@@ -142,7 +143,7 @@ TimestampArg = t.Union[
     None,
     datetime.datetime,
     DatetimeDefault,
-    t.Callable[[], datetime.datetime],
+    Callable[[], datetime.datetime],
 ]
 
 

piccolo/columns/defaults/timestamptz.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import datetime
-import typing as t
+from collections.abc import Callable
 from enum import Enum
+from typing import Union
 
 from .timestamp import TimestampCustom, TimestampNow, TimestampOffset
 
@@ -68,14 +69,14 @@ class TimestamptzCustom(TimestampCustom):
         )
 
 
-TimestamptzArg = t.Union[
+TimestamptzArg = Union[
     TimestamptzCustom,
     TimestamptzNow,
     TimestamptzOffset,
     Enum,
     None,
     datetime.datetime,
-    t.Callable[[], datetime.datetime],
+    Callable[[], datetime.datetime],
 ]
 
 

piccolo/columns/defaults/uuid.py

@@ -1,6 +1,7 @@
-import typing as t
 import uuid
+from collections.abc import Callable
 from enum import Enum
+from typing import Union
 
 from .base import Default
 
@@ -22,7 +23,7 @@ class UUID4(Default):
         return uuid.uuid4()
 
 
-UUIDArg = t.Union[UUID4, uuid.UUID, str, Enum, None, t.Callable[[], uuid.UUID]]
+UUIDArg = Union[UUID4, uuid.UUID, str, Enum, None, Callable[[], uuid.UUID]]
 
 
 __all__ = ["UUIDArg", "UUID4"]

piccolo/columns/m2m.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import inspect
-import typing as t
+from collections.abc import Sequence
 from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 from piccolo.columns.column_types import (
     JSON,
@@ -15,7 +16,7 @@ from piccolo.querystring import QueryString, Selectable
 from piccolo.utils.list import flatten
 from piccolo.utils.sync import run_sync
 
-if t.TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.table import Table
 
 
@@ -151,12 +152,12 @@ class M2MSelect(Selectable):
 
 @dataclass
 class M2MMeta:
-    joining_table: t.Union[t.Type[Table], LazyTableReference]
-    _foreign_key_columns: t.Optional[t.List[ForeignKey]] = None
+    joining_table: Union[type[Table], LazyTableReference]
+    _foreign_key_columns: Optional[list[ForeignKey]] = None
 
     # Set by the Table Metaclass:
-    _name: t.Optional[str] = None
-    _table: t.Optional[t.Type[Table]] = None
+    _name: Optional[str] = None
+    _table: Optional[type[Table]] = None
 
     @property
     def name(self) -> str:
@@ -167,7 +168,7 @@ class M2MMeta:
         return self._name
 
     @property
-    def table(self) -> t.Type[Table]:
+    def table(self) -> type[Table]:
         if not self._table:
             raise ValueError(
                 "`_table` isn't defined - the Table Metaclass should set it."
@@ -175,7 +176,7 @@ class M2MMeta:
         return self._table
 
     @property
-    def resolved_joining_table(self) -> t.Type[Table]:
+    def resolved_joining_table(self) -> type[Table]:
         """
         Evaluates the ``joining_table`` attribute if it's a
         ``LazyTableReference``, raising a ``ValueError`` if it fails, otherwise
@@ -196,7 +197,7 @@ class M2MMeta:
             )
 
     @property
-    def foreign_key_columns(self) -> t.List[ForeignKey]:
+    def foreign_key_columns(self) -> list[ForeignKey]:
         if not self._foreign_key_columns:
             self._foreign_key_columns = (
                 self.resolved_joining_table._meta.foreign_key_columns[:2]
@@ -236,7 +237,7 @@ class M2MMeta:
         raise ValueError("No matching foreign key column found!")
 
     @property
-    def primary_table(self) -> t.Type[Table]:
+    def primary_table(self) -> type[Table]:
         return self.primary_foreign_key._foreign_key_meta.resolved_references
 
     @property
@@ -251,7 +252,7 @@ class M2MMeta:
         raise ValueError("No matching foreign key column found!")
 
     @property
-    def secondary_table(self) -> t.Type[Table]:
+    def secondary_table(self) -> type[Table]:
         return self.secondary_foreign_key._foreign_key_meta.resolved_references
 
 
@@ -259,11 +260,11 @@ class M2MMeta:
 class M2MAddRelated:
     target_row: Table
     m2m: M2M
-    rows: t.Sequence[Table]
-    extra_column_values: t.Dict[t.Union[Column, str], t.Any]
+    rows: Sequence[Table]
+    extra_column_values: dict[Union[Column, str], Any]
 
     @property
-    def resolved_extra_column_values(self) -> t.Dict[str, t.Any]:
+    def resolved_extra_column_values(self) -> dict[str, Any]:
         return {
             i._meta.name if isinstance(i, Column) else i: j
             for i, j in self.extra_column_values.items()
@@ -327,7 +328,7 @@ class M2MAddRelated:
 class M2MRemoveRelated:
     target_row: Table
     m2m: M2M
-    rows: t.Sequence[Table]
+    rows: Sequence[Table]
 
     async def run(self):
         fk = self.m2m._meta.secondary_foreign_key
@@ -372,24 +373,16 @@ class M2MGetRelated:
 
         secondary_table = self.m2m._meta.secondary_table
 
-        # TODO - replace this with a subquery in the future.
-        ids = (
-            await joining_table.select(
-                getattr(
-                    self.m2m._meta.secondary_foreign_key,
-                    secondary_table._meta.primary_key._meta.name,
-                )
-            )
-            .where(self.m2m._meta.primary_foreign_key == self.row)
-            .output(as_list=True)
-        )
-
-        results = (
-            await secondary_table.objects().where(
-                secondary_table._meta.primary_key.is_in(ids)
+        # use a subquery to make only one db query
+        results = await secondary_table.objects().where(
+            secondary_table._meta.primary_key.is_in(
+                joining_table.select(
+                    getattr(
+                        self.m2m._meta.secondary_foreign_key,
+                        secondary_table._meta.primary_key._meta.name,
+                    )
+                ).where(self.m2m._meta.primary_foreign_key == self.row)
             )
-            if len(ids) > 0
-            else []
         )
 
         return results
@@ -404,8 +397,8 @@ class M2MGetRelated:
 class M2M:
     def __init__(
         self,
-        joining_table: t.Union[t.Type[Table], LazyTableReference],
-        foreign_key_columns: t.Optional[t.List[ForeignKey]] = None,
+        joining_table: Union[type[Table], LazyTableReference],
+        foreign_key_columns: Optional[list[ForeignKey]] = None,
     ):
         """
         :param joining_table:
@@ -428,7 +421,7 @@ class M2M:
 
     def __call__(
         self,
-        *columns: t.Union[Column, t.List[Column]],
+        *columns: Union[Column, list[Column]],
         as_list: bool = False,
         load_json: bool = False,
     ) -> M2MSelect:

piccolo/columns/readable.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
-import typing as t
+from collections.abc import Sequence
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
 from piccolo.querystring import QueryString, Selectable
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.columns.base import Column
 
 
@@ -18,7 +19,7 @@ class Readable(Selectable):
     """
 
     template: str
-    columns: t.Sequence[Column]
+    columns: Sequence[Column]
     output_name: str = "readable"
 
     @property

piccolo/columns/reference.py

@@ -6,10 +6,10 @@ from __future__ import annotations
 
 import importlib
 import inspect
-import typing as t
 from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Optional
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.columns.column_types import ForeignKey
     from piccolo.table import Table
 
@@ -36,8 +36,8 @@ class LazyTableReference:
     """
 
     table_class_name: str
-    app_name: t.Optional[str] = None
-    module_path: t.Optional[str] = None
+    app_name: Optional[str] = None
+    module_path: Optional[str] = None
 
     def __post_init__(self):
         if self.app_name is None and self.module_path is None:
@@ -49,7 +49,7 @@ class LazyTableReference:
                 "Specify either app_name or module_path - not both."
             )
 
-    def resolve(self) -> t.Type[Table]:
+    def resolve(self) -> type[Table]:
         if self.app_name is not None:
             from piccolo.conf.apps import Finder
 
@@ -60,7 +60,7 @@ class LazyTableReference:
 
         if self.module_path:
             module = importlib.import_module(self.module_path)
-            table: t.Optional[t.Type[Table]] = getattr(
+            table: Optional[type[Table]] = getattr(
                 module, self.table_class_name, None
             )
 
@@ -91,9 +91,9 @@ class LazyTableReference:
 
 @dataclass
 class LazyColumnReferenceStore:
-    foreign_key_columns: t.List[ForeignKey] = field(default_factory=list)
+    foreign_key_columns: list[ForeignKey] = field(default_factory=list)
 
-    def for_table(self, table: t.Type[Table]) -> t.List[ForeignKey]:
+    def for_table(self, table: type[Table]) -> list[ForeignKey]:
         return [
             i
             for i in self.foreign_key_columns
@@ -101,7 +101,7 @@ class LazyColumnReferenceStore:
             and i._foreign_key_meta.references.resolve() is table
         ]
 
-    def for_tablename(self, tablename: str) -> t.List[ForeignKey]:
+    def for_tablename(self, tablename: str) -> list[ForeignKey]:
         return [
             i
             for i in self.foreign_key_columns