arkindex-base-worker 0.5.0b3__py3-none-any.whl → 0.5.0rc1__py3-none-any.whl

tests/test_elements_worker/{test_entity_create.py → test_entity.py}

@@ -8,216 +8,216 @@ from responses import matchers
 from arkindex.exceptions import ErrorResponse
 from arkindex_worker.cache import (
     CachedElement,
-    CachedEntity,
     CachedTranscription,
     CachedTranscriptionEntity,
 )
 from arkindex_worker.models import Transcription
+from arkindex_worker.worker.entity import MissingEntityType
 from arkindex_worker.worker.transcription import TextOrientation
 from tests import CORPUS_ID
 
 from . import BASE_API_CALLS
 
 
-def test_create_entity_wrong_name(mock_elements_worker):
+def test_create_entity_type_wrong_name(mock_elements_worker):
     with pytest.raises(
         AssertionError, match="name shouldn't be null and should be of type str"
     ):
-        mock_elements_worker.create_entity(
-            name=None,
-            type="person",
-        )
+        mock_elements_worker.create_entity_type(name=None)
 
     with pytest.raises(
         AssertionError, match="name shouldn't be null and should be of type str"
     ):
-        mock_elements_worker.create_entity(
-            name=1234,
-            type="person",
-        )
-
-
-def test_create_entity_wrong_type(mock_elements_worker):
-    with pytest.raises(
-        AssertionError, match="type shouldn't be null and should be of type str"
-    ):
-        mock_elements_worker.create_entity(
-            name="Bob Bob",
-            type=None,
-        )
-
-    with pytest.raises(
-        AssertionError, match="type shouldn't be null and should be of type str"
-    ):
-        mock_elements_worker.create_entity(
-            name="Bob Bob",
-            type=1234,
-        )
-
-
-def test_create_entity_wrong_corpus(mock_elements_worker):
-    # Triggering an error on metas param, not giving corpus should work since
-    # ARKINDEX_CORPUS_ID environment variable is set on mock_elements_worker
-    with pytest.raises(AssertionError, match="metas should be of type dict"):
-        mock_elements_worker.create_entity(
-            name="Bob Bob",
-            type="person",
-            metas="wrong metas",
-        )
-
-
-def test_create_entity_wrong_metas(mock_elements_worker):
-    with pytest.raises(AssertionError, match="metas should be of type dict"):
-        mock_elements_worker.create_entity(
-            name="Bob Bob",
-            type="person",
-            metas="wrong metas",
-        )
+        mock_elements_worker.create_entity_type(name=1234)
 
 
-def test_create_entity_wrong_validated(mock_elements_worker):
-    with pytest.raises(AssertionError, match="validated should be of type bool"):
-        mock_elements_worker.create_entity(
-            name="Bob Bob",
-            type="person",
-            validated="wrong validated",
-        )
-
-
-def test_create_entity_api_error(responses, mock_elements_worker):
-    # Set one entity type
-    mock_elements_worker.entity_types = {"person": "person-entity-type-id"}
+def test_create_entity_type_api_error(responses, mock_elements_worker):
     responses.add(
         responses.POST,
-        "http://testserver/api/v1/entity/",
+        "http://testserver/api/v1/entity/types/",
         status=418,
     )
 
     with pytest.raises(ErrorResponse):
-        mock_elements_worker.create_entity(
-            name="Bob Bob",
-            type="person",
-        )
+        mock_elements_worker.create_entity_type(name="firstname")
 
     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", "http://testserver/api/v1/entity/")]
+    ] == BASE_API_CALLS + [("POST", "http://testserver/api/v1/entity/types/")]
 
 
-def test_create_entity(responses, mock_elements_worker):
-    # Set one entity type
-    mock_elements_worker.entity_types = {"person": "person-entity-type-id"}
+def test_create_entity_type_already_exists(responses, mock_elements_worker):
+    assert mock_elements_worker.entity_types == {}
 
     responses.add(
         responses.POST,
-        "http://testserver/api/v1/entity/",
+        "http://testserver/api/v1/entity/types/",
+        status=400,
+        match=[
+            matchers.json_params_matcher({"name": "firstname", "corpus": CORPUS_ID})
+        ],
+    )
+    responses.add(
+        responses.GET,
+        f"http://testserver/api/v1/corpus/{CORPUS_ID}/entity-types/",
         status=200,
-        json={"id": "12345678-1234-1234-1234-123456789123"},
+        json={
+            "count": 1,
+            "next": None,
+            "results": [
+                {"id": "lastname-id", "name": "lastname", "color": "ffd1b3"},
+                {"id": "firstname-id", "name": "firstname", "color": "ffd1b3"},
+            ],
+        },
     )
 
