pinexq-client 0.3.0.20240620.2__py3-none-any.whl → 0.4.0.2024.717.1__py3-none-any.whl

pinexq_client/job_management/hcos/entrypoint_hco.py

@@ -5,6 +5,7 @@ import httpx
 
 from pinexq_client.core.hco.hco_base import Hco
 from pinexq_client.core.hco.link_hco import LinkHco
+from pinexq_client.core.hco.unavailable import UnavailableLink
 from pinexq_client.job_management.hcos.info_hco import InfoLink
 from pinexq_client.job_management.hcos.jobsroot_hco import JobsRootLink
 from pinexq_client.job_management.hcos.processingsteproot_hco import ProcessingStepsRootLink
@@ -14,44 +15,44 @@ from pinexq_client.job_management.model.sirenentities import EntryPointEntity
 
 
 class EntryPointLink(LinkHco):
-    def navigate(self) -> 'EntryPointHco':
-        return EntryPointHco.from_entity(self._navigate_internal(EntryPointEntity), self._client)
+	def navigate(self) -> 'EntryPointHco':
+		return EntryPointHco.from_entity(self._navigate_internal(EntryPointEntity), self._client)
 
 
 class EntrypointRelations(StrEnum):
-    JOBS_ROOT = "JobsRoot"
-    WORKDATA_ROOT = "WorkDataRoot"
-    PROCESSINGSTEPS_ROOT = "ProcessingStepsRoot"
-    INFO = "Info"
-    ADMIN = "Admin"
+	JOBS_ROOT = "JobsRoot"
+	WORKDATA_ROOT = "WorkDataRoot"
+	PROCESSINGSTEPS_ROOT = "ProcessingStepsRoot"
+	INFO = "Info"
+	ADMIN = "Admin"
 
 
 class EntryPointHco(Hco[EntryPointEntity]):
-    self_link: EntryPointLink
-    job_root_link: JobsRootLink
-    work_data_root_link: WorkDataRootLink
-    processing_step_root_link: ProcessingStepsRootLink
-    info_link: InfoLink
-
-    admin_link: LinkHco | None
-
-    @classmethod
-    def from_entity(cls, entity: EntryPointEntity, client: httpx.Client) -> Self:
-        instance = cls(client, entity)
-        Hco.check_classes(instance._entity.class_, ["EntryPoint"])
-
-        instance.self_link = EntryPointLink.from_entity(
-            instance._client, instance._entity, Relations.SELF)
-        instance.info_link = InfoLink.from_entity(
-            instance._client, instance._entity, EntrypointRelations.INFO)
-        instance.job_root_link = JobsRootLink.from_entity(
-            instance._client, instance._entity, EntrypointRelations.JOBS_ROOT)
-        instance.work_data_root_link = WorkDataRootLink.from_entity(
-            instance._client, instance._entity, EntrypointRelations.WORKDATA_ROOT)
-        instance.processing_step_root_link = ProcessingStepsRootLink.from_entity(
-            instance._client, instance._entity, EntrypointRelations.PROCESSINGSTEPS_ROOT)
-
-        instance.admin_link = LinkHco.from_entity_optional(
-            instance._client, instance._entity, EntrypointRelations.ADMIN)
-
-        return instance
+	self_link: EntryPointLink
+	job_root_link: JobsRootLink
+	work_data_root_link: WorkDataRootLink
+	processing_step_root_link: ProcessingStepsRootLink
+	info_link: InfoLink
+
+	admin_link: LinkHco | UnavailableLink
+
+	@classmethod
+	def from_entity(cls, entity: EntryPointEntity, client: httpx.Client) -> Self:
+		instance = cls(client, entity)
+		Hco.check_classes(instance._entity.class_, ["EntryPoint"])
+
+		instance.self_link = EntryPointLink.from_entity(
+			instance._client, instance._entity, Relations.SELF)
+		instance.info_link = InfoLink.from_entity(
+			instance._client, instance._entity, EntrypointRelations.INFO)
+		instance.job_root_link = JobsRootLink.from_entity(
+			instance._client, instance._entity, EntrypointRelations.JOBS_ROOT)
+		instance.work_data_root_link = WorkDataRootLink.from_entity(
+			instance._client, instance._entity, EntrypointRelations.WORKDATA_ROOT)
+		instance.processing_step_root_link = ProcessingStepsRootLink.from_entity(
+			instance._client, instance._entity, EntrypointRelations.PROCESSINGSTEPS_ROOT)
+
+		instance.admin_link = LinkHco.from_entity_optional(
+			instance._client, instance._entity, EntrypointRelations.ADMIN)
+
+		return instance

pinexq_client/job_management/hcos/input_dataslot_hco.py

