arkindex-base-worker 0.4.0b1__py3-none-any.whl → 0.4.0b3__py3-none-any.whl

tests/test_elements_worker/test_elements.py

@@ -15,6 +15,7 @@ from arkindex_worker.cache import (
     init_cache_db,
 )
 from arkindex_worker.models import Element
+from arkindex_worker.utils import DEFAULT_BATCH_SIZE
 from arkindex_worker.worker import ElementsWorker
 from arkindex_worker.worker.element import MissingTypeError
 from tests import CORPUS_ID
@@ -62,7 +63,7 @@ def test_check_required_types(mock_elements_worker):
     with pytest.raises(
         MissingTypeError,
         match=re.escape(
-            "Element type(s) act, text_line were not found in corpus (11111111-1111-1111-1111-111111111111)."
+            "Element types act, text_line were not found in corpus (11111111-1111-1111-1111-111111111111)."
         ),
     ):
         assert mock_elements_worker.check_required_types("page", "text_line", "act")
@@ -1010,7 +1011,10 @@ def test_create_elements_api_error(responses, mock_elements_worker):
     ]
 
 
-def test_create_elements_cached_element(responses, mock_elements_worker_with_cache):
+@pytest.mark.parametrize("batch_size", [DEFAULT_BATCH_SIZE, 1])
+def test_create_elements_cached_element(
+    batch_size, responses, mock_elements_worker_with_cache
+):
     image = CachedImage.create(
         id=UUID("c0fec0fe-c0fe-c0fe-c0fe-c0fec0fec0fe"),
         width=42,
@@ -1023,12 +1027,28 @@ def test_create_elements_cached_element(responses, mock_elements_worker_with_cac
         image_id=image.id,
         polygon="[[0, 0], [0, 1000], [1000, 1000], [1000, 0], [0, 0]]",
     )
-    responses.add(
-        responses.POST,
-        "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/children/bulk/",
-        status=200,
-        json=[{"id": "497f6eca-6276-4993-bfeb-53cbbbba6f08"}],
-    )
+
+    if batch_size > 1:
+        responses.add(
+            responses.POST,
+            "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/children/bulk/",
+            status=200,
+            json=[
+                {"id": "497f6eca-6276-4993-bfeb-53cbbbba6f08"},
+                {"id": "5468c358-b9c4-499d-8b92-d6349c58e88d"},
+            ],
+        )
+    else:
+        for elt_id in [
+            "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+            "5468c358-b9c4-499d-8b92-d6349c58e88d",
+        ]:
+            responses.add(
+                responses.POST,
+                "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/children/bulk/",
+                status=200,
+                json=[{"id": elt_id}],
+            )
 
     created_ids = mock_elements_worker_with_cache.create_elements(
         parent=elt,
@@ -1037,30 +1057,69 @@ def test_create_elements_cached_element(responses, mock_elements_worker_with_cac
                 "name": "0",
                 "type": "something",
                 "polygon": [[1, 1], [2, 2], [2, 1], [1, 2]],
-            }
+            },
+            {
+                "name": "1",
+                "type": "something",
+                "polygon": [[4, 4], [5, 5], [5, 4], [4, 5]],
+            },
         ],
+        batch_size=batch_size,
     )
 
-    assert len(responses.calls) == len(BASE_API_CALLS) + 1
-    assert [
-        (call.request.method, call.request.url) for call in responses.calls
-    ] == BASE_API_CALLS + [
+    bulk_api_calls = [
         (
             "POST",
             "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/children/bulk/",
-        ),
+        )
     ]
