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

piccolo/query/methods/drop_index.py

@@ -1,20 +1,21 @@
 from __future__ import annotations
 
-import typing as t
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Union
 
 from piccolo.columns.base import Column
 from piccolo.query.base import Query
 from piccolo.querystring import QueryString
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.table import Table
 
 
 class DropIndex(Query):
     def __init__(
         self,
-        table: t.Type[Table],
-        columns: t.Union[t.List[Column], t.List[str]],
+        table: type[Table],
+        columns: Union[list[Column], list[str]],
         if_exists: bool = True,
         **kwargs,
     ):
@@ -23,13 +24,13 @@ class DropIndex(Query):
         super().__init__(table, **kwargs)
 
     @property
-    def column_names(self) -> t.List[str]:
+    def column_names(self) -> list[str]:
         return [
             i._meta.name if isinstance(i, Column) else i for i in self.columns
         ]
 
     @property
-    def default_querystrings(self) -> t.Sequence[QueryString]:
+    def default_querystrings(self) -> Sequence[QueryString]:
         column_names = self.column_names
         index_name = self.table._get_index_name(column_names)
         query = "DROP INDEX"

piccolo/query/methods/exists.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-import typing as t
+from collections.abc import Sequence
+from typing import TypeVar, Union
 
 from piccolo.custom_types import Combinable, TableInstance
 from piccolo.query.base import Query
@@ -12,11 +13,11 @@ from piccolo.querystring import QueryString
 class Exists(Query[TableInstance, bool]):
     __slots__ = ("where_delegate",)
 
-    def __init__(self, table: t.Type[TableInstance], **kwargs):
+    def __init__(self, table: type[TableInstance], **kwargs):
         super().__init__(table, **kwargs)
         self.where_delegate = WhereDelegate()
 
-    def where(self: Self, *where: t.Union[Combinable, QueryString]) -> Self:
+    def where(self: Self, *where: Union[Combinable, QueryString]) -> Self:
         self.where_delegate.where(*where)
         return self
 
@@ -25,7 +26,7 @@ class Exists(Query[TableInstance, bool]):
         return bool(response[0]["exists"])
 
     @property
-    def default_querystrings(self) -> t.Sequence[QueryString]:
+    def default_querystrings(self) -> Sequence[QueryString]:
         select = Select(table=self.table)
         select.where_delegate._where = self.where_delegate._where
         return [
@@ -35,4 +36,4 @@ class Exists(Query[TableInstance, bool]):
         ]
 
 
-Self = t.TypeVar("Self", bound=Exists)
+Self = TypeVar("Self", bound=Exists)

piccolo/query/methods/indexes.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import typing as t
+from collections.abc import Sequence
 
 from piccolo.query.base import Query
 from piccolo.querystring import QueryString
