pinexq-client 0.2.0.2024.607.8__py3-none-any.whl

hypermedia_client/job_management/hcos/job_hco.py

@@ -0,0 +1,174 @@
+from datetime import datetime
+from typing import Self, List
+
+import httpx
+from pydantic import BaseModel, ConfigDict
+
+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.hco_base import Hco, Property
+from hypermedia_client.core.hco.link_hco import LinkHco
+from hypermedia_client.job_management.hcos import InputDataSlotHco
+from hypermedia_client.job_management.hcos.output_dataslot_hco import OutputDataSlotHco
+from hypermedia_client.job_management.hcos.processing_step_hco import ProcessingStepLink
+from hypermedia_client.job_management.known_relations import Relations
+from hypermedia_client.job_management.model.open_api_generated import JobStates, ProcessingView, RenameJobParameters, \
+    SelectProcessingParameters, SetJobTagsParameters
+from hypermedia_client.job_management.model.sirenentities import JobEntity, InputDataSlotEntity, OutputDataSlotEntity
+
+
+class JobRenameAction(ActionWithParametersHco[RenameJobParameters]):
+    def execute(self, parameters: RenameJobParameters):
+        self._execute(parameters)
+
+    def default_parameters(self) -> RenameJobParameters:
+        return self._get_default_parameters(RenameJobParameters, RenameJobParameters())
+
+
+class JobSelectProcessingAction(ActionWithParametersHco[SelectProcessingParameters]):
+    def execute(self, parameters: SelectProcessingParameters):
+        self._execute(parameters)
+
+    def default_parameters(self) -> SelectProcessingParameters:
+        return self._get_default_parameters(SelectProcessingParameters, SelectProcessingParameters())
+
+
+class JobHideAction(ActionHco):
+    def execute(self):
+        self._execute_internal()
+
+
+class JobUnHideAction(ActionHco):
+    def execute(self):
+        self._execute_internal()
+
+
+class JobAllowOutputDataDeletionAction(ActionHco):
+    def execute(self):
+        self._execute_internal()
+
+
+class JobDisAllowOutputDataDeletionAction(ActionHco):
+    def execute(self):
+        self._execute_internal()
+
+
+class GenericProcessingConfigureParameters(BaseModel):
+    """Generic parameter model, that can be set with any dictionary"""
+    model_config = ConfigDict(extra='allow')
+
+
+class JobConfigureProcessingAction(ActionWithParametersHco[GenericProcessingConfigureParameters]):
+    def execute(self, parameters: GenericProcessingConfigureParameters):
+        self._execute(parameters)
+
+    def default_parameters(self) -> GenericProcessingConfigureParameters:
+        return self._get_default_parameters(GenericProcessingConfigureParameters,
+                                            GenericProcessingConfigureParameters())
+
+
+class JobStartProcessingAction(ActionHco):
+    def execute(self):
+        self._execute_internal()
+
+
+class JobLink(LinkHco):
+    def navigate(self) -> 'JobHco':
+        return JobHco.from_entity(self._navigate_internal(JobEntity), self._client)
+
+
+class ParentJobLink(LinkHco):
+    def navigate(self) -> 'JobHco':
+        return JobHco.from_entity(self._navigate_internal(JobEntity), self._client)
+
+
+class JobEditTagsAction(ActionWithParametersHco[SetJobTagsParameters]):
+    def execute(self, parameters: SetJobTagsParameters):
+        self._execute(parameters)
+
+    def default_parameters(self) -> SetJobTagsParameters:
+        # todo check why we have to manually set tags
+        return self._get_default_parameters(SetJobTagsParameters, SetJobTagsParameters(tags=[]))
+
+
+class JobHco(Hco[JobEntity]):
+    name: str = Property()
+    state: JobStates = Property()
+    hidden: bool = Property()
+    tags: list[str] | None = Property()
+    output_is_deletable: bool = Property()
+    created_at: datetime = Property()
+    completed_at: datetime = Property()
+    error_description: str = Property()
+    processing: ProcessingView = Property()
+    result: str = Property()
+
+    self_link: JobLink
+    parent_link: ParentJobLink | None
+    selected_processing_step_link: ProcessingStepLink | None
+
+    rename_action: JobRenameAction
+    select_processing_action: JobSelectProcessingAction
+    configure_processing_action: JobConfigureProcessingAction
+    start_processing_action: JobStartProcessingAction
+    hide_action: JobHideAction
+    unhide_action: JobUnHideAction
+    allow_output_data_deletion_action: JobAllowOutputDataDeletionAction
+    disallow_output_data_deletion_action: JobDisAllowOutputDataDeletionAction
+    edit_tags_action: JobEditTagsAction | None
+
+    input_dataslots: List[InputDataSlotHco]
+    output_dataslots: List[OutputDataSlotHco]
+
+    @classmethod
+    def from_entity(cls, entity: JobEntity, client: httpx.Client) -> Self:
+        instance = cls(client, entity)
+
+        Hco.check_classes(instance._entity.class_, ["Job"])
+
+        instance.self_link = JobLink.from_entity(
+            instance._client, instance._entity, Relations.SELF)
+        instance.parent_link = ParentJobLink.from_entity_optional(
+            instance._client, instance._entity, Relations.PARENT_JOB)
+        instance.selected_processing_step_link = ProcessingStepLink.from_entity_optional(
+            instance._client, instance._entity, Relations.SELECTED_PROCESSING_STEP)
+
+        # actions
+        instance.hide_action = JobHideAction.from_entity_optional(
+            client, instance._entity, "Hide")
+        instance.unhide_action = JobUnHideAction.from_entity_optional(
+            client, instance._entity, "UnHide")
+        instance.rename_action = JobRenameAction.from_entity_optional(
+            client, instance._entity, "Rename")
+        instance.select_processing_action = JobSelectProcessingAction.from_entity_optional(
+            client, instance._entity, "SelectProcessing")
+        instance.configure_processing_action = JobConfigureProcessingAction.from_entity_optional(
+            client, instance._entity, "ConfigureProcessing")
+        instance.start_processing_action = JobStartProcessingAction.from_entity_optional(
+            client, instance._entity, "StartProcessing")
+        instance.allow_output_data_deletion_action = JobAllowOutputDataDeletionAction.from_entity_optional(
+            client, instance._entity, "AllowOutputDataDeletion")
+        instance.disallow_output_data_deletion_action = JobDisAllowOutputDataDeletionAction.from_entity_optional(
+            client, instance._entity, "DisallowOutputDataDeletion")
+        instance.edit_tags_action = JobEditTagsAction.from_entity_optional(
+            client, instance._entity, "EditTags")
+
+        # entities
+        instance._extract_input_dataslots()
+        instance._extract_output_dataslots()
+
+        return instance
+
+    def _extract_input_dataslots(self):
+        self.input_dataslots = []
+        input_dataslots = self._entity.find_all_entities_with_relation(Relations.INPUT_DATASLOT, InputDataSlotEntity)
+        for input_dataslot in input_dataslots:
+            input_dataslot_hco: InputDataSlotHco = InputDataSlotHco.from_entity(input_dataslot, self._client)
+            self.input_dataslots.append(input_dataslot_hco)
+
+    def _extract_output_dataslots(self):
+        self.output_dataslots = []
+        output_dataslots = self._entity.find_all_entities_with_relation(Relations.OUTPUT_DATASLOT, OutputDataSlotEntity)
+        for output_dataslot in output_dataslots:
+            output_dataslot_hco: OutputDataSlotHco = OutputDataSlotHco.from_entity(output_dataslot, self._client)
+            self.output_dataslots.append(output_dataslot_hco)