-    assert json.loads(responses.calls[-1].request.body) == {
-        "elements": [
-            {
-                "name": "0",
-                "type": "something",
-                "polygon": [[1, 1], [2, 2], [2, 1], [1, 2]],
-            }
-        ],
+    if batch_size != DEFAULT_BATCH_SIZE:
+        bulk_api_calls.append(
+            (
+                "POST",
+                "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/children/bulk/",
+            )
+        )
+
+    assert len(responses.calls) == len(BASE_API_CALLS) + len(bulk_api_calls)
+    assert [
+        (call.request.method, call.request.url) for call in responses.calls
+    ] == BASE_API_CALLS + bulk_api_calls
+
+    first_elt = {
+        "name": "0",
+        "type": "something",
+        "polygon": [[1, 1], [2, 2], [2, 1], [1, 2]],
+    }
+    second_elt = {
+        "name": "1",
+        "type": "something",
+        "polygon": [[4, 4], [5, 5], [5, 4], [4, 5]],
+    }
+    empty_payload = {
+        "elements": [],
         "worker_run_id": "56785678-5678-5678-5678-567856785678",
     }
-    assert created_ids == [{"id": "497f6eca-6276-4993-bfeb-53cbbbba6f08"}]
+
+    bodies = []
+    first_call_idx = None
+    if batch_size > 1:
+        first_call_idx = -1
+        bodies.append({**empty_payload, "elements": [first_elt, second_elt]})
+    else:
+        first_call_idx = -2
+        bodies.append({**empty_payload, "elements": [first_elt]})
+        bodies.append({**empty_payload, "elements": [second_elt]})
+
+    assert [
+        json.loads(bulk_call.request.body)
+        for bulk_call in responses.calls[first_call_idx:]
+    ] == bodies
+
+    assert created_ids == [
+        {"id": "497f6eca-6276-4993-bfeb-53cbbbba6f08"},
+        {"id": "5468c358-b9c4-499d-8b92-d6349c58e88d"},
+    ]
 
     # Check that created elements were properly stored in SQLite cache
     assert list(CachedElement.select().order_by(CachedElement.id)) == [
@@ -1072,11 +1131,24 @@ def test_create_elements_cached_element(responses, mock_elements_worker_with_cac
             image_id="c0fec0fe-c0fe-c0fe-c0fe-c0fec0fec0fe",
             polygon=[[1, 1], [2, 2], [2, 1], [1, 2]],
             worker_run_id=UUID("56785678-5678-5678-5678-567856785678"),
+            confidence=None,
+        ),
+        CachedElement(
+            id=UUID("5468c358-b9c4-499d-8b92-d6349c58e88d"),
+            parent_id=elt.id,
+            type="something",
+            image_id="c0fec0fe-c0fe-c0fe-c0fe-c0fec0fec0fe",
+            polygon=[[4, 4], [5, 5], [5, 4], [4, 5]],
+            worker_run_id=UUID("56785678-5678-5678-5678-567856785678"),
+            confidence=None,
         ),
     ]
 
 
-def test_create_elements(responses, mock_elements_worker_with_cache, tmp_path):
+@pytest.mark.parametrize("batch_size", [DEFAULT_BATCH_SIZE, 1])
+def test_create_elements(
+    batch_size, responses, mock_elements_worker_with_cache, tmp_path
+):
     elt = Element(
         {
             "id": "12341234-1234-1234-1234-123412341234",
@@ -1090,12 +1162,28 @@ def test_create_elements(responses, mock_elements_worker_with_cache, tmp_path):
             },
         }
     )
-    responses.add(
-        responses.POST,
-        "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/children/bulk/",
-        status=200,
-        json=[{"id": "497f6eca-6276-4993-bfeb-53cbbbba6f08"}],
-    )
+
+    if batch_size > 1:
+        responses.add(
+            responses.POST,
+            "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/children/bulk/",
+            status=200,
+            json=[
+                {"id": "497f6eca-6276-4993-bfeb-53cbbbba6f08"},
+                {"id": "5468c358-b9c4-499d-8b92-d6349c58e88d"},
+            ],
+        )
+    else:
+        for elt_id in [
+            "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+            "5468c358-b9c4-499d-8b92-d6349c58e88d",
+        ]:
+            responses.add(
+                responses.POST,
+                "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/children/bulk/",
+                status=200,
+                json=[{"id": elt_id}],
+            )
 
     created_ids = mock_elements_worker_with_cache.create_elements(
         parent=elt,
@@ -1104,30 +1192,69 @@ def test_create_elements(responses, mock_elements_worker_with_cache, tmp_path):
                 "name": "0",
                 "type": "something",
                 "polygon": [[1, 1], [2, 2], [2, 1], [1, 2]],
-            }
+            },
+            {
+                "name": "1",
+                "type": "something",
+                "polygon": [[4, 4], [5, 5], [5, 4], [4, 5]],
+            },
         ],
+        batch_size=batch_size,
     )
 
-    assert len(responses.calls) == len(BASE_API_CALLS) + 1
-    assert [
-        (call.request.method, call.request.url) for call in responses.calls
-    ] == BASE_API_CALLS + [
+    bulk_api_calls = [
         (
             "POST",
             "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/children/bulk/",
-        ),
+        )
     ]
