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

piccolo/apps/schema/commands/generate.py

@@ -5,9 +5,9 @@ import dataclasses
 import itertools
 import json
 import re
-import typing as t
 import uuid
 from datetime import date, datetime
+from typing import TYPE_CHECKING, Any, Literal, Optional, Union
 
 import black
 
@@ -43,7 +43,7 @@ from piccolo.engine.postgres import PostgresEngine
 from piccolo.table import Table, create_table_class, sort_table_classes
 from piccolo.utils.naming import _snake_to_camel
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.engine.base import Engine
 
 
@@ -61,13 +61,13 @@ class ConstraintTable:
 class RowMeta:
     column_default: str
     column_name: str
-    is_nullable: t.Literal["YES", "NO"]
+    is_nullable: Literal["YES", "NO"]
     table_name: str
-    character_maximum_length: t.Optional[int]
+    character_maximum_length: Optional[int]
     data_type: str
-    numeric_precision: t.Optional[t.Union[int, str]]
-    numeric_scale: t.Optional[t.Union[int, str]]
-    numeric_precision_radix: t.Optional[t.Literal[2, 10]]
+    numeric_precision: Optional[Union[int, str]]
+    numeric_scale: Optional[Union[int, str]]
+    numeric_precision_radix: Optional[Literal[2, 10]]
 
     @classmethod
     def get_column_name_str(cls) -> str:
@@ -76,10 +76,10 @@ class RowMeta:
 
 @dataclasses.dataclass
 class Constraint:
-    constraint_type: t.Literal["PRIMARY KEY", "UNIQUE", "FOREIGN KEY", "CHECK"]
+    constraint_type: Literal["PRIMARY KEY", "UNIQUE", "FOREIGN KEY", "CHECK"]
     constraint_name: str
-    constraint_schema: t.Optional[str] = None
-    column_name: t.Optional[str] = None
+    constraint_schema: Optional[str] = None
+    column_name: Optional[str] = None
 
 
 @dataclasses.dataclass
@@ -89,12 +89,12 @@ class TableConstraints:
     """
 
     tablename: str
-    constraints: t.List[Constraint]
+    constraints: list[Constraint]
 
     def __post_init__(self) -> None:
-        foreign_key_constraints: t.List[Constraint] = []
-        unique_constraints: t.List[Constraint] = []
-        primary_key_constraints: t.List[Constraint] = []
+        foreign_key_constraints: list[Constraint] = []
+        unique_constraints: list[Constraint] = []
+        primary_key_constraints: list[Constraint] = []
 
         for constraint in self.constraints:
             if constraint.constraint_type == "FOREIGN KEY":
@@ -141,7 +141,7 @@ class Trigger:
     table_name: str
     column_name: str
     on_update: str
-    on_delete: t.Literal[
+    on_delete: Literal[
         "NO ACTION", "RESTRICT", "CASCADE", "SET NULL", "SET_DEFAULT"
     ]
     references_table: str
@@ -155,14 +155,14 @@ class TableTriggers:
     """
 
     tablename: str
-    triggers: t.List[Trigger]
+    triggers: list[Trigger]
 
