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

piccolo/query/mixins.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 import asyncio
 import collections.abc
 import itertools
-import typing as t
+from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
 from enum import Enum, auto
+from typing import TYPE_CHECKING, Any, Literal, Optional, Union
 
 from piccolo.columns import And, Column, Or, Where
 from piccolo.columns.column_types import ForeignKey
@@ -15,7 +16,7 @@ from piccolo.querystring import QueryString
 from piccolo.utils.list import flatten
 from piccolo.utils.sql_values import convert_to_sql_value
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.querystring import Selectable
     from piccolo.table import Table  # noqa
 
@@ -33,7 +34,7 @@ class Distinct:
     __slots__ = ("enabled", "on")
 
     enabled: bool
-    on: t.Optional[t.Sequence[Column]]
+    on: Optional[Sequence[Column]]
 
     @property
     def querystring(self) -> QueryString:
@@ -152,17 +153,17 @@ class OrderByRaw:
 class OrderByItem:
     __slots__ = ("columns", "ascending")
 
-    columns: t.Sequence[t.Union[Column, OrderByRaw]]
+    columns: Sequence[Union[Column, OrderByRaw]]
     ascending: bool
 
 
 @dataclass
 class OrderBy:
-    order_by_items: t.List[OrderByItem] = field(default_factory=list)
+    order_by_items: list[OrderByItem] = field(default_factory=list)
 
     @property
     def querystring(self) -> QueryString:
-        order_by_strings: t.List[str] = []
+        order_by_strings: list[str] = []
         for order_by_item in self.order_by_items:
             order = "ASC" if order_by_item.ascending else "DESC"
             for column in order_by_item.columns:
@@ -185,7 +186,7 @@ class OrderBy:
 class Returning:
     __slots__ = ("columns",)
 
-    columns: t.List[Column]
+    columns: list[Column]
 
     @property
     def querystring(self) -> QueryString:
@@ -230,13 +231,13 @@ class CallbackType(Enum):
 @dataclass
 class Callback:
     kind: CallbackType
-    target: t.Callable
+    target: Callable
 
 
 @dataclass
 class WhereDelegate:
-    _where: t.Optional[Combinable] = None
-    _where_columns: t.List[Column] = field(default_factory=list)
+    _where: Optional[Combinable] = None
+    _where_columns: list[Column] = field(default_factory=list)
 
     def get_where_columns(self):
         """
@@ -257,7 +258,7 @@ class WhereDelegate:
         elif isinstance(combinable, WhereRaw):
             self._where_columns.extend(combinable.querystring.columns)
 
-    def where(self, *where: t.Union[Combinable, QueryString]):
+    def where(self, *where: Union[Combinable, QueryString]):
         for arg in where:
             if isinstance(arg, bool):
                 raise ValueError(
@@ -278,7 +279,7 @@ class WhereDelegate:
 class OrderByDelegate:
     _order_by: OrderBy = field(default_factory=OrderBy)
 
-    def get_order_by_columns(self) -> t.List[Column]:
+    def get_order_by_columns(self) -> list[Column]:
         """
         Used to work out which columns are needed for joins.
         """
@@ -290,7 +291,7 @@ class OrderByDelegate:
             if isinstance(i, Column)
         ]
 
-    def order_by(self, *columns: t.Union[Column, OrderByRaw], ascending=True):
+    def order_by(self, *columns: Union[Column, OrderByRaw], ascending=True):
         if len(columns) < 1:
             raise ValueError("At least one column must be passed to order_by.")
 
@@ -301,7 +302,7 @@ class OrderByDelegate:
 
 @dataclass
 class LimitDelegate:
-    _limit: t.Optional[Limit] = None
+    _limit: Optional[Limit] = None
     _first: bool = False
 
     def limit(self, number: int):
@@ -319,7 +320,7 @@ class AsOfDelegate:
     Currently supports Cockroach using AS OF SYSTEM TIME.
     """
 
-    _as_of: t.Optional[AsOf] = None
+    _as_of: Optional[AsOf] = None
 
     def as_of(self, interval: str = "-1s"):
         self._as_of = AsOf(interval)
@@ -331,9 +332,7 @@ class DistinctDelegate:
         default_factory=lambda: Distinct(enabled=False, on=None)
     )
 