-    assert json.loads(responses.calls[-1].request.body) == {
-        "elements": [
-            {
-                "name": "0",
-                "type": "something",
-                "polygon": [[1, 1], [2, 2], [2, 1], [1, 2]],
-            }
-        ],
+    if batch_size != DEFAULT_BATCH_SIZE:
+        bulk_api_calls.append(
+            (
+                "POST",
+                "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/children/bulk/",
+            )
+        )
+
+    assert len(responses.calls) == len(BASE_API_CALLS) + len(bulk_api_calls)
+    assert [
+        (call.request.method, call.request.url) for call in responses.calls
+    ] == BASE_API_CALLS + bulk_api_calls
+
+    first_elt = {
+        "name": "0",
+        "type": "something",
+        "polygon": [[1, 1], [2, 2], [2, 1], [1, 2]],
+    }
+    second_elt = {
+        "name": "1",
+        "type": "something",
+        "polygon": [[4, 4], [5, 5], [5, 4], [4, 5]],
+    }
+    empty_payload = {
+        "elements": [],
         "worker_run_id": "56785678-5678-5678-5678-567856785678",
     }
-    assert created_ids == [{"id": "497f6eca-6276-4993-bfeb-53cbbbba6f08"}]
+
+    bodies = []
+    first_call_idx = None
+    if batch_size > 1:
+        first_call_idx = -1
+        bodies.append({**empty_payload, "elements": [first_elt, second_elt]})
+    else:
+        first_call_idx = -2
+        bodies.append({**empty_payload, "elements": [first_elt]})
+        bodies.append({**empty_payload, "elements": [second_elt]})
+
+    assert [
+        json.loads(bulk_call.request.body)
+        for bulk_call in responses.calls[first_call_idx:]
+    ] == bodies
+
+    assert created_ids == [
+        {"id": "497f6eca-6276-4993-bfeb-53cbbbba6f08"},
+        {"id": "5468c358-b9c4-499d-8b92-d6349c58e88d"},
+    ]
 
     # Check that created elements were properly stored in SQLite cache
     assert (tmp_path / "db.sqlite").is_file()
@@ -1141,7 +1268,16 @@ def test_create_elements(responses, mock_elements_worker_with_cache, tmp_path):
             polygon=[[1, 1], [2, 2], [2, 1], [1, 2]],
             worker_run_id=UUID("56785678-5678-5678-5678-567856785678"),
             confidence=None,
-        )
+        ),
+        CachedElement(
+            id=UUID("5468c358-b9c4-499d-8b92-d6349c58e88d"),
+            parent_id=UUID("12341234-1234-1234-1234-123412341234"),
+            type="something",
+            image_id="c0fec0fe-c0fe-c0fe-c0fe-c0fec0fec0fe",
+            polygon=[[4, 4], [5, 5], [5, 4], [4, 5]],
+            worker_run_id=UUID("56785678-5678-5678-5678-567856785678"),
+            confidence=None,
+        ),
     ]
 
 
@@ -1268,9 +1404,9 @@ def test_create_elements_integrity_error(
         {"id": "497f6eca-6276-4993-bfeb-53cbbbba6f08"},
     ]
 
-    assert len(caplog.records) == 1
-    assert caplog.records[0].levelname == "WARNING"
-    assert caplog.records[0].message.startswith(
+    assert len(caplog.records) == 3
+    assert caplog.records[-1].levelname == "WARNING"
+    assert caplog.records[-1].message.startswith(
         "Couldn't save created elements in local cache:"
     )
 
@@ -1364,6 +1500,139 @@ def test_create_element_parent(responses, mock_elements_worker):
     }
 
 
