pinexq-client 0.2.0.2024.607.8__py3-none-any.whl

hypermedia_client/job_management/hcos/workdata_hco.py

@@ -0,0 +1,127 @@
+from datetime import datetime
+from typing import Self
+
+import httpx
+
+from hypermedia_client.core.hco.action_hco import ActionHco
+from hypermedia_client.core.hco.action_with_parameters_hco import ActionWithParametersHco
+from hypermedia_client.core.hco.download_link_hco import DownloadLinkHco
+from hypermedia_client.core.hco.hco_base import Hco, Property
+from hypermedia_client.core.hco.link_hco import LinkHco
+from hypermedia_client.job_management.known_relations import Relations
+from hypermedia_client.job_management.model.open_api_generated import (
+    SetNameWorkDataParameters,
+    SetCommentWorkDataParameters,
+    SetTagsWorkDataParameters,
+    WorkDataKind
+)
+from hypermedia_client.job_management.model.sirenentities import WorkDataEntity
+
+
+class WorkDataLink(LinkHco):
+    def navigate(self) -> 'WorkDataHco':
+        return WorkDataHco.from_entity(self._navigate_internal(WorkDataEntity), self._client)
+
+
+class WorkDataDeleteAction(ActionHco):
+    def execute(self):
+        self._execute_internal()
+
+
+class WorkDataRenameAction(ActionWithParametersHco[SetNameWorkDataParameters]):
+    def execute(self, parameters: SetNameWorkDataParameters):
+        self._execute(parameters)
+
+    def default_parameters(self) -> SetNameWorkDataParameters:
+        return self._get_default_parameters(SetNameWorkDataParameters, SetNameWorkDataParameters())
+
+
+class WorkDataEditCommentAction(ActionWithParametersHco[SetCommentWorkDataParameters]):
+    def execute(self, parameters: SetCommentWorkDataParameters):
+        self._execute(parameters)
+
+    def default_parameters(self) -> SetCommentWorkDataParameters:
+        return self._get_default_parameters(SetCommentWorkDataParameters, SetCommentWorkDataParameters())
+
+
+class WorkDataEditTagsAction(ActionWithParametersHco[SetTagsWorkDataParameters]):
+    def execute(self, parameters: SetTagsWorkDataParameters):
+        self._execute(parameters)
+
+    def default_parameters(self) -> SetTagsWorkDataParameters:
+        # todo check why we have to manually set tags
+        return self._get_default_parameters(SetTagsWorkDataParameters, SetTagsWorkDataParameters(tags=[]))
+
+
+class WorkDataAllowDeletionAction(ActionHco):
+    def execute(self):
+        self._execute_internal()
+
+
+class WorkDataDisallowAction(ActionHco):
+    def execute(self):
+        self._execute_internal()
+
+
+class WorkDataHideAction(ActionHco):
+    def execute(self):
+        self._execute_internal()
+
+
+class WorkDataUnHideAction(ActionHco):
+    def execute(self):
+        self._execute_internal()
+
+
+class WorkDataHco(Hco[WorkDataEntity]):
+    name: str | None = Property()
+    created_at: datetime | None = Property()
+    size_in_bytes: int | None = Property()
+    tags: list[str] | None = Property()
+    media_type: str | None = Property()
+    kind: WorkDataKind | None = Property()
+    comments: str | None = Property()
+    is_deletable: bool | None = Property()
+    hidden: bool | None = Property()
+
+    delete_action: WorkDataDeleteAction | None
+    hide_action: WorkDataHideAction | None
+    unhide_action: WorkDataUnHideAction | None
+    allow_deletion_action: WorkDataAllowDeletionAction | None
+    disallow_deletion_action: WorkDataDisallowAction | None
+    rename_action: WorkDataRenameAction | None
+    edit_comment_action: WorkDataEditCommentAction | None
+    edit_tags_action: WorkDataEditTagsAction | None
+
+    self_link: WorkDataLink
+    download_link: DownloadLinkHco
+
+    @classmethod
+    def from_entity(cls, entity: WorkDataEntity, client: httpx.Client) -> Self:
+        instance = cls(client, entity)
+        Hco.check_classes(instance._entity.class_, ["WorkData"])
+
+        # actions
+        instance.hide_action = WorkDataHideAction.from_entity_optional(
+            client, instance._entity, "Hide")
+        instance.unhide_action = WorkDataUnHideAction.from_entity_optional(
+            client, instance._entity, "UnHide")
+        instance.delete_action = WorkDataDeleteAction.from_entity_optional(
+            client, instance._entity, "Delete")
+        instance.rename_action = WorkDataRenameAction.from_entity_optional(
+            client, instance._entity, "Rename")
+        instance.edit_comment_action = WorkDataEditCommentAction.from_entity_optional(
+            client, instance._entity, "EditComment")
+        instance.edit_tags_action = WorkDataEditTagsAction.from_entity_optional(
+            client, instance._entity, "EditTags")
+        instance.allow_deletion_action = WorkDataAllowDeletionAction.from_entity_optional(
+            client, instance._entity, "AllowDeletion")
+        instance.disallow_deletion_action = WorkDataDisallowAction.from_entity_optional(
+            client, instance._entity, "DisallowDeletion")
+
+        # links
+        instance.self_link = WorkDataLink.from_entity(
+            instance._client, instance._entity, Relations.SELF)
+        instance.download_link = DownloadLinkHco.from_entity(
+            instance._client, instance._entity, Relations.DOWNLOAD)
+        return instance