@@ -12,7 +12,7 @@ class Indexes(Query):
     """
 
     @property
-    def postgres_querystrings(self) -> t.Sequence[QueryString]:
+    def postgres_querystrings(self) -> Sequence[QueryString]:
         return [
             QueryString(
                 "SELECT indexname AS name FROM pg_indexes "
@@ -22,11 +22,11 @@ class Indexes(Query):
         ]
 
     @property
-    def cockroach_querystrings(self) -> t.Sequence[QueryString]:
+    def cockroach_querystrings(self) -> Sequence[QueryString]:
         return self.postgres_querystrings
 
     @property
-    def sqlite_querystrings(self) -> t.Sequence[QueryString]:
+    def sqlite_querystrings(self) -> Sequence[QueryString]:
         tablename = self.table._meta.tablename
         return [QueryString(f"PRAGMA index_list({tablename})")]
 

piccolo/query/methods/insert.py

@@ -1,6 +1,15 @@
 from __future__ import annotations
 
-import typing as t
+from collections.abc import Sequence
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Generic,
+    Literal,
+    Optional,
+    TypeVar,
+    Union,
+)
 
 from piccolo.custom_types import Combinable, TableInstance
 from piccolo.query.base import Query
@@ -12,18 +21,18 @@ from piccolo.query.mixins import (
 )
 from piccolo.querystring import QueryString
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.columns.base import Column
     from piccolo.table import Table
 
 
 class Insert(
-    t.Generic[TableInstance], Query[TableInstance, t.List[t.Dict[str, t.Any]]]
+    Generic[TableInstance], Query[TableInstance, list[dict[str, Any]]]
 ):
     __slots__ = ("add_delegate", "on_conflict_delegate", "returning_delegate")
 
     def __init__(
-        self, table: t.Type[TableInstance], *instances: TableInstance, **kwargs
+        self, table: type[TableInstance], *instances: TableInstance, **kwargs
     ):
         super().__init__(table, **kwargs)
         self.add_delegate = AddDelegate()
@@ -44,14 +53,12 @@ class Insert(
 
     def on_conflict(
         self: 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,
     ) -> Self:
         if (
             self.engine_type == "sqlite"
@@ -81,7 +88,7 @@ class Insert(
 
     ###########################################################################
 
-    def _raw_response_callback(self, results: t.List):
+    def _raw_response_callback(self, results: list):
         """
         Assign the ids of the created rows to the model instances.
         """
@@ -97,7 +104,7 @@ class Insert(
             table_instance._exists_in_db = True
 
     @property
-    def default_querystrings(self) -> t.Sequence[QueryString]:
+    def default_querystrings(self) -> Sequence[QueryString]:
         base = f"INSERT INTO {self.table._meta.get_formatted_tablename()}"
         columns = ",".join(
             f'"{i._meta.db_column_name}"' for i in self.table._meta.columns
@@ -142,4 +149,4 @@ class Insert(
         return [querystring]
 
 
-Self = t.TypeVar("Self", bound=Insert)
+Self = TypeVar("Self", bound=Insert)

piccolo/query/methods/objects.py

@@ -1,6 +1,16 @@
 from __future__ import annotations
 
-import typing as t
+from collections.abc import Callable, Generator, Sequence
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Generic,
+    Literal,
+    Optional,
+    TypeVar,
+    Union,
+    cast,
+)
 
 from piccolo.columns.column_types import ForeignKey, ReferencedTable
 from piccolo.columns.combination import And, Where
@@ -27,7 +37,7 @@ from piccolo.querystring import QueryString
 from piccolo.utils.dictionary import make_nested
 from piccolo.utils.sync import run_sync
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.columns import Column
     from piccolo.table import Table
 
@@ -36,14 +46,14 @@ if t.TYPE_CHECKING:  # pragma: no cover
 
 
 class GetOrCreate(
-    Proxy["Objects[TableInstance]", TableInstance], t.Generic[TableInstance]
+    Proxy["Objects[TableInstance]", TableInstance], Generic[TableInstance]
 ):
     def __init__(
         self,
         query: Objects[TableInstance],
-        table_class: t.Type[TableInstance],
+        table_class: type[TableInstance],
         where: Combinable,
-        defaults: t.Dict[Column, t.Any],
+        defaults: dict[Column, Any],
     ):
         self.query = query
         self.table_class = table_class
@@ -51,7 +61,7 @@ class GetOrCreate(
         self.defaults = defaults
 
     async def run(
-        self, node: t.Optional[str] = None, in_pool: bool = True
+        self, node: Optional[str] = None, in_pool: bool = True
     ) -> TableInstance:
         """
         :raises ValueError:
@@ -100,32 +110,32 @@ class GetOrCreate(
                 .run()
             )
 
-        instance = t.cast(TableInstance, instance)
+        instance = cast(TableInstance, instance)
         instance._was_created = True
         return instance
 
 
 class Get(
-    Proxy["First[TableInstance]", t.Optional[TableInstance]],
-    t.Generic[TableInstance],
+    Proxy["First[TableInstance]", Optional[TableInstance]],
+    Generic[TableInstance],
 ):
     pass
 
 
 class First(
-    Proxy["Objects[TableInstance]", t.Optional[TableInstance]],
-    t.Generic[TableInstance],
+    Proxy["Objects[TableInstance]", Optional[TableInstance]],
+    Generic[TableInstance],
 ):
     async def run(
-        self, node: t.Optional[str] = None, in_pool: bool = True
-    ) -> t.Optional[TableInstance]:
+        self, node: Optional[str] = None, in_pool: bool = True
+    ) -> Optional[TableInstance]:
         objects = await self.query.run(
             node=node, in_pool=in_pool, use_callbacks=False
         )
 
         results = objects[0] if objects else None
 