-    def distinct(
-        self, enabled: bool, on: t.Optional[t.Sequence[Column]] = None
-    ):
+    def distinct(self, enabled: bool, on: Optional[Sequence[Column]] = None):
         if on and not isinstance(on, collections.abc.Sequence):
             # Check a sequence is passed in, otherwise the user will get some
             # unuseful errors later on.
@@ -344,9 +343,9 @@ class DistinctDelegate:
 
 @dataclass
 class ReturningDelegate:
-    _returning: t.Optional[Returning] = None
+    _returning: Optional[Returning] = None
 
-    def returning(self, columns: t.Sequence[Column]):
+    def returning(self, columns: Sequence[Column]):
         self._returning = Returning(columns=list(columns))
 
 
@@ -360,9 +359,9 @@ class CountDelegate:
 
 @dataclass
 class AddDelegate:
-    _add: t.List[Table] = field(default_factory=list)
+    _add: list[Table] = field(default_factory=list)
 
-    def add(self, *instances: Table, table_class: t.Type[Table]):
+    def add(self, *instances: Table, table_class: type[Table]):
         for instance in instances:
             if not isinstance(instance, table_class):
                 raise TypeError("Incompatible type added.")
@@ -384,10 +383,10 @@ class OutputDelegate:
 
     def output(
         self,
-        as_list: t.Optional[bool] = None,
-        as_json: t.Optional[bool] = None,
-        load_json: t.Optional[bool] = None,
-        nested: t.Optional[bool] = None,
+        as_list: Optional[bool] = None,
+        as_json: Optional[bool] = None,
+        load_json: Optional[bool] = None,
+        nested: Optional[bool] = None,
     ):
         """
         :param as_list:
@@ -429,13 +428,13 @@ class CallbackDelegate:
     .callback([handler1, handler2])
     """
 
-    _callbacks: t.Dict[CallbackType, t.List[Callback]] = field(
+    _callbacks: dict[CallbackType, list[Callback]] = field(
         default_factory=lambda: {kind: [] for kind in CallbackType}
     )
 
     def callback(
         self,
-        callbacks: t.Union[t.Callable, t.List[t.Callable]],
+        callbacks: Union[Callable, list[Callable]],
         *,
         on: CallbackType,
     ):
@@ -446,7 +445,7 @@ class CallbackDelegate:
         else:
             self._callbacks[on].append(Callback(kind=on, target=callbacks))
 
-    async def invoke(self, results: t.Any, *, kind: CallbackType) -> t.Any:
+    async def invoke(self, results: Any, *, kind: CallbackType) -> Any:
         """
         Utility function that invokes the registered callbacks in the correct
         way, handling both sync and async callbacks. Only callbacks of the
@@ -472,9 +471,9 @@ class PrefetchDelegate:
     .prefetch(MyTable.column_a, MyTable.column_b)
     """
 
-    fk_columns: t.List[ForeignKey] = field(default_factory=list)
+    fk_columns: list[ForeignKey] = field(default_factory=list)
 
-    def prefetch(self, *fk_columns: t.Union[ForeignKey, t.List[ForeignKey]]):
+    def prefetch(self, *fk_columns: Union[ForeignKey, list[ForeignKey]]):
         """
         :param columns:
             We accept ``ForeignKey`` and ``List[ForeignKey]`` here, in case
@@ -482,7 +481,7 @@ class PrefetchDelegate:
             in which case we flatten the list.
 
         """
-        _fk_columns: t.List[ForeignKey] = []
+        _fk_columns: list[ForeignKey] = []
         for column in fk_columns:
             if isinstance(column, list):
                 _fk_columns.extend(column)
@@ -501,9 +500,9 @@ class ColumnsDelegate:
     .columns(MyTable.column_a, MyTable.column_b)
     """
 
-    selected_columns: t.Sequence[Selectable] = field(default_factory=list)
+    selected_columns: Sequence[Selectable] = field(default_factory=list)
 
-    def columns(self, *columns: t.Union[Selectable, t.List[Selectable]]):
+    def columns(self, *columns: Union[Selectable, list[Selectable]]):
         """
         :param columns:
             We accept ``Selectable`` and ``List[Selectable]`` here, in case
@@ -531,10 +530,10 @@ class ValuesDelegate:
     Used to specify new column values - primarily used in update queries.
     """
 
-    table: t.Type[Table]
-    _values: t.Dict[Column, t.Any] = field(default_factory=dict)
+    table: type[Table]
+    _values: dict[Column, Any] = field(default_factory=dict)
 
-    def values(self, values: t.Dict[t.Union[Column, str], t.Any]):
+    def values(self, values: dict[Union[Column, str], Any]):
         """
         Example usage:
 
@@ -549,7 +548,7 @@ class ValuesDelegate:
             .values(column_a=1})
 
         """
-        cleaned_values: t.Dict[Column, t.Any] = {}
+        cleaned_values: dict[Column, Any] = {}
         for key, value in values.items():
             if isinstance(key, Column):
                 column = key
@@ -564,7 +563,7 @@ class ValuesDelegate:
 
         self._values.update(cleaned_values)
 
-    def get_sql_values(self) -> t.List[t.Any]:
+    def get_sql_values(self) -> list[Any]:
         """
         Convert any Enums into values, and serialise any JSON.
         """
@@ -587,7 +586,7 @@ class OffsetDelegate:
 
     """
 
