pinexq-client 0.10.6rc1__py3-none-any.whl → 1.1.0__py3-none-any.whl

{pinexq_client → pinexq/client}/job_management/hcos/processing_step_hco.py

@@ -4,20 +4,28 @@ from typing import List, Self
 import httpx
 from pydantic import BaseModel, ConfigDict
 
-from pinexq_client.core import upload_json, Link, MediaTypes
-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.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 import CopyPsFromUserToOrgActionParameters, \
-    DeprecatePsActionParameters, AssignCodeHashParameters, SetProcessingStepTitleParameters
-from pinexq_client.job_management.model.open_api_generated import (DataSpecificationHto,
-                                                                   SetProcessingStepTagsParameters,
-                                                                   ConfigureDeploymentParameters, DeploymentStates, ProcessingStepDeploymentHto)
-from pinexq_client.job_management.model.sirenentities import ProcessingStepEntity
+from ...core import Link, MediaTypes, upload_json
+from ...core.hco.action_hco import ActionHco
+from ...core.hco.action_with_parameters_hco import ActionWithParametersHco
+from ...core.hco.download_link_hco import DownloadLinkHco
+from ...core.hco.hco_base import Hco, Property
+from ...core.hco.link_hco import LinkHco
+from ...core.hco.unavailable import UnavailableAction
+from ...core.hco.upload_action_hco import UploadAction, UploadParameters
+from ..known_relations import Relations
+from ..model import (
+    AssignCodeHashParameters,
+    CopyPsFromUserToOrgActionParameters,
+    DeprecatePsActionParameters,
+)
+from ..model.open_api_generated import (
+    ConfigureDeploymentParameters,
+    DataSpecificationHto,
+    DeploymentStates,
+    ProcessingStepDeploymentHto,
+    SetProcessingStepTagsParameters, SetProcessingStepTitleParameters, TagDetailsHto,
+)
+from ..model.sirenentities import ProcessingStepEntity
 
 
 class ProcessingStepLink(LinkHco):
@@ -173,6 +181,7 @@ class ProcessingStepHco(Hco[ProcessingStepEntity]):
     owner_id: str | None= Property()
 
     tags: list[str] | None = Property()
+    tag_details: List[TagDetailsHto] | None = Property()
     has_parameters: bool | None = Property()
     is_public: bool | None = Property()
     created_at: datetime | None = Property()

{pinexq_client → pinexq/client}/job_management/hcos/processing_step_used_tags_hco.py

@@ -2,11 +2,11 @@ from typing import List, 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.job_management.known_relations import Relations
-from pinexq_client.job_management.model import ProcessingStepUsedTagsEntityAdmin
-from pinexq_client.job_management.model.sirenentities import ProcessingStepUsedTagsEntity
+from ...core.hco.hco_base import Hco, Property
+from ...core.hco.link_hco import LinkHco
+from ..known_relations import Relations
+from ..model import ProcessingStepUsedTagsEntityAdmin
+from ..model.sirenentities import ProcessingStepUsedTagsEntity
 
 
 class ProcessingStepUsedTagsHco(Hco[ProcessingStepUsedTagsEntity]):

pinexq/client/job_management/hcos/processingstep_query_result_hco.py

@@ -0,0 +1,91 @@
+from typing import Iterator, List, Self
+
+import httpx
+
+from ...core.hco.hco_base import Hco, Property
+from ...core.hco.link_hco import LinkHco
+from ...core.hco.unavailable import UnavailableLink
+from ..hcos.processing_step_hco import ProcessingStepHco
+from ..known_relations import Relations
+from ..model.sirenentities import ProcessingStepEntity, ProcessingStepQueryResultEntity
+
+
+class ProcessingStepQueryResultPaginationLink(LinkHco):
+    def navigate(self) -> 'ProcessingStepQueryResultHco':
+        return ProcessingStepQueryResultHco.from_entity(self._navigate_internal(ProcessingStepQueryResultEntity),
+                                                        self._client)
+
+
+class ProcessingStepQueryResultLink(LinkHco):
+    def navigate(self) -> 'ProcessingStepQueryResultHco':
+        return ProcessingStepQueryResultHco.from_entity(self._navigate_internal(ProcessingStepQueryResultEntity),
+                                                        self._client)
+
+
+class ProcessingStepQueryResultHco(Hco[ProcessingStepQueryResultEntity]):
+    total_entities: int = Property()
+    current_entities_count: int = Property()
+    processing_steps: list[ProcessingStepHco]
+    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

