pinexq-client 0.5.0.20241030.1__py3-none-any.whl → 0.9.0.20241203.1__py3-none-any.whl

pinexq_client/core/hco/link_hco.py

@@ -2,10 +2,13 @@ from typing import Self, Type
 
 import httpx
 from httpx import URL
+from httpx import Response
 
-from pinexq_client.core import Link, Entity, navigate, ensure_siren_response, ClientException
+from pinexq_client.core import Link, Entity, navigate, ensure_siren_response, ClientException, raise_exception_on_error, \
+    ApiException
 from pinexq_client.core.hco.hco_base import ClientContainer, TEntity
 from pinexq_client.core.hco.unavailable import UnavailableLink, HypermediaAvailability
+from pinexq_client.core.model.error import ProblemDetails
 
 
 class LinkHco(ClientContainer, HypermediaAvailability):
@@ -51,6 +54,37 @@ class LinkHco(ClientContainer, HypermediaAvailability):
     def is_available() -> bool:
         return True
 
+    """Checks if the resource can be retrieved (no 404) """
+    def exists(self) -> bool:
+        response = navigate(self._client, self._link)
+        match response:
+            case Response() as r:
+                if r.status_code == 404:
+                    # resource is not found
+                    return False
+                elif r.status_code == 200:
+                    # resource found
+                    return True
+                elif r.status_code >= 400:
+                    raise_exception_on_error("Expected a resource or none, got error", r)
+                else:
+                    raise ApiException(f"Unexpected status code in response: {r.status_code}")
+
+            case ProblemDetails() as p:
+                if p.status == 404:
+                    # resource is not found
+                    return False
+                elif p.status == 200:
+                    # resource found
+                    return True
+                elif p.status >= 400:
+                    raise_exception_on_error("Expected a resource or none, got error", p)
+                else:
+                    raise ApiException(f"Unexpected status code in response: {p.status_code}")
+            case _:
+                # got entity
+                return True
+
     def _navigate_internal(self, parse_type: Type[TEntity] = Entity) -> TEntity:
         response = navigate(self._client, self._link, parse_type)
         return ensure_siren_response(response)
@@ -58,6 +92,13 @@ class LinkHco(ClientContainer, HypermediaAvailability):
     def get_url(self) -> URL:
         return URL(self._link.href)
 
+    def __eq__(self, other):
+        """Compares the link url to determine if the link is pointing to the same resource."""
+        if isinstance(other, LinkHco):
+            return self.get_url() == other.get_url()
+        else:
+            return NotImplemented
+
     def __repr__(self):
         rel_names = ', '.join((f"'{r}'" for r in self._link.rel))
         return f"<{self.__class__.__name__}: {rel_names}>"

pinexq_client/core/media_types.py

@@ -19,6 +19,9 @@ class MediaTypes(StrEnum):
     JPEG = "image/jpeg"
     BMP = "image/bmp"
 
+    WORKFLOW_DEFINITION = "application/vnd.pinexq.workflow.definition+json"
+    WORKFLOW_REPORT = "application/vnd.pinexq.workflow.report+json"
+
 
 class SirenClasses(StrEnum):
     FileUploadAction = "FileUploadAction"

pinexq_client/core/model/error.py

@@ -1,6 +1,6 @@
 from typing import Any
 
-from pydantic import BaseModel, Field, ConfigDict
+from pydantic import BaseModel
 
 
 class ProblemDetails(BaseModel):

pinexq_client/core/sirenaccess.py