-    def get_column_triggers(self, column_name: str) -> t.List[Trigger]:
+    def get_column_triggers(self, column_name: str) -> list[Trigger]:
         return [i for i in self.triggers if i.column_name == column_name]
 
     def get_column_ref_trigger(
         self, column_name: str, references_table: str
-    ) -> t.Optional[Trigger]:
+    ) -> Optional[Trigger]:
         for trigger in self.triggers:
             if (
                 trigger.column_name == column_name
@@ -221,14 +221,14 @@ class TableIndexes:
     """
 
     tablename: str
-    indexes: t.List[Index]
+    indexes: list[Index]
 
-    def get_column_index(self, column_name: str) -> t.Optional[Index]:
+    def get_column_index(self, column_name: str) -> Optional[Index]:
         return next(
             (i for i in self.indexes if i.column_name == column_name), None
         )
 
-    def get_warnings(self) -> t.List[str]:
+    def get_warnings(self) -> list[str]:
         return list(
             itertools.chain(*[index.warnings for index in self.indexes])
         )
@@ -250,13 +250,13 @@ class OutputSchema:
         e.g. ["class MyTable(Table): ..."]
     """
 
-    imports: t.List[str] = dataclasses.field(default_factory=list)
-    warnings: t.List[str] = dataclasses.field(default_factory=list)
-    index_warnings: t.List[str] = dataclasses.field(default_factory=list)
-    trigger_warnings: t.List[str] = dataclasses.field(default_factory=list)
-    tables: t.List[t.Type[Table]] = dataclasses.field(default_factory=list)
+    imports: list[str] = dataclasses.field(default_factory=list)
+    warnings: list[str] = dataclasses.field(default_factory=list)
+    index_warnings: list[str] = dataclasses.field(default_factory=list)
+    trigger_warnings: list[str] = dataclasses.field(default_factory=list)
+    tables: list[type[Table]] = dataclasses.field(default_factory=list)
 
-    def get_table_with_name(self, tablename: str) -> t.Optional[t.Type[Table]]:
+    def get_table_with_name(self, tablename: str) -> Optional[type[Table]]:
         """
         Used to search for a table by name.
         """
@@ -287,7 +287,7 @@ class OutputSchema:
         return self
 
 
-COLUMN_TYPE_MAP: t.Dict[str, t.Type[Column]] = {
+COLUMN_TYPE_MAP: dict[str, type[Column]] = {
     "bigint": BigInt,
     "boolean": Boolean,
     "bytea": Bytea,
@@ -308,12 +308,12 @@ COLUMN_TYPE_MAP: t.Dict[str, t.Type[Column]] = {
 }
 
 # Re-map for Cockroach compatibility.
-COLUMN_TYPE_MAP_COCKROACH: t.Dict[str, t.Type[Column]] = {
+COLUMN_TYPE_MAP_COCKROACH: dict[str, type[Column]] = {
     **COLUMN_TYPE_MAP,
     **{"integer": BigInt, "json": JSONB},
 }
 
-COLUMN_DEFAULT_PARSER: t.Dict[t.Type[Column], t.Any] = {
+COLUMN_DEFAULT_PARSER: dict[type[Column], Any] = {
     BigInt: re.compile(r"^'?(?P<value>-?[0-9]\d*)'?(?:::bigint)?$"),
     Boolean: re.compile(r"^(?P<value>true|false)$"),
     Bytea: re.compile(r"'(?P<value>.*)'::bytea$"),
@@ -373,15 +373,15 @@ COLUMN_DEFAULT_PARSER: t.Dict[t.Type[Column], t.Any] = {
 }
 
 # Re-map for Cockroach compatibility.
-COLUMN_DEFAULT_PARSER_COCKROACH: t.Dict[t.Type[Column], t.Any] = {
+COLUMN_DEFAULT_PARSER_COCKROACH: dict[type[Column], Any] = {
     **COLUMN_DEFAULT_PARSER,
     BigInt: re.compile(r"^(?P<value>-?\d+)$"),
 }
 
 
 def get_column_default(
-    column_type: t.Type[Column], column_default: str, engine_type: str
-) -> t.Any:
+    column_type: type[Column], column_default: str, engine_type: str
+) -> Any:
     if engine_type == "cockroach":
         pat = COLUMN_DEFAULT_PARSER_COCKROACH.get(column_type)
     else:
@@ -455,7 +455,7 @@ def get_column_default(
                 return column_type.value_type(value["value"])
 
 
-INDEX_METHOD_MAP: t.Dict[str, IndexMethod] = {
+INDEX_METHOD_MAP: dict[str, IndexMethod] = {
     "btree": IndexMethod.btree,
     "hash": IndexMethod.hash,
     "gist": IndexMethod.gist,
@@ -465,7 +465,7 @@ INDEX_METHOD_MAP: t.Dict[str, IndexMethod] = {
 
 # 'Indices' seems old-fashioned and obscure in this context.
 async def get_indexes(  # noqa: E302
-    table_class: t.Type[Table], tablename: str, schema_name: str = "public"
+    table_class: type[Table], tablename: str, schema_name: str = "public"
 ) -> TableIndexes:
     """
     Get all of the constraints for a table.
@@ -492,7 +492,7 @@ async def get_indexes(  # noqa: E302
 
 
 async def get_fk_triggers(
-    table_class: t.Type[Table], tablename: str, schema_name: str = "public"
+    table_class: type[Table], tablename: str, schema_name: str = "public"
 ) -> TableTriggers:
     """
     Get all of the constraints for a table.
@@ -540,7 +540,7 @@ async def get_fk_triggers(
 
 
 async def get_constraints(
-    table_class: t.Type[Table], tablename: str, schema_name: str = "public"
+    table_class: type[Table], tablename: str, schema_name: str = "public"
 ) -> TableConstraints:
     """
     Get all of the constraints for a table.
@@ -572,8 +572,8 @@ async def get_constraints(
 
 
 async def get_tablenames(
-    table_class: t.Type[Table], schema_name: str = "public"
-) -> t.List[str]:
+    table_class: type[Table], schema_name: str = "public"
+) -> list[str]:
     """
     Get the tablenames for the schema.
 
@@ -598,8 +598,8 @@ async def get_tablenames(
 
 
 async def get_table_schema(
-    table_class: t.Type[Table], tablename: str, schema_name: str = "public"
-) -> t.List[RowMeta]:
+    table_class: type[Table], tablename: str, schema_name: str = "public"
+) -> list[RowMeta]:
     """
     Get the schema from the database.
 
@@ -629,7 +629,7 @@ async def get_table_schema(
 
 
 async def get_foreign_key_reference(
-    table_class: t.Type[Table], constraint_name: str, constraint_schema: str
+    table_class: type[Table], constraint_name: str, constraint_schema: str
 ) -> ConstraintTable:
     """
     Retrieve the name of the table that a foreign key is referencing.
@@ -652,7 +652,7 @@ async def get_foreign_key_reference(
 
 
 async def create_table_class_from_db(
-    table_class: t.Type[Table],
+    table_class: type[Table],
     tablename: str,
     schema_name: str,
     engine_type: str,
@@ -674,7 +674,7 @@ async def create_table_class_from_db(
         table_class=table_class, tablename=tablename, schema_name=schema_name
     )
 
-    columns: t.Dict[str, Column] = {}
+    columns: dict[str, Column] = {}
 
     for pg_row_meta in table_schema:
         data_type = pg_row_meta.data_type
@@ -692,7 +692,7 @@ async def create_table_class_from_db(
             )
             column_type = Column
 
-        kwargs: t.Dict[str, t.Any] = {
+        kwargs: dict[str, Any] = {
             "null": pg_row_meta.is_nullable == "YES",
             "unique": constraints.is_unique(column_name=column_name),
         }
@@ -721,7 +721,7 @@ async def create_table_class_from_db(
                 constraint_schema=fk_constraint_table.schema,
             )
             if constraint_table.name:
-                referenced_table: t.Union[str, t.Optional[t.Type[Table]]]
+                referenced_table: Union[str, Optional[type[Table]]]
 
                 if constraint_table.name == tablename:
                     referenced_output_schema = output_schema
@@ -805,9 +805,9 @@ async def create_table_class_from_db(
 
 async def get_output_schema(
     schema_name: str = "public",
-    include: t.Optional[t.List[str]] = None,
-    exclude: t.Optional[t.List[str]] = None,
-    engine: t.Optional[Engine] = None,
+    include: Optional[list[str]] = None,
+    exclude: Optional[list[str]] = None,
+    engine: Optional[Engine] = None,
 ) -> OutputSchema:
     """
     :param schema_name:

piccolo/apps/schema/commands/graph.py

@@ -5,7 +5,7 @@ Credit to the Django Extensions team for inspiring this tool.
 import dataclasses
 import os
 import sys
-import typing as t
+from typing import Optional
 
 import jinja2
 
@@ -29,7 +29,7 @@ class GraphColumn:
 @dataclasses.dataclass
 class GraphTable:
     name: str
-    columns: t.List[GraphColumn]
+    columns: list[GraphColumn]
 
 
 @dataclasses.dataclass
@@ -45,7 +45,7 @@ def render_template(**kwargs):
 
 
 def graph(
-    apps: str = "all", direction: str = "LR", output: t.Optional[str] = None
+    apps: str = "all", direction: str = "LR", output: Optional[str] = None
 ):
     """
     Prints out a graphviz .dot file for your schema.
@@ -73,8 +73,8 @@ def graph(
             sys.exit(f"These apps aren't recognised: {', '.join(delta)}.")
         app_names = given_app_names
 
-    tables: t.List[GraphTable] = []
-    relations: t.List[GraphRelation] = []
+    tables: list[GraphTable] = []
+    relations: list[GraphRelation] = []
 
     for app_name in app_names:
         app_config = finder.get_app_config(app_name=app_name)

piccolo/apps/shell/commands/run.py

@@ -1,5 +1,4 @@
 import sys
-import typing as t
 
 from piccolo.conf.apps import Finder
 from piccolo.table import Table
@@ -13,7 +12,7 @@ except ImportError:
     IPYTHON = False
 
 
-def start_ipython_shell(**tables: t.Type[Table]):  # pragma: no cover
+def start_ipython_shell(**tables: type[Table]):  # pragma: no cover
     if not IPYTHON:
         sys.exit(
             "Install iPython using `pip install ipython` to use this feature."

piccolo/apps/sql_shell/commands/run.py

@@ -2,7 +2,7 @@ import os
 import signal
 import subprocess
 import sys
-import typing as t
+from typing import cast
 
 from piccolo.engine.finder import engine_finder
 from piccolo.engine.postgres import PostgresEngine
@@ -24,7 +24,7 @@ def run() -> None:
 
     # Heavily inspired by Django's dbshell command
     if isinstance(engine, PostgresEngine):
-        engine = t.cast(PostgresEngine, engine)
+        engine = cast(PostgresEngine, engine)
 
         args = ["psql"]
 
@@ -56,9 +56,9 @@ def run() -> None:
             signal.signal(signal.SIGINT, sigint_handler)
 
     elif isinstance(engine, SQLiteEngine):
-        engine = t.cast(SQLiteEngine, engine)
+        engine = cast(SQLiteEngine, engine)
 
-        database = t.cast(str, engine.connection_kwargs.get("database"))
+        database = cast(str, engine.connection_kwargs.get("database"))
         if not database:
             sys.exit("Unable to determine which database to connect to.")
 

piccolo/apps/tester/commands/run.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import os
 import sys
-import typing as t
+from typing import Optional
 
 from piccolo.table import TABLE_REGISTRY
 
@@ -25,7 +25,7 @@ class set_env_var:
     def set_var(self, value: str):
         os.environ[self.var_name] = value
 
-    def get_var(self) -> t.Optional[str]:
+    def get_var(self) -> Optional[str]:
         return os.environ.get(self.var_name)
 
     def __enter__(self):
@@ -39,7 +39,7 @@ class set_env_var:
             self.set_var(self.existing_value)
 
 
-def run_pytest(pytest_args: t.List[str]) -> int:  # pragma: no cover
+def run_pytest(pytest_args: list[str]) -> int:  # pragma: no cover
     try:
         import pytest
     except ImportError:

piccolo/apps/user/commands/change_permissions.py

@@ -1,17 +1,17 @@
-import typing as t
+from typing import TYPE_CHECKING, Optional, Union
 
 from piccolo.apps.user.tables import BaseUser
 from piccolo.utils.warnings import Level, colored_string
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.columns import Column
 
 
 async def change_permissions(
     username: str,
-    admin: t.Optional[bool] = None,
-    superuser: t.Optional[bool] = None,
-    active: t.Optional[bool] = None,
+    admin: Optional[bool] = None,
+    superuser: Optional[bool] = None,
+    active: Optional[bool] = None,
 ):
     """
     Change a user's permissions.
@@ -34,7 +34,7 @@ async def change_permissions(
         )
         return
 
-    params: t.Dict[t.Union[Column, str], bool] = {}
+    params: dict[Union[Column, str], bool] = {}
 
     if admin is not None:
         params[BaseUser.admin] = admin

piccolo/apps/user/commands/create.py

@@ -1,6 +1,6 @@
 import sys
-import typing as t
 from getpass import getpass, getuser
+from typing import Optional
 
 from piccolo.apps.user.tables import BaseUser
 
@@ -57,12 +57,12 @@ def get_is_active() -> bool:
 
 
 def create(
-    username: t.Optional[str] = None,
-    email: t.Optional[str] = None,
-    password: t.Optional[str] = None,
-    is_admin: t.Optional[bool] = None,
-    is_superuser: t.Optional[bool] = None,
-    is_active: t.Optional[bool] = None,
+    username: Optional[str] = None,
+    email: Optional[str] = None,
+    password: Optional[str] = None,
+    is_admin: Optional[bool] = None,
+    is_superuser: Optional[bool] = None,
+    is_active: Optional[bool] = None,
 ):
     """
     Create a new user.

piccolo/apps/user/commands/list.py

@@ -1,4 +1,4 @@
-import typing as t
+from typing import Any
 
 from piccolo.apps.user.tables import BaseUser
 from piccolo.columns import Column
@@ -11,7 +11,7 @@ ORDER_BY_COLUMN_NAMES = [
 
 async def get_users(
     order_by: Column, ascending: bool, limit: int, page: int
-) -> t.List[t.Dict[str, t.Any]]:
+) -> list[dict[str, Any]]:
     return (
         await BaseUser.select(
             *BaseUser.all_columns(exclude=[BaseUser.password])

piccolo/apps/user/tables.py

@@ -8,7 +8,7 @@ import datetime
 import hashlib
 import logging
 import secrets
-import typing as t
+from typing import Any, Optional, Union
 
 from piccolo.columns import Boolean, Secret, Timestamp, Varchar
 from piccolo.columns.column_types import Serial
@@ -109,14 +109,14 @@ class BaseUser(Table, tablename="piccolo_user"):
     ###########################################################################
 
     @classmethod
-    def update_password_sync(cls, user: t.Union[str, int], password: str):
+    def update_password_sync(cls, user: Union[str, int], password: str):
         """
         A sync equivalent of :meth:`update_password`.
         """
         return run_sync(cls.update_password(user, password))
 
     @classmethod
-    async def update_password(cls, user: t.Union[str, int], password: str):
+    async def update_password(cls, user: Union[str, int], password: str):
         """
         The password is the raw password string e.g. ``'password123'``.
         The user can be a user ID, or a username.
@@ -139,7 +139,7 @@ class BaseUser(Table, tablename="piccolo_user"):
 
     @classmethod
     def hash_password(
-        cls, password: str, salt: str = "", iterations: t.Optional[int] = None
+        cls, password: str, salt: str = "", iterations: Optional[int] = None
     ) -> str:
         """
         Hashes the password, ready for storage, and for comparing during
@@ -167,7 +167,7 @@ class BaseUser(Table, tablename="piccolo_user"):
         ).hex()
         return f"pbkdf2_sha256${iterations}${salt}${hashed}"
 
-    def __setattr__(self, name: str, value: t.Any):
+    def __setattr__(self, name: str, value: Any):
         """
         Make sure that if the password is set, it's stored in a hashed form.
         """
@@ -177,7 +177,7 @@ class BaseUser(Table, tablename="piccolo_user"):
         super().__setattr__(name, value)
 
     @classmethod
-    def split_stored_password(cls, password: str) -> t.List[str]:
+    def split_stored_password(cls, password: str) -> list[str]:
         elements = password.split("$")
         if len(elements) != 4:
             raise ValueError("Unable to split hashed password")
@@ -186,14 +186,14 @@ class BaseUser(Table, tablename="piccolo_user"):
     ###########################################################################
 
     @classmethod
-    def login_sync(cls, username: str, password: str) -> t.Optional[int]:
+    def login_sync(cls, username: str, password: str) -> Optional[int]:
         """
         A sync equivalent of :meth:`login`.
         """
         return run_sync(cls.login(username, password))
 
     @classmethod
-    async def login(cls, username: str, password: str) -> t.Optional[int]:
+    async def login(cls, username: str, password: str) -> Optional[int]:
         """
         Make sure the user exists and the password is valid. If so, the
         ``last_login`` value is updated in the database.