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

pinexq_client/job_management/__init__.py

@@ -1,6 +1,6 @@
 # ruff: noqa: F401
 from .enterjma import enter_jma
-from .tool import Job
+from .tool import Job, ProcessingStep, WorkData
 
 # Protocol version the JMA is using
-__jma_version__ = [6, 0, 0]
+__jma_version__ = [6, 2, 0]

pinexq_client/job_management/enterjma.py

@@ -35,7 +35,7 @@ def enter_jma(
     jma_version = [int(i) for i in str.split(info.api_version, '.')]
     if not _version_match_major_minor(jma_version, client_version):
         LOG.warning(
-            f"Version mismatch between 'hypermedia_client' (v{'.'.join(map(str ,client_version))}) "
+            f"Version mismatch between 'pinexq_client' (v{'.'.join(map(str ,client_version))}) "
             f"and 'JobManagementAPI' (v{'.'.join(map(str, jma_version))})! "
         )
 

pinexq_client/job_management/hcos/input_dataslot_hco.py

@@ -78,5 +78,5 @@ class InputDataSlotHco(Hco[InputDataSlotEntity]):
         if not workdatas:
             return
 
-        self.selected_workdatas = list[WorkDataHco](
-            WorkDataHco.from_entity(workdata, self._client) for workdata in workdatas)
+        self.selected_workdatas = [WorkDataHco.from_entity(workdata, self._client)
+                                   for workdata in workdatas]

pinexq_client/job_management/hcos/job_hco.py

@@ -43,6 +43,11 @@ class JobUnHideAction(ActionHco):
         self._execute_internal()
 
 
+class JobDeleteAction(ActionHco):
+    def execute(self):
+        self._execute_internal()
+
+
 class JobAllowOutputDataDeletionAction(ActionHco):
     def execute(self):
         self._execute_internal()
@@ -113,6 +118,7 @@ class JobHco(Hco[JobEntity]):
     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
@@ -138,6 +144,8 @@ class JobHco(Hco[JobEntity]):
             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(

pinexq_client/job_management/hcos/job_query_result_hco.py

@@ -30,6 +30,7 @@ class JobQueryResultHco(Hco[JobQueryResultEntity]):
     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':

pinexq_client/job_management/hcos/output_dataslot_hco.py

@@ -40,5 +40,5 @@ class OutputDataSlotHco(Hco[OutputDataSlotEntity]):
         if not workdatas:
             return
 
-        self.assigned_workdatas = list[WorkDataHco](
-            WorkDataHco.from_entity(workdata, self._client) for workdata in workdatas)
+        self.assigned_workdatas = [WorkDataHco.from_entity(workdata, self._client)
+                                   for workdata in workdatas]

pinexq_client/job_management/hcos/processing_step_hco.py

@@ -2,12 +2,17 @@ from datetime import datetime
 from typing import List, Self
 
 import httpx
+from pydantic import BaseModel, ConfigDict
 
+from pinexq_client.core import upload_json
+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.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
 from pinexq_client.job_management.model.sirenentities import ProcessingStepEntity
@@ -27,6 +32,38 @@ class ProcessingStepEditTagsAction(ActionWithParametersHco[SetProcessingStepTags
         return self._get_default_parameters(SetProcessingStepTagsParameters, SetProcessingStepTagsParameters(tags=[]))
 
 
+class ProcessingStepEditPropertiesAction(ActionWithParametersHco[EditProcessingStepParameters]):
+    def execute(self, parameters: EditProcessingStepParameters):
+        self._execute(parameters)
+
+    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')
+
+
+class ConfigureDefaultParametersAction(ActionWithParametersHco[GenericProcessingConfigureParameters]):
+    def execute(self, parameters: GenericProcessingConfigureParameters):
+        self._execute(parameters)
+
+    def default_parameters(self) -> GenericProcessingConfigureParameters:
+        return self._get_default_parameters(GenericProcessingConfigureParameters,
+                                            GenericProcessingConfigureParameters())
+
+
+class ClearDefaultParametersAction(ActionHco):
+    def execute(self):
+        self._execute_internal()
+
+
+class UploadConfigurationAction(UploadAction):
+    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()
@@ -46,6 +83,10 @@ class ProcessingStepHco(Hco[ProcessingStepEntity]):
     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
@@ -60,12 +101,14 @@ class ProcessingStepHco(Hco[ProcessingStepEntity]):
 
         # todo tests
 
-        # actions
-        # todo
-        #   "EditProperties"
-        #   "Upload"
-        #   "ConfigureDefaultParameters"
-        #   "ClearDefaultParameters"
         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,4 +1,4 @@
-from typing import Self
+from typing import Self, List
 
 import httpx
 
@@ -28,6 +28,7 @@ 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

pinexq_client/job_management/hcos/workdata_query_result_hco.py

@@ -1,4 +1,4 @@
-from typing import Self
+from typing import Self, List
 
 import httpx
 
@@ -25,6 +25,7 @@ class WorkDataQueryResultHco(Hco[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

pinexq_client/job_management/model/open_api_generated.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  openapi.json
-#   timestamp: 2024-05-29T12:02:26+00:00
+#   timestamp: 2024-06-17T15:26:52+00:00
 
 from __future__ import annotations
 
@@ -18,20 +18,7 @@ class AdminJobQueryResultHtoOpenApiProperties(BaseModel):
     total_entities: int | None = Field(None, alias='TotalEntities')
     current_entities_count: int | None = Field(None, alias='CurrentEntitiesCount')
     previous_entities_count: int | None = Field(None, alias='PreviousEntitiesCount')
-
-
-class AdminProcessingStepFilterParameter(BaseModel):
-    model_config = ConfigDict(
-        extra='allow',
-        populate_by_name=True,
-    )
-    function_name_contains: str | None = Field(None, alias='FunctionNameContains')
-    title_contains: str | None = Field(None, alias='TitleContains')
-    version: str | None = Field(None, alias='Version')
-    description_contains: str | None = Field(None, alias='DescriptionContains')
-    tags_by_and: List[str] | None = Field(None, alias='TagsByAnd')
-    tags_by_or: List[str] | None = Field(None, alias='TagsByOr')
-    is_public: bool | None = Field(None, alias='IsPublic')
+    remaining_tags: List[str] | None = Field(None, alias='RemainingTags')
 
 
 class AdminProcessingStepQueryResultHtoOpenApiProperties(BaseModel):
@@ -42,6 +29,7 @@ class AdminProcessingStepQueryResultHtoOpenApiProperties(BaseModel):
     total_entities: int | None = Field(None, alias='TotalEntities')
     current_entities_count: int | None = Field(None, alias='CurrentEntitiesCount')
     previous_entities_count: int | None = Field(None, alias='PreviousEntitiesCount')
+    remaining_tags: List[str] | None = Field(None, alias='RemainingTags')
 
 
 class AdminWorkDataQueryResultHtoOpenApiProperties(BaseModel):
@@ -52,6 +40,7 @@ class AdminWorkDataQueryResultHtoOpenApiProperties(BaseModel):
     total_entities: int | None = Field(None, alias='TotalEntities')
     current_entities_count: int | None = Field(None, alias='CurrentEntitiesCount')
     previous_entities_count: int | None = Field(None, alias='PreviousEntitiesCount')
+    remaining_tags: List[str] | None = Field(None, alias='RemainingTags')
 
 
 class CreateJobParameters(BaseModel):
@@ -131,6 +120,11 @@ class FieldModel(BaseModel):
     allow_multiple: bool | None = Field(None, alias='allowMultiple')
 
 
+class FunctionNameMatchTypes(Enum):
+    contains = 'Contains'
+    match_exact = 'MatchExact'
+
+
 class InfoHtoOpenApiProperties(BaseModel):
     model_config = ConfigDict(
         extra='allow',
@@ -149,6 +143,7 @@ class JobQueryResultHtoOpenApiProperties(BaseModel):
     total_entities: int | None = Field(None, alias='TotalEntities')
     current_entities_count: int | None = Field(None, alias='CurrentEntitiesCount')
     previous_entities_count: int | None = Field(None, alias='PreviousEntitiesCount')
+    remaining_tags: List[str] | None = Field(None, alias='RemainingTags')
 
 
 class JobSortProperties(Enum):
@@ -223,7 +218,10 @@ class ProcessingStepFilterParameter(BaseModel):
         extra='allow',
         populate_by_name=True,
     )
-    function_name_contains: str | None = Field(None, alias='FunctionNameContains')
+    function_name: str | None = Field(None, alias='FunctionName')
+    function_name_match_type: FunctionNameMatchTypes | None = Field(
+        None, alias='FunctionNameMatchType'
+    )
     title_contains: str | None = Field(None, alias='TitleContains')
     version: str | None = Field(None, alias='Version')
     description_contains: str | None = Field(None, alias='DescriptionContains')
@@ -278,6 +276,7 @@ class ProcessingStepQueryResultHtoOpenApiProperties(BaseModel):
     total_entities: int | None = Field(None, alias='TotalEntities')
     current_entities_count: int | None = Field(None, alias='CurrentEntitiesCount')
     previous_entities_count: int | None = Field(None, alias='PreviousEntitiesCount')
+    remaining_tags: List[str] | None = Field(None, alias='RemainingTags')
 
 
 class ProcessingStepRootHtoOpenApiProperties(BaseModel):
@@ -418,6 +417,7 @@ class WorkDataQueryResultHtoOpenApiProperties(BaseModel):
     total_entities: int | None = Field(None, alias='TotalEntities')
     current_entities_count: int | None = Field(None, alias='CurrentEntitiesCount')
     previous_entities_count: int | None = Field(None, alias='PreviousEntitiesCount')
+    remaining_tags: List[str] | None = Field(None, alias='RemainingTags')
 
 
 class WorkDataRootHtoOpenApiProperties(BaseModel):
@@ -504,6 +504,23 @@ class AdminJobQueryResultHtoOpenApi(BaseModel):
     links: List[Link] | None = None
 
 
+class AdminProcessingStepFilterParameter(BaseModel):
+    model_config = ConfigDict(
+        extra='allow',
+        populate_by_name=True,
+    )
+    function_name: str | None = Field(None, alias='FunctionName')
+    function_name_match_type: FunctionNameMatchTypes | None = Field(
+        None, alias='FunctionNameMatchType'
+    )
+    title_contains: str | None = Field(None, alias='TitleContains')
+    version: str | None = Field(None, alias='Version')
+    description_contains: str | None = Field(None, alias='DescriptionContains')
+    tags_by_and: List[str] | None = Field(None, alias='TagsByAnd')
+    tags_by_or: List[str] | None = Field(None, alias='TagsByOr')
+    is_public: bool | None = Field(None, alias='IsPublic')
+
+
 class AdminProcessingStepQueryResultHtoOpenApi(BaseModel):
     model_config = ConfigDict(
         extra='allow',
@@ -542,6 +559,7 @@ class AdminWorkDataQueryParameters(BaseModel):
     pagination: Pagination | None = Field(None, alias='Pagination')
     sort_by: WorkDataSortPropertiesSortParameter | None = Field(None, alias='SortBy')
     filter: AdminWorkDataFilterParameter | None = Field(None, alias='Filter')
+    include_remaining_tags: bool | None = Field(None, alias='IncludeRemainingTags')
 
 
 class AdminWorkDataQueryResultHtoOpenApi(BaseModel):
@@ -779,6 +797,7 @@ class WorkDataQueryParameters(BaseModel):
     pagination: Pagination | None = Field(None, alias='Pagination')
     sort_by: WorkDataSortPropertiesSortParameter | None = Field(None, alias='SortBy')
     filter: WorkDataFilterParameter | None = Field(None, alias='Filter')
+    include_remaining_tags: bool | None = Field(None, alias='IncludeRemainingTags')
 
 
 class WorkDataQueryResultHtoOpenApi(BaseModel):
@@ -828,6 +847,7 @@ class AdminJobQueryParameters(BaseModel):
     pagination: Pagination | None = Field(None, alias='Pagination')
     sort_by: JobSortPropertiesSortParameter | None = Field(None, alias='SortBy')
     filter: AdminJobFilterParameter | None = Field(None, alias='Filter')
+    include_remaining_tags: bool | None = Field(None, alias='IncludeRemainingTags')
 
 
 class AdminProcessingStepQueryParameters(BaseModel):
@@ -840,6 +860,7 @@ class AdminProcessingStepQueryParameters(BaseModel):
         None, alias='SortBy'
     )
     filter: AdminProcessingStepFilterParameter | None = Field(None, alias='Filter')
+    include_remaining_tags: bool | None = Field(None, alias='IncludeRemainingTags')
 
 
 class JobHtoOpenApi(BaseModel):
@@ -863,6 +884,7 @@ class JobQueryParameters(BaseModel):
     pagination: Pagination | None = Field(None, alias='Pagination')
     sort_by: JobSortPropertiesSortParameter | None = Field(None, alias='SortBy')
     filter: JobFilterParameter | None = Field(None, alias='Filter')
+    include_remaining_tags: bool | None = Field(None, alias='IncludeRemainingTags')
 
 
 class ProcessingStepQueryParameters(BaseModel):
@@ -875,6 +897,7 @@ class ProcessingStepQueryParameters(BaseModel):
         None, alias='SortBy'
     )
     filter: ProcessingStepFilterParameter | None = Field(None, alias='Filter')
+    include_remaining_tags: bool | None = Field(None, alias='IncludeRemainingTags')
 
 
 class WorkDataHtoOpenApi(BaseModel):

pinexq_client/job_management/tool/__init__.py

@@ -1 +1,3 @@
 from .job import Job
+from .processing_step import ProcessingStep
+from .workdata import WorkData

pinexq_client/job_management/tool/job.py

@@ -7,11 +7,11 @@ from httpx import URL
 from pinexq_client.core import Link, MediaTypes
 from pinexq_client.core.polling import wait_until, PollingException
 from pinexq_client.job_management.enterjma import enter_jma
-from pinexq_client.job_management.hcos import WorkDataLink
+from pinexq_client.job_management.hcos import WorkDataLink, ProcessingStepLink, InputDataSlotHco, OutputDataSlotHco
 from pinexq_client.job_management.hcos.entrypoint_hco import EntryPointHco
 from pinexq_client.job_management.hcos.job_hco import (
-    JobHco,
     GenericProcessingConfigureParameters,
+    JobHco,
     JobLink,
 )
 from pinexq_client.job_management.hcos.job_query_result_hco import JobQueryResultHco
@@ -22,16 +22,22 @@ from pinexq_client.job_management.hcos.processingsteproot_hco import (
 from pinexq_client.job_management.known_relations import Relations
 from pinexq_client.job_management.model import (
     CreateJobParameters,
-    ProcessingStepQueryParameters,
-    ProcessingStepFilterParameter,
-    SelectProcessingParameters,
-    JobStates,
     CreateSubJobParameters,
+    FunctionNameMatchTypes,
+    JobFilterParameter,
     JobQueryParameters,
     JobSortPropertiesSortParameter,
-    JobFilterParameter,
-    SelectWorkDataForDataSlotParameters, SetJobTagsParameters, SelectWorkDataCollectionForDataSlotParameters,
+    JobStates,
+    ProcessingStepFilterParameter,
+    ProcessingStepQueryParameters,
+    ProcessingView,
+    SelectProcessingParameters,
+    SelectWorkDataCollectionForDataSlotParameters,
+    SelectWorkDataForDataSlotParameters,
+    SetJobTagsParameters,
 )
+from pinexq_client.job_management.tool.processing_step import ProcessingStep
+from pinexq_client.job_management.tool.workdata import WorkData
 
 
 class Job:
@@ -88,6 +94,21 @@ class Job:
     def _get_by_link(self, job_link: JobLink):
         self._job = job_link.navigate()
 
+    @classmethod
+    def from_hco(cls, client: httpx.Client, job: JobHco) -> Self:
+        """Initializes a `Job` object from an existing JobHco object.
+
+        Args:
+            client: An httpx.Client instance initialized with the api-host-url as `base_url`
+            job: The 'JobHco' to initialize this job from.
+
+        Returns:
+            The newly created job as `Job` object.
+        """
+        job_instance = cls(client)
+        job_instance._job = job
+        return job_instance
+
     @classmethod
     def from_url(cls, client: httpx.Client, job_url: URL) -> Self:
         """Initializes a `Job` object from an existing job given by its link as URL.
@@ -144,31 +165,43 @@ class Job:
         self.refresh()
         return self._job.state
 
-    def select_processing(self, processing_step: str) -> Self:
+    def select_processing(
+            self,
+            function_name: str | None = None,
+            processing_step_link: ProcessingStepLink | None = None,
+            processing_step_instance: ProcessingStep | None = None
+    ) -> Self:
         """Set the processing step for this job given by name. This will query all
         processing steps of this name from the server and select the first result.
 
         Args:
-            processing_step: Name of the processing step as string
+            function_name: Name of the processing step as string
+            processing_step_link: A ProcessingStepLink instance pointing to the resource
+            processing_step_instance: A ProcessingStep (not the Hco) instance
 
         Returns:
             This `Job` object
         """
-        # ToDo: provide more parameters to query a processing step
-        query_param = ProcessingStepQueryParameters(
-            filter=ProcessingStepFilterParameter(
-                function_name_contains=processing_step,
+        if sum(p is not None for p in [function_name, processing_step_link, processing_step_instance]) != 1:
+            raise ValueError("Exactly one parameter must be provided")
+
+        if processing_step_link is not None:
+            processing_url = processing_step_link.get_url()
+        elif processing_step_instance is not None:
+            processing_url = processing_step_instance.self_link().get_url()
+        else:
+            # ToDo: provide more parameters to query a processing step
+            query_param = ProcessingStepQueryParameters(
+                filter=ProcessingStepFilterParameter(
+                    function_name=function_name,
+                    function_name_match_type=FunctionNameMatchTypes.match_exact
+                )
             )
-        )
-        query_result = self._processing_step_root.query_action.execute(query_param)
-        candidates = [p for p in query_result.processing_steps if p.function_name == processing_step]
-        if len(candidates) == 0:
-            raise AttributeError(f"No processing step with the name '{processing_step}' registered!")
-        if len(candidates) > 1:
-            raise AttributeError(f"Multiple results querying processing step '{processing_step}'!")
-        assert len(candidates) == 1
-        # Todo: For now we choose the first and only result. Make this more flexible?
-        processing_url = candidates[0].self_link.get_url()
+            query_result = self._processing_step_root.query_action.execute(query_param)
+            if len(query_result.processing_steps) != 1:
+                raise AttributeError(f"No processing step with the name '{function_name}' registered!")
+            # Todo: For now we choose the first and only result. Make this more flexible?
+            processing_url = query_result.processing_steps[0].self_link.get_url()
 
         self._job.select_processing_action.execute(
             SelectProcessingParameters(processing_step_url=str(processing_url))
@@ -251,40 +284,68 @@ class Job:
 
         return self
 
-    def assign_input_dataslot(self, index: int, workdata_link: WorkDataLink) -> Self:
+    def assign_input_dataslot(
+            self,
+            index: int,
+            work_data_link: WorkDataLink | None = None,
+            work_data_instance: WorkData | None = None
+    ) -> Self:
         """Assign WorkData to DataSlots.
 
         Args:
             index: The numerical index of the dataslot.
-            workdata_link:  WorkData given by its URL
+            work_data_link:  WorkData given by its URL
+            work_data_instance: WorkData instance
 
         Returns:
             This `Job` object
         """
+        if sum(p is not None for p in [work_data_link, work_data_instance]) != 1:
+            raise ValueError("Exactly one parameter must be provided")
+
+        if work_data_instance is not None:
+            work_data = work_data_instance.self_link()
+        else:
+            work_data = work_data_link
+
         dataslot = self._job.input_dataslots[index]
         dataslot.select_workdata_action.execute(
             parameters=SelectWorkDataForDataSlotParameters(
-                work_data_url=str(workdata_link.get_url())
+                work_data_url=str(work_data.get_url())
             )
         )
         self.refresh()
 
         return self
 
-    def assign_collection_input_dataslot(self, index: int, workdata_links: list[WorkDataLink]) -> Self:
+    def assign_collection_input_dataslot(
+            self,
+            index: int,
+            work_data_links: list[WorkDataLink] | None = None,
+            work_data_instances: list[WorkData] | None = None
+    ) -> Self:
         """Assign WorkData to DataSlots.
 
         Args:
             index: The numerical index of the dataslot.
-            workdata_links:  WorkData collection given by their URLs
+            work_data_links:  WorkData collection given by their URLs
+            work_data_instances: Collection of WorkData instances
 
         Returns:
             This `Job` object
         """
+        if sum(p is not None for p in [work_data_links, work_data_instances]) != 1:
+            raise ValueError("Exactly one parameter must be provided")
+
+        if work_data_instances is not None:
+            work_datas = [work_data_instance.self_link() for work_data_instance in work_data_instances]
+        else:
+            work_datas = work_data_links
+
         dataslot = self._job.input_dataslots[index]
         dataslot.select_workdata_collection_action.execute(
             parameters=SelectWorkDataCollectionForDataSlotParameters(
-                work_data_urls=list[str](str(workdata_link.get_url()) for workdata_link in workdata_links)
+                work_data_urls=[str(workdata_link.get_url()) for workdata_link in work_datas]
             )
         )
         self.refresh()
@@ -351,7 +412,7 @@ class Job:
         """Wait for all sub-jobs to reach the state 'completed'.
 
         This function will block execution until the state is reached or raise an exception
-        if the operation timed out or a sub-job returned an error.
+        if the operation timed out or a sub-job returned an error. Only started jobs will be watched.
 
         Args:
             timeout_ms: Timeout to wait for the sub-jobs to reach the next state.
@@ -369,13 +430,10 @@ class Job:
             timeout_ms=timeout_ms,
             timeout_message=f"Timeout while waiting for sub-jobs to complete! [timeout: {timeout_ms}ms]",
         )
-        wait_until(
-            condition=lambda: self.sub_jobs_in_state(JobStates.completed) >= 0,
-            error_condition=lambda: self.sub_jobs_in_state(JobStates.error) >= 0,
-            error_condition_message="One or more sub-jobs returned an error!",
-            timeout_ms=timeout_ms,
-            timeout_message=f"Timeout while waiting for sub-jobs to complete! [timeout: {timeout_ms}ms]",
-        )
+
+        error_count = self.sub_jobs_in_state(JobStates.error)
+        if error_count > 0:
+            raise PollingException(f"{f':Sub-jobs returned an error! {error_count} sub-jobs in state error .'}")
         return self
 
     def hide(self) -> Self:
@@ -388,55 +446,75 @@ class Job:
         self.refresh()
         return self
 
-    def unhide(self):
+    def delete(self) -> Self:
+        """Delete this job.
+
+        Returns:
+            This `Job` object
+        """
+        self._job.delete_action.execute()
+        return self
+
+    def unhide(self) -> Self:
         """Reveal this job again.
 
         Returns:
-            This `Job` object"""
+            This `Job` object
+        """
         self._job.unhide_action.execute()
         self.refresh()
         return self
 
-    def allow_output_data_deletion(self):
+    def allow_output_data_deletion(self) -> Self:
         """Mark all output workdata from this job as "deletable".
 
         Returns:
-            This `Job` object"""
+            This `Job` object
+        """
         self._job.allow_output_data_deletion_action.execute()
         self.refresh()
         return self
 
-    def disallow_output_data_deletion(self):
+    def disallow_output_data_deletion(self) -> Self:
         """Mark all output workdata from this job as "not deletable".
 
         Returns:
-            This `Job` object"""
+            This `Job` object
+        """
         self._job.disallow_output_data_deletion_action.execute()
         self.refresh()
         return self
 
-    def set_tags(self, tags: list[str]):
+    def set_tags(self, tags: list[str]) -> Self:
         """Set tags to the job.
 
         Returns:
-            This `Job` object"""
-        self._job.edit_tags_action.execute(SetJobTagsParameters(
-            tags=tags
-        ))
+            This `Job` object
+        """
+        self._job.edit_tags_action.execute(
+            SetJobTagsParameters(tags=tags)
+        )
         self.refresh()
         return self
 
-
-    def get_input_data_slots(self):
+    def get_input_data_slots(self) -> list[InputDataSlotHco]:
         """Returns list of InputDataSlotHco objects.
 
         Returns:
-            `list[InputDataSlotHco]` object"""
+            `list[InputDataSlotHco]` object
+        """
         return self._job.input_dataslots
 
-    def get_output_data_slots(self):
+    def get_output_data_slots(self) -> list[OutputDataSlotHco]:
         """Returns list of OutputDataSlotHco objects.
 
         Returns:
-            `list[OutputDataSlotHco]` object"""
+            `list[OutputDataSlotHco]` object
+        """
         return self._job.output_dataslots
+
+    def get_processing_info(self) -> ProcessingView:
+        return self._job.processing
+
+    def self_link(self) -> JobLink:
+        return self._job.self_link

pinexq_client/job_management/tool/processing_step.py

@@ -0,0 +1,182 @@
+from typing import Any, Self
+
+import httpx
+from httpx import URL
+
+from pinexq_client.core import Link, MediaTypes
+from pinexq_client.core.hco.upload_action_hco import UploadParameters
+from pinexq_client.job_management.enterjma import enter_jma
+from pinexq_client.job_management.hcos import ProcessingStepHco, ProcessingStepLink
+from pinexq_client.job_management.hcos.entrypoint_hco import EntryPointHco
+from pinexq_client.job_management.hcos.job_hco import GenericProcessingConfigureParameters
+from pinexq_client.job_management.hcos.processingsteproot_hco import ProcessingStepsRootHco
+from pinexq_client.job_management.known_relations import Relations
+from pinexq_client.job_management.model import (
+    CreateProcessingStepParameters,
+    EditProcessingStepParameters,
+    SetProcessingStepTagsParameters,
+)
+
+
+class ProcessingStep:
+    """Convenience wrapper for handling ProcessingStepHcos in the JobManagement-Api.
+    """
+
+    _client: httpx.Client
+    _entrypoint: EntryPointHco
+    _processing_steps_root: ProcessingStepsRootHco
+    _processing_step: ProcessingStepHco | None = None
+
+    def __init__(self, client: httpx.Client):
+        """
+
+        Args:
+            client: An httpx.Client instance initialized with the api-host-url as `base_url`
+        """
+        self._client = client
+        self._entrypoint = enter_jma(client)
+        self._processing_steps_root = self._entrypoint.processing_step_root_link.navigate()
+
+    def create(self, title: str, function_name: str) -> Self:
+        """
+        Creates a new ProcessingStep by name.
+
+        Args:
+            title: Title of the ProcessingStep to be created
+            function_name: Function name of the ProcessingStep to be created
+
+        Returns:
+            The newly created ProcessingStep as `ProcessingStep` object
+        """
+        processing_step_hco = self._processing_steps_root.register_new_action.execute(CreateProcessingStepParameters(
+            title=title,
+            function_name=function_name
+        ))
+        self._processing_step = processing_step_hco
+        return self
+
+    def _get_by_link(self, processing_step_link: ProcessingStepLink):
+        self._processing_step = processing_step_link.navigate()
+
+    @classmethod
+    def from_hco(cls, client: httpx.Client, processing_step: ProcessingStepHco) -> Self:
+        """Initializes a `ProcessingStep` object from an existing ProcessingStepHco object.
+
+        Args:
+            client: An httpx.Client instance initialized with the api-host-url as `base_url`
+            processing_step: The 'ProcessingStepHco' to initialize this ProcessingStep from.
+
+        Returns:
+            The newly created processing step as `ProcessingStep` object.
+        """
+        processing_step_instance = cls(client)
+        processing_step_instance._processing_step = processing_step
+        return processing_step_instance
+
+    @classmethod
+    def from_url(cls, client: httpx.Client, processing_step_url: URL) -> Self:
+        """Initializes a `ProcessingStep` object from an existing processing step given by its link as URL.
+
+        Args:
+            client: An httpx.Client instance initialized with the api-host-url as `base_url`
+            processing_step_url: The URL of the processing step
+
+        Returns:
+            The newly created processing step as `ProcessingStep` object
+        """
+        link = Link.from_url(
+            processing_step_url,
+            [str(Relations.CREATED_RESSOURCE)],
+            "Created processing step",
+            MediaTypes.SIREN,
+        )
+        processing_step_instance = cls(client)
+        processing_step_instance._get_by_link(ProcessingStepLink.from_link(client, link))
+        return processing_step_instance
+
+    def refresh(self) -> Self:
+        """Updates the processing step from the server
+
+        Returns:
+            This `ProcessingStep` object, but with updated properties.
+        """
+        self._processing_step = self._processing_step.self_link.navigate()
+        return self
+
+    def set_tags(self, tags: list[str]) -> Self:
+        """Set tags to the processing step.
+
+        Returns:
+            This `ProcessingStep` object"""
+        self._processing_step.edit_tags_action.execute(SetProcessingStepTagsParameters(
+            tags=tags
+        ))
+        self.refresh()
+        return self
+
+    def edit_properties(
+            self,
+            *,
+            new_title: str | None = None,
+            new_function_name: str | None = None,
+            is_public: bool | None = None
+    ) -> Self:
+        """Edit processing step properties.
+
+        Returns:
+            This `ProcessingStep` object"""
+        self._processing_step.edit_properties_action.execute(EditProcessingStepParameters(
+            title=new_title,
+            function_name=new_function_name,
+            is_public=is_public
+        ))
+        self.refresh()
+        return self
+
+    def configure_default_parameters(self, **parameters: Any) -> Self:
+        """Set the parameters to run the processing step with.
+
+        Args:
+            **parameters: Any keyword parameters provided will be forwarded as parameters
+                to the processing step function.
+
+        Returns:
+            This `ProcessingStep` object
+        """
+        self._processing_step.configure_default_parameters_action.execute(
+            GenericProcessingConfigureParameters.model_validate(parameters)
+        )
+
+        self.refresh()
+        return self
+
+    def clear_default_parameters(self) -> Self:
+        """Clear default parameters.
+
+        Returns:
+            This `ProcessingStep` object
+        """
+        self._processing_step.clear_default_parameters_action.execute()
+        self.refresh()
+
+        return self
+
+    def upload_configuration(self, json_data: Any) -> Self:
+        """Upload processing configuration.
+
+        Returns:
+            This `ProcessingStep` object
+        """
+        self._processing_step.upload_configuration_action.execute(
+            UploadParameters(
+                filename="config.json",  # placeholder, jma does not care about filename
+                mediatype=MediaTypes.APPLICATION_JSON,
+                json=json_data
+            )
+        )
+        self.refresh()
+
+        return self
+
+    def self_link(self) -> ProcessingStepLink:
+        return self._processing_step.self_link

pinexq_client/job_management/tool/workdata.py

@@ -0,0 +1,148 @@
+from io import IOBase
+from typing import Self, Any, Iterable, AsyncIterable
+
+import httpx
+from httpx import URL
+
+from pinexq_client.core import Link, MediaTypes
+from pinexq_client.core.hco.upload_action_hco import UploadParameters
+from pinexq_client.job_management.enterjma import enter_jma
+from pinexq_client.job_management.hcos import WorkDataLink, WorkDataRootHco, WorkDataHco
+from pinexq_client.job_management.hcos.entrypoint_hco import EntryPointHco
+from pinexq_client.job_management.known_relations import Relations
+from pinexq_client.job_management.model import SetTagsWorkDataParameters
+
+
+class WorkData:
+    """Convenience wrapper for handling WorkDataHcos in the JobManagement-Api.
+    """
+
+    _client: httpx.Client
+    _entrypoint: EntryPointHco
+    _work_data_root: WorkDataRootHco
+    _work_data: WorkDataHco | None = None
+
+    def __init__(self, client: httpx.Client):
+        """
+
+        Args:
+            client: An httpx.Client instance initialized with the api-host-url as `base_url`
+        """
+        self._client = client
+        self._entrypoint = enter_jma(client)
+        self._work_data_root = self._entrypoint.work_data_root_link.navigate()
+
+    def create(
+            self,
+            *,
+            filename: str,
+            mediatype: str = MediaTypes.OCTET_STREAM,
+            json: Any | None = None,
+            file: IOBase | None = None,
+            binary: str | bytes | Iterable[bytes] | AsyncIterable[bytes] | None = None
+    ) -> Self:
+        work_data_link = self._work_data_root.upload_action.execute(
+            UploadParameters(
+                filename=filename, binary=binary, json=json, file=file, mediatype=mediatype
+            )
+        )
+        self._get_by_link(work_data_link)
+        return self
+
+    def _get_by_link(self, processing_step_link: WorkDataLink):
+        self._work_data = processing_step_link.navigate()
+
+    @classmethod
+    def from_hco(cls, client: httpx.Client, work_data: WorkDataHco) -> Self:
+        """Initializes a `WorkData` object from an existing WorkDataHco object.
+
+        Args:
+            client: An httpx.Client instance initialized with the api-host-url as `base_url`
+            work_data: The WorkDataHco to initialize this WorkData from.
+
+        Returns:
+            The newly created work data as `WorkData` object.
+        """
+
+        work_data_instance = cls(client)
+        work_data_instance._work_data = work_data
+        return work_data_instance
+
+    @classmethod
+    def from_url(cls, client: httpx.Client, work_data_url: URL) -> Self:
+        """Initializes a `WorkData` object from an existing work data given by its link as URL.
+
+        Args:
+            client: An httpx.Client instance initialized with the api-host-url as `base_url`
+            work_data_url: The URL of the work data
+
+        Returns:
+            The newly created work data as `WorkData` object
+        """
+        link = Link.from_url(
+            work_data_url,
+            [str(Relations.CREATED_RESSOURCE)],
+            "Uploaded work data",
+            MediaTypes.SIREN,
+        )
+        processing_step_instance = cls(client)
+        processing_step_instance._get_by_link(WorkDataLink.from_link(client, link))
+        return processing_step_instance
+
+    def refresh(self) -> Self:
+        """Updates the work data from the server
+
+        Returns:
+            This `WorkData` object, but with updated properties.
+        """
+        self._work_data = self._work_data.self_link.navigate()
+        return self
+
+    def set_tags(self, tags: list[str]):
+        """Set tags to the processing step.
+
+        Returns:
+            This `WorkData` object"""
+        self._work_data.edit_tags_action.execute(SetTagsWorkDataParameters(
+            tags=tags
+        ))
+        self.refresh()
+        return self
+
+    def allow_deletion(self) -> Self:
+        """Allow deletion.
+
+        Returns:
+            This `WorkData` object"""
+        self._work_data.allow_deletion_action.execute()
+        self.refresh()
+        return self
+
+    def disallow_deletion(self) -> Self:
+        """Disallow deletion.
+
+        Returns:
+            This `WorkData` object"""
+        self._work_data.disallow_deletion_action.execute()
+        self.refresh()
+        return self
+
+    def hide(self) -> Self:
+        """Hide WorkData.
+
+        Returns:
+            This `WorkData` object"""
+        self._work_data.hide_action.execute()
+        self.refresh()
+        return self
+
+    def delete(self) -> Self:
+        """Delete WorkData.
+
+        Returns:
+            This `WorkData` object"""
+        self._work_data.delete_action.execute()
+        return self
+
+    def self_link(self) -> WorkDataLink:
+        return self._work_data.self_link

{pinexq_client-0.3.0.2024.610.1.dist-info → pinexq_client-0.3.0.20240620.2.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: pinexq-client
-Version: 0.3.0.2024.610.1
+Version: 0.3.0.20240620.2
 Summary: A hypermedia-based client for the DataCybernetics PinexQ platform.
-Author-Email: =?utf-8?q?Sebastian_H=C3=B6fer?= <hoefer@data-cybernetics.com>, Mathias Reichardt <reichardt@data-cybernetics.com>
+Author-Email: =?utf-8?q?Sebastian_H=C3=B6fer?= <hoefer@data-cybernetics.com>, Mathias Reichardt <reichardt@data-cybernetics.com>, Pratik Poudel <poudel@data-cybernetics.com>
 Maintainer-Email: Mathias Reichardt <reichardt@data-cybernetics.com>, =?utf-8?q?Sebastian_H=C3=B6fer?= <hoefer@data-cybernetics.com>, Carsten Blank <blank@data-cybernetics.com>
 License: MIT
 Requires-Python: >=3.11

{pinexq_client-0.3.0.2024.610.1.dist-info → pinexq_client-0.3.0.20240620.2.dist-info}/RECORD

@@ -1,6 +1,6 @@
-pinexq_client-0.3.0.2024.610.1.dist-info/METADATA,sha256=R8Xubl7bI3affz5x9-yW0us04uR3Rg3WLnVRTnmDNEw,3191
-pinexq_client-0.3.0.2024.610.1.dist-info/WHEEL,sha256=vnE8JVcI2Wz7GRKorsPArnBdnW2SWKWGow5gu5tHlRU,90
-pinexq_client-0.3.0.2024.610.1.dist-info/licenses/LICENSE,sha256=3oz3tAhM7kOgRukkRe7wmh5T_HihZY77ZtJDJm91ZN8,1072
+pinexq_client-0.3.0.20240620.2.dist-info/METADATA,sha256=70gP6h5Th1XwWj_vF4icSkOllhZ97qy2qM1ohWDhwSc,3236
+pinexq_client-0.3.0.20240620.2.dist-info/WHEEL,sha256=SOP-4bEE0jbVaCHQGVvF08uWxk5rcSsfEybvoQVHlD8,90
+pinexq_client-0.3.0.20240620.2.dist-info/licenses/LICENSE,sha256=3oz3tAhM7kOgRukkRe7wmh5T_HihZY77ZtJDJm91ZN8,1072
 pinexq_client/core/__init__.py,sha256=8SVD_PRgJtpUCOtVjdR6fRrv6KPNk7HD6UQrn0FKR04,235
 pinexq_client/core/base_relations.py,sha256=oIUS58pkbMDdqm-3YOdsenhL1smtzeAk4fp7-U595MY,162
 pinexq_client/core/enterapi.py,sha256=FutPNPBEaoCgb_uTi19z-AQjQGBxfISkTFI7e6wkOdQ,611
@@ -19,31 +19,32 @@ pinexq_client/core/model/error.py,sha256=U-9U1TRc77UNIQe_rvnwzNkTjrUEem3pKMx2c9r
 pinexq_client/core/model/sirenmodels.py,sha256=vGRQlhM2cSa2caxQel91Jr48KWqM-vMYX32iaQCzIds,5547
 pinexq_client/core/polling.py,sha256=Z6VXn-PCGk4XX-4tQWZG59qJyCIS0eIrpPUORQDIGrs,1077
 pinexq_client/core/sirenaccess.py,sha256=5p8twdB0FYMhhBNPH3-xDX20jWR4-b2h8F3BDoyc7C8,6978
-pinexq_client/job_management/__init__.py,sha256=o21xGlNYwHrYtKMX9rDj1L6Gs6f82KYl9W3R9_g3_ec,138
-pinexq_client/job_management/enterjma.py,sha256=VxKe5eFTRfF4bJvyF6OLgn6uoslCAyPAdGqmYnIv2So,1447
+pinexq_client/job_management/__init__.py,sha256=BB5Bik_9rwjDLXCanYzEJgJuLJxwEeRqHH2rWvBdQFY,164
+pinexq_client/job_management/enterjma.py,sha256=R72Wzd4UEGNkkqe1WC80B9VCyMc5kt7gNv0RAad6ibE,1443
 pinexq_client/job_management/hcos/__init__.py,sha256=vMIdxGHBsVcKYKrVkCzD4a_VaheKSNxCimospFn5N88,396
 pinexq_client/job_management/hcos/entrypoint_hco.py,sha256=i4n8R4h1ZGinwuCH2Rj7dwzOkqOd1hQKS3SXmHk1-9A,2316
 pinexq_client/job_management/hcos/info_hco.py,sha256=zWjR63SCEO_sUcZ9ha_aIoC_qUzAWLf50Xu4AHddAn8,1328
-pinexq_client/job_management/hcos/input_dataslot_hco.py,sha256=pxHuymus8J7Syd7Xp25hkmI4ReRQd5HhkJ1fk5K_rf4,3626
-pinexq_client/job_management/hcos/job_hco.py,sha256=-qn37B2MVYerOua9Ji1zee7pma6nSuFr3aWjfRSHUmc,7385
-pinexq_client/job_management/hcos/job_query_result_hco.py,sha256=dTlSES8Nl6FqY6_sFMdG5JpxTaLBuQwaIOdP-Qhu4lc,2994
+pinexq_client/job_management/hcos/input_dataslot_hco.py,sha256=hyfuT5eQb5JSPfhdP4mcOkxVx1BsBJNfWbAXKHgkHrQ,3631
+pinexq_client/job_management/hcos/job_hco.py,sha256=wa2UF8-RmJg8Vt26O5yS4bTH5qWeVjA0enDGdKGIWxo,7631
+pinexq_client/job_management/hcos/job_query_result_hco.py,sha256=IzEi7ul240luUIuEfiTHwezrEJbGXknvyu7R6I25v5g,3044
 pinexq_client/job_management/hcos/job_used_tags_hco.py,sha256=nys6E97NNXATdnvX6KZ46JR9qEb2lnqol9ZvJVEiNpQ,944
 pinexq_client/job_management/hcos/jobsroot_hco.py,sha256=3UPhMyHb9zZO7AQbsCrY_0aimd__VQL54C4vzxgrq0o,3640
-pinexq_client/job_management/hcos/output_dataslot_hco.py,sha256=clnGqgqF4EoNHOOFa3R9YAMqHoX57b2chQEIFOPjxWU,1544
-pinexq_client/job_management/hcos/processing_step_hco.py,sha256=WTKVhG6RsKhLLC0ErvOxf5Q6XzoMGF1oUpAi8mKLu5Y,3027
+pinexq_client/job_management/hcos/output_dataslot_hco.py,sha256=c5__JR2W4GeJ87pYkF43as3U7G6qgt7FrVzEMo8_-ho,1549
+pinexq_client/job_management/hcos/processing_step_hco.py,sha256=7DcHMchq-2JekcZbu6sT53HR_SehNPrNZKmZ8QHT5Go,5391
 pinexq_client/job_management/hcos/processing_step_used_tags_hco.py,sha256=90-2IWlYTcYX62NzmAPnmcUCwMDhmMZyBrNs_G3yigs,1067
-pinexq_client/job_management/hcos/processingstep_query_result_hco.py,sha256=6I1vWylw_nrjiLE00x1tdRaTjze6Hft0AJBUiLtobvo,3248
+pinexq_client/job_management/hcos/processingstep_query_result_hco.py,sha256=WIOeB_rW2_AEjRpJZqAZotZFXi0vUz0i0sepI6vRg8Q,3304
 pinexq_client/job_management/hcos/processingsteproot_hco.py,sha256=xdgVt__1js7NQZJjmvZuisgZkAynN0Dgw9pBnpPhTcs,3758
 pinexq_client/job_management/hcos/user_hco.py,sha256=z6USe-4nYzBfOoEx3n9_UbgomMTimg4EIa_XeVBj01A,1095
 pinexq_client/job_management/hcos/workdata_hco.py,sha256=jJ0gemgmJ9uHzOTUCA7eBtGbQViCoSmaT3p-2ZIWF30,4934
-pinexq_client/job_management/hcos/workdata_query_result_hco.py,sha256=2AfRmbCzedNtaPKqAvyEv2BRtX-e22NPfe7fmXluK-g,2928
+pinexq_client/job_management/hcos/workdata_query_result_hco.py,sha256=uX4EH-5cQLhEnBGbWXSebQU-BuRNGYPxolKruwNyMDk,2984
 pinexq_client/job_management/hcos/workdata_used_tags_query_result_hco.py,sha256=qB1iQpwD63579dq3tUF4DBB_rZRMqJ80y1ysf-41aOo,1087
 pinexq_client/job_management/hcos/workdataroot_hco.py,sha256=isivaMxYV8KwTgFe2W5PuhJ_CJUmZO_Pz_yakwKUup8,4043
-pinexq_client/job_management/ideas.md,sha256=dA2qGLbgh561iLqDn792XhfxHPHdVJ__GpFxcEMTghY,431
 pinexq_client/job_management/known_relations.py,sha256=UlOF-sua8SyOPNNKzT_j6JVG8T-aewHIzn7S2ajXBhI,593
 pinexq_client/job_management/model/__init__.py,sha256=ApHhNfjx4bPuz10sQnyBA2zajYbU7loDTZSKC5H_jBY,34
-pinexq_client/job_management/model/open_api_generated.py,sha256=3NdFG6J24JPnKSf03SZyLarkjfJ7AFAL0HsCkpV06os,28965
+pinexq_client/job_management/model/open_api_generated.py,sha256=TwGg54yv55j3CCetXG9LXaukgFHVkSuBkyGfN1LtcbY,30212
 pinexq_client/job_management/model/sirenentities.py,sha256=OInvxHpC6mnnYQjOMM2xAw7uLtvWwj9E2EQSRJe2jDo,3202
-pinexq_client/job_management/tool/__init__.py,sha256=W_PQvoWNHAhfgSHSC3opcsRUWtWBGACDtRgipZYHA0o,21
-pinexq_client/job_management/tool/job.py,sha256=Q1aieDKACIfROEAVzuZE_JESUDpvFw7DXPXO42zcRsU,14600
-pinexq_client-0.3.0.2024.610.1.dist-info/RECORD,,
+pinexq_client/job_management/tool/__init__.py,sha256=58CRDcP8ifSx9eA2uyTLEg0_fX3FUuNUogY_lirx9AY,96
+pinexq_client/job_management/tool/job.py,sha256=qBCAZu3GRcgQ-9tct7pkyUkQlg3YdR0fr1mMqoXkL4c,17308
+pinexq_client/job_management/tool/processing_step.py,sha256=A8IFemh0MRQUYlHzLhp0Ou4rlMv6OUiZYd4XXmscUfM,6337
+pinexq_client/job_management/tool/workdata.py,sha256=nlfwhCyeYpg20SBy63moHwvxNFCWAmwrhVIpl7mjSe4,4712
+pinexq_client-0.3.0.20240620.2.dist-info/RECORD,,

{pinexq_client-0.3.0.2024.610.1.dist-info → pinexq_client-0.3.0.20240620.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: pdm-backend (2.3.0)
+Generator: pdm-backend (2.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any

pinexq_client/job_management/ideas.md

@@ -1,28 +0,0 @@
-class EntryPoint():
-
-    @LinkRelateion("Info")
-    Info: Link[Info]
-
-    @LinkRelateion("ProcessingSteps")
-    @Mandatory
-    ProcessingSteps: MandatoryLink[Info]
-
-    user: User = Info.navigate().User.navigate()
-    seld["CreateUser"].Excecute()
-
-
-    entrypoint.navigate("Info")
-    def CreateUser(dojgpsj):
-
-class Info():
-
-    CurrentUser: Link[User]
-
-class User():
-
-class Job():
-
-    name = ""
-    title = ""
-    status = ""
-