@@ -43,12 +43,11 @@ def get_resource(client: httpx.Client, href: str, media_type: str = MediaTypes.S
         warnings.warn(f"Unexpected return code: {response.status_code}")
         return response
 
-
-def navigate(client: httpx.Client, link: Link,
+def navigate(client: httpx.Client,
+             link: Link,
              parse_type: type[TEntity] = Entity) -> TEntity | ProblemDetails | Response:
     return get_resource(client, link.href, link.type, parse_type)
 
-
 def ensure_siren_response(response: TEntity | ProblemDetails | Response) -> TEntity:
     raise_exception_on_error(f"Error while navigating, unexpected response", response)
     return response

pinexq_client/job_management/__init__.py

@@ -3,4 +3,4 @@ from .enterjma import enter_jma
 from .tool import Job, ProcessingStep, WorkData
 
 # Protocol version the JMA is using
-__jma_version__ = [7, 0, 0]
+__jma_version__ = [7, 3, 0]

pinexq_client/job_management/hcos/__init__.py

@@ -1,4 +1,5 @@
 from .input_dataslot_hco import *
+from .output_dataslot_hco import *
 from .entrypoint_hco import *
 from .info_hco import *
 from .job_hco import *

pinexq_client/job_management/hcos/job_hco.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Self, List
+from typing import Self, List, TYPE_CHECKING
 
 import httpx
 from pydantic import BaseModel, ConfigDict
@@ -9,8 +9,6 @@ from pinexq_client.core.hco.action_with_parameters_hco import ActionWithParamete
 from pinexq_client.core.hco.hco_base import Hco, Property
 from pinexq_client.core.hco.link_hco import LinkHco
 from pinexq_client.core.hco.unavailable import UnavailableAction, UnavailableLink
-from pinexq_client.job_management.hcos import InputDataSlotHco
-from pinexq_client.job_management.hcos.output_dataslot_hco import OutputDataSlotHco
 from pinexq_client.job_management.hcos.processing_step_hco import ProcessingStepLink
 from pinexq_client.job_management.known_relations import Relations
 from pinexq_client.job_management.model import SetJobErrorStateParameters
@@ -18,6 +16,10 @@ from pinexq_client.job_management.model.open_api_generated import JobStates, Pro
     SelectProcessingParameters, SetJobTagsParameters
 from pinexq_client.job_management.model.sirenentities import JobEntity, InputDataSlotEntity, OutputDataSlotEntity
 
+if TYPE_CHECKING:
+    from pinexq_client.job_management.hcos.input_dataslot_hco import InputDataSlotHco
+    from pinexq_client.job_management.hcos.output_dataslot_hco import OutputDataSlotHco
+
 
 class JobRenameAction(ActionWithParametersHco[RenameJobParameters]):
     def execute(self, parameters: RenameJobParameters):
@@ -136,8 +138,8 @@ class JobHco(Hco[JobEntity]):
     edit_tags_action: JobEditTagsAction | UnavailableAction
     set_to_error_state_action: JobSetToErrorStateAction | UnavailableAction
 
-    input_dataslots: List[InputDataSlotHco]
-    output_dataslots: List[OutputDataSlotHco]
+    input_dataslots: List["InputDataSlotHco"]
+    output_dataslots: List["OutputDataSlotHco"]
 
     @classmethod
     def from_entity(cls, entity: JobEntity, client: httpx.Client) -> Self:
@@ -183,6 +185,7 @@ class JobHco(Hco[JobEntity]):
         return instance
 
     def _extract_input_dataslots(self):
+        from pinexq_client.job_management.hcos.input_dataslot_hco import InputDataSlotHco
         self.input_dataslots = []
         input_dataslots = self._entity.find_all_entities_with_relation(Relations.INPUT_DATASLOT, InputDataSlotEntity)
         for input_dataslot in input_dataslots:
@@ -190,6 +193,7 @@ class JobHco(Hco[JobEntity]):
             self.input_dataslots.append(input_dataslot_hco)
 
     def _extract_output_dataslots(self):
+        from pinexq_client.job_management.hcos.output_dataslot_hco import OutputDataSlotHco
         self.output_dataslots = []
         output_dataslots = self._entity.find_all_entities_with_relation(Relations.OUTPUT_DATASLOT, OutputDataSlotEntity)
         for output_dataslot in output_dataslots:

pinexq_client/job_management/hcos/processing_step_hco.py

@@ -13,103 +13,103 @@ from pinexq_client.core.hco.link_hco import LinkHco
 from pinexq_client.core.hco.unavailable import UnavailableAction
 from pinexq_client.core.hco.upload_action_hco import UploadAction, UploadParameters
 from pinexq_client.job_management.known_relations import Relations
-from pinexq_client.job_management.model import EditProcessingStepParameters
 from pinexq_client.job_management.model.open_api_generated import DataSpecificationHto, \
-	SetProcessingStepTagsParameters
+    SetProcessingStepTagsParameters, EditProcessingStepParameters
 from pinexq_client.job_management.model.sirenentities import ProcessingStepEntity
 
 
 class ProcessingStepLink(LinkHco):
-	def navigate(self) -> 'ProcessingStepHco':
-		return ProcessingStepHco.from_entity(self._navigate_internal(ProcessingStepEntity), self._client)
+    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 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=[]))
+    def default_parameters(self) -> SetProcessingStepTagsParameters:
+        # todo check why we have to manually set tags
+        return self._get_default_parameters(SetProcessingStepTagsParameters, SetProcessingStepTagsParameters(tags=[]))
 
 
 class ProcessingStepEditPropertiesAction(ActionWithParametersHco[EditProcessingStepParameters]):
-	def execute(self, parameters: EditProcessingStepParameters):
-		self._execute(parameters)
+    def execute(self, parameters: EditProcessingStepParameters):
+        self._execute(parameters)
 
