arkindex-base-worker 0.4.0rc6__py3-none-any.whl → 0.5.0__py3-none-any.whl

arkindex_worker/worker/element.py

@@ -5,12 +5,12 @@ ElementsWorker methods for elements and element types.
 import os
 from collections.abc import Iterable
 from operator import attrgetter
-from typing import NamedTuple
 from uuid import UUID
 from warnings import warn
 
 from peewee import IntegrityError
 
+from arkindex.exceptions import ErrorResponse
 from arkindex_worker import logger
 from arkindex_worker.cache import CachedElement, CachedImage, unsupported_cache
 from arkindex_worker.models import Element
@@ -22,19 +22,10 @@ from arkindex_worker.utils import (
 )
 
 
-class ElementType(NamedTuple):
+class MissingElementType(Exception):
     """
-    Arkindex Type of an element
-    """
-
-    name: str
-    slug: str
-    is_folder: bool
-
-
-class MissingTypeError(Exception):
-    """
-    A required element type was not found in a corpus.
+    Raised when the specified element type was not found in the corpus and
+    the worker cannot create it.
     """
 
 
@@ -67,61 +58,96 @@ class ElementMixin:
         }
         count = len(self.corpus_types)
         logger.info(
-            f'Loaded {count} element {pluralize("type", count)} in corpus ({self.corpus_id}).'
+            f"Loaded {count} element {pluralize('type', count)} in corpus ({self.corpus_id})."
         )
 
     @unsupported_cache
-    def create_required_types(self, element_types: list[ElementType]):
-        """Creates given element types in the corpus.
+    def create_element_type(
+        self, slug: str, name: str, is_folder: bool = False
+    ) -> None:
+        """
+        Create an element type on the given corpus.
 
-        :param element_types: The missing element types to create.
+        :param slug: Slug of the element type.
+        :param name: Name of the element type.
+        :param is_folder: Whether an element with this type can contain other elements or not.
         """
-        for element_type in element_types:
-            self.api_client.request(
+        assert slug and isinstance(slug, str), (
+            "slug shouldn't be null and should be of type str"
+        )
+        assert name and isinstance(name, str), (
+            "name shouldn't be null and should be of type str"
+        )
+        assert is_folder is not None and isinstance(is_folder, bool), (
+            "is_folder shouldn't be null and should be of type bool"
+        )
+
+        try:
+            element_type = self.api_client.request(
                 "CreateElementType",
                 body={
-                    "slug": element_type.slug,
-                    "display_name": element_type.name,
-                    "folder": element_type.is_folder,
+                    "slug": slug,
+                    "display_name": name,
+                    "folder": is_folder,
                     "corpus": self.corpus_id,
                 },
             )
-            logger.info(f"Created a new element type with slug {element_type.slug}")
+            self.corpus_types[slug] = element_type
+            logger.info(f"Created a new element type with slug `{slug}`.")
+        except ErrorResponse as e:
+            # Only reload for 400 errors
+            if e.status_code != 400:
+                raise
+
+            # Reload and make sure we have the element type now
+            logger.warning(
+                f"Unable to create the element type `{slug}`. Refreshing corpus element types cache."
+            )
+            self.list_corpus_types()
+            assert slug in self.corpus_types, (
+                f"Missing element type `{slug}` even after refreshing."
+            )
 
     def check_required_types(
-        self, *type_slugs: str, create_missing: bool = False
-    ) -> bool:
+        self, type_slugs: list[str], create_missing: bool = False
+    ) -> None:
         """
-        Check that a corpus has a list of required element types,
-        and raise an exception if any of them are missing.
+        Check that every element type needed is available in the corpus.
+        Missing ones may be created automatically if needed.
 