hypermedia_client/job_management/hcos/workdata_query_result_hco.py

@@ -0,0 +1,67 @@
+from typing import Self
+
+import httpx
+
+from hypermedia_client.job_management.known_relations import Relations
+from hypermedia_client.core.hco.hco_base import Hco, Property
+from hypermedia_client.core.hco.link_hco import LinkHco
+from hypermedia_client.job_management.hcos.workdata_hco import WorkDataHco
+from hypermedia_client.job_management.model.sirenentities import WorkDataQueryResultEntity, WorkDataEntity
+
+
+class WorkDataQueryResultPaginationLink(LinkHco):
+    def navigate(self) -> 'WorkDataQueryResultHco':
+        return WorkDataQueryResultHco.from_entity(self._navigate_internal(WorkDataQueryResultEntity), self._client)
+
+
+class WorkDataQueryResultLink(LinkHco):
+    def navigate(self) -> 'WorkDataQueryResultHco':
+        return WorkDataQueryResultHco.from_entity(self._navigate_internal(WorkDataQueryResultEntity), self._client)
+
+
+class WorkDataQueryResultHco(Hco[WorkDataQueryResultEntity]):
+    workdata_query_action: WorkDataQueryResultEntity
+
+    total_entities: int = Property()
+    current_entities_count: int = Property()
+    workdatas: list[WorkDataHco]
+
+    self_link: WorkDataQueryResultLink
+    all_link: WorkDataQueryResultPaginationLink | None
+    first_link: WorkDataQueryResultPaginationLink | None
+    last_link: WorkDataQueryResultPaginationLink | None
+    next_link: WorkDataQueryResultPaginationLink | None
+    previous_link: WorkDataQueryResultPaginationLink | None
+
+    @classmethod
+    def from_entity(cls, entity: WorkDataQueryResultEntity, client: httpx.Client) -> Self:
+        instance = cls(client, entity)
+
+        Hco.check_classes(instance._entity.class_, ["WorkDataQueryResult"])
+
+        # pagination links
+        instance.self_link = WorkDataQueryResultLink.from_entity(
+            instance._client, instance._entity, Relations.SELF)
+        instance.all_link = WorkDataQueryResultPaginationLink.from_entity_optional(
+            instance._client, instance._entity, Relations.ALL)
+        instance.first_link = WorkDataQueryResultPaginationLink.from_entity_optional(
+            instance._client, instance._entity, Relations.FIRST)
+        instance.last_link = WorkDataQueryResultPaginationLink.from_entity_optional(
+            instance._client, instance._entity, Relations.LAST)
+        instance.next_link = WorkDataQueryResultPaginationLink.from_entity_optional(
+            instance._client, instance._entity, Relations.NEXT)
+        instance.previous_link = WorkDataQueryResultPaginationLink.from_entity_optional(
+            instance._client, instance._entity, Relations.PREVIOUS)
+
+        # entities
+
+        instance._extract_workdatas()
+
+        return instance
+
+    def _extract_workdatas(self):
+        self.workdatas = []
+        workdatas = self._entity.find_all_entities_with_relation(Relations.ITEM, WorkDataEntity)
+        for workdata in workdatas:
+            workdata_hco: WorkDataHco = WorkDataHco.from_entity(workdata, self._client)
+            self.workdatas.append(workdata_hco)

