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

piccolo/apps/migrations/commands/new.py

@@ -3,10 +3,10 @@ from __future__ import annotations
 import datetime
 import os
 import string
-import typing as t
 from dataclasses import dataclass
 from itertools import chain
 from types import ModuleType
+from typing import Optional
 
 import black
 import jinja2
@@ -33,7 +33,7 @@ JINJA_ENV = jinja2.Environment(
     loader=jinja2.FileSystemLoader(searchpath=TEMPLATE_DIRECTORY),
 )
 
-MIGRATION_MODULES: t.Dict[str, ModuleType] = {}
+MIGRATION_MODULES: dict[str, ModuleType] = {}
 
 VALID_PYTHON_MODULE_CHARACTERS = string.ascii_lowercase + string.digits + "_"
 
@@ -115,7 +115,7 @@ async def _create_new_migration(
     app_config: AppConfig,
     auto: bool = False,
     description: str = "",
-    auto_input: t.Optional[str] = None,
+    auto_input: Optional[str] = None,
 ) -> NewMigrationMeta:
     """
     Creates a new migration file on disk.
@@ -170,13 +170,13 @@ async def _create_new_migration(
 
 
 class AutoMigrationManager(BaseMigrationManager):
-    def __init__(self, auto_input: t.Optional[str] = None, *args, **kwargs):
+    def __init__(self, auto_input: Optional[str] = None, *args, **kwargs):
         self.auto_input = auto_input
         super().__init__(*args, **kwargs)
 
     async def get_alter_statements(
         self, app_config: AppConfig
-    ) -> t.List[AlterStatements]:
+    ) -> list[AlterStatements]:
         """
         Works out which alter statements are required.
         """
@@ -214,7 +214,7 @@ async def new(
     app_name: str,
     auto: bool = False,
     desc: str = "",
-    auto_input: t.Optional[str] = None,
+    auto_input: Optional[str] = None,
 ):
     """
     Creates a new migration file in the migrations folder.

piccolo/apps/migrations/tables.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import typing as t
+from typing import Optional
 
 from piccolo.columns import Timestamp, Varchar
 from piccolo.columns.defaults.timestamp import TimestampNow
@@ -14,8 +14,8 @@ class Migration(Table):
 
     @classmethod
     async def get_migrations_which_ran(
-        cls, app_name: t.Optional[str] = None
-    ) -> t.List[str]:
+        cls, app_name: Optional[str] = None
+    ) -> list[str]:
         """
         Returns the names of migrations which have already run, by inspecting
         the database.

piccolo/apps/playground/commands/run.py

@@ -8,10 +8,12 @@ import sys
 import uuid
 from decimal import Decimal
 from enum import Enum
+from typing import Optional
 
 from piccolo.columns import (
     JSON,
     UUID,
+    Array,
     Boolean,
     Date,
     ForeignKey,
@@ -24,7 +26,7 @@ from piccolo.columns import (
     Varchar,
 )
 from piccolo.columns.readable import Readable
-from piccolo.engine import PostgresEngine, SQLiteEngine
+from piccolo.engine import CockroachEngine, PostgresEngine, SQLiteEngine
 from piccolo.engine.base import Engine
 from piccolo.table import Table
 from piccolo.utils.warnings import colored_string
@@ -149,6 +151,7 @@ class Album(Table):
     band = ForeignKey(Band)
     release_date = Date()
     recorded_at = ForeignKey(RecordingStudio)
+    awards = Array(Varchar())
 
     @classmethod
     def get_readable(cls) -> Readable:
@@ -265,6 +268,7 @@ def populate():
                 Album.recorded_at: recording_studio_1,
                 Album.band: pythonistas,
                 Album.release_date: datetime.date(year=2021, month=1, day=1),
+                Album.awards: ["Grammy Award 2021"],
             }
         ),
         Album(
@@ -273,6 +277,7 @@ def populate():
                 Album.recorded_at: recording_studio_2,
                 Album.band: rustaceans,
                 Album.release_date: datetime.date(year=2022, month=2, day=2),
+                Album.awards: ["Mercury Prize 2022"],
             }
         ),
     ).run_sync()
@@ -280,28 +285,29 @@ def populate():
 
 def run(
     engine: str = "sqlite",
-    user: str = "piccolo",
-    password: str = "piccolo",
+    user: Optional[str] = None,
+    password: Optional[str] = None,
     database: str = "piccolo_playground",
     host: str = "localhost",
-    port: int = 5432,
+    port: Optional[int] = None,
     ipython_profile: bool = False,
 ):
     """
     Creates a test database to play with.
 
     :param engine:
-        Which database engine to use - options are sqlite or postgres
+        Which database engine to use - options are sqlite, postgres or
+        cockroach
     :param user:
-        Postgres user
+        Database user (ignored for SQLite)
     :param password:
-        Postgres password
+        Database password (ignored for SQLite)
     :param database:
-        Postgres database
+        Database name (ignored for SQLite)
     :param host:
-        Postgres host
+        Database host (ignored for SQLite)
     :param port:
-        Postgres port
+        Database port (ignored for SQLite)
     :param ipython_profile:
         Set to true to use your own IPython profile. Located at ~/.ipython/.
         For more info see the IPython docs
@@ -320,9 +326,19 @@ def run(
             {
                 "host": host,
                 "database": database,
-                "user": user,
-                "password": password,
-                "port": port,
+                "user": user or "piccolo",
+                "password": password or "piccolo",
+                "port": port or 5432,
+            }
+        )
+    elif engine.upper() == "COCKROACH":
+        db = CockroachEngine(
+            {
+                "host": host,
+                "database": database,
+                "user": user or "root",
+                "password": password or "",
+                "port": port or 26257,
             }
         )
     else:

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])