@@ -7,76 +7,78 @@ from pinexq_client.core.hco.action_hco import ActionHco
 from pinexq_client.core.hco.action_with_parameters_hco import ActionWithParametersHco
 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.upload_action_hco import UploadAction, UploadParameters
 from pinexq_client.job_management.hcos.workdata_hco import WorkDataLink, WorkDataHco
 from pinexq_client.job_management.known_relations import Relations
 from pinexq_client.job_management.model.open_api_generated import SelectWorkDataForDataSlotParameters, \
-    SelectWorkDataCollectionForDataSlotParameters
+	SelectWorkDataCollectionForDataSlotParameters
 from pinexq_client.job_management.model.sirenentities import InputDataSlotEntity, WorkDataEntity
 
 
 class InputDataSlotLink(LinkHco):
-    def navigate(self) -> 'InputDataSlotHco':
-        return InputDataSlotHco.from_entity(self._navigate_internal(InputDataSlotEntity), self._client)
+	def navigate(self) -> 'InputDataSlotHco':
+		return InputDataSlotHco.from_entity(self._navigate_internal(InputDataSlotEntity), self._client)
 
 
 class InputDataSlotSelectWorkDataAction(ActionWithParametersHco[SelectWorkDataForDataSlotParameters]):
-    def execute(self, parameters: SelectWorkDataForDataSlotParameters):
-        self._execute(parameters)
+	def execute(self, parameters: SelectWorkDataForDataSlotParameters):
+		self._execute(parameters)
 
 
-class InputDataSlotSelectWorkDataCollectionAction(ActionWithParametersHco[SelectWorkDataCollectionForDataSlotParameters]):
-    def execute(self, parameters: SelectWorkDataCollectionForDataSlotParameters):
-        self._execute(parameters)
+class InputDataSlotSelectWorkDataCollectionAction(
+	ActionWithParametersHco[SelectWorkDataCollectionForDataSlotParameters]):
+	def execute(self, parameters: SelectWorkDataCollectionForDataSlotParameters):
+		self._execute(parameters)
 
 
 class InputDataSlotUploadWorkDataAction(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)
+	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 InputDataSlotClearDataAction(ActionHco):
-    def execute(self):
-        self._execute_internal()
+	def execute(self):
+		self._execute_internal()
 
 
 class InputDataSlotHco(Hco[InputDataSlotEntity]):
-    is_configured: bool | None = Property()
-    title: str | None = Property()
-    description: str | None = Property()
-    media_type: str | None = Property()
-    selected_workdatas: list[WorkDataHco] | None
-
-    select_workdata_action: InputDataSlotSelectWorkDataAction | None
-    select_workdata_collection_action: InputDataSlotSelectWorkDataCollectionAction | None
-    clear_workdata_action: InputDataSlotClearDataAction | None
-
-    @classmethod
-    def from_entity(cls, entity: InputDataSlotEntity, client: httpx.Client) -> Self:
-        instance = cls(client, entity)
-        Hco.check_classes(instance._entity.class_, ["InputDataSlot"])
-
-        # actions
-        instance.select_workdata_action = InputDataSlotSelectWorkDataAction.from_entity_optional(
-            client, instance._entity, "SelectWorkData")
-        instance.select_workdata_collection_action = InputDataSlotSelectWorkDataCollectionAction.from_entity_optional(
-            client, instance._entity, "SelectWorkDataCollection")
-        instance.clear_workdata_action = InputDataSlotClearDataAction.from_entity_optional(
-            client, instance._entity, "Clear")
-
-        instance._extract_workdata()
-
-        return instance
-
-    def _extract_workdata(self):
-        self.selected_workdatas = []
-
-        workdatas: list[WorkDataEntity] = self._entity.find_all_entities_with_relation(Relations.SELECTED,
-                                                                                       WorkDataEntity)
-        if not workdatas:
-            return
-
-        self.selected_workdatas = [WorkDataHco.from_entity(workdata, self._client)
-                                   for workdata in workdatas]
+	is_configured: bool | None = Property()
+	title: str | None = Property()
+	description: str | None = Property()
+	media_type: str | None = Property()
+	selected_workdatas: list[WorkDataHco]
+
+	select_workdata_action: InputDataSlotSelectWorkDataAction | UnavailableAction
+	select_workdata_collection_action: InputDataSlotSelectWorkDataCollectionAction | UnavailableAction
+	clear_workdata_action: InputDataSlotClearDataAction | UnavailableAction
+
+	@classmethod
+	def from_entity(cls, entity: InputDataSlotEntity, client: httpx.Client) -> Self:
+		instance = cls(client, entity)
+		Hco.check_classes(instance._entity.class_, ["InputDataSlot"])
+
+		# actions
+		instance.select_workdata_action = InputDataSlotSelectWorkDataAction.from_entity_optional(
+			client, instance._entity, "SelectWorkData")
+		instance.select_workdata_collection_action = InputDataSlotSelectWorkDataCollectionAction.from_entity_optional(
+			client, instance._entity, "SelectWorkDataCollection")
+		instance.clear_workdata_action = InputDataSlotClearDataAction.from_entity_optional(
+			client, instance._entity, "Clear")
+
+		instance._extract_workdata()
+
+		return instance
+
+	def _extract_workdata(self):
+		self.selected_workdatas = []
+
+		workdatas: list[WorkDataEntity] = self._entity.find_all_entities_with_relation(Relations.SELECTED,
+																					   WorkDataEntity)
+		if not workdatas:
+			return
+
+		self.selected_workdatas = [WorkDataHco.from_entity(workdata, self._client)
+								   for workdata in workdatas]

