elody 0.0.219__tar.gz → 0.0.221__tar.gz

{elody-0.0.219 → elody-0.0.221}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elody
-Version: 0.0.219
+Version: 0.0.221
 Summary: elody SDK for Python
 Author-email: Inuits <developers@inuits.eu>
 License:                     GNU GENERAL PUBLIC LICENSE

{elody-0.0.219 → elody-0.0.221}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "elody"
-version = "0.0.219"
+version = "0.0.221"
 description = "elody SDK for Python"
 readme = "README.md"
 authors = [{ name = "Inuits", email = "developers@inuits.eu" }]

elody-0.0.221/src/elody/job.py

@@ -0,0 +1,86 @@
+try:
+    from config import get_object_configuration_mapper
+
+    _config = get_object_configuration_mapper().get("job")
+except ModuleNotFoundError:
+    from elody.object_configurations.job_configuration import JobConfiguration
+
+    _config = JobConfiguration()
+
+
+def add_document_to_job(
+    id,
+    id_of_document_job_was_initiated_for,
+    *,
+    get_rabbit,
+):
+    _config.crud()["add_document_to_job"](
+        id=id,
+        id_of_document_job_was_initiated_for=id_of_document_job_was_initiated_for,
+        get_rabbit=get_rabbit,
+    )
+
+
+def init_job(
+    name,
+    job_type,
+    *,
+    get_rabbit,
+    get_user_context=None,
+    user_email=None,
+    parent_id=None,
+    id_of_document_job_was_initiated_for=None,
+    track_async_children: bool | None = None,
+) -> str:
+    return _config.crud()["init_job"](
+        name=name,
+        job_type=job_type,
+        get_rabbit=get_rabbit,
+        get_user_context=get_user_context,
+        user_email=user_email,
+        parent_id=parent_id,
+        id_of_document_job_was_initiated_for=id_of_document_job_was_initiated_for,
+        track_async_children=track_async_children,
+    )
+
+
+def start_job(
+    id,
+    *,
+    get_rabbit,
+):
+    _config.crud()["start_job"](
+        id=id,
+        get_rabbit=get_rabbit,
+    )
+
+
+def finish_job(
+    id,
+    *,
+    get_rabbit,
+):
+    _config.crud()["finish_job"](
+        id=id,
+        get_rabbit=get_rabbit,
+    )
+
+
+def soft_finish_job(
+    id,
+    *,
+    get_rabbit,
+):
+    _config.crud()["soft_finish_job"](id=id, get_rabbit=get_rabbit)
+
+
+def fail_job(id, exception_message, *, get_rabbit):
+    _config.crud()["fail_job"](
+        id=id, exception_message=exception_message, get_rabbit=get_rabbit
+    )
+
+
+def handle_parent_job_finished(id, parent_child_status, *, get_rabbit):
+    _config.crud()["handle_parent_job_finished"](
+        id=id, parent_child_status=parent_child_status, get_rabbit=get_rabbit
+    )

{elody-0.0.219 → elody-0.0.221}/src/elody/object_configurations/elody_configuration.py

@@ -88,7 +88,15 @@ class ElodyConfiguration(BaseObjectConfiguration):
         else:
             document = {**template, **document_defaults}
         document = self._pre_crud_hook(
-            crud="create", timestamp=timestamp, document=document
+            crud="create",
+            timestamp=timestamp,
+            document=document,
+            audit_override={
+                "date_created": document_defaults.get("date_created"),
+                "created_by": document_defaults.get("created_by"),
+                "date_updated": document_defaults.get("date_updated"),
+                "last_editor": document_defaults.get("last_editor"),
+            },
         )
         return document
 
@@ -129,10 +137,14 @@ class ElodyConfiguration(BaseObjectConfiguration):
     def _post_crud_hook(self, **kwargs):
         pass
 
-    def _pre_crud_hook(self, *, crud, timestamp, document={}, **kwargs):
+    def _pre_crud_hook(
+        self, *, crud, timestamp, document={}, audit_override={}, **kwargs
+    ):
         if document:
             document = self.__patch_document_unique_value(document)
