piccolo 1.14.0__tar.gz → 1.15.0__tar.gz

{piccolo-1.14.0 → piccolo-1.15.0}/PKG-INFO

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

piccolo-1.15.0/piccolo/__init__.py

@@ -0,0 +1 @@
+__VERSION__ = "1.15.0"

{piccolo-1.14.0 → piccolo-1.15.0}/piccolo/apps/user/tables.py

@@ -91,10 +91,14 @@ class BaseUser(Table, tablename="piccolo_user"):
             raise ValueError("A password must be provided.")
 
         if len(password) < cls._min_password_length:
-            raise ValueError("The password is too short.")
+            raise ValueError(
+                f"The password is too short. (min {cls._min_password_length})"
+            )
 
         if len(password) > cls._max_password_length:
-            raise ValueError("The password is too long.")
+            raise ValueError(
+                f"The password is too long. (max {cls._max_password_length})"
+            )
 
         if password.startswith("pbkdf2_sha256"):
             logger.warning(

{piccolo-1.14.0 → piccolo-1.15.0}/piccolo/query/base.py

@@ -79,9 +79,7 @@ class Query(t.Generic[TableInstance, QueryResponseType]):
                 if column._alias is not None:
                     json_column_names.append(column._alias)
                 elif len(column._meta.call_chain) > 0:
-                    json_column_names.append(
-                        column._meta.get_default_alias().replace("$", ".")
-                    )
+                    json_column_names.append(column._meta.get_default_alias())
                 else:
                     json_column_names.append(column._meta.name)
 

piccolo-1.15.0/piccolo/query/methods/refresh.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import typing as t
+
+from piccolo.utils.encoding import JSONDict
+from piccolo.utils.sync import run_sync
+
+if t.TYPE_CHECKING:  # pragma: no cover
+    from piccolo.columns import Column
+    from piccolo.table import Table
+
+
+class Refresh:
+    """
+    Used to refresh :class:`Table <piccolo.table.Table>` instances with the
+    latest data data from the database. Accessible via
+    :meth:`refresh <piccolo.table.Table.refresh>`.
+
+    :param instance:
+        The instance to refresh.
+    :param columns:
+        Which columns to refresh - it not specified, then all columns are
+        refreshed.
+    :param load_json:
+        Whether to load ``JSON`` / ``JSONB`` columns as objects, instead of
+        just a string.
+
+    """
+
+    def __init__(
+        self,
+        instance: Table,
+        columns: t.Optional[t.Sequence[Column]] = None,
+        load_json: bool = False,
+    ):
+        self.instance = instance
+
+        if columns:
+            for column in columns:
+                if len(column._meta.call_chain) > 0:
+                    raise ValueError(
+                        "We can't currently selectively refresh certain "
+                        "columns on child objects (e.g. Concert.band_1.name). "
+                        "Please just specify top level columns (e.g. "
+                        "Concert.band_1), and the entire child object will be "
+                        "refreshed."
+                    )
+
+        self.columns = columns
+        self.load_json = load_json
+
+    @property
+    def _columns(self) -> t.Sequence[Column]:
+        """
+        Works out which columns the user wants to refresh.
+        """
+        if self.columns:
+            return self.columns
+
+        return [
+            i for i in self.instance._meta.columns if not i._meta.primary_key
+        ]
+
+    def _get_columns(self, instance: Table, columns: t.Sequence[Column]):
+        """
+        If `prefetch` was used on the object, for example::
+
+            >>> await Band.objects(Band.manager)
+
+        We should also update the prefetched object.
+
+        It works multiple level deep. If we refresh this::
+
+            >>> await Album.objects(Album.band.manager).first()
+
+        It will update the nested `band` object, and also the `manager`
+        object.
+
+        """
+        from piccolo.columns.column_types import ForeignKey
+        from piccolo.table import Table
+
+        select_columns = []
+
+        for column in columns:
+            if isinstance(column, ForeignKey) and isinstance(
+                (child_instance := getattr(instance, column._meta.name)),
+                Table,
+            ):
+                select_columns.extend(
+                    self._get_columns(
+                        child_instance,
+                        # Fetch all columns (even the primary key, just in
+                        # case the foreign key now references a different row).
+                        column.all_columns(),
+                    )
+                )
+            else:
+                select_columns.append(column)
+
+        return select_columns
+
+    def _update_instance(self, instance: Table, data_dict: t.Dict):
+        """
+        Update the table instance. It is called recursively, if the instance
+        has child instances.
+        """
+        for key, value in data_dict.items():
+            if isinstance(value, dict) and not isinstance(value, JSONDict):
+                # If the value is a dict, then it's a child instance.
+                if all(i is None for i in value.values()):
+                    # If all values in the nested object are None, then we can
+                    # safely assume that the object itself is null, as the
+                    # primary key value must be null.
+                    setattr(instance, key, None)
+                else:
+                    self._update_instance(getattr(instance, key), value)
+            else:
+                setattr(instance, key, value)
+
+    async def run(
+        self, in_pool: bool = True, node: t.Optional[str] = None
+    ) -> Table:
+        """
+        Run it asynchronously. For example::
+
+            await my_instance.refresh().run()
+
+            # or for convenience:
+            await my_instance.refresh()
+
+        Modifies the instance in place, but also returns it as a convenience.
+
+        """
+        instance = self.instance
+
+        if not instance._exists_in_db:
+            raise ValueError("The instance doesn't exist in the database.")
+
+        pk_column = instance._meta.primary_key
+
+        primary_key_value = getattr(instance, pk_column._meta.name, None)
+
+        if primary_key_value is None:
+            raise ValueError("The instance's primary key value isn't defined.")
+
+        columns = self._columns
+        if not columns:
+            raise ValueError("No columns to fetch.")
+
+        select_columns = self._get_columns(
+            instance=self.instance, columns=columns
+        )
+
+        data_dict = (
+            await instance.__class__.select(*select_columns)
+            .where(pk_column == primary_key_value)
+            .output(nested=True, load_json=self.load_json)
+            .first()
+            .run(node=node, in_pool=in_pool)
+        )
+
+        if data_dict is None:
+            raise ValueError(
+                "The object doesn't exist in the database any more."
+            )
+
+        self._update_instance(instance=instance, data_dict=data_dict)
+
+        return instance
+
+    def __await__(self):
+        """
+        If the user doesn't explicity call :meth:`run`, proxy to it as a
+        convenience.
+        """
+        return self.run().__await__()
+
+    def run_sync(self, *args, **kwargs) -> Table:
+        """
+        Run it synchronously. For example::
+
+            my_instance.refresh().run_sync()
+
+        """
+        return run_sync(self.run(*args, **kwargs))

{piccolo-1.14.0 → piccolo-1.15.0}/piccolo/query/methods/select.py

@@ -406,6 +406,9 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
     def output(self: Self, *, load_json: bool, as_list: bool) -> SelectJSON:  # type: ignore  # noqa: E501
         ...
 
+    @t.overload
+    def output(self: Self, *, load_json: bool, nested: bool) -> Self: ...
+
     @t.overload
     def output(self: Self, *, nested: bool) -> Self: ...
 

{piccolo-1.14.0 → piccolo-1.15.0}/piccolo/table.py

@@ -541,7 +541,9 @@ class Table(metaclass=TableMetaclass):
         )
 
     def refresh(
-        self, columns: t.Optional[t.Sequence[Column]] = None
+        self,
+        columns: t.Optional[t.Sequence[Column]] = None,
+        load_json: bool = False,
     ) -> Refresh:
         """
         Used to fetch the latest data for this instance from the database.
@@ -551,6 +553,10 @@ class Table(metaclass=TableMetaclass):
             If you only want to refresh certain columns, specify them here.
             Otherwise all columns are refreshed.
 
+        :param load_json:
+            Whether to load ``JSON`` / ``JSONB`` columns as objects, instead of
+            just a string.
+
         Example usage::
 
             # Get an instance from the database.
@@ -564,7 +570,7 @@ class Table(metaclass=TableMetaclass):
             instance.refresh().run_sync()
 
         """