hypermedia_client/job_management/hcos/job_query_result_hco.py

@@ -0,0 +1,63 @@
+from typing import List
+
+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.hcos.job_hco import JobHco
+from hypermedia_client.job_management.known_relations import Relations
+from hypermedia_client.job_management.model.sirenentities import JobQueryResultEntity, JobEntity
+
+
+class JobQueryResultPaginationLink(LinkHco):
+    def navigate(self) -> 'JobQueryResultHco':
+        return JobQueryResultHco.from_entity(self._client, self._navigate_internal(JobQueryResultEntity))
+
+
+class JobQueryResultLink(LinkHco):
+    def navigate(self) -> 'JobQueryResultHco':
+        return JobQueryResultHco.from_entity(self._client, self._navigate_internal(JobQueryResultEntity))
+
+
+class JobQueryResultHco(Hco[JobQueryResultEntity]):
+    self_link: JobQueryResultLink
+    all_link: JobQueryResultPaginationLink | None
+    first_link: JobQueryResultPaginationLink | None
+    last_link: JobQueryResultPaginationLink | None
+    next_link: JobQueryResultPaginationLink | None
+    previous_link: JobQueryResultPaginationLink | None
+
+    total_entities: int = Property()
+    current_entities_count: int = Property()
+    jobs: List[JobHco]
+
+    @classmethod
+    def from_entity(cls, client: httpx.Client, entity: JobQueryResultEntity) -> 'JobQueryResultHco':
+        instance = cls(client, entity)
+
+        Hco.check_classes(instance._entity.class_, ["JobQueryResult"])
+
+        # pagination links
+        instance.self_link = JobQueryResultLink.from_entity(instance._client, instance._entity, Relations.SELF)
+        instance.all_link = JobQueryResultPaginationLink.from_entity_optional(instance._client, instance._entity,
+                                                                              Relations.ALL)
+        instance.first_link = JobQueryResultPaginationLink.from_entity_optional(instance._client, instance._entity,
+                                                                                Relations.FIRST)
+        instance.last_link = JobQueryResultPaginationLink.from_entity_optional(instance._client, instance._entity,
+                                                                               Relations.LAST)
+        instance.next_link = JobQueryResultPaginationLink.from_entity_optional(instance._client, instance._entity,
+                                                                               Relations.NEXT)
+        instance.previous_link = JobQueryResultPaginationLink.from_entity_optional(instance._client, instance._entity,
+                                                                                   Relations.PREVIOUS)
+
+        # entities
+        instance._extract_jobs()
+
+        return instance
+
+    def _extract_jobs(self):
+        self.jobs = []
+        jobs = self._entity.find_all_entities_with_relation(Relations.ITEM, JobEntity)
+        for job in jobs:
+            job_hco: JobHco = JobHco.from_entity(job, self._client)
+            self.jobs.append(job_hco)