-    entity_id = mock_elements_worker.create_entity(
-        name="Bob Bob",
-        type="person",
-    )
+    mock_elements_worker.create_entity_type(name="firstname")
 
-    assert len(responses.calls) == len(BASE_API_CALLS) + 1
+    assert len(responses.calls) == len(BASE_API_CALLS) + 2
     assert [
         (call.request.method, call.request.url) for call in responses.calls
     ] == BASE_API_CALLS + [
-        ("POST", "http://testserver/api/v1/entity/"),
+        ("POST", "http://testserver/api/v1/entity/types/"),
+        ("GET", f"http://testserver/api/v1/corpus/{CORPUS_ID}/entity-types/"),
     ]
-    assert json.loads(responses.calls[-1].request.body) == {
-        "name": "Bob Bob",
-        "type_id": "person-entity-type-id",
-        "metas": {},
-        "validated": None,
-        "corpus": CORPUS_ID,
-        "worker_run_id": "56785678-5678-5678-5678-567856785678",
+
+    # Make sure the entity_types attribute has been updated
+    assert mock_elements_worker.entity_types == {
+        "lastname": "lastname-id",
+        "firstname": "firstname-id",
     }
-    assert entity_id == "12345678-1234-1234-1234-123456789123"
 
 
-def test_create_entity_missing_type(responses, mock_elements_worker):
-    """
-    Create entity with an unknown type will fail.
-    """
-    # Call to list entity types
+def test_create_entity_type(responses, mock_elements_worker):
+    assert mock_elements_worker.entity_types == {}
+
     responses.add(
-        responses.GET,
-        f"http://testserver/api/v1/corpus/{CORPUS_ID}/entity-types/",
+        responses.POST,
+        "http://testserver/api/v1/entity/types/",
         status=200,
+        match=[
+            matchers.json_params_matcher({"name": "firstname", "corpus": CORPUS_ID})
+        ],
         json={
-            "count": 1,
-            "next": None,
-            "results": [
-                {"id": "person-entity-type-id", "name": "person", "color": "00d1b2"}
-            ],
+            "id": "firstname-id",
+            "name": "firstname",
+            "corpus": CORPUS_ID,
+            "color": "ffd1b3",
         },
     )
 
-    with pytest.raises(
-        AssertionError, match="Entity type `new-entity` not found in the corpus."
-    ):
-        mock_elements_worker.create_entity(
-            name="Bob Bob",
-            type="new-entity",
-        )
+    mock_elements_worker.create_entity_type(name="firstname")
 
     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/corpus/{CORPUS_ID}/entity-types/",
-        ),
+        ("POST", "http://testserver/api/v1/entity/types/"),
     ]
 
+    # Make sure the entity_types attribute has been updated
+    assert mock_elements_worker.entity_types == {"firstname": "firstname-id"}
+
+
+def test_check_required_entity_types_wrong_entity_types(mock_elements_worker):
+    with pytest.raises(
+        AssertionError,
+        match="entity_types shouldn't be null and should be of type list",
+    ):
+        mock_elements_worker.check_required_entity_types(entity_types=None)
+
+    with pytest.raises(
+        AssertionError,
+        match="entity_types shouldn't be null and should be of type list",
+    ):
+        mock_elements_worker.check_required_entity_types(entity_types=1234)
+
+    with pytest.raises(
+        AssertionError,
+        match="Entity type at index 1 in entity_types: Should be of type str",
+    ):
+        mock_elements_worker.check_required_entity_types(
+            entity_types=["firstname", 1234]
+        )
+
 
-def test_create_entity_with_cache(responses, mock_elements_worker_with_cache):
+def test_check_required_entity_types_wrong_create_missing(mock_elements_worker):
+    with pytest.raises(
+        AssertionError,
+        match="create_missing shouldn't be null and should be of type bool",
+    ):
+        mock_elements_worker.check_required_entity_types(
+            entity_types=["firstname"], create_missing=None
+        )
+
+    with pytest.raises(
+        AssertionError,
+        match="create_missing shouldn't be null and should be of type bool",
+    ):
+        mock_elements_worker.check_required_entity_types(
+            entity_types=["firstname"], create_missing=1234
+        )
+
+
+def test_check_required_entity_types_do_not_create_missing(
+    responses, mock_elements_worker
+):
     # Set one entity type