-        return Refresh(instance=self, columns=columns)
+        return Refresh(instance=self, columns=columns, load_json=load_json)
 
     @t.overload
     def get_related(

piccolo-1.15.0/piccolo/utils/encoding.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import typing as t
+
+try:
+    import orjson
+
+    ORJSON = True
+except ImportError:
+    import json
+
+    ORJSON = False
+
+
+def dump_json(data: t.Any, pretty: bool = False) -> str:
+    if ORJSON:
+        orjson_params: t.Dict[str, t.Any] = {"default": str}
+        if pretty:
+            orjson_params["option"] = (
+                orjson.OPT_INDENT_2 | orjson.OPT_APPEND_NEWLINE  # type: ignore
+            )
+        return orjson.dumps(data, **orjson_params).decode(  # type: ignore
+            "utf8"
+        )
+    else:
+        params: t.Dict[str, t.Any] = {"default": str}
+        if pretty:
+            params["indent"] = 2
+        return json.dumps(data, **params)  # type: ignore
+
+
+class JSONDict(dict):
+    """
+    Once we have parsed a JSON string into a dictionary, we can't distinguish
+    it from other dictionaries.
+
+    Sometimes we might want to - for example::
+
+        >>> await Album.select(
+        ...     Album.all_columns(),
+        ...     Album.recording_studio.all_columns()
+        ... ).output(
+        ...     nested=True,
+        ...     load_json=True
+        ... )
+
+        [{
+            'id': 1,
+            'band': 1,
+            'name': 'Awesome album 1',
+            'recorded_at': {
+                'id': 1,
+                'facilities': {'restaurant': True, 'mixing_desk': True},
+                'name': 'Abbey Road'
+            },
+            'release_date': datetime.date(2021, 1, 1)
+        }]
+
+    Facilities could be mistaken for a table.
+
+    """
+
+    ...
+
+
+def load_json(data: str) -> t.Any:
+    response = (
+        orjson.loads(data) if ORJSON else json.loads(data)  # type: ignore
+    )
+
+    if isinstance(response, dict):
+        return JSONDict(**response)
+
+    return response

{piccolo-1.14.0 → piccolo-1.15.0}/piccolo.egg-info/PKG-INFO

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

{piccolo-1.14.0 → piccolo-1.15.0}/tests/apps/user/test_tables.py

@@ -109,7 +109,7 @@ class TestLogin(TestCase):
             BaseUser.update_password_sync(username, malicious_password)
         self.assertEqual(
             manager.exception.__str__(),
-            "The password is too long.",
+            f"The password is too long. (max {BaseUser._max_password_length})",
         )
 
         # Test short passwords
@@ -118,7 +118,10 @@ class TestLogin(TestCase):
             BaseUser.update_password_sync(username, short_password)
         self.assertEqual(
             manager.exception.__str__(),
-            "The password is too short.",
+            (
+                "The password is too short. (min "
+                f"{BaseUser._min_password_length})"
+            ),
         )
 
         # Test no password
@@ -205,7 +208,11 @@ class TestCreateUser(TestCase):
             BaseUser.create_user_sync(username="bob", password="abc")
 
         self.assertEqual(
-            manager.exception.__str__(), "The password is too short."
+            manager.exception.__str__(),
+            (
+                "The password is too short. (min "
+                f"{BaseUser._min_password_length})"
+            ),
         )
 
     def test_long_password_error(self):
@@ -216,7 +223,8 @@ class TestCreateUser(TestCase):
             )
 
         self.assertEqual(
-            manager.exception.__str__(), "The password is too long."
+            manager.exception.__str__(),
+            f"The password is too long. (max {BaseUser._max_password_length})",
         )
 
     def test_no_username_error(self):

{piccolo-1.14.0 → piccolo-1.15.0}/tests/columns/m2m/test_m2m.py

@@ -4,6 +4,7 @@ import decimal
 import uuid
 from unittest import TestCase
 
+from piccolo.utils.encoding import JSONDict
 from tests.base import engines_skip
 
 try:
@@ -376,6 +377,9 @@ class TestM2MComplexSchema(TestCase):
 
             if isinstance(column, UUID):
                 self.assertIn(type(returned_value), (uuid.UUID, asyncpgUUID))
+            elif isinstance(column, (JSON, JSONB)):
+                self.assertEqual(type(returned_value), JSONDict)
+                self.assertEqual(original_value, returned_value)
             else:
                 self.assertEqual(
                     type(original_value),
@@ -401,6 +405,9 @@ class TestM2MComplexSchema(TestCase):
             if isinstance(column, UUID):
                 self.assertIn(type(returned_value), (uuid.UUID, asyncpgUUID))
                 self.assertEqual(str(original_value), str(returned_value))
+            elif isinstance(column, (JSON, JSONB)):
+                self.assertEqual(type(returned_value), JSONDict)
+                self.assertEqual(original_value, returned_value)
             else:
                 self.assertEqual(
                     type(original_value),