pinexq-client 0.10.3rc1__py3-none-any.whl → 0.10.5rc1__py3-none-any.whl

pinexq_client/core/hco/action_hco.py

@@ -60,5 +60,11 @@ class ActionHco(ClientContainer, HypermediaAvailability):
         raise_exception_on_error(f"Error while executing action, unexpected response", response)
         return response
 
+    def _execute_returns_url(self) -> URL:
+        result = self._execute_internal()
+        if result is None:
+            raise ClientException("Action did not respond with URL")
+        return result
+
     def __repr__(self):
         return f"<{self.__class__.__name__}: '{self._action.name}'>"

pinexq_client/job_management/__init__.py

@@ -22,4 +22,4 @@ from .model import JobSortPropertiesSortParameter, ProcessingView
 from .tool import Job, JobGroup, ProcessingStep, WorkData
 
 # Protocol version the JMA is using
-__jma_version__ = [8, 8, 0]
+__jma_version__ = [9, 0, 0]

pinexq_client/job_management/hcos/info_hco.py

@@ -19,6 +19,9 @@ class ApiEventsEndpointLink(LinkHco):
 class DeploymentRegistryEndpointLink(LinkHco):
     pass
 
+class RemoteEndpointLink(LinkHco):
+    pass
+
 class InfoHco(Hco[InfoEntity]):
     api_version: str = Property()
     build_version: str = Property()
@@ -29,6 +32,7 @@ class InfoHco(Hco[InfoEntity]):
     self_link: InfoLink
     api_events_endpoint: ApiEventsEndpointLink
     deployment_registry_endpoint: DeploymentRegistryEndpointLink
+    remote_endpoint: RemoteEndpointLink
 
     @classmethod
     def from_entity(cls, entity: InfoEntity, client: httpx.Client) -> Self:
@@ -42,6 +46,7 @@ class InfoHco(Hco[InfoEntity]):
 
         instance.api_events_endpoint = ApiEventsEndpointLink.from_entity(instance._client, instance._entity, Relations.API_EVENTS_ENDPOINT)
         instance.deployment_registry_endpoint = DeploymentRegistryEndpointLink.from_entity_optional(instance._client, instance._entity, Relations.DEPLOYMENT_REGISTRY_ENDPOINT)
+        instance.remote_endpoint = RemoteEndpointLink.from_entity_optional(instance._client, instance._entity, Relations.REMOTE_ENDPOINT)
 
         instance._extract_current_user()
 

pinexq_client/job_management/hcos/input_dataslot_hco.py

@@ -45,11 +45,13 @@ class InputDataSlotClearDataAction(ActionHco):
 
 
 class InputDataSlotHco(Hco[InputDataSlotEntity]):
-	is_configured: bool | None = Property()
+
 	title: str | None = Property()
 	description: str | None = Property()
+	name: str | None = Property()
 	media_type: str | None = Property()
 	selected_workdatas: list[WorkDataHco]
+	is_configured: bool | None = Property()
 
 	select_workdata_action: InputDataSlotSelectWorkDataAction | UnavailableAction
 	select_workdata_collection_action: InputDataSlotSelectWorkDataCollectionAction | UnavailableAction

pinexq_client/job_management/hcos/output_dataslot_hco.py

@@ -20,6 +20,7 @@ class OutputDataSlotLink(LinkHco):
 class OutputDataSlotHco(Hco[OutputDataSlotEntity]):
     title: str | None = Property()
     description: str | None = Property()
+    name: str | None = Property()
     media_type: str | None = Property()
     assigned_workdatas: list[WorkDataHco]
 

pinexq_client/job_management/hcos/processing_step_hco.py

@@ -11,14 +11,12 @@ from pinexq_client.core.hco.download_link_hco import DownloadLinkHco
 from pinexq_client.core.hco.hco_base import Hco, Property
 from pinexq_client.core.hco.link_hco import LinkHco
 from pinexq_client.core.hco.unavailable import UnavailableAction
-from pinexq_client.core.hco.upload_action_hco import UploadAction, UploadParameters
 from pinexq_client.job_management.known_relations import Relations
-from pinexq_client.job_management.model import CopyPsFromUserToOrgActionParameters, CopyPsFromOrgToUserActionParameters, \
-    DeprecatePsActionParameters, AssignCodeHashParameters
+from pinexq_client.job_management.model import CopyPsFromUserToOrgActionParameters, \
+    DeprecatePsActionParameters, AssignCodeHashParameters, SetProcessingStepTitleParameters
 from pinexq_client.job_management.model.open_api_generated import (DataSpecificationHto,
                                                                    SetProcessingStepTagsParameters,
-                                                                   EditProcessingStepParameters,
-                                                                   ConfigureDeploymentParameters, DeploymentStates)
+                                                                   ConfigureDeploymentParameters, DeploymentStates, ProcessingStepDeploymentHto)
 from pinexq_client.job_management.model.sirenentities import ProcessingStepEntity
 
 
