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

pinexq_client/job_management/hcos/processingsteproot_hco.py

@@ -6,12 +6,13 @@ from pinexq_client.core import MediaTypes, Link
 from pinexq_client.core.hco.action_with_parameters_hco import ActionWithParametersHco
 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 UnavailableAction, UnavailableLink
 from pinexq_client.job_management.hcos.processing_step_hco import ProcessingStepLink, ProcessingStepHco
 from pinexq_client.job_management.hcos.processing_step_used_tags_hco import ProcessingStepUsedTagsLink
 from pinexq_client.job_management.hcos.processingstep_query_result_hco import (
-    ProcessingStepQueryResultHco,
-    ProcessingStepQueryResultLink,
-    ProcessingStepQueryResultPaginationLink
+	ProcessingStepQueryResultHco,
+	ProcessingStepQueryResultLink,
+	ProcessingStepQueryResultPaginationLink
 )
 from pinexq_client.job_management.known_relations import Relations
 from pinexq_client.job_management.model import ProcessingStepQueryParameters, CreateProcessingStepParameters
@@ -19,54 +20,54 @@ from pinexq_client.job_management.model.sirenentities import ProcessingStepsRoot
 
 
 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 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())
+	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 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())
+	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)
+	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
+	query_action: ProcessingStepQueryAction | UnavailableAction
+	register_new_action: ProcessingStepRegisterNewAction | UnavailableAction
+
+	self_link: ProcessingStepsRootLink
+	all_link: ProcessingStepQueryResultPaginationLink | UnavailableLink
+	used_tags_link: ProcessingStepUsedTagsLink | UnavailableLink
+
+	@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

pinexq_client/job_management/hcos/workdata_hco.py

@@ -8,120 +8,121 @@ 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.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 | 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
+	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

pinexq_client/job_management/hcos/workdata_query_result_hco.py

@@ -1,68 +1,91 @@
-from typing import Self, List
+from typing import Self, List, Iterator
 
 import httpx
 
-from pinexq_client.job_management.known_relations import Relations
 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 UnavailableLink
 from pinexq_client.job_management.hcos.workdata_hco import WorkDataHco
+from pinexq_client.job_management.known_relations import Relations
 from pinexq_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)
+	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)
+	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]
-    remaining_tags: List[str] | None = Property()
-
-    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)
+	workdata_query_action: WorkDataQueryResultEntity
+
+	total_entities: int = Property()
+	current_entities_count: int = Property()
+	workdatas: list[WorkDataHco]
+	remaining_tags: List[str] | None = Property()
+
+	self_link: WorkDataQueryResultLink
+	all_link: WorkDataQueryResultPaginationLink | UnavailableLink
+	first_link: WorkDataQueryResultPaginationLink | UnavailableLink
+	last_link: WorkDataQueryResultPaginationLink | UnavailableLink
+	next_link: WorkDataQueryResultPaginationLink | UnavailableLink
+	previous_link: WorkDataQueryResultPaginationLink | UnavailableLink
+
+	@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)
+
+	def iter(self) -> Iterator[Self]:
+		"""
+		Returns an Iterator of `WorkDataQueryResultHco` so that all pages can be processed in a loop.
+		Returns:
+			An iterator of `WorkDataQueryResultHco` objects
+		"""
+		result = self
+		while result is not None:
+			yield result
+			if isinstance(result.next_link, UnavailableLink):
+				return
+			result = result.next_link.navigate()
+
+	def iter_flat(self) -> Iterator[WorkDataHco]:
+		"""
+		Returns an Iterator of the `WorkDataHco` so that all WorkDatas can be processed in a loop.
+		Returns:
+			An iterator of `WorkDataHco` objects
+		"""
+		for page in self.iter():
+			yield from page.workdatas

pinexq_client/job_management/hcos/workdataroot_hco.py

@@ -6,79 +6,80 @@ from pinexq_client.core import MediaTypes, Link
 from pinexq_client.core.hco.action_with_parameters_hco import ActionWithParametersHco
 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 UnavailableAction, UnavailableLink
 from pinexq_client.core.hco.upload_action_hco import UploadAction, UploadParameters
-from pinexq_client.job_management.hcos.workdata_used_tags_query_result_hco import WorkDataUsedTagsLink
 from pinexq_client.job_management.hcos.workdata_hco import WorkDataLink
 from pinexq_client.job_management.hcos.workdata_query_result_hco import (
-    WorkDataQueryResultHco,
-    WorkDataQueryResultLink,
-    WorkDataQueryResultPaginationLink
+	WorkDataQueryResultHco,
+	WorkDataQueryResultLink,
+	WorkDataQueryResultPaginationLink
 )
+from pinexq_client.job_management.hcos.workdata_used_tags_query_result_hco import WorkDataUsedTagsLink
 from pinexq_client.job_management.known_relations import Relations
 from pinexq_client.job_management.model import WorkDataQueryParameters, WorkDataUsedTagsFilterParameter
 from pinexq_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 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())
+	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 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())
+	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)
+	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)
+	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
+	query_action: WorkDataQueryAction | UnavailableAction
+	query_tags_action: WorkDataUsedTagsQueryAction | UnavailableAction
+	upload_action: WorkDataUploadAction | None
+
+	self_link: WorkDataRootLink
+	all_link: WorkDataQueryResultPaginationLink | UnavailableLink
+	used_tags_link: WorkDataUsedTagsLink | UnavailableLink
+
+	@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

pinexq_client/job_management/model/open_api_generated.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  openapi.json
-#   timestamp: 2024-06-17T15:26:52+00:00
+#   timestamp: 2024-09-24T10:14:32+00:00
 
 from __future__ import annotations
 
@@ -58,6 +58,7 @@ class CreateProcessingStepParameters(BaseModel):
     )
     title: constr(min_length=1) = Field(..., alias='Title')
     function_name: constr(min_length=1) = Field(..., alias='FunctionName')
+    version: constr(min_length=1) = Field(..., alias='Version')
 
 
 class CreateSubJobParameters(BaseModel):
@@ -785,6 +786,7 @@ class WorkDataHtoOpenApiProperties(BaseModel):
     media_type: str | None = Field(None, alias='MediaType')
     kind: WorkDataKind | None = Field(None, alias='Kind')
     is_deletable: bool | None = Field(None, alias='IsDeletable')
+    is_used_as_job_input: bool | None = Field(None, alias='IsUsedAsJobInput')
     hidden: bool | None = Field(None, alias='Hidden')
     comments: str | None = Field(None, alias='Comments')