{pinexq_client → pinexq/client}/job_management/hcos/processingsteproot_hco.py

@@ -3,23 +3,22 @@ from typing import Self
 import httpx
 from httpx import URL
 
-from pinexq_client.core import MediaTypes, Link, upload_json, ClientException, raise_exception_on_error
-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 UploadParameters, UploadAction
-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, \
-    ProcessingStepUsedTagsAdminLink
-from pinexq_client.job_management.hcos.processingstep_query_result_hco import (
+from ...core import Link, MediaTypes, upload_json, raise_exception_on_error, ClientException
+from ...core.hco.action_with_parameters_hco import ActionWithParametersHco
+from ...core.hco.hco_base import Hco
+from ...core.hco.link_hco import LinkHco
+from ...core.hco.unavailable import UnavailableAction, UnavailableLink
+from ..hcos.processing_step_hco import ProcessingStepHco, ProcessingStepLink
+from ..hcos.processing_step_used_tags_hco import ProcessingStepUsedTagsAdminLink, ProcessingStepUsedTagsLink
+from ..hcos.processingstep_query_result_hco import (
     ProcessingStepQueryResultHco,
     ProcessingStepQueryResultLink,
-    ProcessingStepQueryResultPaginationLink
+    ProcessingStepQueryResultPaginationLink,
 )
-from pinexq_client.job_management.known_relations import Relations
-from pinexq_client.job_management.model import ProcessingStepQueryParameters
-from pinexq_client.job_management.model.sirenentities import ProcessingStepsRootEntity
+from ..known_relations import Relations
+from ..model import ProcessingStepQueryParameters
+from ..model.sirenentities import ProcessingStepsRootEntity
+from ...core.hco.upload_action_hco import UploadAction, UploadParameters
 
 
 class ProcessingStepQueryAction(ActionWithParametersHco[ProcessingStepQueryParameters]):
@@ -35,7 +34,7 @@ class ProcessingStepQueryAction(ActionWithParametersHco[ProcessingStepQueryParam
 
 class ProcessingStepRegisterNewAction(UploadAction):
     def execute(self, parameters: UploadParameters) -> ProcessingStepLink:
-        url = upload_json(self._client, self._action, parameters.json_, parameters.filename) # todo handle errors
+        url = upload_json(self._client, self._action, parameters.json_, parameters.filename)
         raise_exception_on_error(f"Error while uploading", url)
 
         if not isinstance(url, URL):

{pinexq_client → pinexq/client}/job_management/hcos/user_hco.py

@@ -3,10 +3,10 @@ from uuid import UUID
 
 import httpx
 
-from pinexq_client.core.hco.hco_base import Hco, Property
-from pinexq_client.core.hco.link_hco import LinkHco
-from pinexq_client.job_management.known_relations import Relations
-from pinexq_client.job_management.model.sirenentities import UserEntity
+from ...core.hco.hco_base import Hco, Property
+from ...core.hco.link_hco import LinkHco
+from ..known_relations import Relations
+from ..model.sirenentities import UserEntity
 
 
 class UserLink(LinkHco):

{pinexq_client → pinexq/client}/job_management/hcos/workdata_hco.py

@@ -1,26 +1,26 @@
 from datetime import datetime
-from typing import Self
+from typing import Self, List
 
 import httpx
 
-from pinexq_client.core import Link, MediaTypes
-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.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, 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 import CopyWorkDataFromUserToOrgActionParameters
-from pinexq_client.job_management.model.open_api_generated import (
-    SetNameWorkDataParameters,
+from ...core import Link, MediaTypes
+from ...core.hco.action_hco import ActionHco
+from ...core.hco.action_with_parameters_hco import ActionWithParametersHco
+from ...core.hco.download_link_hco import DownloadLinkHco
+from ...core.hco.hco_base import Hco, Property
+from ...core.hco.link_hco import LinkHco
+from ...core.hco.unavailable import UnavailableAction, UnavailableLink
+from ..hcos.job_hco import JobLink
+from ..hcos.processing_step_hco import ProcessingStepLink
+from ..known_relations import Relations
+from ..model import CopyWorkDataFromUserToOrgActionParameters
+from ..model.open_api_generated import (
     SetCommentWorkDataParameters,
+    SetNameWorkDataParameters,
     SetTagsWorkDataParameters,
-    WorkDataKind
+    WorkDataKind, TagDetailsHto,
 )
-from pinexq_client.job_management.model.sirenentities import WorkDataEntity
+from ..model.sirenentities import WorkDataEntity
 
 
 class WorkDataLink(LinkHco):
@@ -100,6 +100,7 @@ class WorkDataHco(Hco[WorkDataEntity]):
     created_at: datetime | None = Property()
     size_in_bytes: int | None = Property()
     tags: list[str] | None = Property()
+    tag_details: List[TagDetailsHto] | None = Property()
     media_type: str | None = Property()
     kind: WorkDataKind | None = Property()
     comments: str | None = Property()

pinexq/client/job_management/hcos/workdata_query_result_hco.py

@@ -0,0 +1,91 @@
+from typing import Iterator, List, Self
+
+import httpx
+
+from ...core.hco.hco_base import Hco, Property
+from ...core.hco.link_hco import LinkHco
+from ...core.hco.unavailable import UnavailableLink
+from ..hcos.workdata_hco import WorkDataHco
+from ..known_relations import Relations
+from ..model.sirenentities import WorkDataEntity, WorkDataQueryResultEntity
+
+
+class WorkDataQueryResultPaginationLink(LinkHco):
+    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)
+
+
+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 | 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 → pinexq/client}/job_management/hcos/workdata_used_tags_query_result_hco.py

@@ -2,11 +2,11 @@ from typing import List, 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.job_management.known_relations import Relations
-from pinexq_client.job_management.model import WorkDataUsedTagsQueryResultEntityAdmin
-from pinexq_client.job_management.model.sirenentities import WorkDataUsedTagsQueryResultEntity
+from ...core.hco.hco_base import Hco, Property
+from ...core.hco.link_hco import LinkHco
+from ..known_relations import Relations
+from ..model import WorkDataUsedTagsQueryResultEntityAdmin
+from ..model.sirenentities import WorkDataUsedTagsQueryResultEntity
 
 
 class WorkDataUsedTagsQueryResultHto(Hco[WorkDataUsedTagsQueryResultEntity]):

{pinexq_client → pinexq/client}/job_management/hcos/workdataroot_hco.py

@@ -2,23 +2,25 @@ from typing import Self
 
 import httpx
 
-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_hco import WorkDataLink
-from pinexq_client.job_management.hcos.workdata_query_result_hco import (
+from ...core import Link, MediaTypes
+from ...core.hco.action_with_parameters_hco import ActionWithParametersHco
+from ...core.hco.hco_base import Hco
+from ...core.hco.link_hco import LinkHco
+from ...core.hco.unavailable import UnavailableAction, UnavailableLink
+from ...core.hco.upload_action_hco import UploadAction, UploadParameters
+from ..hcos.workdata_hco import WorkDataLink
+from ..hcos.workdata_query_result_hco import (
     WorkDataQueryResultHco,
     WorkDataQueryResultLink,
-    WorkDataQueryResultPaginationLink
+    WorkDataQueryResultPaginationLink,
 )
-from pinexq_client.job_management.hcos.workdata_used_tags_query_result_hco import WorkDataUsedTagsLink, \
-    WorkDataUsedTagsAdminLink
-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
+from ..hcos.workdata_used_tags_query_result_hco import (
+    WorkDataUsedTagsAdminLink,
+    WorkDataUsedTagsLink,
+)
+from ..known_relations import Relations
+from ..model import WorkDataQueryParameters, WorkDataUsedTagsFilterParameter
+from ..model.sirenentities import WorkDataRootEntity
 
 
 class WorkDataQueryAction(ActionWithParametersHco[WorkDataQueryParameters]):