arkindex-base-worker 0.3.7rc5__py3-none-any.whl → 0.3.7rc7__py3-none-any.whl

tests/test_elements_worker/test_dataset.py

@@ -4,13 +4,13 @@ import logging
 import pytest
 from apistar.exceptions import ErrorResponse
 
-from arkindex_worker.models import Dataset
+from arkindex_worker.models import Dataset, Element, Set
 from arkindex_worker.worker.dataset import DatasetState
 from tests.conftest import PROCESS_ID
 from tests.test_elements_worker import BASE_API_CALLS
 
 
-def test_list_process_datasets_readonly_error(mock_dataset_worker):
+def test_list_process_sets_readonly_error(mock_dataset_worker):
     # Set worker in read_only mode
     mock_dataset_worker.worker_run_id = None
     assert mock_dataset_worker.is_read_only
@@ -18,85 +18,91 @@ def test_list_process_datasets_readonly_error(mock_dataset_worker):
     with pytest.raises(
         AssertionError, match="This helper is not available in read-only mode."
     ):
-        mock_dataset_worker.list_process_datasets()
+        mock_dataset_worker.list_process_sets()
 
 
-def test_list_process_datasets_api_error(responses, mock_dataset_worker):
+def test_list_process_sets_api_error(responses, mock_dataset_worker):
     responses.add(
         responses.GET,
-        f"http://testserver/api/v1/process/{PROCESS_ID}/datasets/",
+        f"http://testserver/api/v1/process/{PROCESS_ID}/sets/",
         status=500,
     )
 
     with pytest.raises(
         Exception, match="Stopping pagination as data will be incomplete"
     ):
-        next(mock_dataset_worker.list_process_datasets())
+        next(mock_dataset_worker.list_process_sets())
 
     assert len(responses.calls) == len(BASE_API_CALLS) + 5
     assert [
         (call.request.method, call.request.url) for call in responses.calls
     ] == BASE_API_CALLS + [
         # The API call is retried 5 times
-        ("GET", f"http://testserver/api/v1/process/{PROCESS_ID}/datasets/"),
-        ("GET", f"http://testserver/api/v1/process/{PROCESS_ID}/datasets/"),
-        ("GET", f"http://testserver/api/v1/process/{PROCESS_ID}/datasets/"),
-        ("GET", f"http://testserver/api/v1/process/{PROCESS_ID}/datasets/"),
-        ("GET", f"http://testserver/api/v1/process/{PROCESS_ID}/datasets/"),
+        ("GET", f"http://testserver/api/v1/process/{PROCESS_ID}/sets/"),
+        ("GET", f"http://testserver/api/v1/process/{PROCESS_ID}/sets/"),
+        ("GET", f"http://testserver/api/v1/process/{PROCESS_ID}/sets/"),
+        ("GET", f"http://testserver/api/v1/process/{PROCESS_ID}/sets/"),
+        ("GET", f"http://testserver/api/v1/process/{PROCESS_ID}/sets/"),
     ]
 
 
