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

piccolo/conf/apps.py

@@ -6,11 +6,12 @@ import itertools
 import os
 import pathlib
 import traceback
-import typing as t
 from abc import abstractmethod
+from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
 from importlib import import_module
 from types import ModuleType
+from typing import Optional, Union, cast
 
 import black
 
@@ -45,12 +46,12 @@ def get_package(name: str) -> str:
 
 
 def table_finder(
-    modules: t.Sequence[str],
-    package: t.Optional[str] = None,
-    include_tags: t.Optional[t.Sequence[str]] = None,
-    exclude_tags: t.Optional[t.Sequence[str]] = None,
+    modules: Sequence[str],
+    package: Optional[str] = None,
+    include_tags: Optional[Sequence[str]] = None,
+    exclude_tags: Optional[Sequence[str]] = None,
     exclude_imported: bool = False,
-) -> t.List[t.Type[Table]]:
+) -> list[type[Table]]:
     """
     Rather than explicitly importing and registering table classes with the
     ``AppConfig``, ``table_finder`` can be used instead. It imports any ``Table``
@@ -95,7 +96,7 @@ def table_finder(
         # 'blog.tables', instead of ['blog.tables'].
         modules = [modules]
 
-    table_subclasses: t.List[t.Type[Table]] = []
+    table_subclasses: list[type[Table]] = []
 
     for module_path in modules:
         full_module_path = (
@@ -151,9 +152,9 @@ class Command:
 
     """
 
-    callable: t.Callable
-    command_name: t.Optional[str] = None
-    aliases: t.List[str] = field(default_factory=list)
+    callable: Callable
+    command_name: Optional[str] = None
+    aliases: list[str] = field(default_factory=list)
 
 
 @dataclass
@@ -181,12 +182,10 @@ class AppConfig:
     """
 
     app_name: str
-    migrations_folder_path: t.Union[str, pathlib.Path]
-    table_classes: t.List[t.Type[Table]] = field(default_factory=list)
-    migration_dependencies: t.List[str] = field(default_factory=list)
-    commands: t.List[t.Union[t.Callable, Command]] = field(
-        default_factory=list
-    )
+    migrations_folder_path: Union[str, pathlib.Path]
+    table_classes: list[type[Table]] = field(default_factory=list)
+    migration_dependencies: list[str] = field(default_factory=list)
+    commands: list[Union[Callable, Command]] = field(default_factory=list)
 
     @property
     def resolved_migrations_folder_path(self) -> str:
@@ -197,21 +196,21 @@ class AppConfig:
         )
 
     def __post_init__(self) -> None:
-        self._migration_dependency_app_configs: t.Optional[
-            t.List[AppConfig]
-        ] = None
+        self._migration_dependency_app_configs: Optional[list[AppConfig]] = (
+            None
+        )
 
-    def register_table(self, table_class: t.Type[Table]):
+    def register_table(self, table_class: type[Table]):
         self.table_classes.append(table_class)
         return table_class
 
-    def get_commands(self) -> t.List[Command]:
+    def get_commands(self) -> list[Command]:
         return [
             i if isinstance(i, Command) else Command(i) for i in self.commands
         ]
 
     @property
-    def migration_dependency_app_configs(self) -> t.List[AppConfig]:
+    def migration_dependency_app_configs(self) -> list[AppConfig]:
         """
         Get all of the ``AppConfig`` instances from this app's migration
         dependencies.
@@ -219,8 +218,8 @@ class AppConfig:
         # We cache the value so it's more efficient, and also so we can set the
         # underlying value in unit tests for easier mocking.
         if self._migration_dependency_app_configs is None:
-            modules: t.List[PiccoloAppModule] = [
-                t.cast(PiccoloAppModule, import_module(module_path))
+            modules: list[PiccoloAppModule] = [
+                cast(PiccoloAppModule, import_module(module_path))
                 for module_path in self.migration_dependencies
             ]
             self._migration_dependency_app_configs = [
@@ -229,7 +228,7 @@ class AppConfig:
 
         return self._migration_dependency_app_configs
 
-    def get_table_with_name(self, table_class_name: str) -> t.Type[Table]:
+    def get_table_with_name(self, table_class_name: str) -> type[Table]:
         """
         Returns a ``Table`` subclass with the given name from this app, if it
         exists. Otherwise raises a ``ValueError``.
@@ -256,9 +255,9 @@ class AppRegistry:
 
     """
 
-    def __init__(self, apps: t.Optional[t.List[str]] = None):
+    def __init__(self, apps: Optional[list[str]] = None):
         self.apps = apps or []
-        self.app_configs: t.Dict[str, AppConfig] = {}
+        self.app_configs: dict[str, AppConfig] = {}
         app_names = []
 
         for app in self.apps:
@@ -282,7 +281,7 @@ class AppRegistry:
         self._validate_app_names(app_names)
 
     @staticmethod
-    def _validate_app_names(app_names: t.List[str]):
+    def _validate_app_names(app_names: list[str]):
         """
         Raise a ValueError if an app_name is repeated.
         """
@@ -298,10 +297,10 @@ class AppRegistry:
                     "multiple times."
                 )
 
-    def get_app_config(self, app_name: str) -> t.Optional[AppConfig]:
+    def get_app_config(self, app_name: str) -> Optional[AppConfig]:
         return self.app_configs.get(app_name)
 
-    def get_table_classes(self, app_name: str) -> t.List[t.Type[Table]]:
+    def get_table_classes(self, app_name: str) -> list[type[Table]]:
         """
         Returns each Table subclass defined in the given app if it exists.
         Otherwise raises a ValueError.
@@ -317,7 +316,7 @@ class AppRegistry:
 
     def get_table_with_name(
         self, app_name: str, table_class_name: str
-    ) -> t.Optional[t.Type[Table]]:
+    ) -> Optional[type[Table]]:
         """
         Returns a Table subclass registered with the given app if it exists.
         Otherwise raises a ValueError.
@@ -357,8 +356,8 @@ class Finder:
         self.diagnose = diagnose
 
     def _deduplicate(
-        self, config_modules: t.List[PiccoloAppModule]
-    ) -> t.List[PiccoloAppModule]:
+        self, config_modules: list[PiccoloAppModule]
+    ) -> list[PiccoloAppModule]:
         """
         Remove all duplicates - just leaving the first instance.
         """
@@ -366,8 +365,8 @@ class Finder:
         return list({c: None for c in config_modules}.keys())
 
     def _import_app_modules(
-        self, config_module_paths: t.List[str]
-    ) -> t.List[PiccoloAppModule]:
+        self, config_module_paths: list[str]
+    ) -> list[PiccoloAppModule]:
         """
         Import all piccolo_app.py modules within your apps, and all
         dependencies.
@@ -376,7 +375,7 @@ class Finder:
 
         for config_module_path in config_module_paths:
             try:
-                config_module = t.cast(
+                config_module = cast(
                     PiccoloAppModule, import_module(config_module_path)
                 )
             except ImportError as e:
@@ -392,8 +391,8 @@ class Finder:
         return config_modules
 
     def get_piccolo_conf_module(
-        self, module_name: t.Optional[str] = None
-    ) -> t.Optional[PiccoloConfModule]:
+        self, module_name: Optional[str] = None
+    ) -> Optional[PiccoloConfModule]:
         """
         Searches the path for a 'piccolo_conf.py' module to import. The
         location searched can be overriden by:
@@ -413,7 +412,7 @@ class Finder:
             module_name = DEFAULT_MODULE_NAME
 
         try:
-            module = t.cast(PiccoloConfModule, import_module(module_name))
+            module = cast(PiccoloConfModule, import_module(module_name))
         except ModuleNotFoundError as exc:
             if self.diagnose:
                 colored_warning(
@@ -459,10 +458,10 @@ class Finder:
         return getattr(piccolo_conf_module, "APP_REGISTRY")
 
     def get_engine(
-        self, module_name: t.Optional[str] = None
-    ) -> t.Optional[Engine]:
+        self, module_name: Optional[str] = None
+    ) -> Optional[Engine]:
         piccolo_conf = self.get_piccolo_conf_module(module_name=module_name)