-    mock_elements_worker_with_cache.entity_types = {"person": "person-entity-type-id"}
+    mock_elements_worker.entity_types = {"lastname": "lastname-id"}
+
+    with pytest.raises(
+        MissingEntityType, match="Entity type `firstname` was not in the corpus."
+    ):
+        mock_elements_worker.check_required_entity_types(
+            entity_types=["lastname", "firstname"], create_missing=False
+        )
+
+    assert len(responses.calls) == len(BASE_API_CALLS)
+    assert [
+        (call.request.method, call.request.url) for call in responses.calls
+    ] == BASE_API_CALLS
+
+
+def test_check_required_entity_types(responses, mock_elements_worker):
+    # Set one entity type
+    mock_elements_worker.entity_types = {"lastname": "lastname-id"}
+
+    # Call to create a new entity type
     responses.add(
         responses.POST,
-        "http://testserver/api/v1/entity/",
+        "http://testserver/api/v1/entity/types/",
         status=200,
-        json={"id": "12345678-1234-1234-1234-123456789123"},
+        match=[
+            matchers.json_params_matcher({"name": "firstname", "corpus": CORPUS_ID})
+        ],
+        json={
+            "id": "firstname-id",
+            "name": "firstname",
+            "corpus": CORPUS_ID,
+            "color": "ffd1b3",
+        },
     )
 
-    entity_id = mock_elements_worker_with_cache.create_entity(
-        name="Bob Bob",
-        type="person",
+    mock_elements_worker.check_required_entity_types(
+        entity_types=["lastname", "firstname"], create_missing=True
     )
 
     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", "http://testserver/api/v1/entity/"),
+        (
+            "POST",
+            "http://testserver/api/v1/entity/types/",
+        ),
     ]
 
-    assert json.loads(responses.calls[-1].request.body) == {
-        "name": "Bob Bob",
-        "type_id": "person-entity-type-id",
-        "metas": {},
-        "validated": None,
-        "corpus": CORPUS_ID,
-        "worker_run_id": "56785678-5678-5678-5678-567856785678",
+    # Make sure the entity_types attribute has been updated
+    assert mock_elements_worker.entity_types == {
+        "lastname": "lastname-id",
+        "firstname": "firstname-id",
     }
-    assert entity_id == "12345678-1234-1234-1234-123456789123"
-
-    # Check that created entity was properly stored in SQLite cache
-    assert list(CachedEntity.select()) == [
-        CachedEntity(
-            id=UUID("12345678-1234-1234-1234-123456789123"),
-            type="person",
-            name="Bob Bob",
-            validated=False,
-            metas={},
-            worker_run_id=UUID("56785678-5678-5678-5678-567856785678"),
-        )
-    ]
 
 
 def test_create_transcription_entity_wrong_transcription(mock_elements_worker):
@@ -227,7 +227,7 @@ def test_create_transcription_entity_wrong_transcription(mock_elements_worker):
     ):
         mock_elements_worker.create_transcription_entity(
             transcription=None,
-            entity="11111111-1111-1111-1111-111111111111",
+            type_id="11111111-1111-1111-1111-111111111111",
             offset=5,
             length=10,
         )
@@ -238,15 +238,15 @@ def test_create_transcription_entity_wrong_transcription(mock_elements_worker):
     ):
         mock_elements_worker.create_transcription_entity(
             transcription=1234,
-            entity="11111111-1111-1111-1111-111111111111",
+            type_id="11111111-1111-1111-1111-111111111111",
             offset=5,
             length=10,
         )
 
 
-def test_create_transcription_entity_wrong_entity(mock_elements_worker):
+def test_create_transcription_entity_wrong_type_id(mock_elements_worker):
     with pytest.raises(
-        AssertionError, match="entity shouldn't be null and should be of type str"
+        AssertionError, match="type_id shouldn't be null and should be of type str"
     ):
         mock_elements_worker.create_transcription_entity(
             transcription=Transcription(
@@ -255,13 +255,13 @@ def test_create_transcription_entity_wrong_entity(mock_elements_worker):
                     "element": {"id": "myelement"},
                 }
             ),