hypermedia_client/job_management/hcos/job_used_tags_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 JobUsedTagsEntity
+
+
+class JobUsedTagsHco(Hco[JobUsedTagsEntity]):
+    tags: List[str] | None = Property()
+
+    self_link: 'JobUsedTagsLink'
+
+    @classmethod
+    def from_entity(cls, entity: JobUsedTagsEntity, client: httpx.Client) -> Self:
+        instance = cls(client, entity)
+
+        Hco.check_classes(instance._entity.class_, ["JobUsedTags"])
+
+        instance.self_link = JobUsedTagsLink.from_entity(instance._client, instance._entity, Relations.SELF)
+
+        return instance
+
+
+class JobUsedTagsLink(LinkHco):
+    def navigate(self) -> JobUsedTagsHco:
+        return JobUsedTagsHco.from_entity(self._navigate_internal(JobUsedTagsEntity), self._client)
+

hypermedia_client/job_management/hcos/jobsroot_hco.py

@@ -0,0 +1,80 @@
+from typing import Self
+
+import httpx
+from httpx import URL
+
+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.job_management.hcos.job_hco import JobLink
+from hypermedia_client.job_management.hcos.job_query_result_hco import (
+    JobQueryResultHco,
+    JobQueryResultLink
+)
+from hypermedia_client.job_management.hcos.job_used_tags_hco import JobUsedTagsLink
+from hypermedia_client.job_management.known_relations import Relations
+from hypermedia_client.job_management.model.open_api_generated import (
+    CreateJobParameters,
+    JobQueryParameters,
+    CreateSubJobParameters
+)
+from hypermedia_client.job_management.model.sirenentities import JobsRootEntity
+
+
+class CreateJobAction(ActionWithParametersHco[CreateJobParameters]):
+    def execute(self, parameters: CreateJobParameters) -> JobLink:
+        url: URL = self._execute_returns_url(parameters)
+        link = Link.from_url(url, [str(Relations.CREATED_RESSOURCE)], "Created job", MediaTypes.SIREN)
+        return JobLink.from_link(self._client, link)
+
+    def default_parameters(self) -> CreateJobParameters:
+        return self._get_default_parameters(CreateJobParameters, CreateJobParameters())
+
+
+class CreateSubJobAction(ActionWithParametersHco[CreateSubJobParameters]):
+    def execute(self, parameters: CreateSubJobParameters) -> JobLink:
+        url = self._execute_returns_url(parameters)
+        link = Link.from_url(url, [str(Relations.CREATED_RESSOURCE)], "Created sub-job", MediaTypes.SIREN)
+        return JobLink.from_link(self._client, link)
+
+    def default_parameters(self) -> CreateSubJobParameters:
+        return self._get_default_parameters(CreateSubJobParameters, CreateSubJobParameters())
+
+
+class JobQueryAction(ActionWithParametersHco):
+    def execute(self, parameters: JobQueryParameters) -> JobQueryResultHco:
+        url = self._execute_returns_url(parameters)
+        link = Link.from_url(url, [str(Relations.CREATED_RESSOURCE)], "Created job query", MediaTypes.SIREN)
+        # resolve link immediately
+        return JobQueryResultLink.from_link(self._client, link).navigate()
+
+    def default_parameters(self) -> JobQueryParameters:
+        return self._get_default_parameters(JobQueryParameters, JobQueryParameters())
+
+
+class JobsRootHco(Hco[JobsRootEntity]):
+    create_job_action: CreateJobAction | None
+    job_query_action: JobQueryAction | None
+    create_subjob_action: CreateSubJobAction | None
+    used_tags_link: JobUsedTagsLink | None
+
+    self_link: 'JobsRootLink'
+
+    @classmethod
+    def from_entity(cls, entity: JobsRootEntity, client: httpx.Client) -> Self:
+        instance = cls(client, entity)
+
+        Hco.check_classes(instance._entity.class_, ["JobsRoot"])
+        instance.create_job_action = CreateJobAction.from_entity_optional(client, instance._entity, "CreateJob")
+        instance.create_subjob_action = CreateSubJobAction.from_entity_optional(client, instance._entity, "CreateSubJob")
+        instance.job_query_action = JobQueryAction.from_entity_optional(client, instance._entity, "CreateJobQuery")
+        instance.used_tags_link = JobUsedTagsLink.from_entity_optional(
+            instance._client, instance._entity, Relations.USED_TAGS)
+        instance.self_link = JobsRootLink.from_entity(instance._client, instance._entity, Relations.SELF)
+        return instance
+
+
+class JobsRootLink(LinkHco):
+    def navigate(self) -> JobsRootHco:
+        return JobsRootHco.from_entity(self._navigate_internal(JobsRootEntity), self._client)