-	def default_parameters(self) -> EditProcessingStepParameters:
-		return self._get_default_parameters(EditProcessingStepParameters, EditProcessingStepParameters())
+    def default_parameters(self) -> EditProcessingStepParameters:
+        return self._get_default_parameters(EditProcessingStepParameters,
+                                            EditProcessingStepParameters())
 
 
 class GenericProcessingConfigureParameters(BaseModel):
-	"""Generic parameter model, that can be set with any dictionary"""
-	model_config = ConfigDict(extra='allow')
+    """Generic parameter model, that can be set with any dictionary"""
+    model_config = ConfigDict(extra='allow')
 
 
 class ConfigureDefaultParametersAction(ActionWithParametersHco[GenericProcessingConfigureParameters]):
-	def execute(self, parameters: GenericProcessingConfigureParameters):
-		self._execute(parameters)
+    def execute(self, parameters: GenericProcessingConfigureParameters):
+        self._execute(parameters)
 
-	def default_parameters(self) -> GenericProcessingConfigureParameters:
-		return self._get_default_parameters(GenericProcessingConfigureParameters,
-											GenericProcessingConfigureParameters())
+    def default_parameters(self) -> GenericProcessingConfigureParameters:
+        return self._get_default_parameters(GenericProcessingConfigureParameters,
+                                            GenericProcessingConfigureParameters())
 
 
 class ClearDefaultParametersAction(ActionHco):
-	def execute(self):
-		self._execute_internal()
+    def execute(self):
+        self._execute_internal()
 
 
 class UploadConfigurationAction(UploadAction):
-	def execute(self, parameters: UploadParameters):
-		upload_json(self._client, self._action, parameters.json_, parameters.filename)
+    def execute(self, parameters: UploadParameters):
+        upload_json(self._client, self._action, parameters.json_, parameters.filename)
 
 
 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 | UnavailableAction
-	edit_properties_action: ProcessingStepEditPropertiesAction | UnavailableAction
-	configure_default_parameters_action: ConfigureDefaultParametersAction | UnavailableAction
-	clear_default_parameters_action: ClearDefaultParametersAction | UnavailableAction
-	upload_configuration_action: UploadConfigurationAction | 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
-
-		instance.edit_tags_action = ProcessingStepEditTagsAction.from_entity_optional(
-			client, instance._entity, "EditTags")
-		instance.edit_properties_action = ProcessingStepEditPropertiesAction.from_entity_optional(
-			client, instance._entity, "EditProperties")
-		instance.configure_default_parameters_action = ConfigureDefaultParametersAction.from_entity_optional(
-			client, instance._entity, "ConfigureDefaultParameters")
-		instance.clear_default_parameters_action = ClearDefaultParametersAction.from_entity_optional(
-			client, instance._entity, "ClearDefaultParameters")
-		instance.upload_configuration_action = UploadConfigurationAction.from_entity_optional(
-			client, instance._entity, "Upload")
-		return instance
+    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 | UnavailableAction
+    edit_properties_action: ProcessingStepEditPropertiesAction | UnavailableAction
+    configure_default_parameters_action: ConfigureDefaultParametersAction | UnavailableAction
+    clear_default_parameters_action: ClearDefaultParametersAction | UnavailableAction
+    upload_configuration_action: UploadConfigurationAction | 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
+
+        instance.edit_tags_action = ProcessingStepEditTagsAction.from_entity_optional(
+            client, instance._entity, "EditTags")
+        instance.edit_properties_action = ProcessingStepEditPropertiesAction.from_entity_optional(
+            client, instance._entity, "EditProperties")
+        instance.configure_default_parameters_action = ConfigureDefaultParametersAction.from_entity_optional(
+            client, instance._entity, "ConfigureDefaultParameters")
+        instance.clear_default_parameters_action = ClearDefaultParametersAction.from_entity_optional(
+            client, instance._entity, "ClearDefaultParameters")
+        instance.upload_configuration_action = UploadConfigurationAction.from_entity_optional(
+            client, instance._entity, "Upload")
+        return instance

pinexq_client/job_management/hcos/workdata_hco.py

@@ -8,121 +8,129 @@ from pinexq_client.core.hco.action_with_parameters_hco import ActionWithParamete
 from pinexq_client.core.hco.download_link_hco import DownloadLinkHco
 from pinexq_client.core.hco.hco_base import Hco, Property
 from pinexq_client.core.hco.link_hco import LinkHco