@@ -46,15 +44,6 @@ class ProcessingStepUnHideAction(ActionHco):
         self._execute_internal()
 
 
-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')
@@ -109,11 +98,6 @@ class ClearCodeHashAction(ActionHco):
         self._execute_internal()
 
 
-class UploadConfigurationAction(UploadAction):
-    def execute(self, parameters: UploadParameters):
-        upload_json(self._client, self._action, parameters.json_, parameters.filename)
-
-
 class ProcessingStepCopyFromUserToOrgAction(ActionWithParametersHco[CopyPsFromUserToOrgActionParameters]):
     def execute(self, parameters: CopyPsFromUserToOrgActionParameters) -> ProcessingStepLink:
         url = self._execute_returns_url(parameters)
@@ -125,16 +109,12 @@ class ProcessingStepCopyFromUserToOrgAction(ActionWithParametersHco[CopyPsFromUs
                                             CopyPsFromUserToOrgActionParameters())
 
 
-class ProcessingStepCopyFromOrgToUserAction(ActionWithParametersHco[CopyPsFromOrgToUserActionParameters]):
-    def execute(self, parameters: CopyPsFromOrgToUserActionParameters) -> ProcessingStepLink:
-        url = self._execute_returns_url(parameters)
+class ProcessingStepCopyFromOrgToUserAction(ActionHco):
+    def execute(self) -> ProcessingStepLink:
+        url = self._execute_returns_url()
         link = Link.from_url(url, [str(Relations.CREATED_RESSOURCE)], "Copied Processing Step", MediaTypes.SIREN)
         return ProcessingStepLink.from_link(self._client, link)
 
-    def default_parameters(self) -> CopyPsFromOrgToUserActionParameters:
-        return self._get_default_parameters(CopyPsFromOrgToUserActionParameters,
-                                            CopyPsFromOrgToUserActionParameters())
-
 
 class ProcessingStepDeprecateAction(ActionWithParametersHco[DeprecatePsActionParameters]):
     def execute(self, parameters: DeprecatePsActionParameters):
@@ -163,37 +143,64 @@ class AssignCodeHashAction(ActionWithParametersHco[AssignCodeHashParameters]):
                                             AssignCodeHashParameters())
 
 
+class MakePublicAction(ActionHco):
+    def execute(self):
+        self._execute_internal()
+
+
+class MakePrivateAction(ActionHco):
+    def execute(self):
+        self._execute_internal()
+
+
+class SetTitleAction(ActionWithParametersHco[SetProcessingStepTitleParameters]):
+    def execute(self, parameters: SetProcessingStepTitleParameters):
+        self._execute(parameters)
+
+    def default_parameters(self) -> SetProcessingStepTitleParameters:
+        return self._get_default_parameters(SetProcessingStepTitleParameters,
+                                            SetProcessingStepTitleParameters())
+
+
 class ProcessingStepHco(Hco[ProcessingStepEntity]):
     title: str = Property()
     version: str | None = Property()
     function_name: str | None = Property()
     short_description: str | None = Property()
     long_description: str | None = Property()
+
+    created_by: str | None = Property()
+    owner_id: str | None= Property()
+
     tags: list[str] | None = Property()
     has_parameters: bool | None = Property()
     is_public: bool | None = Property()
-    is_configured: bool | None = Property()
     created_at: datetime | None = Property()
     last_modified_at: datetime | None = Property()
     parameter_schema: str | None = Property()
     default_parameters: str | None = Property()
     return_schema: str | None = Property()
-    error_schema: str | None = Property()
     hidden: bool | None = Property()
-    deprecated_on: datetime | None = Property()
+
+    code_hash: str | None= Property()
+    pro_con_version: str | None = Property()
+
+    deprecated_at: datetime | None = Property()
     reason_for_deprecation: str | None = Property()
     is_deprecated: bool | None = Property()
+
     deployment_state: DeploymentStates = Property()
+    deployment: ProcessingStepDeploymentHto = Property()
 
     input_data_slot_specification: List[DataSpecificationHto] | None = Property()
     output_data_slot_specification: List[DataSpecificationHto] | None = Property()
     edit_tags_action: ProcessingStepEditTagsAction | UnavailableAction
-    edit_properties_action: ProcessingStepEditPropertiesAction | UnavailableAction
     configure_default_parameters_action: ConfigureDefaultParametersAction | UnavailableAction
     clear_default_parameters_action: ClearDefaultParametersAction | UnavailableAction
