arkindex-base-worker 0.3.6rc5__py3-none-any.whl → 0.3.7__py3-none-any.whl

tests/test_elements_worker/test_training.py

@@ -179,6 +179,41 @@ def test_validate_model_version_not_created(mock_training_worker):
         mock_training_worker.validate_model_version(hash="a", size=1, archive_hash="b")
 
 
+@pytest.mark.parametrize("status_code", [403, 500])
+def test_validate_model_version_catch_errors(
+    mocker, mock_training_worker, caplog, status_code
+):
+    mocker.patch(
+        "arkindex_worker.worker.base.BaseWorker.request.retry.retry", return_value=False
+    )
+
+    mock_training_worker.model_version = {"id": "model_version_id"}
+    args = {
+        "hash": "hash",
+        "archive_hash": "archive_hash",
+        "size": 30,
+    }
+    mock_training_worker.api_client.add_error_response(
+        "ValidateModelVersion",
+        id="model_version_id",
+        status_code=status_code,
+        body=args,
+    )
+
+    mock_training_worker.validate_model_version(**args)
+    assert mock_training_worker.model_version == {"id": "model_version_id"}
+    assert [
+        (level, message)
+        for module, level, message in caplog.record_tuples
+        if module == "arkindex_worker"
+    ] == [
+        (
+            logging.WARNING,
+            "An error occurred while validating model version model_version_id, please check its status.",
+        ),
+    ]
+
+
 @pytest.mark.parametrize("deletion_failed", [True, False])
 def test_validate_model_version_hash_conflict(
     mock_training_worker, default_model_version, caplog, deletion_failed

tests/test_elements_worker/test_transcriptions.py

@@ -1711,11 +1711,29 @@ def test_list_transcriptions_wrong_recursive(mock_elements_worker):
         )
 
 
-def test_list_transcriptions_wrong_worker_version(mock_elements_worker):
+def test_list_transcriptions_wrong_worker_run(mock_elements_worker):
     elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
 
     with pytest.raises(
-        AssertionError, match="worker_version should be of type str or bool"
+        AssertionError, match="worker_run should be of type str or bool"
+    ):
+        mock_elements_worker.list_transcriptions(
+            element=elt,
+            worker_run=1234,
+        )
+
+
+def test_list_transcriptions_wrong_worker_version(mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    # WARNING: pytest.deprecated_call must be placed BEFORE pytest.raises, otherwise `match` argument won't be checked
+    with (
+        pytest.deprecated_call(
+            match="`worker_version` usage is deprecated. Consider using `worker_run` instead."
+        ),
+        pytest.raises(
+            AssertionError, match="worker_version should be of type str or bool"
+        ),
     ):
         mock_elements_worker.list_transcriptions(
             element=elt,
@@ -1723,11 +1741,30 @@ def test_list_transcriptions_wrong_worker_version(mock_elements_worker):
         )
 
 
-def test_list_transcriptions_wrong_bool_worker_version(mock_elements_worker):
+def test_list_transcriptions_wrong_bool_worker_run(mock_elements_worker):
     elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
 
     with pytest.raises(
-        AssertionError, match="if of type bool, worker_version can only be set to False"
+        AssertionError, match="if of type bool, worker_run can only be set to False"
+    ):
+        mock_elements_worker.list_transcriptions(
+            element=elt,
+            worker_run=True,
+        )
+
+
+def test_list_transcriptions_wrong_bool_worker_version(mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    # WARNING: pytest.deprecated_call must be placed BEFORE pytest.raises, otherwise `match` argument won't be checked
+    with (
+        pytest.deprecated_call(
+            match="`worker_version` usage is deprecated. Consider using `worker_run` instead."
+        ),
+        pytest.raises(
+            AssertionError,
+            match="if of type bool, worker_version can only be set to False",
+        ),
     ):
         mock_elements_worker.list_transcriptions(
             element=elt,
@@ -1784,6 +1821,7 @@ def test_list_transcriptions(responses, mock_elements_worker):
             "text": "hey",
             "confidence": 0.42,
             "worker_version_id": "56785678-5678-5678-5678-567856785678",
+            "worker_run_id": "56785678-5678-5678-5678-567856785678",
             "element": None,
         },
         {
@@ -1791,6 +1829,7 @@ def test_list_transcriptions(responses, mock_elements_worker):
             "text": "it's",
             "confidence": 0.42,
             "worker_version_id": "56785678-5678-5678-5678-567856785678",
+            "worker_run_id": "56785678-5678-5678-5678-567856785678",
             "element": None,
         },
         {
@@ -1798,6 +1837,7 @@ def test_list_transcriptions(responses, mock_elements_worker):
             "text": "me",
             "confidence": 0.42,
             "worker_version_id": "56785678-5678-5678-5678-567856785678",
+            "worker_run_id": "56785678-5678-5678-5678-567856785678",
             "element": None,
         },
     ]
@@ -1836,6 +1876,7 @@ def test_list_transcriptions_manual_worker_version(responses, mock_elements_work
             "text": "hey",
             "confidence": 0.42,
             "worker_version_id": None,
+            "worker_run_id": None,
             "element": None,
         }
     ]