-            document = self.__patch_document_audit_info(crud, document, timestamp)
+            document = self.__patch_document_audit_info(
+                crud, document, timestamp, audit_override
+            )
             document = self._sanitize_document(
                 document=document,
                 object_list_name="metadata",
@@ -164,11 +176,12 @@ class ElodyConfiguration(BaseObjectConfiguration):
                     del element[key]
         return sanitized_document
 
-    def __patch_document_audit_info(self, crud, document, timestamp):
+    def __patch_document_audit_info(self, crud, document, timestamp, audit_override):
         document.update({f"date_{crud}d": timestamp})
         if email := self._get_user_context_id():
             label = f"{crud}d_by" if crud == "create" else "last_editor"
             document.update({label: email})
+        document.update({key: value for key, value in audit_override.items() if value})
         return document
 
     def __patch_document_unique_value(self, document):

elody-0.0.221/src/elody/object_configurations/job_configuration.py

@@ -0,0 +1,245 @@
+from datetime import datetime, timezone
+from enum import Enum
+from os import getenv
+from typing import Literal
+
+from elody.object_configurations.elody_configuration import (
+    ElodyConfiguration,
+)
+from elody.util import send_cloudevent
+
+
+class Status(str, Enum):
+    QUEUED = "queued"
+    RUNNING = "running"
+    FINISHED = "finished"
+    FAILED = "failed"
+    WARNING = "warning"
+
+
+class JobConfiguration(ElodyConfiguration):
+    SCHEMA_TYPE = "elody"
+    SCHEMA_VERSION = 1
+
+    def crud(self):
+        crud = {
+            "collection": "jobs",
+            "collection_history": "",
+            "add_document_to_job": lambda *args, **kwargs: self._add_document_to_job(
+                *args, **kwargs
+            ),
+            "init_job": lambda *args, **kwargs: self._init_job(*args, **kwargs),
+            "start_job": lambda *args, **kwargs: self._start_job(*args, **kwargs),
+            "finish_job": lambda *args, **kwargs: self._finish_job(*args, **kwargs),
+            "finish_job_with_warning": lambda *args, **kwargs: self._finish_job_with_warning(
+                *args, **kwargs
+            ),
+            "fail_job": lambda *args, **kwargs: self._fail_job(*args, **kwargs),
+            "handle_parent_job_finished": lambda *args, **kwargs: self._handle_parent_job_finished(
+                *args, **kwargs
+            ),
+        }
+        return {**super().crud(), **crud}
+
+    def document_info(self):
+        return super().document_info()
+
+    def logging(self, flat_document, **kwargs):
+        return super().logging(flat_document, **kwargs)
+
+    def migration(self):
+        return super().migration()
+
+    def serialization(self, from_format, to_format):
+        return super().serialization(from_format, to_format)
+
+    def validation(self):
+        return super().validation()
+
+    def _creator(self, post_body, *, get_user_context={}, **_):
+        document = super()._creator(post_body)
+        if email := get_user_context().email:
+            document["last_editor"] = email
+        return document
+
+    def _post_crud_hook(self, *, crud, document, get_rabbit, **kwargs):
+        if crud == "create":
+            send_cloudevent(
+                get_rabbit(),
+                getenv("MQ_EXCHANGE", "dams"),
+                "dams.job_created",
+                document,
+            )
+        elif crud == "update":
+            send_cloudevent(
+                get_rabbit(),
+                getenv("MQ_EXCHANGE", "dams"),
+                "dams.job_changed",
+                document,
+            )
+
+    def _add_document_to_job(
+        self,
+        id,
+        id_of_document_job_was_initiated_for,
+        *,
+        get_rabbit,
+    ):
+        relations = []
+        if id_of_document_job_was_initiated_for:
+            relations.append(
+                {"key": id_of_document_job_was_initiated_for, "type": "isJobFor"}
+            )
+        document = {
+            "id": id,
+            "patch": {
+                "relations": (relations),
+            },
+        }
+        self._post_crud_hook(crud="update", document=document, get_rabbit=get_rabbit)
+
+    def _init_job(
+        self,
+        name,
+        job_type,
+        *,
+        get_rabbit,
+        get_user_context=None,
+        user_email=None,
+        parent_id=None,
+        id_of_document_job_was_initiated_for=None,
+        track_async_children: bool | None = None,
+    ) -> str:
+        relations = []
+        if parent_id:
+            relations.append({"key": parent_id, "type": "hasParentJob"})
+        if id_of_document_job_was_initiated_for:
+            relations.append(
+                {"key": id_of_document_job_was_initiated_for, "type": "isJobFor"}
+            )
+
+        metadata = [
+            {"key": "name", "value": name},
+            {"key": "status", "value": Status.QUEUED.value},
+            {"key": "type", "value": job_type},
+        ]
+
+        if track_async_children:
+            metadata.append(
+                {
+                    "key": "child_jobs",
+                    "value": {
+                        Status.QUEUED.value: 0,
+                        Status.RUNNING.value: 0,
+                        Status.FAILED.value: 0,
+                        Status.FINISHED.value: 0,
+                        Status.WARNING.value: 0,
+                    },
+                }
+            )
+
+        job = self.crud()["creator"](
+            {
+                "metadata": metadata,
+                "relations": relations,
+                "type": "job",
+            },
+            get_user_context=get_user_context
+            or (lambda: type("UserContext", (object,), {"email": user_email})()),
+        )
+
+        self._post_crud_hook(
+            crud="create", document=job, parent_id=parent_id, get_rabbit=get_rabbit
+        )
+        return job["_id"]
+
+    def _start_job(
+        self,
+        id,
+        *,
+        get_rabbit,
+    ):
+        document = {
+            "id": id,
+            "patch": {
+                "started_at": datetime.now(timezone.utc),
+                "metadata": [{"key": "status", "value": Status.RUNNING.value}],
+            },
+        }
+        self._post_crud_hook(crud="update", document=document, get_rabbit=get_rabbit)
+
+    def _finish_job(
+        self,
+        id,
+        *,
+        get_rabbit,
+    ):
+        document = {
+            "id": id,
+            "patch": {
+                "metadata": [{"key": "status", "value": Status.FINISHED.value}],
+            },
+        }
+        self._post_crud_hook(crud="update", document=document, get_rabbit=get_rabbit)
+
+    def _finish_job_with_warning(
+        self,
+        id,
+        *,
+        get_rabbit,
+        info_message=None,
+    ):
+        document = {
+            "id": id,
+            "patch": {
+                "metadata": [
+                    {"key": "status", "value": Status.FINISHED.value},
+                    {"key": "info", "value": info_message},
+                ],
+            },
+        }
+        self._post_crud_hook(crud="update", document=document, get_rabbit=get_rabbit)
+
+    def _fail_job(self, id, exception_message, *, get_rabbit):
+
+        status, message = self.__handle_error_warnings(exception_message)
+
+        document = {
+            "id": id,
+            "patch": {
+                "metadata": [
+                    {"key": "info", "value": message},
+                    {
+                        "key": "status",
+                        "value": (status.value),
+                    },
+                ]
+            },
+        }
+        self._post_crud_hook(crud="update", document=document, get_rabbit=get_rabbit)
+
+    def _handle_parent_job_finished(self, id, parent_child_status, *, get_rabbit):
+
+        child_jobs_failed = parent_child_status[Status.FAILED.value]
+        child_jobs_warning = parent_child_status[Status.WARNING.value]
+
+        if child_jobs_failed == 0:
+            if child_jobs_warning:
+                self.crud()["finish_job_with_warning"](
+                    id, get_rabbit=get_rabbit, info_message="Some subjobs have warnings"
+                )
+            self.crud()["finish_job"](id, get_rabbit=get_rabbit)
+        else:
+            self.crud()["fail_job"](
+                id, exception_message="some subjobs failed", get_rabbit=get_rabbit
+            )
+
+    def __handle_error_warnings(
+        self,
+        errormessage: str,
+    ) -> tuple[Literal[Status.WARNING] | Literal[Status.FAILED], str]:
+
+        if errormessage.startswith("W4009"):
+            return Status.WARNING, errormessage
+
+        return Status.FAILED, errormessage

{elody-0.0.219 → elody-0.0.221}/src/elody/util.py

@@ -125,6 +125,13 @@ def get_item_metadata_value(item, key):
     return ""
 
 
+def get_item_relation_key(item, type):
+    for item in item.get("relations", []):
+        if item["type"] == type:
+            return item["key"]
+    return ""
+
+
 def get_mimetype_from_filename(filename):
     mime = mimetypes.guess_type(filename, False)[0]
     return mime if mime else "application/octet-stream"
@@ -267,8 +274,12 @@ def signal_update_copyright_color_mediafile(mq_client, mediafile_id):
     send_cloudevent(mq_client, "dams", "dams.update_copyright_color_mediafile", data)
 
 
-def signal_upload_file(mq_client, upload_links, selected_folder):
-    data = {"upload_links": upload_links, "selected_folder": selected_folder}
+def signal_upload_file(mq_client, upload_links, selected_folder, parent_job_id=None):
+    data = {
+        "upload_links": upload_links,
+        "selected_folder": selected_folder,
+        "parent_job_id": parent_job_id,
+    }
     send_cloudevent(mq_client, "dams", "dams.upload_file", data)
 
 

{elody-0.0.219 → elody-0.0.221}/src/elody.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elody
-Version: 0.0.219
+Version: 0.0.221
 Summary: elody SDK for Python
 Author-email: Inuits <developers@inuits.eu>
 License:                     GNU GENERAL PUBLIC LICENSE

elody-0.0.219/src/elody/job.py

@@ -1,110 +0,0 @@
-from elody.object_configurations.job_configuration import JobConfiguration
-from datetime import datetime, timezone
-
-_config = JobConfiguration()
-_create = _config.crud()["creator"]
-_post_crud_hook = _config.crud()["post_crud_hook"]
-
-
-def add_document_to_job(
-    id,
-    id_of_document_job_was_initiated_for,
-    *,
-    get_rabbit,
-):
-    relations = []
-    if id_of_document_job_was_initiated_for:
-        relations.append(
-            {"key": id_of_document_job_was_initiated_for, "type": "isJobFor"}
-        )
-    document = {
-        "id": id,
-        "patch": {
-            "relations": (relations),
-        },
-    }
-    _post_crud_hook(crud="update", document=document, get_rabbit=get_rabbit)
-
-
-def init_job(
-    name,
-    job_type,
-    *,
-    get_rabbit,
-    get_user_context=None,
-    user_email=None,
-    parent_id=None,
-    id_of_document_job_was_initiated_for=None,
-) -> str:
-    relations = []
-    if parent_id:
-        relations.append({"key": parent_id, "type": "hasParentJob"})
-    if id_of_document_job_was_initiated_for:
-        relations.append(
-            {"key": id_of_document_job_was_initiated_for, "type": "isJobFor"}
-        )
-
-    job = _create(
-        {
-            "metadata": [
-                {"key": "name", "value": name},
-                {"key": "status", "value": "queued"},
-                {"key": "type", "value": job_type},
-            ],
-            "relations": relations,
-            "type": "job",
-        },
-        get_user_context=get_user_context
-        or (lambda: type("UserContext", (object,), {"email": user_email})()),
-    )
-
-    _post_crud_hook(
-        crud="create", document=job, parent_id=parent_id, get_rabbit=get_rabbit
-    )
-    return job["_id"]
-
-
-def start_job(
-    id,
-    id_of_document_job_was_initiated_for=None,
-    *,
-    get_rabbit,
-):
-    document = {
-        "id": id,
-        "patch": {
-            "started_at": datetime.now(timezone.utc),
-            "metadata": [{"key": "status", "value": "running"}],
-            "relations": ([] if id_of_document_job_was_initiated_for else []),
-        },
-    }
-    _post_crud_hook(crud="update", document=document, get_rabbit=get_rabbit)
-
-
-def finish_job(
-    id,
-    id_of_document_job_was_initiated_for=None,
-    *,
-    get_rabbit,
-):
-    document = {
-        "id": id,
-        "patch": {
-            "metadata": [{"key": "status", "value": "finished"}],
-            "relations": ([] if id_of_document_job_was_initiated_for else []),
-        },
-    }
-    _post_crud_hook(crud="update", document=document, get_rabbit=get_rabbit)
-
-
-def fail_job(id, exception_message, *, get_rabbit):
-    document = {
-        "id": id,
-        "patch": {
-            "metadata": [
-                {"key": "info", "value": exception_message},
-                {"key": "status", "value": "failed"},
-            ]
-        },
-    }
-    _post_crud_hook(crud="update", document=document, get_rabbit=get_rabbit)

elody-0.0.219/src/elody/object_configurations/job_configuration.py

@@ -1,51 +0,0 @@
-from elody.object_configurations.elody_configuration import (
-    ElodyConfiguration,
-)
-from elody.util import send_cloudevent
-from os import getenv
-
-
-class JobConfiguration(ElodyConfiguration):
-    SCHEMA_TYPE = "elody"
-    SCHEMA_VERSION = 1
-
-    def crud(self):
-        crud = {"collection": "jobs", "collection_history": ""}
-        return {**super().crud(), **crud}
-
-    def document_info(self):
-        return super().document_info()
-
-    def logging(self, flat_document, **kwargs):
-        return super().logging(flat_document, **kwargs)
-
-    def migration(self):
-        return super().migration()
-
-    def serialization(self, from_format, to_format):
-        return super().serialization(from_format, to_format)
-
-    def validation(self):
-        return super().validation()
-
-    def _creator(self, post_body, *, get_user_context={}, **_):
-        document = super()._creator(post_body)
-        if email := get_user_context().email:
-            document["last_editor"] = email
-        return document
-
-    def _post_crud_hook(self, *, crud, document, get_rabbit, **kwargs):
-        if crud == "create":
-            send_cloudevent(
-                get_rabbit(),
-                getenv("MQ_EXCHANGE", "dams"),
-                "dams.job_created",
-                document,
-            )
-        elif crud == "update":
-            send_cloudevent(
-                get_rabbit(),
-                getenv("MQ_EXCHANGE", "dams"),
-                "dams.job_changed",
-                document,
-            )