-        engine: t.Optional[Engine] = getattr(piccolo_conf, ENGINE_VAR, None)
+        engine: Optional[Engine] = getattr(piccolo_conf, ENGINE_VAR, None)
 
         if not engine:
             colored_warning(
@@ -478,7 +477,7 @@ class Finder:
 
         return engine
 
-    def get_app_modules(self) -> t.List[PiccoloAppModule]:
+    def get_app_modules(self) -> list[PiccoloAppModule]:
         """
         Returns the ``piccolo_app.py`` modules for each registered Piccolo app
         in your project.
@@ -493,7 +492,7 @@ class Finder:
 
     def get_app_names(
         self, sort_by_migration_dependencies: bool = True
-    ) -> t.List[str]:
+    ) -> list[str]:
         """
         Return all of the app names.
 
@@ -509,15 +508,15 @@ class Finder:
             )
         ]
 
-    def get_sorted_app_names(self) -> t.List[str]:
+    def get_sorted_app_names(self) -> list[str]:
         """
         Just here for backwards compatibility - use ``get_app_names`` directly.
         """
         return self.get_app_names(sort_by_migration_dependencies=True)
 
     def sort_app_configs(
-        self, app_configs: t.List[AppConfig]
-    ) -> t.List[AppConfig]:
+        self, app_configs: list[AppConfig]
+    ) -> list[AppConfig]:
         app_config_map = {
             app_config.app_name: app_config for app_config in app_configs
         }
@@ -536,7 +535,7 @@ class Finder:
 
     def get_app_configs(
         self, sort_by_migration_dependencies: bool = True
-    ) -> t.List[AppConfig]:
+    ) -> list[AppConfig]:
         """
         Returns a list of ``AppConfig``, optionally sorted by migration
         dependencies.
@@ -560,7 +559,7 @@ class Finder:
 
     def get_table_with_name(
         self, app_name: str, table_class_name: str
-    ) -> t.Type[Table]:
+    ) -> type[Table]:
         """
         Returns a ``Table`` class registered with the given app if it exists.
         Otherwise it raises an ``ValueError``.
@@ -572,9 +571,9 @@ class Finder:
 
     def get_table_classes(
         self,
-        include_apps: t.Optional[t.List[str]] = None,
-        exclude_apps: t.Optional[t.List[str]] = None,
-    ) -> t.List[t.Type[Table]]:
+        include_apps: Optional[list[str]] = None,
+        exclude_apps: Optional[list[str]] = None,
+    ) -> list[type[Table]]:
         """
         Returns all ``Table`` classes registered with the given apps. If
         ``include_apps`` is ``None``, then ``Table`` classes will be returned
@@ -590,7 +589,7 @@ class Finder:
             if exclude_apps:
                 app_names = [i for i in app_names if i not in exclude_apps]
 
-        tables: t.List[t.Type[Table]] = []
+        tables: list[type[Table]] = []
 
         for app_name in app_names:
             app_config = self.get_app_config(app_name=app_name)
@@ -604,7 +603,7 @@ class Finder:
 
 class PiccoloConfUpdater:
 
-    def __init__(self, piccolo_conf_path: t.Optional[str] = None):
+    def __init__(self, piccolo_conf_path: Optional[str] = None):
         """
         :param piccolo_conf_path:
             The path to the piccolo_conf.py (e.g. `./piccolo_conf.py`). If not

piccolo/custom_types.py

@@ -1,19 +1,41 @@
 from __future__ import annotations
 
-import typing as t
+import datetime
+import decimal
+import uuid
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any, TypeVar, Union
 
-if t.TYPE_CHECKING:  # pragma: no cover
+from typing_extensions import TypeAlias
+
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.columns.combination import And, Or, Where, WhereRaw  # noqa
     from piccolo.table import Table
 
 