@@ -1850,8 +1891,50 @@ def test_list_transcriptions_manual_worker_version(responses, mock_elements_work
         },
     )
 
+    with pytest.deprecated_call(
+        match="`worker_version` usage is deprecated. Consider using `worker_run` instead."
+    ):
+        for idx, transcription in enumerate(
+            mock_elements_worker.list_transcriptions(element=elt, worker_version=False)
+        ):
+            assert transcription == trans[idx]
+
+    assert len(responses.calls) == len(BASE_API_CALLS) + 1
+    assert [
+        (call.request.method, call.request.url) for call in responses.calls
+    ] == BASE_API_CALLS + [
+        (
+            "GET",
+            "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/transcriptions/?worker_version=False",
+        ),
+    ]
+
+
+def test_list_transcriptions_manual_worker_run(responses, mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+    trans = [
+        {
+            "id": "0000",
+            "text": "hey",
+            "confidence": 0.42,
+            "worker_version_id": None,
+            "worker_run_id": None,
+            "element": None,
+        }
+    ]
+    responses.add(
+        responses.GET,
+        "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/transcriptions/?worker_run=False",
+        status=200,
+        json={
+            "count": 1,
+            "next": None,
+            "results": trans,
+        },
+    )
+
     for idx, transcription in enumerate(
-        mock_elements_worker.list_transcriptions(element=elt, worker_version=False)
+        mock_elements_worker.list_transcriptions(element=elt, worker_run=False)
     ):
         assert transcription == trans[idx]
 
@@ -1861,7 +1944,7 @@ def test_list_transcriptions_manual_worker_version(responses, mock_elements_work
     ] == BASE_API_CALLS + [
         (
             "GET",
-            "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/transcriptions/?worker_version=False",
+            "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/transcriptions/?worker_run=False",
         ),
     ]
 
@@ -1895,16 +1978,26 @@ def test_list_transcriptions_manual_worker_version(responses, mock_elements_work
                 "66666666-6666-6666-6666-666666666666",
             ),
         ),
-        # Filter on element and worker_version should give first transcription
+        # Filter on element and worker run should give the first transcription
         (
             {
                 "element": CachedElement(
                     id="11111111-1111-1111-1111-111111111111", type="page"
                 ),
-                "worker_version": "56785678-5678-5678-5678-567856785678",
+                "worker_run": "56785678-5678-5678-5678-567856785678",
             },
             ("11111111-1111-1111-1111-111111111111",),
         ),