-    _offset: t.Optional[Offset] = None
+    _offset: Optional[Offset] = None
 
     def offset(self, number: int = 0):
         self._offset = Offset(number)
@@ -597,7 +596,7 @@ class OffsetDelegate:
 class GroupBy:
     __slots__ = ("columns",)
 
-    columns: t.Sequence[Column]
+    columns: Sequence[Column]
 
     @property
     def querystring(self) -> QueryString:
@@ -620,7 +619,7 @@ class GroupByDelegate:
 
     """
 
-    _group_by: t.Optional[GroupBy] = None
+    _group_by: Optional[GroupBy] = None
 
     def group_by(self, *columns: Column):
         self._group_by = GroupBy(columns=columns)
@@ -637,12 +636,10 @@ class OnConflictAction(str, Enum):
 
 @dataclass
 class OnConflictItem:
-    target: t.Optional[t.Union[str, Column, t.Tuple[Column, ...]]] = None
-    action: t.Optional[OnConflictAction] = None
-    values: t.Optional[t.Sequence[t.Union[Column, t.Tuple[Column, t.Any]]]] = (
-        None
-    )
-    where: t.Optional[Combinable] = None
+    target: Optional[Union[str, Column, tuple[Column, ...]]] = None
+    action: Optional[OnConflictAction] = None
+    values: Optional[Sequence[Union[Column, tuple[Column, Any]]]] = None
+    where: Optional[Combinable] = None
 
     @property
     def target_string(self) -> str:
@@ -726,7 +723,7 @@ class OnConflict:
     parent class.
     """
 
-    on_conflict_items: t.List[OnConflictItem] = field(default_factory=list)
+    on_conflict_items: list[OnConflictItem] = field(default_factory=list)
 
     @property
     def querystring(self) -> QueryString:
@@ -757,14 +754,12 @@ class OnConflictDelegate:
 
     def on_conflict(
         self,
-        target: t.Optional[t.Union[str, Column, t.Tuple[Column, ...]]] = None,
-        action: t.Union[
-            OnConflictAction, t.Literal["DO NOTHING", "DO UPDATE"]
+        target: Optional[Union[str, Column, tuple[Column, ...]]] = None,
+        action: Union[
+            OnConflictAction, Literal["DO NOTHING", "DO UPDATE"]
         ] = OnConflictAction.do_nothing,
-        values: t.Optional[
-            t.Sequence[t.Union[Column, t.Tuple[Column, t.Any]]]
-        ] = None,
-        where: t.Optional[Combinable] = None,
+        values: Optional[Sequence[Union[Column, tuple[Column, Any]]]] = None,
+        where: Optional[Combinable] = None,
     ):
         action_: OnConflictAction
         if isinstance(action, OnConflictAction):
@@ -806,7 +801,7 @@ class LockRows:
     lock_strength: LockStrength
     nowait: bool
     skip_locked: bool
-    of: t.Tuple[t.Type[Table], ...]
+    of: tuple[type[Table], ...]
 
     def __post_init__(self):
         if not isinstance(self.lock_strength, LockStrength):
@@ -846,13 +841,13 @@ class LockRows:
 @dataclass
 class LockRowsDelegate:
 
-    _lock_rows: t.Optional[LockRows] = None
+    _lock_rows: Optional[LockRows] = None
 
     def lock_rows(
         self,
-        lock_strength: t.Union[
+        lock_strength: Union[
             LockStrength,
-            t.Literal[
+            Literal[
                 "UPDATE",
                 "NO KEY UPDATE",
                 "KEY SHARE",
@@ -861,7 +856,7 @@ class LockRowsDelegate:
         ] = LockStrength.update,
         nowait=False,
         skip_locked=False,
-        of: t.Tuple[type[Table], ...] = (),
+        of: tuple[type[Table], ...] = (),
     ):
         lock_strength_: LockStrength
         if isinstance(lock_strength, LockStrength):

piccolo/query/operators/json.py

@@ -1,17 +1,17 @@
 from __future__ import annotations
 
-import typing as t
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 from piccolo.querystring import QueryString
 from piccolo.utils.encoding import dump_json
 
-if t.TYPE_CHECKING:
+if TYPE_CHECKING:
     from piccolo.columns.column_types import JSON
 
 
 class JSONQueryString(QueryString):
 
-    def clean_value(self, value: t.Any):
+    def clean_value(self, value: Any):
         if not isinstance(value, (str, QueryString)):
             value = dump_json(value)
         return value
@@ -42,9 +42,9 @@ class GetChildElement(JSONQueryString):
 
     def __init__(
         self,
-        identifier: t.Union[JSON, QueryString],
-        key: t.Union[str, int, QueryString],
-        alias: t.Optional[str] = None,
+        identifier: Union[JSON, QueryString],
+        key: Union[str, int, QueryString],
+        alias: Optional[str] = None,
     ):
         if isinstance(key, int):
             # asyncpg only accepts integer keys if we explicitly mark it as an
@@ -53,7 +53,7 @@ class GetChildElement(JSONQueryString):
 
         super().__init__("{} -> {}", identifier, key, alias=alias)
 
-    def arrow(self, key: t.Union[str, int, QueryString]) -> GetChildElement:
+    def arrow(self, key: Union[str, int, QueryString]) -> GetChildElement:
         """
         This allows you to drill multiple levels deep into a JSON object if
         needed.
@@ -77,7 +77,7 @@ class GetChildElement(JSONQueryString):
         return GetChildElement(identifier=self, key=key, alias=self._alias)
 
     def __getitem__(
-        self, value: t.Union[str, int, QueryString]
+        self, value: Union[str, int, QueryString]
     ) -> GetChildElement:
         return GetChildElement(identifier=self, key=value, alias=self._alias)
 
@@ -94,9 +94,9 @@ class GetElementFromPath(JSONQueryString):
 
     def __init__(
         self,
-        identifier: t.Union[JSON, QueryString],
-        path: t.List[t.Union[str, int]],
-        alias: t.Optional[str] = None,
+        identifier: Union[JSON, QueryString],
+        path: list[Union[str, int]],
+        alias: Optional[str] = None,
     ):
         """
         :param path:

piccolo/query/proxy.py

@@ -1,5 +1,6 @@
 import inspect
-import typing as t
+from collections.abc import Generator
+from typing import Generic, Optional, TypeVar
 
 from typing_extensions import Protocol
 
@@ -8,22 +9,20 @@ from piccolo.utils.sync import run_sync
 
 
 class Runnable(Protocol):
-    async def run(
-        self, node: t.Optional[str] = None, in_pool: bool = True
-    ): ...
+    async def run(self, node: Optional[str] = None, in_pool: bool = True): ...
 
 
-QueryType = t.TypeVar("QueryType", bound=Runnable)
-ResponseType = t.TypeVar("ResponseType")
+QueryType = TypeVar("QueryType", bound=Runnable)
+ResponseType = TypeVar("ResponseType")
 
 
-class Proxy(t.Generic[QueryType, ResponseType]):
+class Proxy(Generic[QueryType, ResponseType]):
     def __init__(self, query: QueryType):
         self.query = query
 
     async def run(
         self,
-        node: t.Optional[str] = None,
+        node: Optional[str] = None,
         in_pool: bool = True,
     ) -> ResponseType:
         return await self.query.run(node=node, in_pool=in_pool)
@@ -33,7 +32,7 @@ class Proxy(t.Generic[QueryType, ResponseType]):
 
     def __await__(
         self,
-    ) -> t.Generator[None, None, ResponseType]:
+    ) -> Generator[None, None, ResponseType]:
         """
         If the user doesn't explicity call .run(), proxy to it as a
         convenience.

piccolo/querystring.py

@@ -1,15 +1,16 @@
 from __future__ import annotations
 
-import typing as t
 from abc import ABCMeta, abstractmethod
+from collections.abc import Sequence
 from dataclasses import dataclass
 from datetime import datetime
 from importlib.util import find_spec
 from string import Formatter
+from typing import TYPE_CHECKING, Any, Optional
 
-if t.TYPE_CHECKING:  # pragma: no cover
-    from piccolo.table import Table
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.columns import Column
+    from piccolo.table import Table
 
 from uuid import UUID
 
@@ -26,7 +27,7 @@ class Selectable(metaclass=ABCMeta):
 
     __slots__ = ("_alias",)
 
-    _alias: t.Optional[str]
+    _alias: Optional[str]
 
     @abstractmethod
     def get_select_string(
@@ -74,10 +75,10 @@ class QueryString(Selectable):
     def __init__(
         self,
         template: str,
-        *args: t.Any,
+        *args: Any,
         query_type: str = "generic",
-        table: t.Optional[t.Type[Table]] = None,
-        alias: t.Optional[str] = None,
+        table: Optional[type[Table]] = None,
+        alias: Optional[str] = None,
     ) -> None:
         """
         :param template:
@@ -99,15 +100,13 @@ class QueryString(Selectable):
         self.template = template
         self.query_type = query_type
         self.table = table
-        self._frozen_compiled_strings: t.Optional[
-            t.Tuple[str, t.List[t.Any]]
-        ] = None
+        self._frozen_compiled_strings: Optional[tuple[str, list[Any]]] = None
         self._alias = alias
         self.args, self.columns = self.process_args(args)
 
     def process_args(
-        self, args: t.Sequence[t.Any]
-    ) -> t.Tuple[t.Sequence[t.Any], t.Sequence[Column]]:
+        self, args: Sequence[Any]
+    ) -> tuple[Sequence[Any], Sequence[Column]]:
         """
         If a Column is passed in, we convert it to the name of the column
         (including joins).
@@ -168,8 +167,8 @@ class QueryString(Selectable):
     def bundle(
         self,
         start_index: int = 1,
-        bundled: t.Optional[t.List[Fragment]] = None,
-        combined_args: t.Optional[t.List] = None,
+        bundled: Optional[list[Fragment]] = None,
+        combined_args: Optional[list] = None,
     ):
         # Split up the string, separating by {}.
         fragments = [
@@ -206,7 +205,7 @@ class QueryString(Selectable):
 
     def compile_string(
         self, engine_type: str = "postgres"
-    ) -> t.Tuple[str, t.List[t.Any]]:
+    ) -> tuple[str, list[Any]]:
         """
         Compiles the template ready for the engine - keeping the arguments
         separate from the template.

piccolo/schema.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import abc
-import typing as t
+from typing import Optional, cast
 
 from piccolo.engine.base import Engine
 from piccolo.engine.finder import engine_finder
@@ -110,7 +110,7 @@ class MoveTable(SchemaDDLBase):
         table_name: str,
         new_schema: str,
         db: Engine,
-        current_schema: t.Optional[str] = None,
+        current_schema: Optional[str] = None,
     ):
         self.table_name = table_name
         self.current_schema = current_schema
@@ -131,9 +131,9 @@ class ListTables:
         self.db = db
         self.schema_name = schema_name
 
-    async def run(self) -> t.List[str]:
-        response = t.cast(
-            t.List[t.Dict],
+    async def run(self) -> list[str]:
+        response = cast(
+            list[dict],
             await self.db.run_querystring(
                 QueryString(
                     """
@@ -158,9 +158,9 @@ class ListSchemas:
     def __init__(self, db: Engine):
         self.db = db
 
-    async def run(self) -> t.List[str]:
-        response = t.cast(
-            t.List[t.Dict],
+    async def run(self) -> list[str]:
+        response = cast(
+            list[dict],
             await self.db.run_querystring(
                 QueryString(
                     "SELECT schema_name FROM information_schema.schemata"
@@ -177,7 +177,7 @@ class ListSchemas:
 
 
 class SchemaManager:
-    def __init__(self, db: t.Optional[Engine] = None):
+    def __init__(self, db: Optional[Engine] = None):
         """
         A useful utility class for interacting with schemas.
 
@@ -267,7 +267,7 @@ class SchemaManager:
         self,
         table_name: str,
         new_schema: str,
-        current_schema: t.Optional[str] = None,
+        current_schema: Optional[str] = None,
     ) -> MoveTable:
         """
         Moves a table to a different schema::