-        :param *type_slugs: Type slugs to look for.
-        :param create_missing: Whether missing types should be created.
-        :returns: Whether all of the specified type slugs have been found.
-        :raises MissingTypeError: If any of the specified type slugs were not found.
+        :param type_slugs: Element type slugs to search.
+        :param create_missing: Whether the missing types should be created. Defaults to False.
+        :raises MissingElementType: When an entity type is missing and cannot be created.
         """
-        assert len(type_slugs), "At least one element type slug is required."
-        assert all(
-            isinstance(slug, str) for slug in type_slugs
-        ), "Element type slugs must be strings."
+        assert type_slugs and isinstance(type_slugs, list), (
+            "type_slugs shouldn't be null and should be of type list"
+        )
+
+        for index, slug in enumerate(type_slugs):
+            assert isinstance(slug, str), (
+                f"Element type at index {index} in type_slugs: Should be of type str"
+            )
+
+        assert create_missing is not None and isinstance(create_missing, bool), (
+            "create_missing shouldn't be null and should be of type bool"
+        )
 
         if not self.corpus_types:
             self.list_corpus_types()
 
-        missing_slugs = set(type_slugs) - set(self.corpus_types)
-        if missing_slugs:
-            if create_missing:
-                self.create_required_types(
-                    element_types=[
-                        ElementType(slug, slug, False) for slug in missing_slugs
-                    ],
-                )
-            else:
-                raise MissingTypeError(
-                    f'Element {pluralize("type", len(missing_slugs))} {", ".join(sorted(missing_slugs))} were not found in corpus ({self.corpus_id}).'
+        for slug in type_slugs:
+            # Do nothing if the type already exists
+            if slug in self.corpus_types:
+                continue
+
+            # Do not create missing if not requested
+            if not create_missing:
+                raise MissingElementType(
+                    f"Element type `{slug}` was not in the corpus."
                 )
 
-        return True
+            # Create the type if non-existent
+            self.create_element_type(slug=slug, name=slug)
 
     @unsupported_cache
     def create_sub_element(
@@ -146,18 +172,18 @@ class ElementMixin:
         :param slim_output: Whether to return the child ID or the full child.
         :returns: UUID of the created element.
         """