-from pinexq_client.core.hco.unavailable import UnavailableAction
+from pinexq_client.core.hco.unavailable import UnavailableAction, UnavailableLink
+from pinexq_client.job_management.hcos.processing_step_hco import ProcessingStepLink
+from pinexq_client.job_management.hcos.job_hco import JobLink
 from pinexq_client.job_management.known_relations import Relations
 from pinexq_client.job_management.model.open_api_generated import (
-	SetNameWorkDataParameters,
-	SetCommentWorkDataParameters,
-	SetTagsWorkDataParameters,
-	WorkDataKind
+    SetNameWorkDataParameters,
+    SetCommentWorkDataParameters,
+    SetTagsWorkDataParameters,
+    WorkDataKind
 )
 from pinexq_client.job_management.model.sirenentities import WorkDataEntity
 
 
 class WorkDataLink(LinkHco):
-	def navigate(self) -> 'WorkDataHco':
-		return WorkDataHco.from_entity(self._navigate_internal(WorkDataEntity), self._client)
+    def navigate(self) -> 'WorkDataHco':
+        return WorkDataHco.from_entity(self._navigate_internal(WorkDataEntity), self._client)
 
 
 class WorkDataDeleteAction(ActionHco):
-	def execute(self):
-		self._execute_internal()
+    def execute(self):
+        self._execute_internal()
 
 
 class WorkDataRenameAction(ActionWithParametersHco[SetNameWorkDataParameters]):
-	def execute(self, parameters: SetNameWorkDataParameters):
-		self._execute(parameters)
+    def execute(self, parameters: SetNameWorkDataParameters):
+        self._execute(parameters)
 
-	def default_parameters(self) -> SetNameWorkDataParameters:
-		return self._get_default_parameters(SetNameWorkDataParameters, SetNameWorkDataParameters())
+    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 execute(self, parameters: SetCommentWorkDataParameters):
+        self._execute(parameters)
 
-	def default_parameters(self) -> SetCommentWorkDataParameters:
-		return self._get_default_parameters(SetCommentWorkDataParameters, SetCommentWorkDataParameters())
+    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 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=[]))
+    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()
+    def execute(self):
+        self._execute_internal()
 
 
 class WorkDataDisallowAction(ActionHco):
-	def execute(self):
-		self._execute_internal()
+    def execute(self):
+        self._execute_internal()
 
 
 class WorkDataHideAction(ActionHco):
-	def execute(self):
-		self._execute_internal()
+    def execute(self):
+        self._execute_internal()
 
 
 class WorkDataUnHideAction(ActionHco):
-	def execute(self):
-		self._execute_internal()
+    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 | UnavailableAction
-	hide_action: WorkDataHideAction | UnavailableAction
-	unhide_action: WorkDataUnHideAction | UnavailableAction
-	allow_deletion_action: WorkDataAllowDeletionAction | UnavailableAction
-	disallow_deletion_action: WorkDataDisallowAction | UnavailableAction
-	rename_action: WorkDataRenameAction | UnavailableAction
-	edit_comment_action: WorkDataEditCommentAction | UnavailableAction
-	edit_tags_action: WorkDataEditTagsAction | UnavailableAction
-
-	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
+    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 | UnavailableAction
+    hide_action: WorkDataHideAction | UnavailableAction
+    unhide_action: WorkDataUnHideAction | UnavailableAction
+    allow_deletion_action: WorkDataAllowDeletionAction | UnavailableAction
+    disallow_deletion_action: WorkDataDisallowAction | UnavailableAction
+    rename_action: WorkDataRenameAction | UnavailableAction
+    edit_comment_action: WorkDataEditCommentAction | UnavailableAction
+    edit_tags_action: WorkDataEditTagsAction | UnavailableAction
+
+    self_link: WorkDataLink
+    download_link: DownloadLinkHco
+    producer_job_link: JobLink | UnavailableLink
+    producer_processing_step_link: ProcessingStepLink | UnavailableLink
+
+    @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)
+        instance.producer_job_link = JobLink.from_entity_optional(
+            instance._client, instance._entity, Relations.PRODUCED_BY_JOB)
+        instance.producer_processing_step_link = ProcessingStepLink.from_entity_optional(
+            instance._client, instance._entity, Relations.PRODUCED_BY_PROCESSING_STEP)
+        return instance

pinexq_client/job_management/known_relations.py

@@ -21,6 +21,10 @@ class Relations(StrEnum):
     INPUT_DATASLOT = "InputDataSlot"
     OUTPUT_DATASLOT = "OutputDataSlot"
 
+    # workdata
+    PRODUCED_BY_JOB = "ProducedByJob"
+    PRODUCED_BY_PROCESSING_STEP = "ProducedByProcessingStep"
+
     # dataslots
     SELECTED = "Selected"
     ASSIGNED = "Assigned"