-            entity=None,
+            type_id=None,
             offset=5,
             length=10,
         )
 
     with pytest.raises(
-        AssertionError, match="entity shouldn't be null and should be of type str"
+        AssertionError, match="type_id shouldn't be null and should be of type str"
     ):
         mock_elements_worker.create_transcription_entity(
             transcription=Transcription(
@@ -270,7 +270,7 @@ def test_create_transcription_entity_wrong_entity(mock_elements_worker):
                     "element": {"id": "myelement"},
                 }
             ),
-            entity=1234,
+            type_id=1234,
             offset=5,
             length=10,
         )
@@ -288,7 +288,7 @@ def test_create_transcription_entity_wrong_offset(mock_elements_worker):
                     "element": {"id": "myelement"},
                 }
             ),
-            entity="11111111-1111-1111-1111-111111111111",
+            type_id="11111111-1111-1111-1111-111111111111",
             offset=None,
             length=10,
         )
@@ -304,7 +304,7 @@ def test_create_transcription_entity_wrong_offset(mock_elements_worker):
                     "element": {"id": "myelement"},
                 }
             ),
-            entity="11111111-1111-1111-1111-111111111111",
+            type_id="11111111-1111-1111-1111-111111111111",
             offset="not an int",
             length=10,
         )
@@ -320,7 +320,7 @@ def test_create_transcription_entity_wrong_offset(mock_elements_worker):
                     "element": {"id": "myelement"},
                 }
             ),
-            entity="11111111-1111-1111-1111-111111111111",
+            type_id="11111111-1111-1111-1111-111111111111",
             offset=-1,
             length=10,
         )
@@ -338,7 +338,7 @@ def test_create_transcription_entity_wrong_length(mock_elements_worker):
                     "element": {"id": "myelement"},
                 }
             ),
-            entity="11111111-1111-1111-1111-111111111111",
+            type_id="11111111-1111-1111-1111-111111111111",
             offset=5,
             length=None,
         )
@@ -354,7 +354,7 @@ def test_create_transcription_entity_wrong_length(mock_elements_worker):
                     "element": {"id": "myelement"},
                 }
             ),
-            entity="11111111-1111-1111-1111-111111111111",
+            type_id="11111111-1111-1111-1111-111111111111",
             offset=5,
             length="not an int",
         )
@@ -370,7 +370,7 @@ def test_create_transcription_entity_wrong_length(mock_elements_worker):
                     "element": {"id": "myelement"},
                 }
             ),
-            entity="11111111-1111-1111-1111-111111111111",
+            type_id="11111111-1111-1111-1111-111111111111",
             offset=5,
             length=0,
         )
@@ -379,7 +379,7 @@ def test_create_transcription_entity_wrong_length(mock_elements_worker):
 def test_create_transcription_entity_api_error(responses, mock_elements_worker):
     responses.add(
         responses.POST,
-        "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entity/",
+        "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entities/",
         status=418,
     )
 
@@ -391,7 +391,7 @@ def test_create_transcription_entity_api_error(responses, mock_elements_worker):
                     "element": {"id": "myelement"},
                 }
             ),
-            entity="11111111-1111-1111-1111-111111111111",
+            type_id="11111111-1111-1111-1111-111111111111",
             offset=5,
             length=10,
         )
@@ -402,7 +402,7 @@ def test_create_transcription_entity_api_error(responses, mock_elements_worker):
     ] == BASE_API_CALLS + [
         (
             "POST",
-            "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entity/",
+            "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entities/",
         )
     ]
 
@@ -410,10 +410,10 @@ def test_create_transcription_entity_api_error(responses, mock_elements_worker):
 def test_create_transcription_entity_no_confidence(responses, mock_elements_worker):
     responses.add(
         responses.POST,
-        "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entity/",
+        "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entities/",
         status=200,
         json={
-            "entity": "11111111-1111-1111-1111-111111111111",
+            "type": {"id": "11111111-1111-1111-1111-111111111111"},
             "offset": 5,
             "length": 10,
         },
@@ -426,7 +426,7 @@ def test_create_transcription_entity_no_confidence(responses, mock_elements_work
                 "element": {"id": "myelement"},
             }
         ),
-        entity="11111111-1111-1111-1111-111111111111",
+        type_id="11111111-1111-1111-1111-111111111111",
         offset=5,
         length=10,
     )