-Combinable = t.Union["Where", "WhereRaw", "And", "Or"]
-Iterable = t.Iterable[t.Any]
+Combinable = Union["Where", "WhereRaw", "And", "Or"]
+CustomIterable = Iterable[Any]
+
 
+TableInstance = TypeVar("TableInstance", bound="Table")
+QueryResponseType = TypeVar("QueryResponseType", bound=Any)
 
-TableInstance = t.TypeVar("TableInstance", bound="Table")
-QueryResponseType = t.TypeVar("QueryResponseType", bound=t.Any)
 
+# These are types we can reasonably expect to send to the database.
+BasicTypes: TypeAlias = Union[
+    bytes,
+    datetime.date,
+    datetime.datetime,
+    datetime.time,
+    datetime.timedelta,
+    decimal.Decimal,
+    dict,
+    float,
+    int,
+    list,
+    str,
+    uuid.UUID,
+]
 
 ###############################################################################
 # For backwards compatibility:

piccolo/engine/base.py

@@ -4,8 +4,8 @@ import contextvars
 import logging
 import pprint
 import string
-import typing as t
 from abc import ABCMeta, abstractmethod
+from typing import TYPE_CHECKING, Final, Generic, Optional, TypeVar, Union
 
 from typing_extensions import Self
 
@@ -13,14 +13,14 @@ from piccolo.querystring import QueryString
 from piccolo.utils.sync import run_sync
 from piccolo.utils.warnings import Level, colored_string, colored_warning
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.query.base import DDL, Query
 
 
 logger = logging.getLogger(__name__)
 # This is a set to speed up lookups from O(n) when
 # using str vs O(1) when using set[str]
-VALID_SAVEPOINT_CHARACTERS: t.Final[set[str]] = set(
+VALID_SAVEPOINT_CHARACTERS: Final[set[str]] = set(
     string.ascii_letters + string.digits + "-" + "_"
 )
 
@@ -45,12 +45,12 @@ class BaseBatch(metaclass=ABCMeta):
     def __aiter__(self: Self) -> Self: ...
 
     @abstractmethod
-    async def __anext__(self) -> t.List[t.Dict]: ...
+    async def __anext__(self) -> list[dict]: ...
 
 
 class BaseTransaction(metaclass=ABCMeta):
 
-    __slots__: t.Tuple[str, ...] = tuple()
+    __slots__: tuple[str, ...] = tuple()
 
     @abstractmethod
     async def __aenter__(self, *args, **kwargs): ...
@@ -61,10 +61,10 @@ class BaseTransaction(metaclass=ABCMeta):
 
 class BaseAtomic(metaclass=ABCMeta):
 
-    __slots__: t.Tuple[str, ...] = tuple()
+    __slots__: tuple[str, ...] = tuple()
 
     @abstractmethod
-    def add(self, *query: t.Union[Query, DDL]): ...
+    def add(self, *query: Union[Query, DDL]): ...
 
     @abstractmethod
     async def run(self): ...
@@ -76,10 +76,10 @@ class BaseAtomic(metaclass=ABCMeta):
     def __await__(self): ...
 
 
-TransactionClass = t.TypeVar("TransactionClass", bound=BaseTransaction)
+TransactionClass = TypeVar("TransactionClass", bound=BaseTransaction)
 
 
-class Engine(t.Generic[TransactionClass], metaclass=ABCMeta):
+class Engine(Generic[TransactionClass], metaclass=ABCMeta):
     __slots__ = (
         "query_id",
         "log_queries",
@@ -92,7 +92,7 @@ class Engine(t.Generic[TransactionClass], metaclass=ABCMeta):
     def __init__(
         self,
         engine_type: str,
-        min_version_number: t.Union[int, float],
+        min_version_number: Union[int, float],
         log_queries: bool = False,
         log_responses: bool = False,
     ):
@@ -122,7 +122,7 @@ class Engine(t.Generic[TransactionClass], metaclass=ABCMeta):
         self,
         query: Query,
         batch_size: int = 100,
-        node: t.Optional[str] = None,
+        node: Optional[str] = None,
     ) -> BaseBatch:
         pass
 
@@ -132,7 +132,7 @@ class Engine(t.Generic[TransactionClass], metaclass=ABCMeta):
     ):
         pass
 
