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

arkindex_worker/worker/dataset.py

@@ -113,9 +113,9 @@ class DatasetMixin:
         :param dataset_set: Set to find elements in.
         :returns: An iterator of Element built from the ``ListDatasetElements`` API endpoint.
         """
-        assert dataset_set and isinstance(
-            dataset_set, Set
-        ), "dataset_set shouldn't be null and should be a Set"
+        assert dataset_set and isinstance(dataset_set, Set), (
+            "dataset_set shouldn't be null and should be a Set"
+        )
 
         results = self.api_client.paginate(
             "ListDatasetElements", id=dataset_set.dataset.id, set=dataset_set.name
@@ -152,12 +152,12 @@ class DatasetMixin:
         :param state: State of the dataset.
         :returns: The updated ``Dataset`` object from the ``PartialUpdateDataset`` API endpoint.
         """
-        assert dataset and isinstance(
-            dataset, Dataset
-        ), "dataset shouldn't be null and should be a Dataset"
-        assert state and isinstance(
-            state, DatasetState
-        ), "state shouldn't be null and should be a str from DatasetState"
+        assert dataset and isinstance(dataset, Dataset), (
+            "dataset shouldn't be null and should be a Dataset"
+        )
+        assert state and isinstance(state, DatasetState), (
+            "state shouldn't be null and should be a str from DatasetState"
+        )
 
         if self.is_read_only:
             logger.warning("Cannot update dataset as this worker is in read-only mode")

arkindex_worker/worker/element.py

@@ -67,7 +67,7 @@ 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
@@ -101,9 +101,9 @@ class ElementMixin:
         :raises MissingTypeError: If any of the specified type slugs were not found.
         """
         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 all(isinstance(slug, str) for slug in type_slugs), (
+            "Element type slugs must be strings."
+        )
 
         if not self.corpus_types:
             self.list_corpus_types()
@@ -118,7 +118,7 @@ class ElementMixin:
                 )
             else:
                 raise MissingTypeError(
-                    f'Element {pluralize("type", len(missing_slugs))} {", ".join(sorted(missing_slugs))} were not found in corpus ({self.corpus_id}).'
+                    f"Element {pluralize('type', len(missing_slugs))} {', '.join(sorted(missing_slugs))} were not found in corpus ({self.corpus_id})."
                 )
 
         return True
@@ -146,18 +146,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 +177,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 +233,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 +354,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 +388,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 +437,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 +466,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 +578,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 +605,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 +623,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 +647,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 +735,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 +754,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 +781,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 +799,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 +823,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 +911,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 +930,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 +957,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 +975,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 +999,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