piccolo 1.13.1__tar.gz → 1.15.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.13.1
+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.13.1 → 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.13.1 → piccolo-1.15.0}/piccolo/columns/base.py

@@ -250,11 +250,11 @@ class ColumnMeta:
 
         if self.call_chain:
             column_name = (
-                "$".join(
+                ".".join(
                     t.cast(str, i._meta.db_column_name)
                     for i in self.call_chain
                 )
-                + f"${column_name}"
+                + f".{column_name}"
             )
 
         return column_name
@@ -291,7 +291,7 @@ class ColumnMeta:
                 'band$manager.name'
 
                 >>> Band.manager.name._meta.get_full_name(with_alias=True)
-                'band$manager.name AS "manager$name"'
+                'band$manager.name AS "manager.name"'
 
         :param include_quotes:
             If you're using the name in a SQL query, each component needs to be

{piccolo-1.13.1 → piccolo-1.15.0}/piccolo/engine/base.py

@@ -132,6 +132,13 @@ class Engine(t.Generic[TransactionClass], metaclass=ABCMeta):
     ):
         pass
 
+    def transform_response_to_dicts(self, results) -> t.List[t.Dict]:
+        """
+        If the database adapter returns something other than a list of
+        dictionaries, it should perform the transformation here.
+        """
+        return results
+
     @abstractmethod
     async def run_ddl(self, ddl: str, in_pool: bool = True):
         pass

{piccolo-1.13.1 → piccolo-1.15.0}/piccolo/engine/postgres.py

@@ -579,6 +579,13 @@ class PostgresEngine(Engine[PostgresTransaction]):
 
         return response
 
+    def transform_response_to_dicts(self, results) -> t.List[t.Dict]:
+        """
+        asyncpg returns a special Record object, so we need to convert it to
+        a dict.
+        """
+        return [dict(i) for i in results]
+
     def atomic(self) -> Atomic:
         return Atomic(engine=self)
 

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

@@ -45,20 +45,11 @@ class Query(t.Generic[TableInstance, QueryResponseType]):
             raise ValueError("Engine isn't defined.")
 
     async def _process_results(self, results) -> QueryResponseType:
-        if results:
-            keys = results[0].keys()
-            keys = [i.replace("$", ".") for i in keys]
-            if self.engine_type in ("postgres", "cockroach"):
-                # asyncpg returns a special Record object. We can pass it
-                # directly into zip without calling `values` on it. This can
-                # save us hundreds of microseconds, depending on the number of
-                # results.
-                raw = [dict(zip(keys, i)) for i in results]
-            else:
-                # SQLite returns a list of dictionaries.
-                raw = [dict(zip(keys, i.values())) for i in results]
-        else:
-            raw = []
+        raw = (
+            self.table._meta.db.transform_response_to_dicts(results)
+            if results
+            else []
+        )
 
         if hasattr(self, "_raw_response_callback"):
             self._raw_response_callback(raw)
@@ -88,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.13.1 → 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: ...
 
@@ -574,7 +577,7 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
         query += "{}"
         args.append(distinct.querystring)
 
-        columns_str = ", ".join("{}" for i in select_strings)
+        columns_str = ", ".join("{}" for _ in select_strings)
         query += f" {columns_str} FROM {self.table._meta.get_formatted_tablename()}"  # noqa: E501
         args.extend(select_strings)
 

{piccolo-1.13.1 → piccolo-1.15.0}/piccolo/querystring.py

@@ -246,7 +246,7 @@ class QueryString(Selectable):
         self, engine_type: str, with_alias: bool = True
     ) -> QueryString:
         if with_alias and self._alias:
-            return QueryString("{} AS " + self._alias, self)
+            return QueryString("{} AS " + f'"{self._alias}"', self)
         else:
             return self
 

{piccolo-1.13.1 → 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.13.1 → piccolo-1.15.0}/piccolo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.13.1
+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.13.1 → 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.13.1 → 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),