pinexq_client/job_management/hcos/job_hco.py

@@ -8,175 +8,176 @@ from pinexq_client.core.hco.action_hco import ActionHco
 from pinexq_client.core.hco.action_with_parameters_hco import ActionWithParametersHco
 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.open_api_generated import JobStates, ProcessingView, RenameJobParameters, \
-    SelectProcessingParameters, SetJobTagsParameters
+	SelectProcessingParameters, SetJobTagsParameters
 from pinexq_client.job_management.model.sirenentities import JobEntity, InputDataSlotEntity, OutputDataSlotEntity
 
 
 class JobRenameAction(ActionWithParametersHco[RenameJobParameters]):
-    def execute(self, parameters: RenameJobParameters):
-        self._execute(parameters)
+	def execute(self, parameters: RenameJobParameters):
+		self._execute(parameters)
 
-    def default_parameters(self) -> RenameJobParameters:
-        return self._get_default_parameters(RenameJobParameters, RenameJobParameters())
+	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 execute(self, parameters: SelectProcessingParameters):
+		self._execute(parameters)
 
-    def default_parameters(self) -> SelectProcessingParameters:
-        return self._get_default_parameters(SelectProcessingParameters, SelectProcessingParameters())
+	def default_parameters(self) -> SelectProcessingParameters:
+		return self._get_default_parameters(SelectProcessingParameters, SelectProcessingParameters())
 
 
 class JobHideAction(ActionHco):
-    def execute(self):
-        self._execute_internal()
+	def execute(self):
+		self._execute_internal()
 
 
 class JobUnHideAction(ActionHco):
-    def execute(self):
-        self._execute_internal()
+	def execute(self):
+		self._execute_internal()
 
 
 class JobDeleteAction(ActionHco):
-    def execute(self):
-        self._execute_internal()
+	def execute(self):
+		self._execute_internal()
 
 
 class JobAllowOutputDataDeletionAction(ActionHco):
-    def execute(self):
-        self._execute_internal()
+	def execute(self):
+		self._execute_internal()
 
 
 class JobDisAllowOutputDataDeletionAction(ActionHco):
-    def execute(self):
-        self._execute_internal()
+	def execute(self):
+		self._execute_internal()
 
 
 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 JobConfigureProcessingAction(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 JobStartProcessingAction(ActionHco):
-    def execute(self):
-        self._execute_internal()
+	def execute(self):
+		self._execute_internal()
 
 
 class JobLink(LinkHco):
-    def navigate(self) -> 'JobHco':
-        return JobHco.from_entity(self._navigate_internal(JobEntity), self._client)
+	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)
+	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 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=[]))
+	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
-    delete_action: JobDeleteAction
-    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.delete_action = JobDeleteAction.from_entity_optional(
-            client, instance._entity, "Delete")
-        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)
+	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 | UnavailableLink
+	selected_processing_step_link: ProcessingStepLink | UnavailableLink
+
+	rename_action: JobRenameAction | UnavailableAction
+	select_processing_action: JobSelectProcessingAction | UnavailableAction
+	configure_processing_action: JobConfigureProcessingAction | UnavailableAction
+	start_processing_action: JobStartProcessingAction | UnavailableAction
+	hide_action: JobHideAction | UnavailableAction
+	unhide_action: JobUnHideAction | UnavailableAction
+	delete_action: JobDeleteAction | UnavailableAction
+	allow_output_data_deletion_action: JobAllowOutputDataDeletionAction | UnavailableAction
+	disallow_output_data_deletion_action: JobDisAllowOutputDataDeletionAction | UnavailableAction
+	edit_tags_action: JobEditTagsAction | UnavailableAction
+
+	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.delete_action = JobDeleteAction.from_entity_optional(
+			client, instance._entity, "Delete")
+		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)