-    upload_configuration_action: UploadConfigurationAction | None
     hide_action: ProcessingStepHideAction | UnavailableAction
     unhide_action: ProcessingStepUnHideAction | UnavailableAction
+    make_public_action: MakePublicAction | UnavailableAction
+    make_private_action: MakePrivateAction | UnavailableAction
     copy_from_user_to_org_action: ProcessingStepCopyFromUserToOrgAction | UnavailableAction
     copy_from_org_to_user_action: ProcessingStepCopyFromOrgToUserAction | UnavailableAction
     delete_action: DeleteAction | UnavailableAction
@@ -206,6 +213,7 @@ class ProcessingStepHco(Hco[ProcessingStepEntity]):
     suspend_deployment_action: SuspendDeploymentAction | UnavailableAction
     resume_deployment_action: ResumeDeploymentAction | UnavailableAction
     clear_code_hash_action: ClearCodeHashAction | UnavailableAction
+    set_title_action: SetTitleAction | UnavailableAction
 
     self_link: ProcessingStepLink
     download_link: DownloadLinkHco
@@ -222,18 +230,18 @@ class ProcessingStepHco(Hco[ProcessingStepEntity]):
 
         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")
         instance.hide_action = ProcessingStepHideAction.from_entity_optional(
             client, instance._entity, "Hide")
         instance.unhide_action = ProcessingStepUnHideAction.from_entity_optional(
             client, instance._entity, "UnHide")
+        instance.make_public_action = MakePublicAction.from_entity_optional(
+            client, instance._entity, "MakePublic")
+        instance.make_private_action = MakePrivateAction.from_entity_optional(
+            client, instance._entity, "MakePrivate")
         instance.copy_from_user_to_org_action = ProcessingStepCopyFromUserToOrgAction.from_entity_optional(
             client, instance._entity, "CopyToOrg")
         instance.copy_from_org_to_user_action = ProcessingStepCopyFromOrgToUserAction.from_entity_optional(
@@ -258,5 +266,7 @@ class ProcessingStepHco(Hco[ProcessingStepEntity]):
             client, instance._entity, "ResumeDeployment")
         instance.clear_code_hash_action = ClearCodeHashAction.from_entity_optional(
             client, instance._entity, "ClearCodeHash")
+        instance.set_title_action = SetTitleAction.from_entity_optional(
+            client, instance._entity, "EditTitle")
 
         return instance

pinexq_client/job_management/hcos/processingsteproot_hco.py

@@ -1,12 +1,14 @@
 from typing import Self
 
 import httpx
+from httpx import URL
 
-from pinexq_client.core import MediaTypes, Link
+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
@@ -16,7 +18,7 @@ from pinexq_client.job_management.hcos.processingstep_query_result_hco import (
     ProcessingStepQueryResultPaginationLink
 )
 from pinexq_client.job_management.known_relations import Relations
-from pinexq_client.job_management.model import ProcessingStepQueryParameters, CreateProcessingStepParameters
+from pinexq_client.job_management.model import ProcessingStepQueryParameters
 from pinexq_client.job_management.model.sirenentities import ProcessingStepsRootEntity
 
 
@@ -31,15 +33,17 @@ class ProcessingStepQueryAction(ActionWithParametersHco[ProcessingStepQueryParam
         return self._get_default_parameters(ProcessingStepQueryParameters, ProcessingStepQueryParameters())
 
 
-class ProcessingStepRegisterNewAction(ActionWithParametersHco[CreateProcessingStepParameters]):
-    def execute(self, parameters: CreateProcessingStepParameters) -> ProcessingStepHco:
-        url = self._execute_returns_url(parameters)
+class ProcessingStepRegisterNewAction(UploadAction):
+    def execute(self, parameters: UploadParameters) -> ProcessingStepLink:
+        url = upload_json(self._client, self._action, parameters.json_, parameters.filename) # todo handle errors
+        raise_exception_on_error(f"Error while uploading", url)
+
+        if not isinstance(url, URL):
+            raise ClientException("Upload did not respond with location")
+
         link = Link.from_url(url, [str(Relations.CREATED_RESSOURCE)], "Created processing-step", MediaTypes.SIREN)
         # resolve link immediately
-        return ProcessingStepLink.from_link(self._client, link).navigate()
-
-    def default_parameters(self) -> CreateProcessingStepParameters:
-        return self._get_default_parameters(CreateProcessingStepParameters, CreateProcessingStepParameters())
+        return ProcessingStepLink.from_link(self._client, link)
 
 
 class ProcessingStepsRootLink(LinkHco):

pinexq_client/job_management/known_relations.py

@@ -38,3 +38,4 @@ class Relations(StrEnum):
 
     # Deployment
     DEPLOYMENT_REGISTRY_ENDPOINT = "Registry"
+    REMOTE_ENDPOINT = "Remote"