hypermedia_client/job_management/hcos/output_dataslot_hco.py

@@ -0,0 +1,44 @@
+from typing import 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.hcos.workdata_hco import WorkDataHco
+from hypermedia_client.job_management.known_relations import Relations
+from hypermedia_client.job_management.model.sirenentities import (
+    OutputDataSlotEntity,
+    WorkDataEntity
+)
+
+
+class OutputDataSlotLink(LinkHco):
+    def navigate(self) -> 'OutputDataSlotHco':
+        return OutputDataSlotHco.from_entity(self._navigate_internal(OutputDataSlotEntity), self._client)
+
+
+class OutputDataSlotHco(Hco[OutputDataSlotEntity]):
+    title: str | None = Property()
+    description: str | None = Property()
+    media_type: str | None = Property()
+    assigned_workdata: WorkDataHco | None
+
+    @classmethod
+    def from_entity(cls, entity: OutputDataSlotEntity, client: httpx.Client) -> Self:
+        instance = cls(client, entity)
+        Hco.check_classes(instance._entity.class_, ["OutputDataSlot"])
+
+        instance._extract_workdata()
+
+        return instance
+
+    def _extract_workdata(self):
+        self.assigned_workdatas = []
+
+        workdatas: list[WorkDataEntity] = self._entity.find_all_entities_with_relation(Relations.ASSIGNED,
+                                                                                       WorkDataEntity)
+        if not workdatas:
+            return
+
+        self.assigned_workdatas = list[WorkDataHco](
+            WorkDataHco.from_entity(workdata, self._client) for workdata in workdatas)