@@ -437,11 +437,11 @@ def test_create_transcription_entity_no_confidence(responses, mock_elements_work
     ] == BASE_API_CALLS + [
         (
             "POST",
-            "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entity/",
+            "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entities/",
         ),
     ]
     assert json.loads(responses.calls[-1].request.body) == {
-        "entity": "11111111-1111-1111-1111-111111111111",
+        "type_id": "11111111-1111-1111-1111-111111111111",
         "offset": 5,
         "length": 10,
         "worker_run_id": "56785678-5678-5678-5678-567856785678",
@@ -451,10 +451,10 @@ def test_create_transcription_entity_no_confidence(responses, mock_elements_work
 def test_create_transcription_entity_with_confidence(responses, mock_elements_worker):
     responses.add(
         responses.POST,
-        "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entity/",
+        "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entities/",
         status=200,
         json={
-            "entity": "11111111-1111-1111-1111-111111111111",
+            "type": {"id": "11111111-1111-1111-1111-111111111111"},
             "offset": 5,
             "length": 10,
             "confidence": 0.33,
@@ -468,7 +468,7 @@ def test_create_transcription_entity_with_confidence(responses, mock_elements_wo
                 "element": {"id": "myelement"},
             }
         ),
-        entity="11111111-1111-1111-1111-111111111111",
+        type_id="11111111-1111-1111-1111-111111111111",
         offset=5,
         length=10,
         confidence=0.33,
@@ -480,11 +480,11 @@ def test_create_transcription_entity_with_confidence(responses, mock_elements_wo
     ] == BASE_API_CALLS + [
         (
             "POST",
-            "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entity/",
+            "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entities/",
         ),
     ]
     assert json.loads(responses.calls[-1].request.body) == {
-        "entity": "11111111-1111-1111-1111-111111111111",
+        "type_id": "11111111-1111-1111-1111-111111111111",
         "offset": 5,
         "length": 10,
         "worker_run_id": "56785678-5678-5678-5678-567856785678",
@@ -495,10 +495,10 @@ def test_create_transcription_entity_with_confidence(responses, mock_elements_wo
 def test_create_transcription_entity_confidence_none(responses, mock_elements_worker):
     responses.add(
         responses.POST,
-        "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entity/",
+        "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entities/",
         status=200,
         json={
-            "entity": "11111111-1111-1111-1111-111111111111",
+            "type": {"id": "11111111-1111-1111-1111-111111111111"},
             "offset": 5,
             "length": 10,
             "confidence": None,
@@ -512,7 +512,7 @@ def test_create_transcription_entity_confidence_none(responses, mock_elements_wo
                 "element": {"id": "myelement"},
             }
         ),
-        entity="11111111-1111-1111-1111-111111111111",
+        type_id="11111111-1111-1111-1111-111111111111",
         offset=5,
         length=10,
         confidence=None,
@@ -524,11 +524,11 @@ def test_create_transcription_entity_confidence_none(responses, mock_elements_wo
     ] == BASE_API_CALLS + [
         (
             "POST",
-            "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entity/",
+            "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entities/",
         ),
     ]
     assert json.loads(responses.calls[-1].request.body) == {
-        "entity": "11111111-1111-1111-1111-111111111111",
+        "type_id": "11111111-1111-1111-1111-111111111111",
         "offset": 5,
         "length": 10,
         "worker_run_id": "56785678-5678-5678-5678-567856785678",
@@ -550,19 +550,13 @@ def test_create_transcription_entity_with_cache(
         orientation=TextOrientation.HorizontalLeftToRight,
         worker_run_id=UUID("56785678-5678-5678-5678-567856785678"),
     )
-    CachedEntity.create(
-        id=UUID("11111111-1111-1111-1111-111111111111"),
-        type="person",
-        name="Bob Bob",
-        worker_run_id=UUID("56785678-5678-5678-5678-567856785678"),
-    )
 
     responses.add(
         responses.POST,
-        "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entity/",
+        "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entities/",
         status=200,
         json={
-            "entity": "11111111-1111-1111-1111-111111111111",
+            "type": {"id": "11111111-1111-1111-1111-111111111111", "name": "Whatever"},
             "offset": 5,
             "length": 10,
         },
@@ -575,7 +569,7 @@ def test_create_transcription_entity_with_cache(
                 "element": {"id": "myelement"},
             }
         ),
-        entity="11111111-1111-1111-1111-111111111111",
+        type_id="11111111-1111-1111-1111-111111111111",
         offset=5,
         length=10,
     )
@@ -586,11 +580,11 @@ def test_create_transcription_entity_with_cache(
     ] == BASE_API_CALLS + [
         (
             "POST",
-            "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entity/",
+            "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entities/",
         ),
     ]
     assert json.loads(responses.calls[-1].request.body) == {
-        "entity": "11111111-1111-1111-1111-111111111111",
+        "type_id": "11111111-1111-1111-1111-111111111111",
         "offset": 5,
         "length": 10,
         "worker_run_id": "56785678-5678-5678-5678-567856785678",
@@ -599,7 +593,7 @@ def test_create_transcription_entity_with_cache(
     assert list(CachedTranscriptionEntity.select()) == [
         CachedTranscriptionEntity(
             transcription=UUID("11111111-1111-1111-1111-111111111111"),
-            entity=UUID("11111111-1111-1111-1111-111111111111"),
+            type="Whatever",
             offset=5,
             length=10,
             worker_run_id=UUID("56785678-5678-5678-5678-567856785678"),
@@ -622,19 +616,13 @@ def test_create_transcription_entity_with_confidence_with_cache(
         orientation=TextOrientation.HorizontalLeftToRight,
         worker_run_id=UUID("56785678-5678-5678-5678-567856785678"),
     )
-    CachedEntity.create(
-        id=UUID("11111111-1111-1111-1111-111111111111"),
-        type="person",
-        name="Bob Bob",
-        worker_run_id=UUID("56785678-5678-5678-5678-567856785678"),
-    )
 
     responses.add(
         responses.POST,
-        "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entity/",
+        "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entities/",
         status=200,
         json={
-            "entity": "11111111-1111-1111-1111-111111111111",
+            "type": {"id": "11111111-1111-1111-1111-111111111111", "name": "Whatever"},
             "offset": 5,
             "length": 10,
             "confidence": 0.77,
@@ -648,7 +636,7 @@ def test_create_transcription_entity_with_confidence_with_cache(
                 "element": {"id": "myelement"},
             }
         ),
-        entity="11111111-1111-1111-1111-111111111111",
+        type_id="11111111-1111-1111-1111-111111111111",
         offset=5,
         length=10,
         confidence=0.77,
@@ -660,11 +648,11 @@ def test_create_transcription_entity_with_confidence_with_cache(
     ] == BASE_API_CALLS + [
         (
             "POST",
-            "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entity/",
+            "http://testserver/api/v1/transcription/11111111-1111-1111-1111-111111111111/entities/",
         ),
     ]
     assert json.loads(responses.calls[-1].request.body) == {
-        "entity": "11111111-1111-1111-1111-111111111111",
+        "type_id": "11111111-1111-1111-1111-111111111111",
         "offset": 5,
         "length": 10,
         "worker_run_id": "56785678-5678-5678-5678-567856785678",
@@ -675,7 +663,7 @@ def test_create_transcription_entity_with_confidence_with_cache(
     assert list(CachedTranscriptionEntity.select()) == [
         CachedTranscriptionEntity(
             transcription=UUID("11111111-1111-1111-1111-111111111111"),
-            entity=UUID("11111111-1111-1111-1111-111111111111"),
+            type="Whatever",
             offset=5,
             length=10,
             worker_run_id=UUID("56785678-5678-5678-5678-567856785678"),
@@ -710,7 +698,6 @@ def test_create_transcription_entities_wrong_transcription(
         (
             [
                 {
-                    "name": "A",
                     "type_id": "12341234-1234-1234-1234-123412341234",
                     "offset": 0,
                     "length": 1,
@@ -746,26 +733,15 @@ def test_create_transcription_entities_wrong_entities_subtype(mock_elements_work
     ("entity", "error"),
     [
         (
-            {
-                "name": None,
-                "type_id": "12341234-1234-1234-1234-123412341234",
-                "offset": 0,
-                "length": 1,
-                "confidence": 0.5,
-            },
-            "Entity at index 0 in entities: name shouldn't be null and should be of type str",
-        ),
-        (
-            {"name": "A", "type_id": None, "offset": 0, "length": 1, "confidence": 0.5},
+            {"type_id": None, "offset": 0, "length": 1, "confidence": 0.5},
             "Entity at index 0 in entities: type_id shouldn't be null and should be of type str",
         ),
         (
-            {"name": "A", "type_id": 0, "offset": 0, "length": 1, "confidence": 0.5},
+            {"type_id": 0, "offset": 0, "length": 1, "confidence": 0.5},
             "Entity at index 0 in entities: type_id shouldn't be null and should be of type str",
         ),
         (
             {
-                "name": "A",
                 "type_id": "12341234-1234-1234-1234-123412341234",
                 "offset": None,
                 "length": 1,
@@ -775,7 +751,6 @@ def test_create_transcription_entities_wrong_entities_subtype(mock_elements_work
         ),
         (
             {
-                "name": "A",
                 "type_id": "12341234-1234-1234-1234-123412341234",
                 "offset": -2,
                 "length": 1,
@@ -785,7 +760,6 @@ def test_create_transcription_entities_wrong_entities_subtype(mock_elements_work
         ),
         (
             {
-                "name": "A",
                 "type_id": "12341234-1234-1234-1234-123412341234",
                 "offset": 0,
                 "length": None,
@@ -795,7 +769,6 @@ def test_create_transcription_entities_wrong_entities_subtype(mock_elements_work
         ),
         (
             {
-                "name": "A",
                 "type_id": "12341234-1234-1234-1234-123412341234",
                 "offset": 0,
                 "length": 0,
@@ -805,7 +778,6 @@ def test_create_transcription_entities_wrong_entities_subtype(mock_elements_work
         ),
         (
             {
-                "name": "A",
                 "type_id": "12341234-1234-1234-1234-123412341234",
                 "offset": 0,
                 "length": 1,
@@ -815,7 +787,6 @@ def test_create_transcription_entities_wrong_entities_subtype(mock_elements_work
         ),
         (
             {
-                "name": "A",
                 "type_id": "12341234-1234-1234-1234-123412341234",
                 "offset": 0,
                 "length": 1,
@@ -847,16 +818,14 @@ def test_create_transcription_entities(responses, mock_elements_worker):
             matchers.json_params_matcher(
                 {
                     "worker_run_id": "56785678-5678-5678-5678-567856785678",
-                    "entities": [
+                    "transcription_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,
@@ -866,18 +835,7 @@ def test_create_transcription_entities(responses, mock_elements_worker):
                 }
             )
         ],
-        json={
-            "entities": [
-                {
-                    "transcription_entity_id": "transc-entity-id",
-                    "entity_id": "entity-id1",
-                },
-                {
-                    "transcription_entity_id": "transc-entity-id",
-                    "entity_id": "entity-id2",
-                },
-            ]
-        },
+        json={"transcription_entities": ["transc-entity-id", "transc-entity-id"]},
     )
 
     # Store entity type/slug correspondence on the worker
@@ -888,14 +846,12 @@ def test_create_transcription_entities(responses, mock_elements_worker):
         transcription=transcription,
         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,
@@ -915,3 +871,40 @@ def test_create_transcription_entities(responses, mock_elements_worker):
             "http://testserver/api/v1/transcription/transcription-id/entities/bulk/",
         )
     ]
+
+
+def test_list_transcription_entities_deprecation(fake_dummy_worker):
+    transcription = Transcription({"id": "fake_transcription_id"})
+    worker_version = "worker_version_id"
+    fake_dummy_worker.api_client.add_response(
+        "ListTranscriptionEntities",
+        id=transcription.id,
+        worker_version=worker_version,
+        response={"id": "entity_id"},
+    )
+    with pytest.deprecated_call(
+        match="`worker_version` usage is deprecated. Consider using `worker_run` instead."
+    ):
+        assert fake_dummy_worker.list_transcription_entities(
+            transcription, worker_version=worker_version
+        ) == {"id": "entity_id"}
+
+    assert len(fake_dummy_worker.api_client.history) == 1
+    assert len(fake_dummy_worker.api_client.responses) == 0
+
+
+def test_list_transcription_entities(fake_dummy_worker):
+    transcription = Transcription({"id": "fake_transcription_id"})
+    worker_run = "worker_run_id"
+    fake_dummy_worker.api_client.add_response(
+        "ListTranscriptionEntities",
+        id=transcription.id,
+        worker_run=worker_run,
+        response={"id": "entity_id"},
+    )
+    assert fake_dummy_worker.list_transcription_entities(
+        transcription, worker_run=worker_run
+    ) == {"id": "entity_id"}
+
+    assert len(fake_dummy_worker.api_client.history) == 1
+    assert len(fake_dummy_worker.api_client.responses) == 0