Support MetaData creation and reporting

arkindex_worker/reporting.py

@@ -37,6 +37,8 @@ class Reporter(object):
                 "classifications": {},
                 # Created entities ({"id": "", "type": "", "name": ""}) from this element
                 "entities": [],
+                # Created metadata ({"id": "", "type": "", "name": ""}) from this element
+                "metadata": [],
                 "errors": [],
             },
         )
@@ -124,6 +126,13 @@ class Reporter(object):
     def add_entity_role(self, *args, **kwargs):
         raise NotImplementedError
 
+    def add_metadata(self, element_id, metadata_id, type, name):
+        """
+        Report creating a metadata from an element.
+        """
+        metadata = self._get_element(element_id)["metadata"]
+        metadata.append({"id": metadata_id, "type": type, "name": name})
+
     def error(self, element_id, exception):
         error_data = {
             "class": exception.__class__.__name__,

arkindex_worker/worker.py

@@ -180,6 +180,15 @@ class EntityType(Enum):
     Date = "date"
 
 
+class MetaType(Enum):
+    Text = "text"
+    HTML = "html"
+    Date = "date"
+    Location = "location"
+    # Element's original structure reference (intended to be indexed)
+    Reference = "reference"
+
+
 class ElementsWorker(BaseWorker):
     def __init__(self, description="Arkindex Elements Worker"):
         super().__init__(description)
@@ -592,6 +601,43 @@ class ElementsWorker(BaseWorker):
 
         return annotations
 
+    def create_metadata(self, element, type, name, value, entity=None):
+        """
+        Create a metadata on the given element through API
+        """
+        assert element and isinstance(
+            element, Element
+        ), "element shouldn't be null and should be of type Element"
+        assert type and isinstance(
+            type, MetaType
+        ), "type shouldn't be null and should be of type MetaType"
+        assert name and isinstance(
+            name, str
+        ), "name shouldn't be null and should be of type str"
+        assert value and isinstance(
+            value, str
+        ), "value shouldn't be null and should be of type str"
+        if entity:
+            assert isinstance(entity, str), "entity should be of type str"
+        if self.is_read_only:
+            logger.warning("Cannot create metadata as this worker is in read-only mode")
+            return
+
+        metadata = self.api_client.request(
+            "CreateMetaData",
+            id=element.id,
+            body={
+                "type": type.value,
+                "name": name,
+                "value": value,
+                "entity": entity,
+                "worker_version": self.worker_version_id,
+            },
+        )
+        self.report.add_metadata(element.id, metadata["id"], type.value, name)
+
+        return metadata["id"]
+
     def get_worker_version(self, worker_version_id: str) -> dict:
         """
         Get worker version from cache if possible, otherwise make API request

tests/test_elements_worker.py

@@ -14,6 +14,7 @@ from arkindex_worker.worker import (
     MANUAL_SLUG,
     ElementsWorker,
     EntityType,
+    MetaType,
     TranscriptionType,
 )
 
@@ -1115,7 +1116,7 @@ def test_create_classification_duplicate(responses, mock_elements_worker):
 def test_create_entity_wrong_element(mock_elements_worker):
     with pytest.raises(AssertionError) as e:
         mock_elements_worker.create_entity(
-            element="not element type",
+            element=None,
             name="Bob Bob",
             type=EntityType.Person,
             corpus="12341234-1234-1234-1234-123412341234",
@@ -1749,6 +1750,169 @@ def test_create_element_transcriptions(responses, mock_elements_worker):
     ]
 
 
+def test_create_metadata_wrong_element(mock_elements_worker):
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=None,
+            type=MetaType.Location,
+            name="Teklia",
+            value="La Turbine, Grenoble 38000",
+        )
+    assert str(e.value) == "element shouldn't be null and should be of type Element"
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element="not element type",
+            type=MetaType.Location,
+            name="Teklia",
+            value="La Turbine, Grenoble 38000",
+        )
+    assert str(e.value) == "element shouldn't be null and should be of type Element"
+
+
+def test_create_metadata_wrong_type(mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type=None,
+            name="Teklia",
+            value="La Turbine, Grenoble 38000",
+        )
+    assert str(e.value) == "type shouldn't be null and should be of type MetaType"
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type=1234,
+            name="Teklia",
+            value="La Turbine, Grenoble 38000",
+        )
+    assert str(e.value) == "type shouldn't be null and should be of type MetaType"
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type="not_a_metadata_type",
+            name="Teklia",
+            value="La Turbine, Grenoble 38000",
+        )
+    assert str(e.value) == "type shouldn't be null and should be of type MetaType"
+
+
+def test_create_metadata_wrong_name(mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type=MetaType.Location,
+            name=None,
+            value="La Turbine, Grenoble 38000",
+        )
+    assert str(e.value) == "name shouldn't be null and should be of type str"
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type=MetaType.Location,
+            name=1234,
+            value="La Turbine, Grenoble 38000",
+        )
+    assert str(e.value) == "name shouldn't be null and should be of type str"
+
+
+def test_create_metadata_wrong_value(mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type=MetaType.Location,
+            name="Teklia",
+            value=None,
+        )
+    assert str(e.value) == "value shouldn't be null and should be of type str"
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type=MetaType.Location,
+            name="Teklia",
+            value=1234,
+        )
+    assert str(e.value) == "value shouldn't be null and should be of type str"
+
+
+def test_create_metadata_wrong_entity(mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type=MetaType.Location,
+            name="Teklia",
+            value="La Turbine, Grenoble 38000",
+            entity=1234,
+        )
+    assert str(e.value) == "entity should be of type str"
+
+
+def test_create_metadata_api_error(responses, mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+    responses.add(
+        responses.POST,
+        "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/metadata/",
+        status=500,
+    )
+
+    with pytest.raises(ErrorResponse):
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type=MetaType.Location,
+            name="Teklia",
+            value="La Turbine, Grenoble 38000",
+        )
+
+    assert len(responses.calls) == 2
+    assert [call.request.url for call in responses.calls] == [
+        "http://testserver/api/v1/workers/versions/12341234-1234-1234-1234-123412341234/",
+        "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/metadata/",
+    ]
+
+
+def test_create_metadata(responses, mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+    responses.add(
+        responses.POST,
+        "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/metadata/",
+        status=200,
+        json={"id": "12345678-1234-1234-1234-123456789123"},
+    )
+
+    metadata_id = mock_elements_worker.create_metadata(
+        element=elt,
+        type=MetaType.Location,
+        name="Teklia",
+        value="La Turbine, Grenoble 38000",
+    )
+
+    assert len(responses.calls) == 2
+    assert [call.request.url for call in responses.calls] == [
+        "http://testserver/api/v1/workers/versions/12341234-1234-1234-1234-123412341234/",
+        "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/metadata/",
+    ]
+    assert json.loads(responses.calls[1].request.body) == {
+        "type": "location",
+        "name": "Teklia",
+        "value": "La Turbine, Grenoble 38000",
+        "entity": None,
+        "worker_version": "12341234-1234-1234-1234-123412341234",
+    }
+    assert metadata_id == "12345678-1234-1234-1234-123456789123"
+
+
 def test_get_worker_version(fake_dummy_worker):
     api_client = fake_dummy_worker.api_client
 

tests/test_reporting.py

@@ -24,6 +24,7 @@ def test_process():
         "transcriptions": 0,
         "classifications": {},
         "entities": [],
+        "metadata": [],
         "errors": [],
     }
 
@@ -39,6 +40,7 @@ def test_add_element():
         "transcriptions": 0,
         "classifications": {},
         "entities": [],
+        "metadata": [],
         "errors": [],
     }
 
@@ -57,6 +59,7 @@ def test_add_element_count():
         "transcriptions": 0,
         "classifications": {},
         "entities": [],
+        "metadata": [],
         "errors": [],
     }
 
@@ -72,6 +75,7 @@ def test_add_classification():
         "transcriptions": 0,
         "classifications": {"three": 1},
         "entities": [],
+        "metadata": [],
         "errors": [],
     }
 
@@ -101,6 +105,7 @@ def test_add_classifications():
         "transcriptions": 0,
         "classifications": {"three": 3, "two": 2},
         "entities": [],
+        "metadata": [],
         "errors": [],
     }
 
@@ -116,6 +121,7 @@ def test_add_transcription():
         "transcriptions": 1,
         "classifications": {},
         "entities": [],
+        "metadata": [],
         "errors": [],
     }
 
@@ -139,6 +145,7 @@ def test_add_transcription_warning():
         "transcriptions": 1,
         "classifications": {},
         "entities": [],
+        "metadata": [],
         "errors": [],
     }
 
@@ -157,6 +164,7 @@ def test_add_transcription_count():
         "transcriptions": 1337,
         "classifications": {},
         "entities": [],
+        "metadata": [],
         "errors": [],
     }
 
@@ -189,6 +197,7 @@ def test_add_transcriptions():
         "transcriptions": 5,
         "classifications": {},
         "entities": [],
+        "metadata": [],
         "errors": [],
     }
 
@@ -212,6 +221,31 @@ def test_add_entity():
                 "name": "Bob Bob",
             }
         ],
+        "metadata": [],
+        "errors": [],
+    }
+
+
+def test_add_metadata():
+    reporter = Reporter("worker")
+    reporter.add_metadata(
+        "myelement", "12341234-1234-1234-1234-123412341234", "location", "Teklia"
+    )
+    assert "myelement" in reporter.report_data["elements"]
+    element_data = reporter.report_data["elements"]["myelement"]
+    del element_data["started"]
+    assert element_data == {
+        "elements": {},
+        "transcriptions": 0,
+        "classifications": {},
+        "entities": [],
+        "metadata": [
+            {
+                "id": "12341234-1234-1234-1234-123412341234",
+                "type": "location",
+                "name": "Teklia",
+            }
+        ],
         "errors": [],
     }