arkindex-base-worker 0.5.0a1__py3-none-any.whl → 0.5.0a3__py3-none-any.whl

arkindex_worker/worker/entity.py

@@ -85,12 +85,12 @@ class EntityMixin:
         :param name: Name of the entity.
         :param type: Type of the entity.
         """
-        assert name and isinstance(
-            name, str
-        ), "name shouldn't be null and should be of type str"
-        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 type and isinstance(type, str), (
+            "type shouldn't be null and should be of type str"
+        )
         metas = metas or {}
         if metas:
             assert isinstance(metas, dict), "metas should be of type dict"
@@ -160,18 +160,18 @@ class EntityMixin:
         :returns: A dict as returned by the ``CreateTranscriptionEntity`` API endpoint,
            or None if the worker is in read-only mode.
         """
-        assert transcription and isinstance(
-            transcription, Transcription
-        ), "transcription shouldn't be null and should be a Transcription"
-        assert entity and isinstance(
-            entity, str
-        ), "entity shouldn't be null and should be of type str"
-        assert (
-            offset is not None and isinstance(offset, int) and offset >= 0
-        ), "offset shouldn't be null and should be a positive integer"
-        assert (
-            length is not None and isinstance(length, int) and length > 0
-        ), "length shouldn't be null and should be a strictly positive integer"
+        assert transcription and isinstance(transcription, Transcription), (
+            "transcription shouldn't be null and should be a Transcription"
+        )
+        assert entity and isinstance(entity, str), (
+            "entity shouldn't be null and should be of type str"
+        )
+        assert offset is not None and isinstance(offset, int) and offset >= 0, (
+            "offset shouldn't be null and should be a positive integer"
+        )
+        assert length is not None and isinstance(length, int) and length > 0, (
+            "length shouldn't be null and should be a strictly positive integer"
+        )
         assert (
             confidence is None or isinstance(confidence, float) and 0 <= confidence <= 1
         ), "confidence should be null or a float in [0..1] range"
@@ -242,44 +242,45 @@ class EntityMixin:
 
         :return: List of dicts, with each dict having a two keys, `transcription_entity_id` and `entity_id`, holding the UUID of each created object.
         """
-        assert transcription and isinstance(
-            transcription, Transcription
-        ), "transcription shouldn't be null and should be of type Transcription"
+        assert transcription and isinstance(transcription, Transcription), (
+            "transcription shouldn't be null and should be of type Transcription"
+        )
 
-        assert entities and isinstance(
-            entities, list
-        ), "entities shouldn't be null and should be of type list"
+        assert entities and isinstance(entities, list), (
+            "entities shouldn't be null and should be of type list"
+        )
 
         for index, entity in enumerate(entities):
-            assert isinstance(
-                entity, dict
-            ), f"Entity at index {index} in entities: Should be of type dict"
+            assert isinstance(entity, dict), (
+                f"Entity at index {index} in entities: Should be of type dict"
+            )
 
             name = entity.get("name")
-            assert (
-                name and isinstance(name, str)
-            ), f"Entity at index {index} in entities: name shouldn't be null and should be of type str"
+            assert name and isinstance(name, str), (
+                f"Entity at index {index} in entities: name shouldn't be null and should be of type str"
+            )
 
             type_id = entity.get("type_id")
-            assert (
-                type_id and isinstance(type_id, str)
-            ), f"Entity at index {index} in entities: type_id shouldn't be null and should be of type str"
+            assert type_id and isinstance(type_id, str), (
+                f"Entity at index {index} in entities: type_id shouldn't be null and should be of type str"
+            )
 
             offset = entity.get("offset")
-            assert (
-                offset is not None and isinstance(offset, int) and offset >= 0
-            ), f"Entity at index {index} in entities: offset shouldn't be null and should be a positive integer"
+            assert offset is not None and isinstance(offset, int) and offset >= 0, (
+                f"Entity at index {index} in entities: offset shouldn't be null and should be a positive integer"
+            )
 
             length = entity.get("length")
-            assert (
-                length is not None and isinstance(length, int) and length > 0
-            ), f"Entity at index {index} in entities: length shouldn't be null and should be a strictly positive integer"
+            assert length is not None and isinstance(length, int) and length > 0, (
+                f"Entity at index {index} in entities: length shouldn't be null and should be a strictly positive integer"
+            )
 
             confidence = entity.get("confidence")
-            assert (
-                confidence is None
-                or (isinstance(confidence, float) and 0 <= confidence <= 1)
-            ), f"Entity at index {index} in entities: confidence should be None or a float in [0..1] range"
+            assert confidence is None or (
+                isinstance(confidence, float) and 0 <= confidence <= 1
+            ), (
+                f"Entity at index {index} in entities: confidence should be None or a float in [0..1] range"
+            )
 
         assert len(entities) == len(
             set(map(itemgetter("offset", "length", "name", "type_id"), entities))
@@ -323,9 +324,9 @@ class EntityMixin:
         :param worker_run: Restrict to entities created by a worker run with this UUID. Set to False to look for manually created entities.
         """
         query_params = {}