-        modified_response: t.Optional[TableInstance] = (
+        modified_response: Optional[TableInstance] = (
             await self.query.callback_delegate.invoke(
                 results=results, kind=CallbackType.success
             )
@@ -133,7 +143,7 @@ class First(
         return modified_response
 
 
-class Create(t.Generic[TableInstance]):
+class Create(Generic[TableInstance]):
     """
     This is provided as a simple convenience. Rather than running::
 
@@ -148,22 +158,22 @@ class Create(t.Generic[TableInstance]):
 
     def __init__(
         self,
-        table_class: t.Type[TableInstance],
-        columns: t.Dict[str, t.Any],
+        table_class: type[TableInstance],
+        columns: dict[str, Any],
     ):
         self.table_class = table_class
         self.columns = columns
 
     async def run(
         self,
-        node: t.Optional[str] = None,
+        node: Optional[str] = None,
         in_pool: bool = True,
     ) -> TableInstance:
         instance = self.table_class(**self.columns)
         await instance.save().run(node=node, in_pool=in_pool)
         return instance
 
-    def __await__(self) -> t.Generator[None, None, TableInstance]:
+    def __await__(self) -> Generator[None, None, TableInstance]:
         """
         If the user doesn't explicity call .run(), proxy to it as a
         convenience.
@@ -179,14 +189,14 @@ class UpdateSelf:
     def __init__(
         self,
         row: Table,
-        values: t.Dict[t.Union[Column, str], t.Any],
+        values: dict[Union[Column, str], Any],
     ):
         self.row = row
         self.values = values
 
     async def run(
         self,
-        node: t.Optional[str] = None,
+        node: Optional[str] = None,
         in_pool: bool = True,
     ) -> None:
         if not self.row._exists_in_db:
@@ -218,7 +228,7 @@ class UpdateSelf:
         for key, value in response[0].items():
             setattr(self.row, key, value)
 
-    def __await__(self) -> t.Generator[None, None, None]:
+    def __await__(self) -> Generator[None, None, None]:
         """
         If the user doesn't explicity call .run(), proxy to it as a
         convenience.
@@ -229,7 +239,7 @@ class UpdateSelf:
         return run_sync(self.run(*args, **kwargs))
 
 
-class GetRelated(t.Generic[ReferencedTable]):
+class GetRelated(Generic[ReferencedTable]):
 
     def __init__(self, row: Table, foreign_key: ForeignKey[ReferencedTable]):
         self.row = row
@@ -237,9 +247,9 @@ class GetRelated(t.Generic[ReferencedTable]):
 
     async def run(
         self,
-        node: t.Optional[str] = None,
+        node: Optional[str] = None,
         in_pool: bool = True,
-    ) -> t.Optional[ReferencedTable]:
+    ) -> Optional[ReferencedTable]:
         if not self.row._exists_in_db:
             raise ValueError("The object doesn't exist in the database.")
 
@@ -264,8 +274,8 @@ class GetRelated(t.Generic[ReferencedTable]):
         if data is None or not any(data.values()):
             return None
 
-        references = t.cast(
-            t.Type[ReferencedTable],
+        references = cast(
+            type[ReferencedTable],
             self.foreign_key._foreign_key_meta.resolved_references,
         )
 
@@ -275,14 +285,14 @@ class GetRelated(t.Generic[ReferencedTable]):
 
     def __await__(
         self,
-    ) -> t.Generator[None, None, t.Optional[ReferencedTable]]:
+    ) -> Generator[None, None, Optional[ReferencedTable]]:
         """
         If the user doesn't explicity call .run(), proxy to it as a
         convenience.
         """
         return self.run().__await__()
 
-    def run_sync(self, *args, **kwargs) -> t.Optional[ReferencedTable]:
+    def run_sync(self, *args, **kwargs) -> Optional[ReferencedTable]:
         return run_sync(self.run(*args, **kwargs))
 
 
@@ -290,7 +300,7 @@ class GetRelated(t.Generic[ReferencedTable]):
 
 
 class Objects(
-    Query[TableInstance, t.List[TableInstance]], t.Generic[TableInstance]
+    Query[TableInstance, list[TableInstance]], Generic[TableInstance]
 ):
     """
     Almost identical to select, except you have to select all fields, and
@@ -312,8 +322,8 @@ class Objects(
 
     def __init__(
         self,
-        table: t.Type[TableInstance],
-        prefetch: t.Sequence[t.Union[ForeignKey, t.List[ForeignKey]]] = (),
+        table: type[TableInstance],
+        prefetch: Sequence[Union[ForeignKey, list[ForeignKey]]] = (),
         **kwargs,
     ):
         super().__init__(table, **kwargs)
@@ -337,7 +347,7 @@ class Objects(
 
     def callback(
         self: Self,
-        callbacks: t.Union[t.Callable, t.List[t.Callable]],
+        callbacks: Union[Callable, list[Callable]],
         *,
         on: CallbackType = CallbackType.success,
     ) -> Self:
@@ -355,7 +365,7 @@ class Objects(
         return self
 
     def prefetch(
-        self: Self, *fk_columns: t.Union[ForeignKey, t.List[ForeignKey]]
+        self: Self, *fk_columns: Union[ForeignKey, list[ForeignKey]]
     ) -> Self:
         self.prefetch_delegate.prefetch(*fk_columns)
         return self
@@ -365,9 +375,9 @@ class Objects(
         return self
 
     def order_by(
-        self: Self, *columns: t.Union[Column, str, OrderByRaw], ascending=True
+        self: Self, *columns: Union[Column, str, OrderByRaw], ascending=True
     ) -> Self:
-        _columns: t.List[t.Union[Column, OrderByRaw]] = []
+        _columns: list[Union[Column, OrderByRaw]] = []
         for column in columns:
             if isinstance(column, str):
                 _columns.append(self.table._meta.get_column_by_name(column))
@@ -377,7 +387,7 @@ class Objects(
         self.order_by_delegate.order_by(*_columns, ascending=ascending)
         return self
 
-    def where(self: Self, *where: t.Union[Combinable, QueryString]) -> Self:
+    def where(self: Self, *where: Union[Combinable, QueryString]) -> Self:
         self.where_delegate.where(*where)
         return self
 
@@ -389,9 +399,9 @@ class Objects(
 
     def lock_rows(
         self: Self,
-        lock_strength: t.Union[
+        lock_strength: Union[
             LockStrength,
-            t.Literal[
+            Literal[
                 "UPDATE",
                 "NO KEY UPDATE",
                 "KEY SHARE",
@@ -400,7 +410,7 @@ class Objects(
         ] = LockStrength.update,
         nowait: bool = False,
         skip_locked: bool = False,
-        of: t.Tuple[type[Table], ...] = (),
+        of: tuple[type[Table], ...] = (),
     ) -> Self:
         self.lock_rows_delegate.lock_rows(
             lock_strength, nowait, skip_locked, of
@@ -415,7 +425,7 @@ class Objects(
     def get_or_create(
         self,
         where: Combinable,
-        defaults: t.Optional[t.Dict[Column, t.Any]] = None,
+        defaults: Optional[dict[Column, Any]] = None,
     ) -> GetOrCreate[TableInstance]:
         if defaults is None:
             defaults = {}
@@ -423,15 +433,15 @@ class Objects(
             query=self, table_class=self.table, where=where, defaults=defaults
         )
 
-    def create(self, **columns: t.Any) -> Create[TableInstance]:
+    def create(self, **columns: Any) -> Create[TableInstance]:
         return Create[TableInstance](table_class=self.table, columns=columns)
 
     ###########################################################################
 
     async def batch(
         self,
-        batch_size: t.Optional[int] = None,
-        node: t.Optional[str] = None,
+        batch_size: Optional[int] = None,
+        node: Optional[str] = None,
         **kwargs,
     ) -> BaseBatch:
         if batch_size:
@@ -447,7 +457,7 @@ class Objects(
             return response
 
     @property
-    def default_querystrings(self) -> t.Sequence[QueryString]:
+    def default_querystrings(self) -> Sequence[QueryString]:
         select = Select(table=self.table)
 
         for attr in (
@@ -481,17 +491,17 @@ class Objects(
 
     async def run(
         self,
-        node: t.Optional[str] = None,
+        node: Optional[str] = None,
         in_pool: bool = True,
         use_callbacks: bool = True,
-    ) -> t.List[TableInstance]:
+    ) -> list[TableInstance]:
         results = await super().run(node=node, in_pool=in_pool)
 
         if use_callbacks:
             # With callbacks, the user can return any data that they want.
             # Assume that most of the time they will still return a list of
             # Table instances.
-            modified: t.List[TableInstance] = (
+            modified: list[TableInstance] = (
                 await self.callback_delegate.invoke(
                     results, kind=CallbackType.success
                 )
@@ -502,8 +512,8 @@ class Objects(
 
     def __await__(
         self,
-    ) -> t.Generator[None, None, t.List[TableInstance]]:
+    ) -> Generator[None, None, list[TableInstance]]:
         return super().__await__()
 
 
-Self = t.TypeVar("Self", bound=Objects)
+Self = TypeVar("Self", bound=Objects)

piccolo/query/methods/raw.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
-import typing as t
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Optional
 
 from piccolo.engine.base import BaseBatch
 from piccolo.query.base import Query
 from piccolo.querystring import QueryString
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.table import Table
 
 
@@ -15,7 +16,7 @@ class Raw(Query):
 
     def __init__(
         self,
-        table: t.Type[Table],
+        table: type[Table],
         querystring: QueryString = QueryString(""),
         **kwargs,
     ):
@@ -24,8 +25,8 @@ class Raw(Query):
 
     async def batch(
         self,
-        batch_size: t.Optional[int] = None,
-        node: t.Optional[str] = None,
+        batch_size: Optional[int] = None,
+        node: Optional[str] = None,
         **kwargs,
     ) -> BaseBatch:
         if batch_size:
@@ -35,5 +36,5 @@ class Raw(Query):
         return await self.table._meta.db.batch(self, **kwargs)
 
     @property
-    def default_querystrings(self) -> t.Sequence[QueryString]:
+    def default_querystrings(self) -> Sequence[QueryString]:
         return [self.querystring]

piccolo/query/methods/refresh.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
-import typing as t
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Optional
 
 from piccolo.utils.encoding import JSONDict
 from piccolo.utils.sync import run_sync
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.columns import Column
     from piccolo.table import Table
 
@@ -30,7 +31,7 @@ class Refresh:
     def __init__(
         self,
         instance: Table,
-        columns: t.Optional[t.Sequence[Column]] = None,
+        columns: Optional[Sequence[Column]] = None,
         load_json: bool = False,
     ):
         self.instance = instance
@@ -50,7 +51,7 @@ class Refresh:
         self.load_json = load_json
 
     @property
-    def _columns(self) -> t.Sequence[Column]:
+    def _columns(self) -> Sequence[Column]:
         """
         Works out which columns the user wants to refresh.
         """
@@ -61,7 +62,7 @@ class Refresh:
             i for i in self.instance._meta.columns if not i._meta.primary_key
         ]
 
-    def _get_columns(self, instance: Table, columns: t.Sequence[Column]):
+    def _get_columns(self, instance: Table, columns: Sequence[Column]):
         """
         If `prefetch` was used on the object, for example::
 
@@ -100,7 +101,7 @@ class Refresh:
 
         return select_columns
 
-    def _update_instance(self, instance: Table, data_dict: t.Dict):
+    def _update_instance(self, instance: Table, data_dict: dict):
         """
         Update the table instance. It is called recursively, if the instance
         has child instances.
@@ -119,7 +120,7 @@ class Refresh:
                 setattr(instance, key, value)
 
     async def run(
-        self, in_pool: bool = True, node: t.Optional[str] = None
+        self, in_pool: bool = True, node: Optional[str] = None
     ) -> Table:
         """
         Run it asynchronously. For example::