-    def transform_response_to_dicts(self, results) -> t.List[t.Dict]:
+    def transform_response_to_dicts(self, results) -> list[dict]:
         """
         If the database adapter returns something other than a list of
         dictionaries, it should perform the transformation here.
@@ -196,7 +196,7 @@ class Engine(t.Generic[TransactionClass], metaclass=ABCMeta):
 
     ###########################################################################
 
-    current_transaction: contextvars.ContextVar[t.Optional[TransactionClass]]
+    current_transaction: contextvars.ContextVar[Optional[TransactionClass]]
 
     def transaction_exists(self) -> bool:
         """
@@ -222,7 +222,7 @@ class Engine(t.Generic[TransactionClass], metaclass=ABCMeta):
         print(colored_string(f"\nQuery {query_id}:"))
         print(query)
 
-    def print_response(self, query_id: int, response: t.List):
+    def print_response(self, query_id: int, response: list):
         print(
             colored_string(f"\nQuery {query_id} response:", level=Level.high)
         )

piccolo/engine/cockroach.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-import typing as t
+from collections.abc import Sequence
+from typing import Any, Optional
 
 from piccolo.utils.lazy_loader import LazyLoader
 from piccolo.utils.warnings import Level, colored_warning
@@ -18,11 +19,11 @@ class CockroachEngine(PostgresEngine):
 
     def __init__(
         self,
-        config: t.Dict[str, t.Any],
-        extensions: t.Sequence[str] = (),
+        config: dict[str, Any],
+        extensions: Sequence[str] = (),
         log_queries: bool = False,
         log_responses: bool = False,
-        extra_nodes: t.Optional[t.Dict[str, CockroachEngine]] = None,
+        extra_nodes: Optional[dict[str, CockroachEngine]] = None,
     ) -> None:
         super().__init__(
             config=config,

piccolo/engine/finder.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
-import typing as t
+from typing import Optional
 
 from piccolo.engine.base import Engine
 
 
-def engine_finder(module_name: t.Optional[str] = None) -> t.Optional[Engine]:
+def engine_finder(module_name: Optional[str] = None) -> Optional[Engine]:
     """
     An example module name is `my_piccolo_conf`.
 

piccolo/engine/postgres.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import contextvars
-import typing as t
+from collections.abc import Sequence
 from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Mapping, Optional, Union
 
 from typing_extensions import Self
 
@@ -22,7 +23,7 @@ from piccolo.utils.warnings import Level, colored_warning
 
 asyncpg = LazyLoader("asyncpg", globals(), "asyncpg")
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from asyncpg.connection import Connection
     from asyncpg.cursor import Cursor
     from asyncpg.pool import Pool
@@ -36,8 +37,8 @@ class AsyncBatch(BaseBatch):
     batch_size: int
 
     # Set internally
-    _transaction: t.Optional[Transaction] = None
-    _cursor: t.Optional[Cursor] = None
+    _transaction: Optional[Transaction] = None
+    _cursor: Optional[Cursor] = None
 
     @property
     def cursor(self) -> Cursor:
@@ -51,14 +52,14 @@ class AsyncBatch(BaseBatch):
             raise ValueError("The transaction can't be found.")
         return self._transaction
 
-    async def next(self) -> t.List[t.Dict]:
+    async def next(self) -> list[dict]:
         data = await self.cursor.fetch(self.batch_size)
         return await self.query._process_results(data)
 
     def __aiter__(self: Self) -> Self:
         return self
 
-    async def __anext__(self) -> t.List[t.Dict]:
+    async def __anext__(self) -> list[dict]:
         response = await self.next()
         if response == []:
             raise StopAsyncIteration()
@@ -107,9 +108,9 @@ class Atomic(BaseAtomic):
 
     def __init__(self, engine: PostgresEngine):
         self.engine = engine
-        self.queries: t.List[t.Union[Query, DDL]] = []
+        self.queries: list[Union[Query, DDL]] = []
 
-    def add(self, *query: t.Union[Query, DDL]):
+    def add(self, *query: Union[Query, DDL]):
         self.queries += list(query)
 
     async def run(self):
@@ -250,7 +251,7 @@ class PostgresTransaction(BaseTransaction):
         self._savepoint_id += 1
         return self._savepoint_id
 
-    async def savepoint(self, name: t.Optional[str] = None) -> Savepoint:
+    async def savepoint(self, name: Optional[str] = None) -> Savepoint:
         name = name or f"savepoint_{self.get_savepoint_id()}"
         validate_savepoint_name(name)
         await self.connection.execute(f"SAVEPOINT {name}")
@@ -352,11 +353,11 @@ class PostgresEngine(Engine[PostgresTransaction]):
 
     def __init__(
         self,
-        config: t.Dict[str, t.Any],
-        extensions: t.Sequence[str] = ("uuid-ossp",),
+        config: dict[str, Any],
+        extensions: Sequence[str] = ("uuid-ossp",),
         log_queries: bool = False,
         log_responses: bool = False,
-        extra_nodes: t.Optional[t.Mapping[str, PostgresEngine]] = None,
+        extra_nodes: Optional[Mapping[str, PostgresEngine]] = None,
     ) -> None:
         if extra_nodes is None:
             extra_nodes = {}
@@ -366,7 +367,7 @@ class PostgresEngine(Engine[PostgresTransaction]):
         self.log_queries = log_queries
         self.log_responses = log_responses
         self.extra_nodes = extra_nodes
-        self.pool: t.Optional[Pool] = None
+        self.pool: Optional[Pool] = None
         database_name = config.get("database", "Unknown")
         self.current_transaction = contextvars.ContextVar(
             f"pg_current_transaction_{database_name}", default=None
@@ -396,7 +397,7 @@ class PostgresEngine(Engine[PostgresTransaction]):
         Returns the version of Postgres being run.
         """
         try:
-            response: t.Sequence[t.Dict] = await self._run_in_new_connection(
+            response: Sequence[dict] = await self._run_in_new_connection(
                 "SHOW server_version"
             )
         except ConnectionRefusedError as exception:
@@ -483,7 +484,7 @@ class PostgresEngine(Engine[PostgresTransaction]):
         self,
         query: Query,
         batch_size: int = 100,
-        node: t.Optional[str] = None,
+        node: Optional[str] = None,
     ) -> AsyncBatch:
         """
         :param query:
@@ -494,7 +495,7 @@ class PostgresEngine(Engine[PostgresTransaction]):
             Which node to run the query on (see ``extra_nodes``). If not
             specified, it runs on the main Postgres node.
         """
-        engine: t.Any = self.extra_nodes.get(node) if node else self
+        engine: Any = self.extra_nodes.get(node) if node else self
         connection = await engine.get_new_connection()
         return AsyncBatch(
             connection=connection, query=query, batch_size=batch_size
@@ -503,7 +504,7 @@ class PostgresEngine(Engine[PostgresTransaction]):
     ###########################################################################
 
     async def _run_in_pool(
-        self, query: str, args: t.Optional[t.Sequence[t.Any]] = None
+        self, query: str, args: Optional[Sequence[Any]] = None
     ):
         if args is None:
             args = []
@@ -516,7 +517,7 @@ class PostgresEngine(Engine[PostgresTransaction]):
         return response
 
     async def _run_in_new_connection(
-        self, query: str, args: t.Optional[t.Sequence[t.Any]] = None
+        self, query: str, args: Optional[Sequence[Any]] = None
     ):
         if args is None:
             args = []
@@ -579,7 +580,7 @@ class PostgresEngine(Engine[PostgresTransaction]):
 
         return response
 
-    def transform_response_to_dicts(self, results) -> t.List[t.Dict]:
+    def transform_response_to_dicts(self, results) -> list[dict]:
         """
         asyncpg returns a special Record object, so we need to convert it to
         a dict.