-        assert transcription and isinstance(
-            transcription, Transcription
-        ), "transcription shouldn't be null and should be a Transcription"
+        assert transcription and isinstance(transcription, Transcription), (
+            "transcription shouldn't be null and should be a Transcription"
+        )
 
         if worker_version is not None:
             warn(
@@ -333,23 +334,23 @@ class EntityMixin:
                 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
 
         return self.api_client.paginate(
@@ -384,7 +385,7 @@ class EntityMixin:
         }
         count = len(self.entities)
         logger.info(
-            f'Loaded {count} {pluralize("entity", count)} in corpus ({self.corpus_id})'
+            f"Loaded {count} {pluralize('entity', count)} in corpus ({self.corpus_id})"
         )
 
     def list_corpus_entity_types(self):
@@ -399,5 +400,5 @@ class EntityMixin:
         }
         count = len(self.entity_types)
         logger.info(
-            f'Loaded {count} entity {pluralize("type", count)} in corpus ({self.corpus_id}).'
+            f"Loaded {count} entity {pluralize('type', count)} in corpus ({self.corpus_id})."
         )

arkindex_worker/worker/image.py

@@ -14,8 +14,8 @@ class ImageMixin:
         :param url: URL of the image.
         :returns: The created image.
         """
-        assert url and isinstance(
-            url, str
-        ), "url shouldn't be null and should be of type str"
+        assert url and isinstance(url, str), (
+            "url shouldn't be null and should be of type str"
+        )
 
         return Image(self.api_client.request("CreateIIIFURL", body={"url": url}))

arkindex_worker/worker/metadata.py

@@ -76,18 +76,18 @@ class MetaDataMixin:
         :param entity: UUID of an entity this metadata is related to.
         :returns: UUID of the created metadata.
         """
-        assert element and isinstance(
-            element, Element | CachedElement
-        ), "element shouldn't be null and should be of type Element or CachedElement"
-        assert type and isinstance(
-            type, MetaType
-        ), "type shouldn't be null and should be of type MetaType"
-        assert name and isinstance(
-            name, str
-        ), "name shouldn't be null and should be of type str"
-        assert value and isinstance(
-            value, str
-        ), "value shouldn't be null and should be of type str"
+        assert element and isinstance(element, Element | CachedElement), (
+            "element shouldn't be null and should be of type Element or CachedElement"
+        )
+        assert type and isinstance(type, MetaType), (
+            "type shouldn't be null and should be of type MetaType"
+        )
+        assert name and isinstance(name, str), (
+            "name shouldn't be null and should be of type str"
+        )
+        assert value and isinstance(value, str), (
+            "value shouldn't be null and should be of type str"
+        )
         if entity:
             assert isinstance(entity, str), "entity should be of type str"
         if self.is_read_only:
@@ -130,28 +130,28 @@ class MetaDataMixin:
 
         :returns: A list of dicts as returned in the ``metadata_list`` field by the ``CreateMetaDataBulk`` API endpoint.
         """
-        assert element and isinstance(
-            element, Element | CachedElement
-        ), "element shouldn't be null and should be of type Element or CachedElement"
+        assert element and isinstance(element, Element | CachedElement), (
+            "element shouldn't be null and should be of type Element or CachedElement"
+        )
 
-        assert metadata_list and isinstance(
-            metadata_list, list
-        ), "metadata_list shouldn't be null and should be of type list of dict"
+        assert metadata_list and isinstance(metadata_list, list), (
+            "metadata_list shouldn't be null and should be of type list of dict"
+        )
 
         # Make a copy to avoid modifying the metadata_list argument
         metas = []
         for index, metadata in enumerate(metadata_list):
-            assert isinstance(
-                metadata, dict
-            ), f"Element at index {index} in metadata_list: Should be of type dict"
+            assert isinstance(metadata, dict), (
+                f"Element at index {index} in metadata_list: Should be of type dict"
+            )
 
             assert metadata.get("type") and isinstance(
                 metadata.get("type"), MetaType
             ), "type shouldn't be null and should be of type MetaType"
 
-            assert metadata.get("name") and isinstance(
-                metadata.get("name"), str
-            ), "name shouldn't be null and should be of type str"
+            assert metadata.get("name") and isinstance(metadata.get("name"), str), (
+                "name shouldn't be null and should be of type str"
+            )
 
             assert metadata.get("value") is not None and isinstance(
                 metadata.get("value"), str | float | int
@@ -199,9 +199,9 @@ class MetaDataMixin:
         :param element: The element to list metadata on.
         :param load_parents: Also include all metadata from the element's parents in the response.
         """