-def test_list_process_datasets(
+def test_list_process_sets(
     responses,
     mock_dataset_worker,
 ):
     expected_results = [
         {
-            "id": "process_dataset_1",
+            "id": "set_1",
             "dataset": {
                 "id": "dataset_1",
                 "name": "Dataset 1",
                 "description": "My first great dataset",
-                "sets": ["train", "val", "test"],
+                "sets": [
+                    {"id": "set_1", "name": "train"},
+                    {"id": "set_2", "name": "val"},
+                ],
                 "state": "open",
                 "corpus_id": "corpus_id",
                 "creator": "test@teklia.com",
                 "task_id": "task_id_1",
             },
-            "sets": ["test"],
+            "set_name": "train",
         },
         {
-            "id": "process_dataset_2",
+            "id": "set_2",
             "dataset": {
-                "id": "dataset_2",
-                "name": "Dataset 2",
-                "description": "My second great dataset",
-                "sets": ["train", "val"],
-                "state": "complete",
+                "id": "dataset_1",
+                "name": "Dataset 1",
+                "description": "My first great dataset",
+                "sets": [
+                    {"id": "set_1", "name": "train"},
+                    {"id": "set_2", "name": "val"},
+                ],
+                "state": "open",
                 "corpus_id": "corpus_id",
                 "creator": "test@teklia.com",
-                "task_id": "task_id_2",
+                "task_id": "task_id_1",
             },
-            "sets": ["train", "val"],
+            "set_name": "val",
         },
         {
-            "id": "process_dataset_3",
+            "id": "set_3",
             "dataset": {
-                "id": "dataset_3",
-                "name": "Dataset 3 (TRASHME)",
-                "description": "My third dataset, in error",
-                "sets": ["nonsense", "random set"],
-                "state": "error",
+                "id": "dataset_2",
+                "name": "Dataset 2",
+                "description": "My second great dataset",
+                "sets": [{"id": "set_3", "name": "my_set"}],
+                "state": "complete",
                 "corpus_id": "corpus_id",
                 "creator": "test@teklia.com",
-                "task_id": "task_id_3",
+                "task_id": "task_id_2",
             },
-            "sets": ["random set"],
+            "set_name": "my_set",
         },
     ]
     responses.add(
         responses.GET,
-        f"http://testserver/api/v1/process/{PROCESS_ID}/datasets/",
+        f"http://testserver/api/v1/process/{PROCESS_ID}/sets/",
         status=200,
         json={
             "count": 3,
@@ -105,57 +111,44 @@ def test_list_process_datasets(
         },
     )
 
-    for idx, dataset in enumerate(mock_dataset_worker.list_process_datasets()):
-        assert isinstance(dataset, Dataset)
-        assert dataset == {
-            **expected_results[idx]["dataset"],
-            "selected_sets": expected_results[idx]["sets"],
-        }
+    for idx, dataset_set in enumerate(mock_dataset_worker.list_process_sets()):
+        assert isinstance(dataset_set, Set)
+        assert dataset_set.name == expected_results[idx]["set_name"]
+
+        assert isinstance(dataset_set.dataset, Dataset)
+        assert dataset_set.dataset == expected_results[idx]["dataset"]
 
     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", f"http://testserver/api/v1/process/{PROCESS_ID}/datasets/"),
+        ("GET", f"http://testserver/api/v1/process/{PROCESS_ID}/sets/"),
     ]
 
 
 @pytest.mark.parametrize(
     ("payload", "error"),
     [
-        # Dataset
+        # Set
         (
-            {"dataset": None},
-            "dataset shouldn't be null and should be a Dataset",
+            {"dataset_set": None},
+            "dataset_set shouldn't be null and should be a Set",
         ),
         (
-            {"dataset": "not Dataset type"},
-            "dataset shouldn't be null and should be a Dataset",
+            {"dataset_set": "not Set type"},
+            "dataset_set shouldn't be null and should be a Set",
         ),
     ],
 )
-def test_list_dataset_elements_wrong_param_dataset(mock_dataset_worker, payload, error):
+def test_list_set_elements_wrong_param_dataset_set(mock_dataset_worker, payload, error):
     with pytest.raises(AssertionError, match=error):
-        mock_dataset_worker.list_dataset_elements(**payload)
+        mock_dataset_worker.list_set_elements(**payload)
 
 
-@pytest.mark.parametrize(
-    "sets",
-    [
-        ["set_1"],
-        ["set_1", "set_2", "set_3"],
-        ["set_1", "set_2", "set_3", "set_4"],
-    ],
-)
-def test_list_dataset_elements_api_error(
-    responses, mock_dataset_worker, sets, default_dataset
+def test_list_set_elements_api_error(
+    responses, mock_dataset_worker, default_dataset, default_train_set
 ):
-    default_dataset.selected_sets = sets
-    query_params = (
-        "?with_count=true"
-        if sets == default_dataset.sets
-        else "?set=set_1&with_count=true"
-    )
+    query_params = f"?set={default_train_set.name}&with_count=true"
     responses.add(
         responses.GET,
         f"http://testserver/api/v1/datasets/{default_dataset.id}/elements/{query_params}",
@@ -165,7 +158,7 @@ def test_list_dataset_elements_api_error(
     with pytest.raises(
         Exception, match="Stopping pagination as data will be incomplete"
     ):
-        next(mock_dataset_worker.list_dataset_elements(dataset=default_dataset))
+        next(mock_dataset_worker.list_set_elements(dataset_set=default_train_set))
 
     assert len(responses.calls) == len(BASE_API_CALLS) + 5
     assert [
@@ -195,99 +188,60 @@ def test_list_dataset_elements_api_error(
     ]
 
 
-@pytest.mark.parametrize(
-    "sets",
-    [
-        ["set_1"],
-        ["set_1", "set_2", "set_3"],
-        ["set_1", "set_2", "set_3", "set_4"],
-    ],
-)
-def test_list_dataset_elements(
+def test_list_set_elements(
     responses,
     mock_dataset_worker,
-    sets,
     default_dataset,
+    default_train_set,
 ):
-    default_dataset.selected_sets = sets
-
-    dataset_elements = []
-    for split in default_dataset.sets:
-        index = split[-1]
-        dataset_elements.append(
-            {
-                "set": split,
-                "element": {
-                    "id": str(index) * 4,
-                    "type": "page",
-                    "name": f"Test {index}",
-                    "corpus": {},
-                    "thumbnail_url": None,
-                    "zone": {},
-                    "best_classes": None,
-                    "has_children": None,
-                    "worker_version_id": None,
-                    "worker_run_id": None,
-                },
-            }
-        )
-        if split == "set_1":
-            dataset_elements.append({**dataset_elements[-1]})
-            dataset_elements[-1]["element"]["name"] = f"Test {index} (bis)"
-
-    # All sets are selected, we call the unfiltered endpoint once
-    if default_dataset.sets == default_dataset.selected_sets:
-        expected_results = dataset_elements
-        responses.add(
-            responses.GET,
-            f"http://testserver/api/v1/datasets/{default_dataset.id}/elements/?with_count=true",
-            status=200,
-            json={
-                "count": len(expected_results),
-                "next": None,
-                "results": expected_results,
+    expected_results = [
+        {
+            "set": "train",
+            "element": {
+                "id": "element_1",
+                "type": "page",
+                "name": "1",
+                "corpus": {},
+                "thumbnail_url": None,
+                "zone": {},
+                "best_classes": None,
+                "has_children": None,
+                "worker_version_id": None,
+                "worker_run_id": None,
             },
-        )
-        expected_calls = [
-            f"http://testserver/api/v1/datasets/{default_dataset.id}/elements/?with_count=true"
-        ]
-
-    # Not all sets are selected, we call the filtered endpoint multiple times, once per set
-    else:
-        expected_results, expected_calls = [], []
-        for selected_set in default_dataset.selected_sets:
-            partial_results = [
-                element
-                for element in dataset_elements
-                if element["set"] == selected_set
-            ]
-            expected_results += partial_results
-            responses.add(
-                responses.GET,
-                f"http://testserver/api/v1/datasets/{default_dataset.id}/elements/?set={selected_set}&with_count=true",
-                status=200,
-                json={
-                    "count": len(partial_results),
-                    "next": None,
-                    "results": partial_results,
-                },
-            )
-            expected_calls += [
-                f"http://testserver/api/v1/datasets/{default_dataset.id}/elements/?set={selected_set}&with_count=true"
-            ]
+        }
+    ]
+    expected_results.append({**expected_results[-1]})
+    expected_results[-1]["element"]["id"] = "element_2"
+    expected_results[-1]["element"]["name"] = "2"
+
+    query_params = f"?set={default_train_set.name}&with_count=true"
+    responses.add(
+        responses.GET,
+        f"http://testserver/api/v1/datasets/{default_dataset.id}/elements/{query_params}",
+        status=200,
+        json={
+            "count": 2,
+            "next": None,
+            "results": expected_results,
+        },
+    )
 
     for idx, element in enumerate(
-        mock_dataset_worker.list_dataset_elements(dataset=default_dataset)
+        mock_dataset_worker.list_set_elements(dataset_set=default_train_set)
     ):
-        assert element == (
-            expected_results[idx]["set"],
-            expected_results[idx]["element"],
-        )
+        assert isinstance(element, Element)
+        assert element == expected_results[idx]["element"]
 
-    assert len(responses.calls) == len(BASE_API_CALLS) + len(expected_calls)
+    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", expected_call) for expected_call in expected_calls]
+    ] == BASE_API_CALLS + [
+        (
+            "GET",
+            f"http://testserver/api/v1/datasets/{default_dataset.id}/elements/{query_params}",
+        )
+    ]
 
 
 @pytest.mark.parametrize(

tests/test_elements_worker/test_metadata.py

@@ -259,7 +259,7 @@ def test_create_metadata_cached_element(responses, mock_elements_worker_with_cac
         ],
     ],
 )
-def test_create_metadatas(responses, mock_elements_worker, metadata_list):
+def test_create_metadata_bulk(responses, mock_elements_worker, metadata_list):
     element = Element({"id": "12341234-1234-1234-1234-123412341234"})
     responses.add(
         responses.POST,
@@ -280,7 +280,7 @@ def test_create_metadatas(responses, mock_elements_worker, metadata_list):
         },
     )
 
-    created_metadata_list = mock_elements_worker.create_metadatas(
+    created_metadata_list = mock_elements_worker.create_metadata_bulk(
         element, metadata_list
     )
 
@@ -327,7 +327,7 @@ def test_create_metadatas(responses, mock_elements_worker, metadata_list):
         ],
     ],
 )
-def test_create_metadatas_cached_element(
+def test_create_metadata_bulk_cached_element(
     responses, mock_elements_worker_with_cache, metadata_list
 ):
     element = CachedElement.create(
@@ -352,7 +352,7 @@ def test_create_metadatas_cached_element(
         },
     )
 
-    created_metadata_list = mock_elements_worker_with_cache.create_metadatas(
+    created_metadata_list = mock_elements_worker_with_cache.create_metadata_bulk(
         element, metadata_list
     )
 
@@ -386,7 +386,7 @@ def test_create_metadatas_cached_element(
 
 
 @pytest.mark.parametrize("wrong_element", [None, "not_element_type", 1234, 12.5])
-def test_create_metadatas_wrong_element(mock_elements_worker, wrong_element):
+def test_create_metadata_bulk_wrong_element(mock_elements_worker, wrong_element):
     wrong_metadata_list = [
         {"type": MetaType.Text, "name": "fake_name", "value": "fake_value"}
     ]
@@ -394,13 +394,13 @@ def test_create_metadatas_wrong_element(mock_elements_worker, wrong_element):
         AssertionError,
         match="element shouldn't be null and should be of type Element or CachedElement",
     ):
-        mock_elements_worker.create_metadatas(
-            element=wrong_element, metadatas=wrong_metadata_list
+        mock_elements_worker.create_metadata_bulk(
+            element=wrong_element, metadata_list=wrong_metadata_list
         )
 
 
 @pytest.mark.parametrize("wrong_type", [None, "not_metadata_type", 1234, 12.5])
-def test_create_metadatas_wrong_type(mock_elements_worker, wrong_type):
+def test_create_metadata_bulk_wrong_type(mock_elements_worker, wrong_type):
     element = Element({"id": "12341234-1234-1234-1234-123412341234"})
     wrong_metadata_list = [
         {"type": wrong_type, "name": "fake_name", "value": "fake_value"}
@@ -408,13 +408,13 @@ def test_create_metadatas_wrong_type(mock_elements_worker, wrong_type):
     with pytest.raises(
         AssertionError, match="type shouldn't be null and should be of type MetaType"
     ):
-        mock_elements_worker.create_metadatas(
-            element=element, metadatas=wrong_metadata_list
+        mock_elements_worker.create_metadata_bulk(
+            element=element, metadata_list=wrong_metadata_list
         )
 
 
 @pytest.mark.parametrize("wrong_name", [None, 1234, 12.5, [1, 2, 3, 4]])
-def test_create_metadatas_wrong_name(mock_elements_worker, wrong_name):
+def test_create_metadata_bulk_wrong_name(mock_elements_worker, wrong_name):
     element = Element({"id": "fake_element_id"})
     wrong_metadata_list = [
         {"type": MetaType.Text, "name": wrong_name, "value": "fake_value"}
@@ -422,13 +422,13 @@ def test_create_metadatas_wrong_name(mock_elements_worker, wrong_name):
     with pytest.raises(
         AssertionError, match="name shouldn't be null and should be of type str"
     ):
-        mock_elements_worker.create_metadatas(
-            element=element, metadatas=wrong_metadata_list
+        mock_elements_worker.create_metadata_bulk(
+            element=element, metadata_list=wrong_metadata_list
         )
 
 
 @pytest.mark.parametrize("wrong_value", [None, [1, 2, 3, 4]])
-def test_create_metadatas_wrong_value(mock_elements_worker, wrong_value):
+def test_create_metadata_bulk_wrong_value(mock_elements_worker, wrong_value):
     element = Element({"id": "fake_element_id"})
     wrong_metadata_list = [
         {"type": MetaType.Text, "name": "fake_name", "value": wrong_value}
@@ -439,13 +439,13 @@ def test_create_metadatas_wrong_value(mock_elements_worker, wrong_value):
             "value shouldn't be null and should be of type (str or float or int)"
         ),
     ):
-        mock_elements_worker.create_metadatas(
-            element=element, metadatas=wrong_metadata_list
+        mock_elements_worker.create_metadata_bulk(
+            element=element, metadata_list=wrong_metadata_list
         )
 
 
 @pytest.mark.parametrize("wrong_entity", [[1, 2, 3, 4], 1234, 12.5])
-def test_create_metadatas_wrong_entity(mock_elements_worker, wrong_entity):
+def test_create_metadata_bulk_wrong_entity(mock_elements_worker, wrong_entity):
     element = Element({"id": "fake_element_id"})
     wrong_metadata_list = [
         {
@@ -456,12 +456,12 @@ def test_create_metadatas_wrong_entity(mock_elements_worker, wrong_entity):
         }
     ]
     with pytest.raises(AssertionError, match="entity_id should be None or a str"):
-        mock_elements_worker.create_metadatas(
-            element=element, metadatas=wrong_metadata_list
+        mock_elements_worker.create_metadata_bulk(
+            element=element, metadata_list=wrong_metadata_list
         )
 
 
-def test_create_metadatas_api_error(responses, mock_elements_worker):
+def test_create_metadata_bulk_api_error(responses, mock_elements_worker):
     element = Element({"id": "12341234-1234-1234-1234-123412341234"})
     metadata_list = [
         {
@@ -478,7 +478,7 @@ def test_create_metadatas_api_error(responses, mock_elements_worker):
     )
 
     with pytest.raises(ErrorResponse):
-        mock_elements_worker.create_metadatas(element, metadata_list)
+        mock_elements_worker.create_metadata_bulk(element, metadata_list)
 
     assert len(responses.calls) == len(BASE_API_CALLS) + 5
     assert [

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()