+        # Filter on element, manual worker run should give the sixth transcription
+        (
+            {
+                "element": CachedElement(
+                    id="11111111-1111-1111-1111-111111111111", type="page"
+                ),
+                "worker_run": False,
+            },
+            ("66666666-6666-6666-6666-666666666666",),
+        ),
         # Filter recursively on element should give all transcriptions inserted
         (
             {
@@ -1922,33 +2015,70 @@ def test_list_transcriptions_manual_worker_version(responses, mock_elements_work
                 "66666666-6666-6666-6666-666666666666",
             ),
         ),
-        # Filter recursively on element and worker_version should give four transcriptions
+        # Filter recursively on element and element_type should give three transcriptions
         (
             {
                 "element": CachedElement(
                     id="11111111-1111-1111-1111-111111111111", type="page"
                 ),
-                "worker_version": "90129012-9012-9012-9012-901290129012",
+                "element_type": "something_else",
                 "recursive": True,
             },
             (
                 "22222222-2222-2222-2222-222222222222",
-                "33333333-3333-3333-3333-333333333333",
                 "44444444-4444-4444-4444-444444444444",
                 "55555555-5555-5555-5555-555555555555",
             ),
         ),
-        # Filter recursively on element and element_type should give three transcriptions
+    ],
+)
+def test_list_transcriptions_with_cache(
+    responses, mock_elements_worker_with_cache, filters, expected_ids
+):
+    # Check we have 5 elements already present in database
+    assert CachedTranscription.select().count() == 6
+
+    # Query database through cache
+    transcriptions = mock_elements_worker_with_cache.list_transcriptions(**filters)
+    assert transcriptions.count() == len(expected_ids)
+    for transcription, expected_id in zip(
+        transcriptions.order_by(CachedTranscription.id), expected_ids, strict=True
+    ):
+        assert transcription.id == UUID(expected_id)
+
+    # Check the worker never hits the API for elements
+    assert len(responses.calls) == len(BASE_API_CALLS)
+    assert [
+        (call.request.method, call.request.url) for call in responses.calls
+    ] == BASE_API_CALLS
+
+
+@pytest.mark.usefixtures("_mock_cached_transcriptions")
+@pytest.mark.parametrize(
+    ("filters", "expected_ids"),
+    [
+        # Filter on element and worker_version should give first transcription
         (
             {
                 "element": CachedElement(
                     id="11111111-1111-1111-1111-111111111111", type="page"
                 ),
-                "element_type": "something_else",
+                "worker_version": "56785678-5678-5678-5678-567856785678",
+            },
+            ("11111111-1111-1111-1111-111111111111",),
+        ),
+        # Filter recursively on element and worker_version should give four transcriptions
+        (
+            {
+                "element": CachedElement(
+                    id="11111111-1111-1111-1111-111111111111", type="page"
+                ),
+                "worker_version": "90129012-9012-9012-9012-901290129012",
                 "recursive": True,
             },
             (
                 "22222222-2222-2222-2222-222222222222",
+                "33333333-3333-3333-3333-333333333333",
                 "44444444-4444-4444-4444-444444444444",
                 "55555555-5555-5555-5555-555555555555",
             ),
@@ -1965,14 +2095,17 @@ def test_list_transcriptions_manual_worker_version(responses, mock_elements_work
         ),
     ],
 )
-def test_list_transcriptions_with_cache(
+def test_list_transcriptions_with_cache_deprecation(
     responses, mock_elements_worker_with_cache, filters, expected_ids
 ):
     # Check we have 5 elements already present in database
     assert CachedTranscription.select().count() == 6
 
-    # Query database through cache
-    transcriptions = mock_elements_worker_with_cache.list_transcriptions(**filters)
+    with pytest.deprecated_call(
+        match="`worker_version` usage is deprecated. Consider using `worker_run` instead."
+    ):
+        # Query database through cache
+        transcriptions = mock_elements_worker_with_cache.list_transcriptions(**filters)
     assert transcriptions.count() == len(expected_ids)
     for transcription, expected_id in zip(
         transcriptions.order_by(CachedTranscription.id), expected_ids, strict=True

tests/test_elements_worker/test_worker.py

@@ -20,7 +20,8 @@ def test_get_worker_version(fake_dummy_worker):
 
     api_client.add_response("RetrieveWorkerVersion", response, id=TEST_VERSION_ID)
 
-    res = fake_dummy_worker.get_worker_version(TEST_VERSION_ID)
+    with pytest.deprecated_call(match="WorkerVersion usage is deprecated."):
+        res = fake_dummy_worker.get_worker_version(TEST_VERSION_ID)
 
     assert res == response
     assert fake_dummy_worker._worker_version_cache[TEST_VERSION_ID] == response
@@ -33,8 +34,11 @@ def test_get_worker_version__uses_cache(fake_dummy_worker):
 
     api_client.add_response("RetrieveWorkerVersion", response, id=TEST_VERSION_ID)
 
-    response_1 = fake_dummy_worker.get_worker_version(TEST_VERSION_ID)
-    response_2 = fake_dummy_worker.get_worker_version(TEST_VERSION_ID)
+    with pytest.deprecated_call(match="WorkerVersion usage is deprecated."):
+        response_1 = fake_dummy_worker.get_worker_version(TEST_VERSION_ID)
+
+    with pytest.deprecated_call(match="WorkerVersion usage is deprecated."):
+        response_2 = fake_dummy_worker.get_worker_version(TEST_VERSION_ID)
 
     assert response_1 == response
     assert response_1 == response_2
@@ -51,12 +55,17 @@ def test_get_worker_version_slug(mocker, fake_dummy_worker):
         "worker": {"slug": "mock_slug"},
     }
 
-    slug = fake_dummy_worker.get_worker_version_slug(TEST_VERSION_ID)
+    with pytest.deprecated_call(match="WorkerVersion usage is deprecated."):
+        slug = fake_dummy_worker.get_worker_version_slug(TEST_VERSION_ID)
     assert slug == "mock_slug"
 
 
 def test_get_worker_version_slug_none(fake_dummy_worker):
-    with pytest.raises(ValueError, match="No worker version ID"):
+    # WARNING: pytest.deprecated_call must be placed BEFORE pytest.raises, otherwise `match` argument won't be checked
+    with (
+        pytest.deprecated_call(match="WorkerVersion usage is deprecated."),
+        pytest.raises(ValueError, match="No worker version ID"),
+    ):
         fake_dummy_worker.get_worker_version_slug(None)
 
 
@@ -301,7 +310,7 @@ def test_start_activity_error(
         ),
     ]
     assert logger.error.call_args_list == [
-        mocker.call("Ran on 1 elements: 0 completed, 1 failed")
+        mocker.call("Ran on 1 element: 0 completed, 1 failed")
     ]
 
 
@@ -459,6 +468,10 @@ def test_worker_config_multiple_source(
             "id": "12341234-1234-1234-1234-123412341234",
             "name": "Model version 1337",
             "configuration": model_config,
+            "model": {
+                "id": "hahahaha-haha-haha-haha-hahahahahaha",
+                "name": "My model",
+            },
         },
         "process": {
             "name": None,

tests/test_image.py

@@ -7,6 +7,7 @@ from pathlib import Path
 
 import pytest
 from PIL import Image, ImageChops, ImageOps
+from requests import HTTPError
 
 from arkindex_worker.cache import CachedElement, create_tables, init_cache_db
 from arkindex_worker.image import (
@@ -19,6 +20,7 @@ from arkindex_worker.image import (
     polygon_bounding_box,
     revert_orientation,
     trim_polygon,
+    upload_image,
 )
 from arkindex_worker.models import Element
 
@@ -547,3 +549,38 @@ def test_download_image_retry_with_max(responses):
     assert list(map(attrgetter("request.url"), responses.calls)) == [full_url] * 3 + [
         max_url
     ]
+
+
+def test_upload_image_retries(responses):
+    dest_url = "https://blabla.com/iiif/2/image_path.jpg/full/full/0/default.jpg"
+    responses.add(
+        responses.PUT,
+        dest_url,
+        status=400,
+    )
+
+    image = Image.open(FULL_IMAGE).convert("RGB")
+    with pytest.raises(
+        HTTPError, match=f"400 Client Error: Bad Request for url: {dest_url}"
+    ):
+        upload_image(image, dest_url)
+
+    # We try 3 times
+    assert len(responses.calls) == 3
+    assert list(map(attrgetter("request.url"), responses.calls)) == [dest_url] * 3
+
+
+def test_upload_image(responses):
+    dest_url = "https://blabla.com/iiif/2/image_path.jpg/full/full/0/default.jpg"
+    responses.add(
+        responses.PUT,
+        dest_url,
+        status=200,
+    )
+
+    image = Image.open(FULL_IMAGE).convert("RGB")
+    resp = upload_image(image, dest_url)
+    assert resp
+
+    assert len(responses.calls) == 1
+    assert list(map(attrgetter("request.url"), responses.calls)) == [dest_url]

tests/test_utils.py

@@ -1,11 +1,33 @@
 from pathlib import Path
 
-from arkindex_worker.utils import close_delete_file, extract_tar_zst_archive
+import pytest
+
+from arkindex_worker.utils import (
+    close_delete_file,
+    extract_tar_zst_archive,
+    parse_source_id,
+)
 
 FIXTURES = Path(__file__).absolute().parent / "data"
 ARCHIVE = FIXTURES / "archive.tar.zst"
 
 
+@pytest.mark.parametrize(
+    ("source_id", "expected"),
+    [
+        (None, None),
+        ("", None),
+        (
+            "cafecafe-cafe-cafe-cafe-cafecafecafe",
+            "cafecafe-cafe-cafe-cafe-cafecafecafe",
+        ),
+        ("manual", False),
+    ],
+)
+def test_parse_source_id(source_id, expected):
+    assert parse_source_id(source_id) == expected
+
+
 def test_extract_tar_zst_archive(tmp_path):
     destination = tmp_path / "destination"
     _, archive_path = extract_tar_zst_archive(ARCHIVE, destination)

worker-demo/tests/conftest.py

@@ -0,0 +1,32 @@
+import os
+
+import pytest
+
+from arkindex.mock import MockApiClient
+from arkindex_worker.worker.base import BaseWorker
+
+
+@pytest.fixture(autouse=True)
+def _setup_environment(responses, monkeypatch) -> None:
+    """Setup needed environment variables"""
+
+    # Allow accessing remote API schemas
+    # defaulting to the prod environment
+    schema_url = os.environ.get(
+        "ARKINDEX_API_SCHEMA_URL",
+        "https://demo.arkindex.org/api/v1/openapi/?format=openapi-json",
+    )
+    responses.add_passthru(schema_url)
+
+    # Set schema url in environment
+    os.environ["ARKINDEX_API_SCHEMA_URL"] = schema_url
+    # Setup a fake worker run ID
+    os.environ["ARKINDEX_WORKER_RUN_ID"] = "1234-demo"
+    # Setup a fake corpus ID
+    os.environ["ARKINDEX_CORPUS_ID"] = "1234-corpus-id"
+
+    # Setup a mock api client instead of using a real one
+    def mock_setup_api_client(self):
+        self.api_client = MockApiClient()
+
+    monkeypatch.setattr(BaseWorker, "setup_api_client", mock_setup_api_client)

worker-demo/tests/test_worker.py

@@ -0,0 +1,12 @@
+import importlib
+
+
+def test_dummy():
+    assert True
+
+
+def test_import():
+    """Import our newly created module, through importlib to avoid parsing issues"""
+    worker = importlib.import_module("worker_demo.worker")
+    assert hasattr(worker, "Demo")
+    assert hasattr(worker.Demo, "process_element")

worker-demo/worker_demo/__init__.py

@@ -0,0 +1,6 @@
+import logging
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s/%(name)s: %(message)s",
+)

worker-demo/worker_demo/worker.py

@@ -0,0 +1,19 @@
+from logging import Logger, getLogger
+
+from arkindex_worker.models import Element
+from arkindex_worker.worker import ElementsWorker
+
+logger: Logger = getLogger(__name__)
+
+
+class Demo(ElementsWorker):
+    def process_element(self, element: Element) -> None:
+        logger.info(f"Demo processing element ({element.id})")
+
+
+def main() -> None:
+    Demo(description="Demo ML worker for Arkindex").run()
+
+
+if __name__ == "__main__":
+    main()

arkindex_base_worker-0.3.6rc5.dist-info/RECORD

@@ -1,41 +0,0 @@
-arkindex_worker/__init__.py,sha256=OlgCtTC9MaWeejviY0a3iQpALcRQGMVArFVVYwTF6I8,162
-arkindex_worker/cache.py,sha256=ZbXJo-O24W8x6nbS0IJm32Tas9CKLaHBBeyQyvF-Nyo,10903
-arkindex_worker/image.py,sha256=uwfUE9hy0Iw-e3vU7OHmLSqouxbznWq08SykXmPD1Cs,14107
-arkindex_worker/models.py,sha256=DVrZPIurSiOoHvj3t_Szwd0j1t6pnwBx_dqwhNakzN0,9528
-arkindex_worker/utils.py,sha256=_lC1-RYvNWXEkK-AuF4_FraoggP1tYPdalNFSj4jDb4,6885
-arkindex_worker/worker/__init__.py,sha256=Iun6jhuakKdCGKjQtgqDWEpWO1HrxK34RoxdzE5gcRs,19322
-arkindex_worker/worker/base.py,sha256=4eG4v4vejvFv9UtTRhxEZkXEBVzlFd3rILHK8lt-mbc,19397
-arkindex_worker/worker/classification.py,sha256=CoMIj7SFFlt90W1r5FQmsB80qK9Zfltcm3k-37FSHA0,10693
-arkindex_worker/worker/dataset.py,sha256=LRZU_KkOuCRkxlkdqw1PHYnu1zmoQfm_OiY8Sqt6mi0,2754
-arkindex_worker/worker/element.py,sha256=6lbJFu4vQrTOJvF4GqlnH3ynYtR-6WB5ljLV6wz7dGg,32283
-arkindex_worker/worker/entity.py,sha256=l0gCoeaoUBFU7pv2iC4pHkSQVjiIur4M15P7Mg_WlaA,13601
-arkindex_worker/worker/metadata.py,sha256=PnzyHkPyb-mtgItzRi4s-_f0dsEOM3ak8F_bFoqp3O0,6225
-arkindex_worker/worker/task.py,sha256=cz3wJNPgogZv1lm_3lm7WScitQtYQtL6H6I7Xokq208,1475
-arkindex_worker/worker/training.py,sha256=rhg4TPFo0ignnCkgbekUYmNXX8u2iZGyeM1VCs1R5kI,10140
-arkindex_worker/worker/transcription.py,sha256=OCjgajaPcX7CPHG1fT4nZccfp6bG6Mqdz3POPc9_iYQ,18765
-arkindex_worker/worker/version.py,sha256=uL-OrwuFZB8TNU6ePmdKIL3g3e-GE2tqHEWBRpXu-FU,1428
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/conftest.py,sha256=9dmc6Lq-XpTZvv1hxfb0rl6zzfcwCtcPMqSBSeEONqc,21847
-tests/test_base_worker.py,sha256=AF1pjvNckN80LVyLJ4ILXJ122fEnWtztK7ZncVDI_Ms,24976
-tests/test_cache.py,sha256=ii0gyr0DrG7ChEs7pmT8hMdSguAOAcCze4bRMiFQxuk,10640
-tests/test_dataset_worker.py,sha256=XxBCLRroCIq97P37_qWc9I7QiyE3zUL7fLAw1J_BI7E,27703
-tests/test_element.py,sha256=2G9M15TLxQRmvrWM9Kw2ucnElh4kSv_oF_5FYwwAxTY,13181
-tests/test_image.py,sha256=nIT0NhmuHtD9I1rcMSvqSfjQqvTE5Ko8tAQGLIkm_zo,15232
-tests/test_merge.py,sha256=Q4zCbtZbe0wBfqE56gvAD06c6pDuhqnjKaioFqIgAQw,8331
-tests/test_utils.py,sha256=pFXegcBvIuy1tJDDSgQtCbC_tRaoLjd2055R5lu3hS0,1236
-tests/test_elements_worker/__init__.py,sha256=Fh4nkbbyJSMv_VtjQxnWrOqTnxXaaWI8S9WU0VrzCHs,179
-tests/test_elements_worker/test_classifications.py,sha256=0_6vryoQc2-s3CQWANsEvajkyC3aub34cxb3r97pRsk,32027
-tests/test_elements_worker/test_cli.py,sha256=DdCRKobesehL61c5QwaZOZCde7bsTlmeSN2iosQ5_2s,2873
-tests/test_elements_worker/test_dataset.py,sha256=ElDPrYTTt8KzaZ_Xf5uslUD6_kiGZybntO10uqCquLo,12063
-tests/test_elements_worker/test_elements.py,sha256=YQpF7y9depXElJcV9yECUGxVI7tF1kkJJ2ruYgXsVWE,79582
-tests/test_elements_worker/test_entities.py,sha256=ZOFB3ckKJvNG2kIPUX_kz_378k3uQrJmvYHpR_xiVuo,33789
-tests/test_elements_worker/test_metadata.py,sha256=c3kXPYRXVPDnGim28Ncg5YO4I0ejh3qyi7dBvbSYxMU,17739
-tests/test_elements_worker/test_task.py,sha256=FCpxE9UpouKXgjGvWgNHEai_Hiy2d1YmqRG-_v2s27s,6312
-tests/test_elements_worker/test_training.py,sha256=WeG-cDuJ-YhPgfKH47TtXBxyargtLuk7c8tsik2WnL8,8414
-tests/test_elements_worker/test_transcriptions.py,sha256=6UWGriQVwEORunJYW11mGcD16voZGFY41i_NIdXuqnI,68750
-tests/test_elements_worker/test_worker.py,sha256=zD8sY5yZFhuUr1txVX8z7bSgW4I2jNuzH5i1TM3qkZI,16491
-arkindex_base_worker-0.3.6rc5.dist-info/LICENSE,sha256=NVshRi1efwVezMfW7xXYLrdDr2Li1AfwfGOd5WuH1kQ,1063
-arkindex_base_worker-0.3.6rc5.dist-info/METADATA,sha256=E6SjEuSYO53WaxWUvFEPes6Tsap5wYoz87mhdoSeCkE,3413
-arkindex_base_worker-0.3.6rc5.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-arkindex_base_worker-0.3.6rc5.dist-info/top_level.txt,sha256=TtagLI8LSv7GE7nG8MQqDFAJ5bNDPJn7Z5vizOgrWkA,22
-arkindex_base_worker-0.3.6rc5.dist-info/RECORD,,