-        assert element and isinstance(
-            element, Element
-        ), "element shouldn't be null and should be of type Element"
-        assert type and isinstance(
-            type, str
-        ), "type shouldn't be null and should be of type str"
-        assert name and isinstance(
-            name, str
-        ), "name shouldn't be null and should be of type str"
-        assert polygon is None or isinstance(
-            polygon, list
-        ), "polygon should be None or a list"
+        assert element and isinstance(element, Element), (
+            "element shouldn't be null and should be of type Element"
+        )
+        assert type and isinstance(type, str), (
+            "type shouldn't be null and should be of type str"
+        )
+        assert name and isinstance(name, str), (
+            "name shouldn't be null and should be of type str"
+        )
+        assert polygon is None or isinstance(polygon, list), (
+            "polygon should be None or a list"
+        )
         if polygon is not None:
             assert len(polygon) >= 3, "polygon should have at least three points"
             assert all(
@@ -177,7 +203,9 @@ class ElementMixin:
             except ValueError as e:
                 raise ValueError("image is not a valid uuid.") from e
         if polygon and image is None:
-            assert element.zone, "An image or a parent with an image is required to create an element with a polygon."
+            assert element.zone, (
+                "An image or a parent with an image is required to create an element with a polygon."
+            )
         assert isinstance(slim_output, bool), "slim_output should be of type bool"
 
         if self.is_read_only:
@@ -231,56 +259,61 @@ class ElementMixin:
         :return: List of dicts, with each dict having a single key, ``id``, holding the UUID of each created element.
         """
         if isinstance(parent, Element):
-            assert parent.get(
-                "zone"
-            ), "create_elements cannot be used on parents without zones"
+            assert parent.get("zone"), (
+                "create_elements cannot be used on parents without zones"
+            )
         elif isinstance(parent, CachedElement):
-            assert (
-                parent.image_id
-            ), "create_elements cannot be used on parents without images"
+            assert parent.image_id, (
+                "create_elements cannot be used on parents without images"
+            )
         else:
             raise TypeError(
                 "Parent element should be an Element or CachedElement instance"
             )
 
-        assert elements and isinstance(
-            elements, list
-        ), "elements shouldn't be null and should be of type list"
+        assert elements and isinstance(elements, list), (
+            "elements shouldn't be null and should be of type list"
+        )
 
         for index, element in enumerate(elements):
-            assert isinstance(
-                element, dict
-            ), f"Element at index {index} in elements: Should be of type dict"
+            assert isinstance(element, dict), (
+                f"Element at index {index} in elements: Should be of type dict"
+            )
 
             name = element.get("name")
-            assert (
-                name and isinstance(name, str)
-            ), f"Element at index {index} in elements: name shouldn't be null and should be of type str"
+            assert name and isinstance(name, str), (
+                f"Element at index {index} in elements: name shouldn't be null and should be of type str"
+            )
 
             type = element.get("type")
-            assert (
-                type and isinstance(type, str)
-            ), f"Element at index {index} in elements: type shouldn't be null and should be of type str"
+            assert type and isinstance(type, str), (
+                f"Element at index {index} in elements: type shouldn't be null and should be of type str"
+            )
 
             polygon = element.get("polygon")
-            assert (
-                polygon and isinstance(polygon, list)
-            ), f"Element at index {index} in elements: polygon shouldn't be null and should be of type list"
-            assert (
-                len(polygon) >= 3
-            ), f"Element at index {index} in elements: polygon should have at least three points"
+            assert polygon and isinstance(polygon, list), (
+                f"Element at index {index} in elements: polygon shouldn't be null and should be of type list"
+            )
+            assert len(polygon) >= 3, (
+                f"Element at index {index} in elements: polygon should have at least three points"
+            )
             assert all(
                 isinstance(point, list) and len(point) == 2 for point in polygon
-            ), f"Element at index {index} in elements: polygon points should be lists of two items"
+            ), (
+                f"Element at index {index} in elements: polygon points should be lists of two items"
+            )
             assert all(
                 isinstance(coord, int | float) for point in polygon for coord in point
-            ), f"Element at index {index} in elements: polygon points should be lists of two numbers"
+            ), (
+                f"Element at index {index} in elements: polygon points should be lists of two numbers"
+            )
 
             confidence = element.get("confidence")
-            assert (
-                confidence is None
-                or (isinstance(confidence, float) and 0 <= confidence <= 1)
-            ), f"Element at index {index} in elements: confidence should be None or a float in [0..1] range"
+            assert confidence is None or (
+                isinstance(confidence, float) and 0 <= confidence <= 1
+            ), (
+                f"Element at index {index} in elements: confidence should be None or a float in [0..1] range"
+            )
 
         if self.is_read_only:
             logger.warning("Cannot create elements as this worker is in read-only mode")
@@ -347,12 +380,12 @@ class ElementMixin:
         :param child: Child element.
         :returns: A dict from the ``CreateElementParent`` API endpoint.
         """
-        assert parent and isinstance(
-            parent, Element
-        ), "parent shouldn't be null and should be of type Element"
-        assert child and isinstance(
-            child, Element
-        ), "child shouldn't be null and should be of type Element"
+        assert parent and isinstance(parent, Element), (
+            "parent shouldn't be null and should be of type Element"
+        )
+        assert child and isinstance(child, Element), (
+            "child shouldn't be null and should be of type Element"
+        )
 
         if self.is_read_only:
             logger.warning("Cannot link elements as this worker is in read-only mode")
@@ -381,18 +414,18 @@ class ElementMixin:
 
         :returns: A list containing the string UUID of each child linked to the parent.
         """
-        assert parent and isinstance(
-            parent, Element
-        ), "parent shouldn't be null and should be of type Element"
+        assert parent and isinstance(parent, Element), (
+            "parent shouldn't be null and should be of type Element"
+        )
 
-        assert children and isinstance(
-            children, list
-        ), "children shouldn't be null and should be of type list"
+        assert children and isinstance(children, list), (
+            "children shouldn't be null and should be of type list"
+        )
 
         for index, child in enumerate(children):
-            assert isinstance(
-                child, Element
-            ), f"Child at index {index} in children: Should be of type Element"
+            assert isinstance(child, Element), (
+                f"Child at index {index} in children: Should be of type Element"
+            )
 
         if self.is_read_only:
             logger.warning("Cannot link elements as this worker is in read-only mode")
@@ -430,9 +463,9 @@ class ElementMixin:
 
         :returns: A dict from the ``PartialUpdateElement`` API endpoint.
         """
-        assert element and isinstance(
-            element, Element | CachedElement
-        ), "element shouldn't be null and should be an Element or CachedElement"
+        assert element and isinstance(element, Element | CachedElement), (
+            "element shouldn't be null and should be an Element or CachedElement"
+        )
 
         if "type" in kwargs:
             assert isinstance(kwargs["type"], str), "type should be a str"
@@ -459,9 +492,9 @@ class ElementMixin:
 
         if "rotation_angle" in kwargs:
             rotation_angle = kwargs["rotation_angle"]
-            assert (
-                isinstance(rotation_angle, int) and rotation_angle >= 0
-            ), "rotation_angle should be a positive integer"
+            assert isinstance(rotation_angle, int) and rotation_angle >= 0, (
+                "rotation_angle should be a positive integer"
+            )
 
         if "mirrored" in kwargs:
             assert isinstance(kwargs["mirrored"], bool), "mirrored should be a boolean"
@@ -571,22 +604,22 @@ class ElementMixin:
                 DeprecationWarning,
                 stacklevel=1,
             )