-        assert element and isinstance(
-            element, Element | CachedElement
-        ), "element shouldn't be null and should be of type Element or CachedElement"
+        assert element and isinstance(element, Element | CachedElement), (
+            "element shouldn't be null and should be of type Element or CachedElement"
+        )
 
         query_params = {}
         if load_parents is not None:

arkindex_worker/worker/task.py

@@ -17,9 +17,9 @@ class TaskMixin:
         :param task_id: Task ID to find artifacts from.
         :returns: An iterator of ``Artifact`` objects built from the ``ListArtifacts`` API endpoint.
         """
-        assert task_id and isinstance(
-            task_id, uuid.UUID
-        ), "task_id shouldn't be null and should be an UUID"
+        assert task_id and isinstance(task_id, uuid.UUID), (
+            "task_id shouldn't be null and should be an UUID"
+        )
 
         results = self.api_client.request("ListArtifacts", id=task_id)
 
@@ -35,12 +35,12 @@ class TaskMixin:
         :param artifact: Artifact to download content from.
         :returns: A temporary file containing the ``Artifact`` downloaded from the ``DownloadArtifact`` API endpoint.
         """
-        assert task_id and isinstance(
-            task_id, uuid.UUID
-        ), "task_id shouldn't be null and should be an UUID"
-        assert artifact and isinstance(
-            artifact, Artifact
-        ), "artifact shouldn't be null and should be an Artifact"
+        assert task_id and isinstance(task_id, uuid.UUID), (
+            "task_id shouldn't be null and should be an UUID"
+        )
+        assert artifact and isinstance(artifact, Artifact), (
+            "artifact shouldn't be null and should be an Artifact"
+        )
 
         return self.api_client.request(
             "DownloadArtifact", id=task_id, path=artifact.path

arkindex_worker/worker/training.py

@@ -122,9 +122,9 @@ class TrainingMixin:
             )
 
         elif tag or description or configuration or parent:
-            assert (
-                self.model_version.get("model_id") == model_id
-            ), "Given `model_id` does not match the current model version"
+            assert self.model_version.get("model_id") == model_id, (
+                "Given `model_id` does not match the current model version"
+            )
             # If any attribute field has been defined, PATCH the current model version
             self.update_model_version(
                 tag=tag,
@@ -237,15 +237,17 @@ class TrainingMixin:
         Upload the archive of the model's files to an Amazon s3 compatible storage
         """
 
-        assert (
-            self.model_version
-        ), "You must create the model version before uploading an archive."
-        assert (
-            self.model_version["state"] != "Available"
-        ), "The model is already marked as available."
+        assert self.model_version, (
+            "You must create the model version before uploading an archive."
+        )
+        assert self.model_version["state"] != "Available", (
+            "The model is already marked as available."
+        )
 
         s3_put_url = self.model_version.get("s3_put_url")
-        assert s3_put_url, "S3 PUT URL is not set, please ensure you have the right to validate a model version."
+        assert s3_put_url, (
+            "S3 PUT URL is not set, please ensure you have the right to validate a model version."
+        )
 
         logger.info("Uploading to s3...")
         # Upload the archive on s3
@@ -271,7 +273,9 @@ class TrainingMixin:
         :param size: The size of the uploaded archive
         :param archive_hash: MD5 hash of the uploaded archive
         """
-        assert self.model_version, "You must create the model version and upload its archive before validating it."
+        assert self.model_version, (
+            "You must create the model version and upload its archive before validating it."
+        )
         try:
             self.model_version = self.api_client.request(
                 "PartialUpdateModelVersion",

arkindex_worker/worker/transcription.py

@@ -59,18 +59,18 @@ class TranscriptionMixin:
         :returns: A dict as returned by the ``CreateTranscription`` API endpoint,
            or None if the worker is in read-only mode.
         """
-        assert element and isinstance(
-            element, Element | CachedElement
-        ), "element shouldn't be null and should be an Element or CachedElement"
-        assert text and isinstance(
-            text, str
-        ), "text shouldn't be null and should be of type str"
-        assert orientation and isinstance(
-            orientation, TextOrientation
-        ), "orientation shouldn't be null and should be of type TextOrientation"
-        assert (
-            isinstance(confidence, float) and 0 <= confidence <= 1
-        ), "confidence shouldn't be null and should be a float in [0..1] range"
+        assert element and isinstance(element, Element | CachedElement), (
+            "element shouldn't be null and should be an Element or CachedElement"
+        )
+        assert text and isinstance(text, str), (
+            "text shouldn't be null and should be of type str"
+        )
+        assert orientation and isinstance(orientation, TextOrientation), (
+            "orientation shouldn't be null and should be of type TextOrientation"
+        )
+        assert isinstance(confidence, float) and 0 <= confidence <= 1, (
+            "confidence shouldn't be null and should be a float in [0..1] range"
+        )
 
         if self.is_read_only:
             logger.warning(
@@ -136,37 +136,39 @@ class TranscriptionMixin:
         :returns: A list of dicts as returned in the ``transcriptions`` field by the ``CreateTranscriptions`` API endpoint.
         """
 
-        assert transcriptions and isinstance(
-            transcriptions, list
-        ), "transcriptions shouldn't be null and should be of type list"
+        assert transcriptions and isinstance(transcriptions, list), (
+            "transcriptions shouldn't be null and should be of type list"
+        )
 
         # Create shallow copies of every transcription to avoid mutating the original payload
         transcriptions_payload = list(map(dict, transcriptions))
 
         for index, transcription in enumerate(transcriptions_payload):
             element_id = transcription.get("element_id")
-            assert (
-                element_id and isinstance(element_id, str)
-            ), f"Transcription at index {index} in transcriptions: element_id shouldn't be null and should be of type str"
+            assert element_id and isinstance(element_id, str), (
+                f"Transcription at index {index} in transcriptions: element_id shouldn't be null and should be of type str"
+            )
 
             text = transcription.get("text")
-            assert (
-                text and isinstance(text, str)
-            ), f"Transcription at index {index} in transcriptions: text shouldn't be null and should be of type str"
+            assert text and isinstance(text, str), (
+                f"Transcription at index {index} in transcriptions: text shouldn't be null and should be of type str"
+            )
 
             confidence = transcription.get("confidence")
             assert (
                 confidence is not None
                 and isinstance(confidence, float)
                 and 0 <= confidence <= 1
-            ), f"Transcription at index {index} in transcriptions: confidence shouldn't be null and should be a float in [0..1] range"
+            ), (
+                f"Transcription at index {index} in transcriptions: confidence shouldn't be null and should be a float in [0..1] range"
+            )
 
             orientation = transcription.get(
                 "orientation", TextOrientation.HorizontalLeftToRight
             )
-            assert (
-                orientation and isinstance(orientation, TextOrientation)
-            ), f"Transcription at index {index} in transcriptions: orientation shouldn't be null and should be of type TextOrientation"
+            assert orientation and isinstance(orientation, TextOrientation), (
+                f"Transcription at index {index} in transcriptions: orientation shouldn't be null and should be of type TextOrientation"
+            )
             if orientation:
                 transcription["orientation"] = orientation.value
 
@@ -242,63 +244,67 @@ class TranscriptionMixin:
 
         :returns: A list of dicts as returned by the ``CreateElementTranscriptions`` API endpoint.
         """
-        assert element and isinstance(
-            element, Element | CachedElement
-        ), "element shouldn't be null and should be an Element or CachedElement"
-        assert sub_element_type and isinstance(
-            sub_element_type, str
-        ), "sub_element_type shouldn't be null and should be of type str"
-        assert transcriptions and isinstance(
-            transcriptions, list
-        ), "transcriptions shouldn't be null and should be of type list"
+        assert element and isinstance(element, Element | CachedElement), (
+            "element shouldn't be null and should be an Element or CachedElement"
+        )
+        assert sub_element_type and isinstance(sub_element_type, str), (
+            "sub_element_type shouldn't be null and should be of type str"
+        )
+        assert transcriptions and isinstance(transcriptions, list), (
+            "transcriptions shouldn't be null and should be of type list"
+        )
 
         # Create shallow copies of every transcription to avoid mutating the original payload
         transcriptions_payload = list(map(dict, transcriptions))
 
         for index, transcription in enumerate(transcriptions_payload):
             text = transcription.get("text")
-            assert (
-                text and isinstance(text, str)
-            ), f"Transcription at index {index} in transcriptions: text shouldn't be null and should be of type str"
+            assert text and isinstance(text, str), (
+                f"Transcription at index {index} in transcriptions: text shouldn't be null and should be of type str"
+            )
 
             confidence = transcription.get("confidence")
             assert (
                 confidence is not None
                 and isinstance(confidence, float)
                 and 0 <= confidence <= 1
-            ), f"Transcription at index {index} in transcriptions: confidence shouldn't be null and should be a float in [0..1] range"
+            ), (
+                f"Transcription at index {index} in transcriptions: confidence shouldn't be null and should be a float in [0..1] range"
+            )
 
             orientation = transcription.get(
                 "orientation", TextOrientation.HorizontalLeftToRight
             )
-            assert (
-                orientation and isinstance(orientation, TextOrientation)
-            ), f"Transcription at index {index} in transcriptions: orientation shouldn't be null and should be of type TextOrientation"
+            assert orientation and isinstance(orientation, TextOrientation), (
+                f"Transcription at index {index} in transcriptions: orientation shouldn't be null and should be of type TextOrientation"
+            )
             if orientation:
                 transcription["orientation"] = orientation.value
 
             polygon = transcription.get("polygon")
-            assert (
-                polygon and isinstance(polygon, list)
-            ), f"Transcription at index {index} in transcriptions: polygon shouldn't be null and should be of type list"
-            assert (
-                len(polygon) >= 3
-            ), f"Transcription at index {index} in transcriptions: polygon should have at least three points"
+            assert polygon and isinstance(polygon, list), (
+                f"Transcription at index {index} in transcriptions: polygon shouldn't be null and should be of type list"
+            )
+            assert len(polygon) >= 3, (
+                f"Transcription at index {index} in transcriptions: polygon should have at least three points"
+            )
             assert all(
                 isinstance(point, list) and len(point) == 2 for point in polygon
-            ), f"Transcription at index {index} in transcriptions: polygon points should be lists of two items"
+            ), (
+                f"Transcription at index {index} in transcriptions: polygon points should be lists of two items"
+            )
             assert all(
                 isinstance(coord, int | float) for point in polygon for coord in point
-            ), f"Transcription at index {index} in transcriptions: polygon points should be lists of two numbers"
+            ), (
+                f"Transcription at index {index} in transcriptions: polygon points should be lists of two numbers"
+            )
 
             element_confidence = transcription.get("element_confidence")
-            assert (
-                element_confidence is None
-                or (
-                    isinstance(element_confidence, float)
-                    and 0 <= element_confidence <= 1
-                )
-            ), f"Transcription at index {index} in transcriptions: element_confidence should be either null or a float in [0..1] range"
+            assert element_confidence is None or (
+                isinstance(element_confidence, float) and 0 <= element_confidence <= 1
+            ), (
+                f"Transcription at index {index} in transcriptions: element_confidence should be either null or a float in [0..1] range"
+            )
 
         if self.is_read_only:
             logger.warning(
@@ -407,9 +413,9 @@ class TranscriptionMixin:
         :returns: An iterable of dicts representing each transcription,
            or an iterable of CachedTranscription when cache support 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 element_type:
             assert isinstance(element_type, str), "element_type should be of type str"
@@ -423,22 +429,22 @@ class TranscriptionMixin:
                 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:

tests/test_elements_worker/test_training.py

@@ -51,9 +51,9 @@ def test_create_archive(model_file_dir):
         archive_hash,
     ):
         assert zst_archive_path.exists(), "The archive was not created"
-        assert (
-            hash == "c5aedde18a768757351068b840c8c8f9"
-        ), "Hash was not properly computed"
+        assert hash == "c5aedde18a768757351068b840c8c8f9", (
+            "Hash was not properly computed"
+        )
         assert 300 < size < 700
 
     assert not zst_archive_path.exists(), "Auto removal failed"
@@ -69,9 +69,9 @@ def test_create_archive_with_subfolder(model_file_dir_with_subfolder):
         archive_hash,
     ):
         assert zst_archive_path.exists(), "The archive was not created"
-        assert (
-            hash == "3e453881404689e6e125144d2db3e605"
-        ), "Hash was not properly computed"
+        assert hash == "3e453881404689e6e125144d2db3e605", (
+            "Hash was not properly computed"
+        )
         assert 300 < size < 1500
 
     assert not zst_archive_path.exists(), "Auto removal failed"