+@pytest.mark.parametrize(
+    ("arg_name", "data", "error_message"),
+    [
+        (
+            "parent",
+            None,
+            "parent shouldn't be null and should be of type Element",
+        ),
+        (
+            "parent",
+            "not element type",
+            "parent shouldn't be null and should be of type Element",
+        ),
+        (
+            "children",
+            None,
+            "children shouldn't be null and should be of type list",
+        ),
+        (
+            "children",
+            "not a list",
+            "children shouldn't be null and should be of type list",
+        ),
+        (
+            "children",
+            [
+                Element({"id": "11111111-1111-1111-1111-111111111111"}),
+                "not element type",
+            ],
+            "Child at index 1 in children: Should be of type Element",
+        ),
+    ],
+)
+def test_create_element_children_wrong_params(
+    arg_name, data, error_message, mock_elements_worker
+):
+    with pytest.raises(AssertionError, match=error_message):
+        mock_elements_worker.create_element_children(
+            **{
+                "parent": Element({"id": "12341234-1234-1234-1234-123412341234"}),
+                "children": [
+                    Element({"id": "11111111-1111-1111-1111-111111111111"}),
+                    Element({"id": "22222222-2222-2222-2222-222222222222"}),
+                ],
+                # Overwrite with wrong data
+                arg_name: data,
+            },
+        )
+
+
+def test_create_element_children_api_error(responses, mock_elements_worker):
+    parent = Element({"id": "12341234-1234-1234-1234-123412341234"})
+    responses.add(
+        responses.POST,
+        f"http://testserver/api/v1/element/parent/{parent.id}/",
+        status=418,
+    )
+
+    with pytest.raises(ErrorResponse):
+        mock_elements_worker.create_element_children(
+            parent=parent,
+            children=[
+                Element({"id": "11111111-1111-1111-1111-111111111111"}),
+                Element({"id": "22222222-2222-2222-2222-222222222222"}),
+            ],
+        )
+
+    assert len(responses.calls) == len(BASE_API_CALLS) + 1
+    assert [
+        (call.request.method, call.request.url) for call in responses.calls
+    ] == BASE_API_CALLS + [
+        (
+            "POST",
+            f"http://testserver/api/v1/element/parent/{parent.id}/",
+        )
+    ]
+
+
+@pytest.mark.parametrize("batch_size", [DEFAULT_BATCH_SIZE, 1])
+def test_create_element_children(batch_size, responses, mock_elements_worker):
+    parent = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    first_child = Element({"id": "11111111-1111-1111-1111-111111111111"})
+    second_child = Element({"id": "22222222-2222-2222-2222-222222222222"})
+
+    responses.add(
+        responses.POST,
+        f"http://testserver/api/v1/element/parent/{parent.id}/",
+        status=200,
+        json={"children": []},
+    )
+
+    mock_elements_worker.create_element_children(
+        parent=parent,
+        children=[first_child, second_child],
+        batch_size=batch_size,
+    )
+
+    bulk_api_calls = [
+        (
+            "POST",
+            f"http://testserver/api/v1/element/parent/{parent.id}/",
+        )
+    ]
+    if batch_size != DEFAULT_BATCH_SIZE:
+        bulk_api_calls.append(
+            (
+                "POST",
+                f"http://testserver/api/v1/element/parent/{parent.id}/",
+            )
+        )
+
+    assert len(responses.calls) == len(BASE_API_CALLS) + len(bulk_api_calls)
+    assert [
+        (call.request.method, call.request.url) for call in responses.calls
+    ] == BASE_API_CALLS + bulk_api_calls
+
+    bodies = []
+    first_call_idx = None
+    if batch_size > 1:
+        first_call_idx = -1
+        bodies.append({"children": [first_child.id, second_child.id]})
+    else:
+        first_call_idx = -2
+        bodies.append({"children": [first_child.id]})
+        bodies.append({"children": [second_child.id]})
+
+    assert [
+        json.loads(bulk_call.request.body)
+        for bulk_call in responses.calls[first_call_idx:]
+    ] == bodies
+
+
 @pytest.mark.parametrize(
     ("payload", "error"),
     [

tests/test_elements_worker/test_entities.py

@@ -13,6 +13,7 @@ from arkindex_worker.cache import (
     CachedTranscriptionEntity,
 )
 from arkindex_worker.models import Transcription
+from arkindex_worker.utils import DEFAULT_BATCH_SIZE
 from arkindex_worker.worker.entity import MissingEntityType
 from arkindex_worker.worker.transcription import TextOrientation
 from tests import CORPUS_ID
@@ -988,38 +989,89 @@ def test_create_transcription_entities_wrong_entity(
         )
 
 
-def test_create_transcription_entities(responses, mock_elements_worker):
+@pytest.mark.parametrize("batch_size", [DEFAULT_BATCH_SIZE, 1])
+def test_create_transcription_entities(batch_size, responses, mock_elements_worker):
     transcription = Transcription(id="transcription-id")
+
     # Call to Transcription entities creation in bulk
-    responses.add(
-        responses.POST,
-        "http://testserver/api/v1/transcription/transcription-id/entities/bulk/",
-        status=201,
-        match=[
-            matchers.json_params_matcher(
-                {
-                    "worker_run_id": "56785678-5678-5678-5678-567856785678",
+    if batch_size > 1:
+        responses.add(
+            responses.POST,
+            "http://testserver/api/v1/transcription/transcription-id/entities/bulk/",
+            status=201,
+            match=[
+                matchers.json_params_matcher(
+                    {
+                        "worker_run_id": "56785678-5678-5678-5678-567856785678",
+                        "entities": [
+                            {
+                                "name": "Teklia",
+                                "type_id": "22222222-2222-2222-2222-222222222222",
+                                "offset": 0,
+                                "length": 6,
+                                "confidence": 1.0,
+                            },
+                            {
+                                "name": "Team Rocket",
+                                "type_id": "22222222-2222-2222-2222-222222222222",
+                                "offset": 7,
+                                "length": 11,
+                                "confidence": 1.0,
+                            },
+                        ],
+                    }
+                )
+            ],
+            json={
+                "entities": [
+                    {
+                        "transcription_entity_id": "transc-entity-id",
+                        "entity_id": "entity-id1",
+                    },
+                    {
+                        "transcription_entity_id": "transc-entity-id",
+                        "entity_id": "entity-id2",
+                    },
+                ]
+            },
+        )
+    else:
+        for idx, (name, offset, length) in enumerate(
+            [
+                ("Teklia", 0, 6),
+                ("Team Rocket", 7, 11),
+            ],
+            start=1,
+        ):
+            responses.add(
+                responses.POST,
+                "http://testserver/api/v1/transcription/transcription-id/entities/bulk/",
+                status=201,
+                match=[
+                    matchers.json_params_matcher(
+                        {
+                            "worker_run_id": "56785678-5678-5678-5678-567856785678",
+                            "entities": [
+                                {
+                                    "name": name,
+                                    "type_id": "22222222-2222-2222-2222-222222222222",
+                                    "offset": offset,
+                                    "length": length,
+                                    "confidence": 1.0,
+                                }
+                            ],
+                        }
+                    )
+                ],
+                json={
                     "entities": [
                         {
-                            "name": "Teklia",
-                            "type_id": "22222222-2222-2222-2222-222222222222",
-                            "offset": 0,
-                            "length": 6,
-                            "confidence": 1.0,
+                            "transcription_entity_id": "transc-entity-id",
+                            "entity_id": f"entity-id{idx}",
                         }
-                    ],
-                }
+                    ]
+                },
             )
-        ],
-        json={
-            "entities": [
-                {
-                    "transcription_entity_id": "transc-entity-id",
-                    "entity_id": "entity-id",
-                }
-            ]
-        },
-    )
 
     # Store entity type/slug correspondence on the worker
     mock_elements_worker.entity_types = {
@@ -1034,18 +1086,35 @@ def test_create_transcription_entities(responses, mock_elements_worker):
                 "offset": 0,
                 "length": 6,
                 "confidence": 1.0,
-            }
+            },
+            {
+                "name": "Team Rocket",
+                "type_id": "22222222-2222-2222-2222-222222222222",
+                "offset": 7,
+                "length": 11,
+                "confidence": 1.0,
+            },
         ],
+        batch_size=batch_size,
     )
 
-    assert len(created_objects) == 1
+    assert len(created_objects) == 2
 
-    assert len(responses.calls) == len(BASE_API_CALLS) + 1
-    assert [
-        (call.request.method, call.request.url) for call in responses.calls
-    ] == BASE_API_CALLS + [
+    bulk_api_calls = [
         (
             "POST",
             "http://testserver/api/v1/transcription/transcription-id/entities/bulk/",
-        ),
+        )
     ]
+    if batch_size != DEFAULT_BATCH_SIZE:
+        bulk_api_calls.append(
+            (
+                "POST",
+                "http://testserver/api/v1/transcription/transcription-id/entities/bulk/",
+            )
+        )
+
+    assert len(responses.calls) == len(BASE_API_CALLS) + len(bulk_api_calls)
+    assert [
+        (call.request.method, call.request.url) for call in responses.calls
+    ] == BASE_API_CALLS + bulk_api_calls