-            assert isinstance(
-                transcription_worker_version, str | bool
-            ), "transcription_worker_version should be of type str or bool"
+            assert isinstance(transcription_worker_version, str | bool), (
+                "transcription_worker_version should be of type str or bool"
+            )
             if isinstance(transcription_worker_version, bool):
-                assert (
-                    transcription_worker_version is False
-                ), "if of type bool, transcription_worker_version can only be set to False"
+                assert transcription_worker_version is False, (
+                    "if of type bool, transcription_worker_version can only be set to False"
+                )
             query_params["transcription_worker_version"] = transcription_worker_version
         if transcription_worker_run is not None:
-            assert isinstance(
-                transcription_worker_run, str | bool
-            ), "transcription_worker_run should be of type str or bool"
+            assert isinstance(transcription_worker_run, str | bool), (
+                "transcription_worker_run should be of type str or bool"
+            )
             if isinstance(transcription_worker_run, bool):
-                assert (
-                    transcription_worker_run is False
-                ), "if of type bool, transcription_worker_run can only be set to False"
+                assert transcription_worker_run is False, (
+                    "if of type bool, transcription_worker_run can only be set to False"
+                )
             query_params["transcription_worker_run"] = transcription_worker_run
         if type:
             assert isinstance(type, str), "type should be of type str"
@@ -598,14 +631,14 @@ class ElementMixin:
             assert isinstance(with_corpus, bool), "with_corpus should be of type bool"
             query_params["with_corpus"] = with_corpus
         if with_has_children is not None:
-            assert isinstance(
-                with_has_children, bool
-            ), "with_has_children should be of type bool"
+            assert isinstance(with_has_children, bool), (
+                "with_has_children should be of type bool"
+            )
             query_params["with_has_children"] = with_has_children
         if with_metadata is not None:
-            assert isinstance(
-                with_metadata, bool
-            ), "with_metadata should be of type bool"
+            assert isinstance(with_metadata, bool), (
+                "with_metadata should be of type bool"
+            )
             query_params["with_metadata"] = with_metadata
         if with_zone is not None:
             assert isinstance(with_zone, bool), "with_zone should be of type bool"
@@ -616,22 +649,22 @@ class ElementMixin:
                 DeprecationWarning,
                 stacklevel=1,
             )
-            assert isinstance(
-                worker_version, str | bool
-            ), "worker_version should be of type str or bool"
+            assert isinstance(worker_version, str | bool), (
+                "worker_version should be of type str or bool"
+            )
             if isinstance(worker_version, bool):
-                assert (
-                    worker_version is False
-                ), "if of type bool, worker_version can only be set to False"
+                assert worker_version is False, (
+                    "if of type bool, worker_version can only be set to False"
+                )
             query_params["worker_version"] = worker_version
         if worker_run is not None:
-            assert isinstance(
-                worker_run, str | bool
-            ), "worker_run should be of type str or bool"
+            assert isinstance(worker_run, str | bool), (
+                "worker_run should be of type str or bool"
+            )
             if isinstance(worker_run, bool):
-                assert (
-                    worker_run is False
-                ), "if of type bool, worker_run can only be set to False"
+                assert worker_run is False, (
+                    "if of type bool, worker_run can only be set to False"
+                )
             query_params["worker_run"] = worker_run
 
         if not self.use_cache:
@@ -640,14 +673,13 @@ class ElementMixin:
             )
 
         # Checking that we only received query_params handled by the cache
-        assert (
-            set(query_params.keys())
-            <= {
-                "type",
-                "worker_version",
-                "worker_run",
-            }
-        ), "When using the local cache, you can only filter by 'type' and/or 'worker_version' and/or 'worker_run'"
+        assert set(query_params.keys()) <= {
+            "type",
+            "worker_version",
+            "worker_run",
+        }, (
+            "When using the local cache, you can only filter by 'type' and/or 'worker_version' and/or 'worker_run'"
+        )
 
         query = CachedElement.select()
         if type:
@@ -729,9 +761,9 @@ class ElementMixin:
         :return: An iterable of dicts from the ``ListElementChildren`` API endpoint,
            or an iterable of [CachedElement][arkindex_worker.cache.CachedElement] when caching is enabled.
         """
-        assert element and isinstance(
-            element, Element | CachedElement
-        ), "element shouldn't be null and should be an Element or CachedElement"
+        assert element and isinstance(element, Element | CachedElement), (
+            "element shouldn't be null and should be an Element or CachedElement"
+        )
         query_params = {}
         if folder is not None:
             assert isinstance(folder, bool), "folder should be of type bool"
@@ -748,22 +780,22 @@ class ElementMixin:
                 DeprecationWarning,
                 stacklevel=1,
             )
-            assert isinstance(
-                transcription_worker_version, str | bool
-            ), "transcription_worker_version should be of type str or bool"
+            assert isinstance(transcription_worker_version, str | bool), (
+                "transcription_worker_version should be of type str or bool"
+            )
             if isinstance(transcription_worker_version, bool):
-                assert (
-                    transcription_worker_version is False
-                ), "if of type bool, transcription_worker_version can only be set to False"
+                assert transcription_worker_version is False, (
+                    "if of type bool, transcription_worker_version can only be set to False"
+                )
             query_params["transcription_worker_version"] = transcription_worker_version
         if transcription_worker_run is not None:
-            assert isinstance(
-                transcription_worker_run, str | bool
-            ), "transcription_worker_run should be of type str or bool"
+            assert isinstance(transcription_worker_run, str | bool), (
+                "transcription_worker_run should be of type str or bool"
+            )
             if isinstance(transcription_worker_run, bool):
-                assert (
-                    transcription_worker_run is False
-                ), "if of type bool, transcription_worker_run can only be set to False"
+                assert transcription_worker_run is False, (
+                    "if of type bool, transcription_worker_run can only be set to False"
+                )
             query_params["transcription_worker_run"] = transcription_worker_run
         if type:
             assert isinstance(type, str), "type should be of type str"
@@ -775,14 +807,14 @@ class ElementMixin:
             assert isinstance(with_corpus, bool), "with_corpus should be of type bool"
             query_params["with_corpus"] = with_corpus
         if with_has_children is not None:
-            assert isinstance(
-                with_has_children, bool
-            ), "with_has_children should be of type bool"
+            assert isinstance(with_has_children, bool), (
+                "with_has_children should be of type bool"
+            )
             query_params["with_has_children"] = with_has_children
         if with_metadata is not None:
-            assert isinstance(
-                with_metadata, bool
-            ), "with_metadata should be of type bool"
+            assert isinstance(with_metadata, bool), (
+                "with_metadata should be of type bool"
+            )
             query_params["with_metadata"] = with_metadata
         if with_zone is not None:
             assert isinstance(with_zone, bool), "with_zone should be of type bool"
@@ -793,22 +825,22 @@ class ElementMixin:
                 DeprecationWarning,
                 stacklevel=1,
             )
-            assert isinstance(
-                worker_version, str | bool
-            ), "worker_version should be of type str or bool"
+            assert isinstance(worker_version, str | bool), (
+                "worker_version should be of type str or bool"
+            )
             if isinstance(worker_version, bool):
-                assert (
-                    worker_version is False
-                ), "if of type bool, worker_version can only be set to False"
+                assert worker_version is False, (
+                    "if of type bool, worker_version can only be set to False"
+                )
             query_params["worker_version"] = worker_version
         if worker_run is not None:
-            assert isinstance(
-                worker_run, str | bool
-            ), "worker_run should be of type str or bool"
+            assert isinstance(worker_run, str | bool), (
+                "worker_run should be of type str or bool"
+            )
             if isinstance(worker_run, bool):
-                assert (
-                    worker_run is False
-                ), "if of type bool, worker_run can only be set to False"
+                assert worker_run is False, (
+                    "if of type bool, worker_run can only be set to False"
+                )
             query_params["worker_run"] = worker_run
 
         if not self.use_cache:
@@ -817,14 +849,13 @@ class ElementMixin:
             )
 
         # Checking that we only received query_params handled by the cache
-        assert (
-            set(query_params.keys())
-            <= {
-                "type",
-                "worker_version",
-                "worker_run",
-            }
-        ), "When using the local cache, you can only filter by 'type' and/or 'worker_version' and/or 'worker_run'"
+        assert set(query_params.keys()) <= {
+            "type",
+            "worker_version",
+            "worker_run",
+        }, (
+            "When using the local cache, you can only filter by 'type' and/or 'worker_version' and/or 'worker_run'"
+        )
 
         query = CachedElement.select().where(CachedElement.parent_id == element.id)
         if type:
@@ -906,9 +937,9 @@ class ElementMixin:
         :return: An iterable of dicts from the ``ListElementParents`` API endpoint,
            or an iterable of [CachedElement][arkindex_worker.cache.CachedElement] when caching is enabled.
         """