hypermedia_client/job_management/hcos/workdata_used_tags_query_result_hco.py

@@ -0,0 +1,30 @@
+from typing import List, Self
+
+import httpx
+
+from hypermedia_client.core.hco.hco_base import Hco, Property
+from hypermedia_client.core.hco.link_hco import LinkHco
+from hypermedia_client.job_management.known_relations import Relations
+from hypermedia_client.job_management.model.sirenentities import WorkDataUsedTagsQueryResultEntity
+
+
+class WorkDataUsedTagsQueryResultHto(Hco[WorkDataUsedTagsQueryResultEntity]):
+    tags: List[str] | None = Property()
+
+    self_link: 'WorkDataUsedTagsLink'
+
+    @classmethod
+    def from_entity(cls, entity: WorkDataUsedTagsQueryResultEntity, client: httpx.Client) -> Self:
+        instance = cls(client, entity)
+
+        Hco.check_classes(instance._entity.class_, ["WorkDataUsedTagsQueryResult"])
+
+        instance.self_link = WorkDataUsedTagsLink.from_entity(instance._client, instance._entity, Relations.SELF)
+
+        return instance
+
+
+class WorkDataUsedTagsLink(LinkHco):
+    def navigate(self) -> WorkDataUsedTagsQueryResultHto:
+        return WorkDataUsedTagsQueryResultHto.from_entity(self._navigate_internal(WorkDataUsedTagsQueryResultEntity), self._client)
+

hypermedia_client/job_management/hcos/workdataroot_hco.py

