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/job_query_result_hco.py

@@ -1,64 +1,89 @@
-from typing import List
+from typing import List, Iterator, Self
 
 import httpx
 
 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.job_hco import JobHco
 from pinexq_client.job_management.known_relations import Relations
 from pinexq_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))
+	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))
+	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]
-    remaining_tags: List[str] | None = Property()
-
-    @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)
+	self_link: JobQueryResultLink
+	all_link: JobQueryResultPaginationLink | UnavailableLink
+	first_link: JobQueryResultPaginationLink | UnavailableLink
+	last_link: JobQueryResultPaginationLink | UnavailableLink
+	next_link: JobQueryResultPaginationLink | UnavailableLink
+	previous_link: JobQueryResultPaginationLink | UnavailableLink
+
+	total_entities: int = Property()
+	current_entities_count: int = Property()
+	jobs: List[JobHco]
+	remaining_tags: List[str] | None = Property()
+
+	@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)
+
+	def iter(self) -> Iterator[Self]:
+		"""
+		Returns an Iterator of `JobQueryResultHco` so that all pages can be processed in a loop.
+
+		Returns:
+			An iterator of `JobQueryResultHco` 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[JobHco]:
+		"""
+		Returns an Iterator of `JobHco` so that all jobs can be processed in a loop.
+
+		Returns:
+			An iterator of `JobHco` objects
+		"""
+		for page in self.iter():
+			yield from page.jobs

pinexq_client/job_management/hcos/jobsroot_hco.py

@@ -7,74 +7,76 @@ 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.job_hco import JobLink
 from pinexq_client.job_management.hcos.job_query_result_hco import (
-    JobQueryResultHco,
-    JobQueryResultLink
+	JobQueryResultHco,
+	JobQueryResultLink
 )
 from pinexq_client.job_management.hcos.job_used_tags_hco import JobUsedTagsLink
 from pinexq_client.job_management.known_relations import Relations
 from pinexq_client.job_management.model.open_api_generated import (
-    CreateJobParameters,
-    JobQueryParameters,
-    CreateSubJobParameters
+	CreateJobParameters,
+	JobQueryParameters,
+	CreateSubJobParameters
 )
 from pinexq_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 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())
+	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 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())
+	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 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())
+	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
+	create_job_action: CreateJobAction | UnavailableAction
+	job_query_action: JobQueryAction | UnavailableAction
+	create_subjob_action: CreateSubJobAction | UnavailableAction
+	used_tags_link: JobUsedTagsLink | UnavailableLink
 
-    self_link: 'JobsRootLink'
+	self_link: 'JobsRootLink'
 
-    @classmethod
-    def from_entity(cls, entity: JobsRootEntity, client: httpx.Client) -> Self:
-        instance = cls(client, entity)
+	@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
+		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)
+	def navigate(self) -> JobsRootHco:
+		return JobsRootHco.from_entity(self._navigate_internal(JobsRootEntity), self._client)

pinexq_client/job_management/hcos/output_dataslot_hco.py

@@ -21,7 +21,7 @@ class OutputDataSlotHco(Hco[OutputDataSlotEntity]):
     title: str | None = Property()
     description: str | None = Property()
     media_type: str | None = Property()
-    assigned_workdata: WorkDataHco | None
+    assigned_workdatas: list[WorkDataHco]
 
     @classmethod
     def from_entity(cls, entity: OutputDataSlotEntity, client: httpx.Client) -> Self:

pinexq_client/job_management/hcos/processing_step_hco.py

@@ -10,105 +10,106 @@ 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.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
 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 | None
-    edit_properties_action: ProcessingStepEditPropertiesAction | None
-    configure_default_parameters_action: ConfigureDefaultParametersAction | None
-    clear_default_parameters_action: ClearDefaultParametersAction | None
-    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/processingstep_query_result_hco.py

@@ -1,69 +1,94 @@
-from typing import Self, List
+from typing import Self, List, Iterator
 
 import httpx
 
 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.processing_step_hco import ProcessingStepHco
 from pinexq_client.job_management.known_relations import Relations
 from pinexq_client.job_management.model.sirenentities import (
-    ProcessingStepQueryResultEntity,
-    ProcessingStepEntity
+	ProcessingStepQueryResultEntity,
+	ProcessingStepEntity
 )
 
 
 class ProcessingStepQueryResultPaginationLink(LinkHco):
-    def navigate(self) -> 'ProcessingStepQueryResultHco':
-        return ProcessingStepQueryResultHco.from_entity(self._navigate_internal(ProcessingStepQueryResultEntity),
-                                                        self._client)
+	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)
+	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]
-    remaining_tags: List[str] | None = Property()
-
-    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)
+	total_entities: int = Property()
+	current_entities_count: int = Property()
+	processing_steps: list[ProcessingStepHco]
+	remaining_tags: List[str] | None = Property()
+
+	self_link: ProcessingStepQueryResultLink
+	all_link: ProcessingStepQueryResultPaginationLink | UnavailableLink
+	first_link: ProcessingStepQueryResultPaginationLink | UnavailableLink
+	last_link: ProcessingStepQueryResultPaginationLink | UnavailableLink
+	next_link: ProcessingStepQueryResultPaginationLink | UnavailableLink
+	previous_link: ProcessingStepQueryResultPaginationLink | UnavailableLink
+
+	@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)
+
+	def iter(self) -> Iterator[Self]:
+		"""
+		Returns an Iterator of `ProcessingStepQueryResultHco` objects so that all pages can be processed in a loop.
+
+		Returns:
+			An iterator of `ProcessingStepQueryResultHco` 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[ProcessingStepHco]:
+		"""
+		Returns an Iterator of `ProcessingStepHco` objects so that all processing steps can be processed in a loop.
+
+		Returns:
+			An iterator of `ProcessingStepHco` objects
+		"""
+		for page in self.iter():
+			yield from page.processing_steps