hypermedia_client/job_management/hcos/processing_step_hco.py

@@ -0,0 +1,71 @@
+from datetime import datetime
+from typing import List, Self
+
+import httpx
+
+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 DataSpecificationHto, \
+    SetProcessingStepTagsParameters
+from hypermedia_client.job_management.model.sirenentities import ProcessingStepEntity
+
+
+class ProcessingStepLink(LinkHco):
+    def navigate(self) -> 'ProcessingStepHco':
+        return ProcessingStepHco.from_entity(self._navigate_internal(ProcessingStepEntity), self._client)
+
+
+class ProcessingStepEditTagsAction(ActionWithParametersHco[SetProcessingStepTagsParameters]):
+    def execute(self, parameters: SetProcessingStepTagsParameters):
+        self._execute(parameters)
+
+    def default_parameters(self) -> SetProcessingStepTagsParameters:
+        # todo check why we have to manually set tags
+        return self._get_default_parameters(SetProcessingStepTagsParameters, SetProcessingStepTagsParameters(tags=[]))
+
+
+class ProcessingStepHco(Hco[ProcessingStepEntity]):
+    title: str = Property()
+    version: str | None = Property()
+    function_name: str | None = Property()
+    short_description: str | None = Property()
+    long_description: str | None = Property()
+    tags: list[str] | None = Property()
+    has_parameters: bool | None = Property()
+    is_public: bool | None = Property()
+    is_configured: bool | None = Property()
+    created_at: datetime | None = Property()
+    last_modified_at: datetime | None = Property()
+    parameter_schema: str | None = Property()
+    default_parameters: str | None = Property()
+    return_schema: str | None = Property()
+    error_schema: str | None = Property()
+    input_data_slot_specification: List[DataSpecificationHto] | None = Property()
+    output_data_slot_specification: List[DataSpecificationHto] | None = Property()
+    edit_tags_action: ProcessingStepEditTagsAction | None
+
+    self_link: ProcessingStepLink
+    download_link: DownloadLinkHco
+
+    @classmethod
+    def from_entity(cls, entity: ProcessingStepEntity, client: httpx.Client) -> Self:
+        instance = cls(client, entity)
+        Hco.check_classes(instance._entity.class_, ["ProcessingStep"])
+
+        instance.self_link = ProcessingStepLink.from_entity(instance._client, instance._entity, Relations.SELF)
+        instance.download_link = DownloadLinkHco.from_entity(instance._client, instance._entity, Relations.DOWNLOAD)
+
+        # todo tests
+
+        # actions
+        # todo
+        #   "EditProperties"
+        #   "Upload"
+        #   "ConfigureDefaultParameters"
+        #   "ClearDefaultParameters"
+        instance.edit_tags_action = ProcessingStepEditTagsAction.from_entity_optional(
+            client, instance._entity, "EditTags")
+        return instance

hypermedia_client/job_management/hcos/processing_step_used_tags_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 ProcessingStepUsedTagsEntity
+
+
+class ProcessingStepUsedTagsHco(Hco[{ProcessingStepUsedTagsEntity}]):
+    tags: List[str] | None = Property()
+
+    self_link: 'ProcessingStepUsedTagsLink'
+
+    @classmethod
+    def from_entity(cls, entity: ProcessingStepUsedTagsEntity, client: httpx.Client) -> Self:
+        instance = cls(client, entity)
+
+        Hco.check_classes(instance._entity.class_, ["ProcessingStepUsedTags"])
+
+        instance.self_link = ProcessingStepUsedTagsLink.from_entity(instance._client, instance._entity, Relations.SELF)
+
+        return instance
+
+
+class ProcessingStepUsedTagsLink(LinkHco):
+    def navigate(self) -> ProcessingStepUsedTagsHco:
+        return ProcessingStepUsedTagsHco.from_entity(self._navigate_internal(ProcessingStepUsedTagsEntity), self._client)
+

