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

pinexq_client/job_management/tool/job.py

@@ -1,10 +1,11 @@
 import json as json_
+import warnings
 from typing import Any, Self
 
 import httpx
 from httpx import URL
 
-from pinexq_client.core import Link, MediaTypes
+from pinexq_client.core import Link, MediaTypes, ClientException, ApiException
 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, ProcessingStepLink, InputDataSlotHco, OutputDataSlotHco
@@ -39,7 +40,6 @@ from pinexq_client.job_management.model import (
 from pinexq_client.job_management.tool.processing_step import ProcessingStep
 from pinexq_client.job_management.tool.workdata import WorkData
 
-
 class Job:
     """Convenience wrapper for handling JobHcos in the JobManagement-Api.
 
@@ -165,9 +165,19 @@ class Job:
         self.refresh()
         return self._job.state
 
+    def get_name(self) -> str:
+        """Returns the name of this job
+
+        Returns:
+            The name of this `Job`
+        """
+        self.refresh()
+        return self._job.name
+
     def select_processing(
             self,
             function_name: str | None = None,
+            *,
             processing_step_link: ProcessingStepLink | None = None,
             processing_step_instance: ProcessingStep | None = None
     ) -> Self:
@@ -186,10 +196,16 @@ class Job:
             raise ValueError("Exactly one parameter must be provided")
 
         if processing_step_link is not None:
+            if not isinstance(processing_step_link, ProcessingStepLink):
+                raise TypeError('Instance passed to "processing_step_link" is not of type "ProcessingStepLink"')
             processing_url = processing_step_link.get_url()
         elif processing_step_instance is not None:
+            if not isinstance(processing_step_instance, ProcessingStep):
+                raise TypeError('Instance passed to "processing_step_instance" is not of type "ProcessingStep"')
             processing_url = processing_step_instance.self_link().get_url()
         else:
+            if not isinstance(function_name, str):
+                raise TypeError('Instance passed to "function_name" is not of type "str"')
             # ToDo: provide more parameters to query a processing step
             query_param = ProcessingStepQueryParameters(
                 filter=ProcessingStepFilterParameter(
@@ -199,7 +215,7 @@ class Job:
             )
             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!")
+                raise NameError(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()
 
@@ -253,16 +269,19 @@ class Job:
         result = self._job.result
         return json_.loads(result) if result else None
 
-    def wait_for_state(self, state: JobStates, timeout_ms: int = 5000) -> Self:
-        """Wait for this job to reach a state.
+    def wait_for_state(self, state: JobStates, timeout_ms: int = 5000, polling_interval_ms: int = 1000) -> Self:
+        """Wait for this job to reach a state. If the job enters error state an exception is risen
 
         Args:
             state: The state to wait for. After the job enters this state this function returns.
-            timeout_ms: Time span in milliseconds to wait for reaching the state before
-                raising an exception.
+            timeout_ms: Time span in milliseconds to wait for reaching the state before raising an exception.
+            polling_interval_ms: will determine how fast the API is polled for updates.
+            Note that low values will produce unnecessary load.
 
         Returns:
             This `Job` object
+
+
         """
         try:
             wait_until(
@@ -270,23 +289,25 @@ class Job:
                 timeout_ms=timeout_ms,
                 timeout_message="Waiting for job completion",
                 error_condition=lambda: self._job.state == JobStates.error,
+                polling_interval_ms=polling_interval_ms
             )
         except TimeoutError as timeout:
-            raise Exception(
+            raise TimeoutError(
                 f"Job did not reach state: '{state.value}' "
                 f"current state: '{self.get_state().value}'. Error:{str(timeout)}"
             )
         except PollingException:
             if self._job.state == JobStates.error:
                 error_reason = self._job.error_description
-                raise Exception(f"Job failed'. Error:{error_reason}")
-            raise Exception("Job failed")
+                raise PollingException(f"Job failed'. Error:{error_reason}")
+            raise PollingException("Job failed")
 
         return self
 
     def assign_input_dataslot(
             self,
             index: int,
+            *,
             work_data_link: WorkDataLink | None = None,
             work_data_instance: WorkData | None = None
     ) -> Self:
@@ -304,8 +325,12 @@ class Job:
             raise ValueError("Exactly one parameter must be provided")
 
         if work_data_instance is not None:
+            if not isinstance(work_data_instance, WorkData):
+                raise Exception('Instance passed to "work_data_instance" is not of type "WorkData"')
             work_data = work_data_instance.self_link()
         else:
+            if not isinstance(work_data_link, WorkDataLink):
+                raise Exception('Instance passed to "work_data_link" is not of type "WorkDataLink"')
             work_data = work_data_link
 
         dataslot = self._job.input_dataslots[index]
@@ -321,6 +346,7 @@ class Job:
     def assign_collection_input_dataslot(
             self,
             index: int,
+            *,
             work_data_links: list[WorkDataLink] | None = None,
             work_data_instances: list[WorkData] | None = None
     ) -> Self:
@@ -338,8 +364,13 @@ class Job:
             raise ValueError("Exactly one parameter must be provided")
 
         if work_data_instances is not None:
+            if not isinstance(work_data_instances, list) or any(
+                    not isinstance(i, WorkData) for i in work_data_instances):
+                raise Exception('Instance passed to "work_data_instances" is not of type "list[WorkData]"')
             work_datas = [work_data_instance.self_link() for work_data_instance in work_data_instances]
         else:
+            if not isinstance(work_data_links, list) or any(not isinstance(i, WorkDataLink) for i in work_data_links):
+                raise Exception('Instance passed to "work_data_links" is not of type "list[WorkDataLink]"')
             work_datas = work_data_links
 
         dataslot = self._job.input_dataslots[index]
@@ -408,7 +439,7 @@ class Job:
         query_result = self._get_sub_jobs(state=state)
         return query_result.total_entities
 
-    def wait_for_sub_jobs_complete(self, timeout_ms: int = 0) -> Self:
+    def wait_for_sub_jobs_complete(self, timeout_ms: int = 60000, polling_interval_ms: int = 1000) -> Self:
         """Wait for all sub-jobs to reach the state 'completed'.
 
         This function will block execution until the state is reached or raise an exception
@@ -419,16 +450,21 @@ class Job:
 
         Returns:
             This `Job` object
+            :param timeout_ms: Wil determine how long to wait for success
+            :param polling_interval_ms: will determine how fast the API is polled for updates.
+            Note that low values will produce unnecessary load.
         """
         wait_until(
             condition=lambda: self.sub_jobs_in_state(JobStates.pending) == 0,
             timeout_ms=timeout_ms,
             timeout_message=f"Timeout while waiting for sub-jobs to complete! [timeout: {timeout_ms}ms]",
+            polling_interval_ms=polling_interval_ms
         )
         wait_until(
             condition=lambda: self.sub_jobs_in_state(JobStates.processing) == 0,
             timeout_ms=timeout_ms,
             timeout_message=f"Timeout while waiting for sub-jobs to complete! [timeout: {timeout_ms}ms]",
+            polling_interval_ms=polling_interval_ms
         )
 
         error_count = self.sub_jobs_in_state(JobStates.error)
@@ -455,6 +491,67 @@ class Job:
         self._job.delete_action.execute()
         return self
 
+    def delete_with_associated(
+            self,
+            *,
+            delete_output_workdata: bool = True,
+            delete_input_workdata: bool = False,
+            delete_subjobs_with_data: bool = True
+    ) -> Self:
+        """Delete this job after deleting output workdata and subjobs depending on the flag.
+        Afterward, also deletes input workdata depending on the flag. This is a best effort operation,
+        if an operation can not be executed a warning will be printed but the process continues.
+
+        Args:
+            delete_output_workdata: boolean flag to specify if output WorkData should be attempted for deletion. Default: True
+            delete_input_workdata: boolean flag to specify if input WorkData should be attempted for deletion. Default: False
+            delete_subjobs_with_data: boolean flag tp specify if Sub jobs should be attempted for deletion. Default: True
+
+        Returns:
+            This `Job` object
+        """
+
+        # delete subjobs
+        if delete_subjobs_with_data is True:
+            for subjob in self._get_sub_jobs().iter_flat():
+                try:
+                    subjob.delete_action.execute()
+                except (ClientException, ApiException) as e:
+                    warnings.warn(f"Could not delete subjob: {subjob.self_link.get_url()}\n{e}")
+                    pass
+
+        # delete output workdatas
+        if delete_output_workdata is True:
+            for slot in self._job.output_dataslots:
+                for wd in slot.assigned_workdatas:
+                    try:
+                        wd.delete_action.execute()
+                    except (ClientException, ApiException) as e:
+                        warnings.warn(f"Could not delete output workdata: {wd.self_link.get_url()}\n{e}")
+                        pass
+
+        # delete this job
+        self.refresh()
+
+        try:
+            self.delete()
+        except (ClientException, ApiException) as e:
+            warnings.warn(f"Could not delete job: {self.self_link().get_url()}\n{e}")
+
+        # finally delete input workdatas
+        if delete_input_workdata is True:
+            for slot in self._job.input_dataslots:
+                for wd in slot.selected_workdatas:
+                    try:
+                        wd.allow_deletion_action.execute()
+                        wd = wd.self_link.navigate()
+                        wd.delete_action.execute()
+                    except (ClientException, ApiException) as e:
+                        warnings.warn(f"Could not delete input workdata: {wd.self_link.get_url()}\n{e}")
+                        pass
+
+        return self
+
     def unhide(self) -> Self:
         """Reveal this job again.
 

pinexq_client/job_management/tool/job_group.py

@@ -0,0 +1,158 @@
+import time
+from typing import Union, Self
+
+import httpx
+
+from pinexq_client.job_management import Job
+from pinexq_client.job_management.hcos import JobQueryResultHco
+from pinexq_client.job_management.model import JobStates
+
+
+class JobGroup:
+    """
+    A wrapper class for a group of jobs for easier execution and waiting
+
+    Attributes:
+        _client:
+            The http client
+        _jobs:
+            List of jobs in the group
+    """
+
+    _client: httpx.Client
+
+    def __init__(self, client: httpx.Client):
+        self._jobs: list[Job] = []
+        self._client = client
+
+    @classmethod
+    def from_query_result(cls, client: httpx.Client, job_query_result: JobQueryResultHco) -> Self:
+        """
+        Initializes a `JobGroup` object from a JobQueryResultHco object
+        Args:
+            client: The http client
+            job_query_result: The JobQueryResultHco object whose jobs are to be added to the JobGroup
+
+        Returns:
+            The newly created `JobGroup` instance
+        """
+        instance = cls(client)
+        for job in job_query_result.iter_flat():
+            instance.add_jobs(Job.from_hco(instance._client, job))
+        return instance
+
+    def add_jobs(self, jobs: Union[Job, list[Job]]) -> Self:
+        """
+        Add a job or multiple jobs to the group
+
+        Args:
+            jobs: A job or a list of job objects to be added to the JobGroup
+
+        Returns:
+            This `JobGroup` object
+        """
+
+        if isinstance(jobs, list):
+            self._jobs.extend(jobs)
+        else:
+            self._jobs.append(jobs)
+        return self
+
+    def start_all(self) -> Self:
+        """
+        Start all jobs
+
+        Returns:
+            This `JobGroup` object
+        """
+        for job in self._jobs:
+            job.start()
+        return self
+
+    def wait_all(self, *, job_timeout_ms: int = 5000, total_timeout_ms: int | None = None) -> Self:
+        """
+        Wait for all jobs to complete or error state.
+        If the overall timeout elapses and some jobs are not complete, then exception.
+
+        Args:
+            job_timeout_ms:
+                Individual job timeout in milliseconds. Default is 5000 ms.
+            total_timeout_ms:
+                Timeout for the whole operation in milliseconds. Default is no timeout.
+        Returns:
+            This `JobGroup` object
+        """
+        start_time = time.time()
+        for job in self._jobs:
+            if total_timeout_ms is not None:
+                elapsed_time_ms = (time.time() - start_time) * 1000
+                if total_timeout_ms - elapsed_time_ms <= 0:
+                    raise Exception("Total timeout exceeded while waiting for jobs.")
+
+            try:
+                job.wait_for_state(JobStates.completed, timeout_ms=job_timeout_ms)
+            except Exception:
+                pass
+        return self
+
+    def all_jobs_completed_ok(self) -> bool:
+        for job in self._jobs:
+            state = job.get_state()
+            if state is not JobStates.completed:
+                return False
+        return True
+
+    def incomplete_jobs(self) -> list[Job]:
+        """
+        Returns the incomplete jobs
+
+        Returns:
+            Count of incomplete jobs
+        """
+        incomplete_jobs = []
+        for job in self._jobs:
+            state = job.get_state()
+            if state in (JobStates.processing, JobStates.pending):
+                incomplete_jobs.append(job)
+        return incomplete_jobs
+
+    def jobs_with_error(self) -> list[Job]:
+        """
+        Returns the list of jobs that produced errors
+
+        Returns:
+            List of jobs that produced errors
+        """
+        return [job for job in self._jobs if job.get_state() == JobStates.error]
+
+    def remove(self, job_name: str) -> Self:
+        """
+        Removes all jobs from the group whose name matches the provided name
+
+        Args:
+            job_name:
+                The name of the job(s) to be removed
+        Returns:
+            This `JobGroup` object
+        """
+        self._jobs = [job for job in self._jobs if job.get_name() != job_name]
+        return self
+
+    def clear(self) -> Self:
+        """
+        Removes all jobs from the group
+
+        Returns:
+            This `JobGroup` object
+        """
+        self._jobs = []
+        return self
+
+    def get_jobs(self) -> list[Job]:
+        """
+        Returns the list of jobs in the group
+
+        Returns:
+            List of jobs in the group
+        """
+        return self._jobs

pinexq_client/job_management/tool/processing_step.py

@@ -1,4 +1,4 @@
-from typing import Any, Self
+from typing import Any, Self, List, Optional
 
 import httpx
 from httpx import URL
@@ -6,7 +6,7 @@ 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 import ProcessingStepHco, ProcessingStepLink, ProcessingStepQueryResultHco
 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
@@ -14,7 +14,8 @@ from pinexq_client.job_management.known_relations import Relations
 from pinexq_client.job_management.model import (
     CreateProcessingStepParameters,
     EditProcessingStepParameters,
-    SetProcessingStepTagsParameters,
+    SetProcessingStepTagsParameters, ProcessingStepQueryParameters, ProcessingStepFilterParameter,
+    FunctionNameMatchTypes,
 )
 
 
@@ -37,20 +38,22 @@ class ProcessingStep:
         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:
+    def create(self, title: str, function_name: str, version: str = "0") -> 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
+            version: Version 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
+            function_name=function_name,
+            version=version
         ))
         self._processing_step = processing_step_hco
         return self
@@ -94,6 +97,81 @@ class ProcessingStep:
         processing_step_instance._get_by_link(ProcessingStepLink.from_link(client, link))
         return processing_step_instance
 
+    @classmethod
+    def from_name(cls, client: httpx.Client, step_name: str, version: str = "0") -> Self:
+        """Create a ProcessingStep object from an existing name.
+
+        Args:
+            client: Create a ProcessingStep object from an existing name.
+            step_name: Name of the registered processing step.
+            version: Version of the ProcessingStep to be created
+
+        Returns:
+            The newly created processing step as `ProcessingStep` object
+        """
+
+        # Attempt to find the processing step
+        query_result = cls._query_processing_steps(client, step_name, version)
+
+        # Check if exactly one result is found
+        if len(query_result.processing_steps) != 1:
+            # Attempt to suggest alternative steps if exact match not found
+            suggested_steps = cls._processing_steps_by_name(client, step_name)
+            raise NameError(
+                f"No processing step with the name {step_name} and version {version} registered. "
+                f"Suggestions: {suggested_steps}"
+            )
+
+        # Todo: For now we choose the first and only result. Make this more flexible?
+        processing_step_hco = query_result.processing_steps[0]
+        return ProcessingStep.from_hco(client, processing_step_hco)
+
+    @staticmethod
+    def _query_processing_steps(client: httpx.Client, step_name: str, version: Optional[str] = None) -> ProcessingStepQueryResultHco:
+        """
+        Helper function to query processing steps based on name and optional version.
+
+        Args:
+            client: HTTP client for executing queries.
+            step_name: Name of the processing step.
+            version: Optional version to match.
+
+        Returns:
+            Query result object containing the matching processing steps.
+        """
+        query_param = ProcessingStepQueryParameters(
+            filter=ProcessingStepFilterParameter(
+                function_name=step_name,
+                function_name_match_type=FunctionNameMatchTypes.match_exact,
+                version=version
+            )
+        )
+        instance = ProcessingStep(client)
+        return instance._processing_steps_root.query_action.execute(query_param)
+
+    @staticmethod
+    def _processing_steps_by_name(client: httpx.Client, step_name: str) -> list:
+        """
+        Suggest processing steps if the exact step is not found.
+
+        Args:
+            client: HTTP client for executing queries.
+            step_name: Name of the processing step.
+
+        Returns:
+            A list of alternative processing steps matching the step name.
+        """
+        # Query for steps without  version to get suggestions
+        instance = ProcessingStep(client)
+        query_result = instance._query_processing_steps(client, step_name)
+
+        # If no suggestions are found, raise an error
+        if len(query_result.processing_steps) == 0:
+            raise NameError(f"No processing steps found with the name '{step_name}'.")
+
+        # Return list of alternative steps as suggestions
+        return [f"{step.function_name}:{step.version}" for step in query_result.processing_steps]
+
     def refresh(self) -> Self:
         """Updates the processing step from the server
 

pinexq_client/job_management/tool/workdata.py

@@ -144,5 +144,13 @@ class WorkData:
         self._work_data.delete_action.execute()
         return self
 
+    def download(self) -> bytes:
+        """Download WorkData.
+
+        Returns:
+            Downloaded WorkData in bytes
+        """
+        return self._work_data.download_link.download()
+
     def self_link(self) -> WorkDataLink:
         return self._work_data.self_link

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

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: pinexq-client
-Version: 0.3.0.20240620.2
+Version: 0.4.2.20241009.1
 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>, Pratik Poudel <poudel@data-cybernetics.com>
+Author-Email: =?utf-8?q?Sebastian_H=C3=B6fer?= <hoefer@data-cybernetics.com>, Mathias Reichardt <reichardt@data-cybernetics.com>, Jasim Ahmed <ahmed@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.4.2.20241009.1.dist-info/RECORD

@@ -0,0 +1,53 @@
+pinexq_client-0.4.2.20241009.1.dist-info/METADATA,sha256=OwWRTY8LrZ0sTtVPcvKWudbDLVg_25sdw9B8inJczfc,3278
+pinexq_client-0.4.2.20241009.1.dist-info/WHEEL,sha256=Vza3XR51HW1KmFP0iIMUVYIvz0uQuKJpIXKYOBGQyFQ,90
+pinexq_client-0.4.2.20241009.1.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+pinexq_client-0.4.2.20241009.1.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=sL9TmF1L5LaDJnre1l_tiHDUo9vTbZ8cvPSov3Q1UTs,671
+pinexq_client/core/exceptions.py,sha256=NqB3y1ufjOfG3kv7Rz4ppXqJRAugt2zlgxkto2nIVQU,2228
+pinexq_client/core/hco/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pinexq_client/core/hco/action_hco.py,sha256=lctChgDHHwRqv0LU_8r8YRS708n5blYFxVkFNYf8YC8,2219
+pinexq_client/core/hco/action_with_parameters_hco.py,sha256=V-8n7-X2oSglQ4fYbLm4YKNcFhIoaT3SNIUVDflI9yY,3161
+pinexq_client/core/hco/download_link_hco.py,sha256=_ijLtRfzy0qKG_QXpsWBZ8FJfp60o5Lw7QVv4_EpgPY,1335
+pinexq_client/core/hco/hco_base.py,sha256=NglQuS6p1EimgtIx55G8ngBDGXc4lzyq08jsXzztE1I,3367
+pinexq_client/core/hco/link_hco.py,sha256=m-TxPtlBg7bVEcj_fztD84Kwvf5lWpqcAS_MBHdggkc,2063
+pinexq_client/core/hco/unavailable.py,sha256=rbIAXEtIjW7G0lQB5xsFSrakDDc_xAnr100sh2VE_Ds,566
+pinexq_client/core/hco/upload_action_hco.py,sha256=oOGw0Z_nx67CbqJ-QkQJbffdXajBgKmBAfSfFtyq8wk,4690
+pinexq_client/core/http_headers.py,sha256=tY4h3DKVDMkjw9DLFn57HdEnwR1NAixMF8Yjgy3gjQY,183
+pinexq_client/core/media_types.py,sha256=qU-Jd92H5HKczWDk51EstFHadO6A_QJL4lLXHRlfgjQ,600
+pinexq_client/core/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pinexq_client/core/model/error.py,sha256=FNJrXVTkVnh6oDkHHc3sSZ2wNtEPCZyqgzZT01MG8Tc,390
+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=5GDTolgIlt9rW2g9qG7LerUlmz0BQNKYGp78T2UPrv0,6771
+pinexq_client/job_management/__init__.py,sha256=pvdID8cHtpXcjx-PKW9svc9DxMGG58cXyW-mhYEJPQE,164
+pinexq_client/job_management/enterjma.py,sha256=Ivl_jVPw_gaLyU5nKbywM-bbVGpn0MoCrZ0DMbJYf3s,1411
+pinexq_client/job_management/hcos/__init__.py,sha256=vMIdxGHBsVcKYKrVkCzD4a_VaheKSNxCimospFn5N88,396
+pinexq_client/job_management/hcos/entrypoint_hco.py,sha256=qodjAwO_MtawUuhmaYjhGXHV-uW1k94V9gKRYZRkhn4,2234
+pinexq_client/job_management/hcos/info_hco.py,sha256=zWjR63SCEO_sUcZ9ha_aIoC_qUzAWLf50Xu4AHddAn8,1328
+pinexq_client/job_management/hcos/input_dataslot_hco.py,sha256=SDflhyW8kjpcTUfKAXnJxNR-etPzAHfoTqlYUcJZrxs,3442
+pinexq_client/job_management/hcos/job_hco.py,sha256=0ZzeBXjwJd3kbe3peIdGgnIHR_cvwSz1_yuO5135g34,7340
+pinexq_client/job_management/hcos/job_query_result_hco.py,sha256=I0G8YIlYDhTahLz8n06L8BywlcsMGNWUEsmEr4Sk0GU,3315
+pinexq_client/job_management/hcos/job_used_tags_hco.py,sha256=nys6E97NNXATdnvX6KZ46JR9qEb2lnqol9ZvJVEiNpQ,944
+pinexq_client/job_management/hcos/jobsroot_hco.py,sha256=aLVlGEl4BG3HboelTu3srTdbQOXPQJWVZrYPHeWe3m4,3594
+pinexq_client/job_management/hcos/output_dataslot_hco.py,sha256=zxpo-fI9eHcp_pMKcf2l-gRoPHX1RzQO53auHMRB_T8,1549
+pinexq_client/job_management/hcos/processing_step_hco.py,sha256=MykmFssysIc8fIUoPyNOLEGLGQNoC4zFgjIAIjf0v7U,5190
+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=YcCgigKvOIggILixgaEbmnM23FlkjCgxnhZC2Eh98dY,3817
+pinexq_client/job_management/hcos/processingsteproot_hco.py,sha256=gQBGMWEKX5kq_HwC7-eEjjfAm6oYTuIxGX5kKw_GKUM,3684
+pinexq_client/job_management/hcos/user_hco.py,sha256=z6USe-4nYzBfOoEx3n9_UbgomMTimg4EIa_XeVBj01A,1095
+pinexq_client/job_management/hcos/workdata_hco.py,sha256=lyqUQ93oNOIOS3J9V0BKNq7opoHdTQTTCcpJTubEbVU,4734
+pinexq_client/job_management/hcos/workdata_query_result_hco.py,sha256=yxEnu_COMxP3mt553JZD13jjPyqSp3DJjgd8es5Nq_E,3520
+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=LdEPW2JJTqAWi-6zj-40lfREhthcDL6nPXQk_nfMtCA,3936
+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=9VQtoenAmAVsRdR9GaQSBqrJIPrWFYkF5DKv8n9Z6Ow,30354
+pinexq_client/job_management/model/sirenentities.py,sha256=OInvxHpC6mnnYQjOMM2xAw7uLtvWwj9E2EQSRJe2jDo,3202
+pinexq_client/job_management/tool/__init__.py,sha256=58CRDcP8ifSx9eA2uyTLEg0_fX3FUuNUogY_lirx9AY,96
+pinexq_client/job_management/tool/job.py,sha256=BA1S2NY6D4Cpa3Mmoly0M3qCzCiv6p-MP7_decSlP-0,22209
+pinexq_client/job_management/tool/job_group.py,sha256=4zW_SEbQMLVNqu_zLUP57epkypBbRc5gxjPLp_FZgZo,4515
+pinexq_client/job_management/tool/processing_step.py,sha256=0qq64JOESPFAgpUpmM9hWndh21BnCB95EExd21ZHYOg,9730
+pinexq_client/job_management/tool/workdata.py,sha256=8DwvzcjefKL-wBuCxy9ziaUC7gTf0TMXAa1WoCmHvZM,4903
+pinexq_client-0.4.2.20241009.1.dist-info/RECORD,,

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

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

pinexq_client-0.4.2.20241009.1.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+
+[gui_scripts]
+