@@ -0,0 +1,84 @@
+from typing import Self
+
+import httpx
+
+from hypermedia_client.core import MediaTypes, Link
+from hypermedia_client.core.hco.action_with_parameters_hco import ActionWithParametersHco
+from hypermedia_client.core.hco.hco_base import Hco
+from hypermedia_client.core.hco.link_hco import LinkHco
+from hypermedia_client.core.hco.upload_action_hco import UploadAction, UploadParameters
+from hypermedia_client.job_management.hcos.workdata_used_tags_query_result_hco import WorkDataUsedTagsLink
+from hypermedia_client.job_management.hcos.workdata_hco import WorkDataLink
+from hypermedia_client.job_management.hcos.workdata_query_result_hco import (
+    WorkDataQueryResultHco,
+    WorkDataQueryResultLink,
+    WorkDataQueryResultPaginationLink
+)
+from hypermedia_client.job_management.known_relations import Relations
+from hypermedia_client.job_management.model import WorkDataQueryParameters, WorkDataUsedTagsFilterParameter
+from hypermedia_client.job_management.model.sirenentities import WorkDataRootEntity
+
+
+class WorkDataQueryAction(ActionWithParametersHco[WorkDataQueryParameters]):
+    def execute(self, parameters: WorkDataQueryParameters) -> WorkDataQueryResultHco:
+        url = self._execute_returns_url(parameters)
+        link = Link.from_url(url, [str(Relations.CREATED_RESSOURCE)], "Created query", MediaTypes.SIREN)
+        # resolve link immediately
+        return WorkDataQueryResultLink.from_link(self._client, link).navigate()
+
+    def default_parameters(self) -> WorkDataQueryParameters:
+        return self._get_default_parameters(WorkDataQueryParameters, WorkDataQueryParameters())
+
+
+class WorkDataUsedTagsQueryAction(ActionWithParametersHco[WorkDataUsedTagsFilterParameter]):
+    def execute(self, parameters: WorkDataUsedTagsFilterParameter) -> WorkDataUsedTagsLink:
+        url = self._execute_returns_url(parameters)
+        link = Link.from_url(url, [str(Relations.CREATED_RESSOURCE)], "Created query", MediaTypes.SIREN)
+        return WorkDataUsedTagsLink.from_link(self._client, link)
+
+    def default_parameters(self) -> WorkDataUsedTagsFilterParameter:
+        return self._get_default_parameters(WorkDataUsedTagsFilterParameter, WorkDataUsedTagsFilterParameter())
+
+
+class WorkDataUploadAction(UploadAction):
+    def execute(self, parameters: UploadParameters) -> WorkDataLink:
+        url = self._upload(parameters)
+        link = Link.from_url(url, [str(Relations.CREATED_RESSOURCE)], "Uploaded workdata", MediaTypes.SIREN)
+        return WorkDataLink.from_link(self._client, link)
+
+
+class WorkDataRootLink(LinkHco):
+    def navigate(self) -> 'WorkDataRootHco':
+        return WorkDataRootHco.from_entity(self._navigate_internal(WorkDataRootEntity), self._client)
+
+
+class WorkDataRootHco(Hco[WorkDataRootEntity]):
+    query_action: WorkDataQueryAction | None
+    query_tags_action: WorkDataUsedTagsQueryAction | None
+    upload_action: WorkDataUploadAction | None
+
+    self_link: WorkDataRootLink
+    all_link: WorkDataQueryResultPaginationLink | None
+    used_tags_link: WorkDataUsedTagsLink | None
+
+    @classmethod
+    def from_entity(cls, entity: WorkDataRootEntity, client: httpx.Client) -> Self:
+        instance = cls(client, entity)
+        Hco.check_classes(instance._entity.class_, ["WorkDataRoot"])
+
+        instance.query_action = WorkDataQueryAction.from_entity_optional(
+            client, instance._entity, "CreateWorkDataQuery")
+        instance.query_tags_action = WorkDataUsedTagsQueryAction.from_entity_optional(
+            client, instance._entity, "CreateWorkDataTagsQuery")
+        instance.upload_action = WorkDataUploadAction.from_entity_optional(
+            client, instance._entity, "Upload")
+
+        instance.self_link = WorkDataRootLink.from_entity(
+            instance._client, instance._entity, Relations.SELF)
+
+        instance.all_link = WorkDataQueryResultPaginationLink.from_entity_optional(
+            instance._client, instance._entity, Relations.ALL)
+
+        instance.used_tags_link = WorkDataUsedTagsLink.from_entity_optional(
+            instance._client, instance._entity, Relations.USED_TAGS)
+        return instance

hypermedia_client/job_management/ideas.md

@@ -0,0 +1,28 @@
+class EntryPoint():
+
+    @LinkRelateion("Info")
+    Info: Link[Info]
+
+    @LinkRelateion("ProcessingSteps")
+    @Mandatory
+    ProcessingSteps: MandatoryLink[Info]
+
+    user: User = Info.navigate().User.navigate()
+    seld["CreateUser"].Excecute()
+
+
+    entrypoint.navigate("Info")
+    def CreateUser(dojgpsj):
+
+class Info():
+
+    CurrentUser: Link[User]
+
+class User():
+
+class Job():
+
+    name = ""
+    title = ""
+    status = ""
+

hypermedia_client/job_management/known_relations.py

@@ -0,0 +1,29 @@
+from enum import StrEnum
+
+
+class Relations(StrEnum):
+    SELF = "self"
+    ITEM = "item"
+    DOWNLOAD = "Download"
+    CREATED_RESSOURCE = "created-resource"
+    USED_TAGS = "UsedTags"
+
+    # query pagination
+    FIRST = "first"
+    PREVIOUS = "previous"
+    NEXT = "next"
+    LAST = "last"
+    ALL = "all"
+
+    # job
+    PARENT_JOB = "ParentJob"
+    SELECTED_PROCESSING_STEP = "SelectedProcessingStep"
+    INPUT_DATASLOT = "InputDataSlot"
+    OUTPUT_DATASLOT = "OutputDataSlot"
+
+    # dataslots
+    SELECTED = "Selected"
+    ASSIGNED = "Assigned"
+
+    # info
+    CURRENT_USER = "CurrentUser"

hypermedia_client/job_management/model/__init__.py

@@ -0,0 +1 @@
+from .open_api_generated import *