hypermedia_client/job_management/hcos/processingstep_query_result_hco.py

@@ -0,0 +1,68 @@
+from typing import 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.hcos.processing_step_hco import ProcessingStepHco
+from hypermedia_client.job_management.known_relations import Relations
+from hypermedia_client.job_management.model.sirenentities import (
+    ProcessingStepQueryResultEntity,
+    ProcessingStepEntity
+)
+
+
+class ProcessingStepQueryResultPaginationLink(LinkHco):
+    def navigate(self) -> 'ProcessingStepQueryResultHco':
+        return ProcessingStepQueryResultHco.from_entity(self._navigate_internal(ProcessingStepQueryResultEntity),
+                                                        self._client)
+
+
+class ProcessingStepQueryResultLink(LinkHco):
+    def navigate(self) -> 'ProcessingStepQueryResultHco':
+        return ProcessingStepQueryResultHco.from_entity(self._navigate_internal(ProcessingStepQueryResultEntity),
+                                                        self._client)
+
+
+class ProcessingStepQueryResultHco(Hco[ProcessingStepQueryResultEntity]):
+    total_entities: int = Property()
+    current_entities_count: int = Property()
+    processing_steps: list[ProcessingStepHco]
+
+    self_link: ProcessingStepQueryResultLink
+    all_link: ProcessingStepQueryResultPaginationLink | None
+    first_link: ProcessingStepQueryResultPaginationLink | None
+    last_link: ProcessingStepQueryResultPaginationLink | None
+    next_link: ProcessingStepQueryResultPaginationLink | None
+    previous_link: ProcessingStepQueryResultPaginationLink | None
+
+    @classmethod
+    def from_entity(cls, entity: ProcessingStepQueryResultEntity, client: httpx.Client) -> Self:
+        instance = cls(client, entity)
+
+        Hco.check_classes(instance._entity.class_, ["ProcessingStepQueryResult"])
+
+        # pagination links
+        instance.self_link = ProcessingStepQueryResultLink.from_entity(
+            instance._client, instance._entity, Relations.SELF)
+        instance.all_link = ProcessingStepQueryResultPaginationLink.from_entity_optional(
+            instance._client, instance._entity, Relations.ALL)
+        instance.first_link = ProcessingStepQueryResultPaginationLink.from_entity_optional(
+            instance._client, instance._entity, Relations.FIRST)
+        instance.last_link = ProcessingStepQueryResultPaginationLink.from_entity_optional(
+            instance._client, instance._entity, Relations.LAST)
+        instance.next_link = ProcessingStepQueryResultPaginationLink.from_entity_optional(
+            instance._client, instance._entity, Relations.NEXT)
+        instance.previous_link = ProcessingStepQueryResultPaginationLink.from_entity_optional(
+            instance._client, instance._entity, Relations.PREVIOUS)
+
+        instance._extract_processing_steps()
+
+        return instance
+
+    def _extract_processing_steps(self):
+        self.processing_steps = []
+        processing_steps = self._entity.find_all_entities_with_relation(Relations.ITEM, ProcessingStepEntity)
+        for processing_step in processing_steps:
+            processing_step_hco: ProcessingStepHco = ProcessingStepHco.from_entity(processing_step, self._client)
+            self.processing_steps.append(processing_step_hco)

hypermedia_client/job_management/hcos/processingsteproot_hco.py

