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

piccolo/testing/model_builder.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 import datetime
+import decimal
 import json
-import typing as t
+from collections.abc import Callable
 from decimal import Decimal
+from typing import Any, Optional, Union, cast
 from uuid import UUID
 
 from piccolo.columns import JSON, JSONB, Array, Column, ForeignKey
@@ -13,12 +15,13 @@ from piccolo.utils.sync import run_sync
 
 
 class ModelBuilder:
-    __DEFAULT_MAPPER: t.Dict[t.Type, t.Callable] = {
+    __DEFAULT_MAPPER: dict[type, Callable] = {
         bool: RandomBuilder.next_bool,
         bytes: RandomBuilder.next_bytes,
         datetime.date: RandomBuilder.next_date,
         datetime.datetime: RandomBuilder.next_datetime,
         float: RandomBuilder.next_float,
+        decimal.Decimal: RandomBuilder.next_decimal,
         int: RandomBuilder.next_int,
         str: RandomBuilder.next_str,
         datetime.time: RandomBuilder.next_time,
@@ -29,8 +32,8 @@ class ModelBuilder:
     @classmethod
     async def build(
         cls,
-        table_class: t.Type[TableInstance],
-        defaults: t.Optional[t.Dict[t.Union[Column, str], t.Any]] = None,
+        table_class: type[TableInstance],
+        defaults: Optional[dict[Union[Column, str], Any]] = None,
         persist: bool = True,
         minimal: bool = False,
     ) -> TableInstance:
@@ -80,8 +83,8 @@ class ModelBuilder:
     @classmethod
     def build_sync(
         cls,
-        table_class: t.Type[TableInstance],
-        defaults: t.Optional[t.Dict[t.Union[Column, str], t.Any]] = None,
+        table_class: type[TableInstance],
+        defaults: Optional[dict[Union[Column, str], Any]] = None,
         persist: bool = True,
         minimal: bool = False,
     ) -> TableInstance:
@@ -100,8 +103,8 @@ class ModelBuilder:
     @classmethod
     async def _build(
         cls,
-        table_class: t.Type[TableInstance],
-        defaults: t.Optional[t.Dict[t.Union[Column, str], t.Any]] = None,
+        table_class: type[TableInstance],
+        defaults: Optional[dict[Union[Column, str], Any]] = None,
         minimal: bool = False,
         persist: bool = True,
     ) -> TableInstance:
@@ -151,7 +154,7 @@ class ModelBuilder:
         return model
 
     @classmethod
-    def _randomize_attribute(cls, column: Column) -> t.Any:
+    def _randomize_attribute(cls, column: Column) -> Any:
         """
         Generate a random value for a column and apply formatting.
 
@@ -159,18 +162,18 @@ class ModelBuilder:
             Column class to randomize.
 
         """
-        random_value: t.Any
+        random_value: Any
         if column.value_type == Decimal:
             precision, scale = column._meta.params["digits"] or (4, 2)
-            random_value = RandomBuilder.next_float(
-                maximum=10 ** (precision - scale), scale=scale
+            random_value = RandomBuilder.next_decimal(
+                precision=precision, scale=scale
             )
         elif column.value_type == datetime.datetime:
             tz_aware = getattr(column, "tz_aware", False)
             random_value = RandomBuilder.next_datetime(tz_aware=tz_aware)
         elif column.value_type == list:
             length = RandomBuilder.next_int(maximum=10)
-            base_type = t.cast(Array, column).base_column.value_type
+            base_type = cast(Array, column).base_column.value_type
             random_value = [
                 cls.__DEFAULT_MAPPER[base_type]() for _ in range(length)
             ]

piccolo/testing/random_builder.py

@@ -1,9 +1,10 @@
 import datetime
+import decimal
 import enum
 import random
 import string
-import typing as t
 import uuid
+from typing import Any
 
 
 class RandomBuilder:
@@ -36,13 +37,24 @@ class RandomBuilder:
         )
 
     @classmethod
-    def next_enum(cls, e: t.Type[enum.Enum]) -> t.Any:
+    def next_enum(cls, e: type[enum.Enum]) -> Any:
         return random.choice([item.value for item in e])
 
     @classmethod
     def next_float(cls, minimum=0, maximum=2147483647, scale=5) -> float:
         return round(random.uniform(minimum, maximum), scale)
 
+    @classmethod
+    def next_decimal(
+        cls, precision: int = 4, scale: int = 2
+    ) -> decimal.Decimal:
+        # For precision 4 and scale 2, maximum needs to be 99.99.
+        maximum = (10 ** (precision - scale)) - (10 ** (-1 * scale))
+        float_number = cls.next_float(maximum=maximum, scale=scale)
+        # We convert float_number to a string first, otherwise the decimal
+        # value is slightly off due to floating point precision.
+        return decimal.Decimal(str(float_number))
+
     @classmethod
     def next_int(cls, minimum=0, maximum=2147483647) -> int:
         return random.randint(minimum, maximum)

piccolo/testing/test_case.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import typing as t
+from typing import Optional
 from unittest import IsolatedAsyncioTestCase, TestCase
 
 from piccolo.engine import Engine, engine_finder
@@ -30,7 +30,7 @@ class TableTest(TestCase):
 
     """  # noqa: E501
 
-    tables: t.List[t.Type[Table]]
+    tables: list[type[Table]]
 
     def setUp(self) -> None:
         create_db_tables_sync(*self.tables)
@@ -54,7 +54,7 @@ class AsyncTableTest(IsolatedAsyncioTestCase):
 
     """
 
-    tables: t.List[t.Type[Table]]
+    tables: list[type[Table]]
 
     async def asyncSetUp(self) -> None:
         await create_db_tables(*self.tables)
@@ -106,7 +106,7 @@ class AsyncTransactionTest(IsolatedAsyncioTestCase):
     #
     #     ...
     #
-    db: t.Optional[Engine] = None
+    db: Optional[Engine] = None
 
     async def asyncSetUp(self) -> None:
         db = self.db or engine_finder()

piccolo/utils/dictionary.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-import typing as t
+from typing import Any
 
 
-def make_nested(dictionary: t.Dict[str, t.Any]) -> t.Dict[str, t.Any]:
+def make_nested(dictionary: dict[str, Any]) -> dict[str, Any]:
     """
     Rows are returned from the database as a flat dictionary, with keys such
     as ``'manager.name'`` if the column belongs to a related table.
@@ -20,7 +20,7 @@ def make_nested(dictionary: t.Dict[str, t.Any]) -> t.Dict[str, t.Any]:
         {'name': 'Pythonistas', 'band': {'name': 'Guido'}}
 
     """
-    output: t.Dict[str, t.Any] = {}
+    output: dict[str, Any] = {}
 
     items = list(dictionary.items())
     items.sort(key=lambda x: x[0])

piccolo/utils/encoding.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import typing as t
+from typing import Any
 
 try:
     import orjson
@@ -12,9 +12,9 @@ except ImportError:
     ORJSON = False
 
 
-def dump_json(data: t.Any, pretty: bool = False) -> str:
+def dump_json(data: Any, pretty: bool = False) -> str:
     if ORJSON:
-        orjson_params: t.Dict[str, t.Any] = {"default": str}
+        orjson_params: dict[str, Any] = {"default": str}
         if pretty:
             orjson_params["option"] = (
                 orjson.OPT_INDENT_2 | orjson.OPT_APPEND_NEWLINE  # type: ignore
@@ -23,7 +23,7 @@ def dump_json(data: t.Any, pretty: bool = False) -> str:
             "utf8"
         )
     else:
-        params: t.Dict[str, t.Any] = {"default": str}
+        params: dict[str, Any] = {"default": str}
         if pretty:
             params["indent"] = 2
         return json.dumps(data, **params)  # type: ignore
@@ -63,7 +63,7 @@ class JSONDict(dict):
     ...
 
 
-def load_json(data: str) -> t.Any:
+def load_json(data: str) -> Any:
     response = (
         orjson.loads(data) if ORJSON else json.loads(data)  # type: ignore
     )

piccolo/utils/lazy_loader.py

@@ -3,7 +3,7 @@ from __future__ import absolute_import, division, print_function
 
 import importlib
 import types
-import typing as t
+from typing import Any
 
 
 class LazyLoader(types.ModuleType):
@@ -48,10 +48,10 @@ class LazyLoader(types.ModuleType):
             else:
                 raise exc from exc
 
-    def __getattr__(self, item) -> t.Any:
+    def __getattr__(self, item) -> Any:
         module = self._load()
         return getattr(module, item)
 
-    def __dir__(self) -> t.List[str]:
+    def __dir__(self) -> list[str]:
         module = self._load()
         return dir(module)

piccolo/utils/list.py

@@ -1,11 +1,12 @@
-import typing as t
+from collections.abc import Sequence
+from typing import TypeVar, Union
 
-ElementType = t.TypeVar("ElementType")
+ElementType = TypeVar("ElementType")
 
 
 def flatten(
-    items: t.Sequence[t.Union[ElementType, t.List[ElementType]]]
-) -> t.List[ElementType]:
+    items: Sequence[Union[ElementType, list[ElementType]]]
+) -> list[ElementType]:
     """
     Takes a sequence of elements, and flattens it out. For example::
 
@@ -17,7 +18,7 @@ def flatten(
         await Band.select(Band.name, Band.manager.all_columns())
 
     """
-    _items: t.List[ElementType] = []
+    _items: list[ElementType] = []
     for item in items:
         if isinstance(item, list):
             _items.extend(item)
@@ -27,9 +28,7 @@ def flatten(
     return _items
 
 
-def batch(
-    data: t.List[ElementType], chunk_size: int
-) -> t.List[t.List[ElementType]]:
+def batch(data: list[ElementType], chunk_size: int) -> list[list[ElementType]]:
     """
     Breaks the list down into sublists of the given ``chunk_size``. The last
     sublist may have fewer elements than ``chunk_size``::

piccolo/utils/objects.py

@@ -1,16 +1,14 @@
 from __future__ import annotations
 
-import typing as t
+from typing import TYPE_CHECKING, Any
 
 from piccolo.columns.column_types import ForeignKey
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.table import Table
 
 
-def make_nested_object(
-    row: t.Dict[str, t.Any], table_class: t.Type[Table]
-) -> Table:
+def make_nested_object(row: dict[str, Any], table_class: type[Table]) -> Table:
     """
     Takes a nested dictionary such as this:
 
@@ -38,7 +36,7 @@ def make_nested_object(
         1
 
     """
-    table_params: t.Dict[str, t.Any] = {}
+    table_params: dict[str, Any] = {}
 
     for key, value in row.items():
         if isinstance(value, dict):

piccolo/utils/pydantic.py

@@ -2,9 +2,10 @@ from __future__ import annotations
 
 import itertools
 import json
-import typing as t
 from collections import defaultdict
+from collections.abc import Callable
 from functools import partial
+from typing import Any, Optional, Union
 
 import pydantic
 
@@ -30,7 +31,7 @@ except ImportError:
     JsonDict = dict  # type: ignore
 
 
-def pydantic_json_validator(value: t.Optional[str], required: bool = True):
+def pydantic_json_validator(value: Optional[str], required: bool = True):
     if value is None:
         if required:
             raise ValueError("The JSON value wasn't provided.")
@@ -45,7 +46,7 @@ def pydantic_json_validator(value: t.Optional[str], required: bool = True):
         return value
 
 
-def is_table_column(column: Column, table: t.Type[Table]) -> bool:
+def is_table_column(column: Column, table: type[Table]) -> bool:
     """
     Verify that the given ``Column`` belongs to the given ``Table``.
     """
@@ -60,9 +61,7 @@ def is_table_column(column: Column, table: t.Type[Table]) -> bool:
     return False
 
 
-def validate_columns(
-    columns: t.Tuple[Column, ...], table: t.Type[Table]
-) -> bool:
+def validate_columns(columns: tuple[Column, ...], table: type[Table]) -> bool:
     """
     Verify that each column is a ``Column``` instance, and its parent is the
     given ``Table``.
@@ -74,9 +73,7 @@ def validate_columns(
     )
 
 
-def get_array_value_type(
-    column: Array, inner: t.Optional[t.Type] = None
-) -> t.Type:
+def get_array_value_type(column: Array, inner: Optional[type] = None) -> type:
     """
     Gets the correct type for an ``Array`` column (which might be
     multidimensional).
@@ -86,14 +83,14 @@ def get_array_value_type(
     else:
         inner_type = get_pydantic_value_type(column.base_column)
 
-    return t.List[inner_type]  # type: ignore
+    return list[inner_type]  # type: ignore
 
 
-def get_pydantic_value_type(column: Column) -> t.Type:
+def get_pydantic_value_type(column: Column) -> type:
     """
     Map the Piccolo ``Column`` to a Pydantic type.
     """
-    value_type: t.Type
+    value_type: type
 
     if isinstance(column, (Decimal, Numeric)):
         value_type = pydantic.condecimal(
@@ -112,20 +109,20 @@ def get_pydantic_value_type(column: Column) -> t.Type:
 
 
 def create_pydantic_model(
-    table: t.Type[Table],
-    nested: t.Union[bool, t.Tuple[ForeignKey, ...]] = False,
-    exclude_columns: t.Tuple[Column, ...] = (),
-    include_columns: t.Tuple[Column, ...] = (),
+    table: type[Table],
+    nested: Union[bool, tuple[ForeignKey, ...]] = False,
+    exclude_columns: tuple[Column, ...] = (),
+    include_columns: tuple[Column, ...] = (),
     include_default_columns: bool = False,
     include_readable: bool = False,
     all_optional: bool = False,
-    model_name: t.Optional[str] = None,
+    model_name: Optional[str] = None,
     deserialize_json: bool = False,
     recursion_depth: int = 0,
     max_recursion_depth: int = 5,
-    pydantic_config: t.Optional[pydantic.config.ConfigDict] = None,
-    json_schema_extra: t.Optional[t.Dict[str, t.Any]] = None,
-) -> t.Type[pydantic.BaseModel]:
+    pydantic_config: Optional[pydantic.config.ConfigDict] = None,
+    json_schema_extra: Optional[dict[str, Any]] = None,
+) -> type[pydantic.BaseModel]:
     """
     Create a Pydantic model representing a table.
 
@@ -205,8 +202,8 @@ def create_pydantic_model(
 
     ###########################################################################
 
-    columns: t.Dict[str, t.Any] = {}
-    validators: t.Dict[str, t.Callable] = {}
+    columns: dict[str, Any] = {}
+    validators: dict[str, Callable] = {}
 
     piccolo_columns = tuple(
         table._meta.columns
@@ -264,11 +261,11 @@ def create_pydantic_model(
         else:
             value_type = get_pydantic_value_type(column=column)
 
-        _type = t.Optional[value_type] if is_optional else value_type
+        _type = Optional[value_type] if is_optional else value_type
 
         #######################################################################
 
-        params: t.Dict[str, t.Any] = {}
+        params: dict[str, Any] = {}
         if is_optional:
             params["default"] = None
 

piccolo/utils/sql_values.py

@@ -1,17 +1,17 @@
 from __future__ import annotations
 
 import functools
-import typing as t
 from enum import Enum
+from typing import TYPE_CHECKING, Any
 
 from piccolo.utils.encoding import dump_json
 from piccolo.utils.warnings import colored_warning
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:  # pragma: no cover
     from piccolo.columns import Column
 
 
-def convert_to_sql_value(value: t.Any, column: Column) -> t.Any:
+def convert_to_sql_value(value: Any, column: Column) -> Any:
     """
     Some values which can be passed into Piccolo queries aren't valid in the
     database. For example, Enums, Table instances, and dictionaries for JSON

piccolo/utils/sync.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
 
 import asyncio
-import typing as t
+from collections.abc import Coroutine
 from concurrent.futures import Future, ThreadPoolExecutor
+from typing import Any, TypeVar
 
-ReturnType = t.TypeVar("ReturnType")
+ReturnType = TypeVar("ReturnType")
 
 
 def run_sync(
-    coroutine: t.Coroutine[t.Any, t.Any, ReturnType],
+    coroutine: Coroutine[Any, Any, ReturnType],
 ) -> ReturnType:
     """
     Run the coroutine synchronously - trying to accommodate as many edge cases

piccolo/utils/warnings.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import typing as t
 import warnings
 from enum import Enum
 
@@ -21,7 +20,7 @@ def colored_string(message: str, level: Level = Level.medium) -> str:
 
 def colored_warning(
     message: str,
-    category: t.Type[Warning] = Warning,
+    category: type[Warning] = Warning,
     stacklevel: int = 3,
     level: Level = Level.medium,
 ):

{piccolo-1.27.1.dist-info → piccolo-1.29.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: piccolo
-Version: 1.27.1
+Version: 1.29.0
 Summary: A fast, user friendly ORM and query builder which supports asyncio.
 Home-page: https://github.com/piccolo-orm/piccolo
 Author: Daniel Townsend