-        assert element and isinstance(
-            element, Element | CachedElement
-        ), "element shouldn't be null and should be an Element or CachedElement"
+        assert element and isinstance(element, Element | CachedElement), (
+            "element shouldn't be null and should be an Element or CachedElement"
+        )
         query_params = {}
         if folder is not None:
             assert isinstance(folder, bool), "folder should be of type bool"
@@ -925,22 +956,22 @@ class ElementMixin:
                 DeprecationWarning,
                 stacklevel=1,
             )
-            assert isinstance(
-                transcription_worker_version, str | bool
-            ), "transcription_worker_version should be of type str or bool"
+            assert isinstance(transcription_worker_version, str | bool), (
+                "transcription_worker_version should be of type str or bool"
+            )
             if isinstance(transcription_worker_version, bool):
-                assert (
-                    transcription_worker_version is False
-                ), "if of type bool, transcription_worker_version can only be set to False"
+                assert transcription_worker_version is False, (
+                    "if of type bool, transcription_worker_version can only be set to False"
+                )
             query_params["transcription_worker_version"] = transcription_worker_version
         if transcription_worker_run is not None:
-            assert isinstance(
-                transcription_worker_run, str | bool
-            ), "transcription_worker_run should be of type str or bool"
+            assert isinstance(transcription_worker_run, str | bool), (
+                "transcription_worker_run should be of type str or bool"
+            )
             if isinstance(transcription_worker_run, bool):
-                assert (
-                    transcription_worker_run is False
-                ), "if of type bool, transcription_worker_run can only be set to False"
+                assert transcription_worker_run is False, (
+                    "if of type bool, transcription_worker_run can only be set to False"
+                )
             query_params["transcription_worker_run"] = transcription_worker_run
         if type:
             assert isinstance(type, str), "type should be of type str"
@@ -952,14 +983,14 @@ class ElementMixin:
             assert isinstance(with_corpus, bool), "with_corpus should be of type bool"
             query_params["with_corpus"] = with_corpus
         if with_has_children is not None:
-            assert isinstance(
-                with_has_children, bool
-            ), "with_has_children should be of type bool"
+            assert isinstance(with_has_children, bool), (
+                "with_has_children should be of type bool"
+            )
             query_params["with_has_children"] = with_has_children
         if with_metadata is not None:
-            assert isinstance(
-                with_metadata, bool
-            ), "with_metadata should be of type bool"
+            assert isinstance(with_metadata, bool), (
+                "with_metadata should be of type bool"
+            )
             query_params["with_metadata"] = with_metadata
         if with_zone is not None:
             assert isinstance(with_zone, bool), "with_zone should be of type bool"
@@ -970,22 +1001,22 @@ class ElementMixin:
                 DeprecationWarning,
                 stacklevel=1,
             )
-            assert isinstance(
-                worker_version, str | bool
-            ), "worker_version should be of type str or bool"
+            assert isinstance(worker_version, str | bool), (
+                "worker_version should be of type str or bool"
+            )
             if isinstance(worker_version, bool):
-                assert (
-                    worker_version is False
-                ), "if of type bool, worker_version can only be set to False"
+                assert worker_version is False, (
+                    "if of type bool, worker_version can only be set to False"
+                )
             query_params["worker_version"] = worker_version
         if worker_run is not None:
-            assert isinstance(
-                worker_run, str | bool
-            ), "worker_run should be of type str or bool"
+            assert isinstance(worker_run, str | bool), (
+                "worker_run should be of type str or bool"
+            )
             if isinstance(worker_run, bool):
-                assert (
-                    worker_run is False
-                ), "if of type bool, worker_run can only be set to False"
+                assert worker_run is False, (
+                    "if of type bool, worker_run can only be set to False"
+                )
             query_params["worker_run"] = worker_run
 
         if not self.use_cache:
@@ -994,14 +1025,13 @@ class ElementMixin:
             )
 
         # Checking that we only received query_params handled by the cache
-        assert (
-            set(query_params.keys())
-            <= {
-                "type",
-                "worker_version",
-                "worker_run",
-            }
-        ), "When using the local cache, you can only filter by 'type' and/or 'worker_version' and/or 'worker_run'"
+        assert set(query_params.keys()) <= {
+            "type",
+            "worker_version",
+            "worker_run",
+        }, (
+            "When using the local cache, you can only filter by 'type' and/or 'worker_version' and/or 'worker_run'"
+        )
 
         parent_ids = CachedElement.select(CachedElement.parent_id).where(
             CachedElement.id == element.id