@@ -0,0 +1,72 @@
+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.job_management.hcos.processing_step_hco import ProcessingStepLink, ProcessingStepHco
+from hypermedia_client.job_management.hcos.processing_step_used_tags_hco import ProcessingStepUsedTagsLink
+from hypermedia_client.job_management.hcos.processingstep_query_result_hco import (
+    ProcessingStepQueryResultHco,
+    ProcessingStepQueryResultLink,
+    ProcessingStepQueryResultPaginationLink
+)
+from hypermedia_client.job_management.known_relations import Relations
+from hypermedia_client.job_management.model import ProcessingStepQueryParameters, CreateProcessingStepParameters
+from hypermedia_client.job_management.model.sirenentities import ProcessingStepsRootEntity
+
+
+class ProcessingStepQueryAction(ActionWithParametersHco[ProcessingStepQueryParameters]):
+    def execute(self, parameters: ProcessingStepQueryParameters) -> ProcessingStepQueryResultHco:
+        url = self._execute_returns_url(parameters)
+        link = Link.from_url(url, [str(Relations.CREATED_RESSOURCE)], "Created query", MediaTypes.SIREN)
+        # resolve link immediately
+        return ProcessingStepQueryResultLink.from_link(self._client, link).navigate()
+
+    def default_parameters(self) -> ProcessingStepQueryParameters:
+        return self._get_default_parameters(ProcessingStepQueryParameters, ProcessingStepQueryParameters())
+
+
+class ProcessingStepRegisterNewAction(ActionWithParametersHco[CreateProcessingStepParameters]):
+    def execute(self, parameters: CreateProcessingStepParameters) -> ProcessingStepHco:
+        url = self._execute_returns_url(parameters)
+        link = Link.from_url(url, [str(Relations.CREATED_RESSOURCE)], "Created processing-step", MediaTypes.SIREN)
+        # resolve link immediately
+        return ProcessingStepLink.from_link(self._client, link).navigate()
+
+    def default_parameters(self) -> CreateProcessingStepParameters:
+        return self._get_default_parameters(CreateProcessingStepParameters, CreateProcessingStepParameters())
+
+
+class ProcessingStepsRootLink(LinkHco):
+    def navigate(self) -> 'ProcessingStepsRootHco':
+        return ProcessingStepsRootHco.from_entity(self._navigate_internal(ProcessingStepsRootEntity), self._client)
+
+
+class ProcessingStepsRootHco(Hco[ProcessingStepsRootEntity]):
+    query_action: ProcessingStepQueryAction | None
+    register_new_action: ProcessingStepRegisterNewAction | None
+
+    self_link: ProcessingStepsRootLink
+    all_link: ProcessingStepQueryResultPaginationLink | None
+    used_tags_link: ProcessingStepUsedTagsLink | None
+
+    @classmethod
+    def from_entity(cls, entity: ProcessingStepsRootEntity, client: httpx.Client) -> Self:
+        instance = cls(client, entity)
+        Hco.check_classes(instance._entity.class_, ["ProcessingStepRoot"])
+
+        instance.register_new_action = ProcessingStepRegisterNewAction.from_entity_optional(
+            client, instance._entity, "RegisterNewProcessingStep")
+        instance.query_action = ProcessingStepQueryAction.from_entity_optional(
+            client, instance._entity, "CreateProcessingStepQuery")
+        instance.used_tags_link = ProcessingStepUsedTagsLink.from_entity_optional(
+            instance._client, instance._entity, Relations.USED_TAGS)
+        instance.self_link = ProcessingStepsRootLink.from_entity(
+            instance._client, instance._entity, Relations.SELF)
+        instance.all_link = ProcessingStepQueryResultPaginationLink.from_entity_optional(
+            instance._client, instance._entity, Relations.ALL)
+
+        return instance

hypermedia_client/job_management/hcos/user_hco.py

@@ -0,0 +1,37 @@
+from typing import Self
+from uuid import UUID
+
+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 UserEntity
+
+
+class UserLink(LinkHco):
+    def navigate(self) -> "UserHco":
+        return UserHco.from_entity(self._navigate_internal(UserEntity), self._client)
+
+
+class UserHco(Hco[UserEntity]):
+    user_id: UUID = Property()
+    user_groups: list[str] = Property()
+
+    self_link: UserLink
+
+    @classmethod
+    def from_entity(cls, entity: UserEntity, client: httpx.Client) -> Self:
+        instance = cls(client, entity)
+
+        Hco.check_classes(instance._entity.class_, ["User"])
+
+        instance.self_link = UserLink.from_entity(
+            instance._client, instance._entity, Relations.SELF
+        )
+
+        return instance
+
+    def _extract_current_user(self):
+        self.current_user = self._entity.find_all_entities_with_relation(
+            Relations.CURRENT_USER, UserEntity)