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

{pinexq_client → pinexq/client}/core/api_event_manager.py

@@ -1,15 +1,14 @@
 import queue
 import threading
 import time
+from dataclasses import dataclass
 from datetime import datetime, timedelta
-from pydantic import BaseModel
 
 import httpx
 from httpx_sse import connect_sse
+from pydantic import BaseModel
 
-from dataclasses import dataclass
-
-from pinexq_client.job_management import EntryPointHco, enter_jma
+from ..job_management import EntryPointHco, enter_jma
 
 
 @dataclass

{pinexq_client → pinexq/client}/core/enterapi.py

@@ -1,9 +1,11 @@
+from typing import Type, TypeVar
+
 import httpx
 
-from typing import TypeVar, Type
-from pinexq_client.core.sirenaccess import get_resource, raise_exception_on_error
-from pinexq_client.core.model.sirenmodels import Entity
-from pinexq_client.core.hco.hco_base import Hco
+from .hco.hco_base import Hco
+from .model.sirenmodels import Entity
+from .sirenaccess import get_resource, raise_exception_on_error
+
 
 THco = TypeVar('THco', bound=Hco)
 

{pinexq_client → pinexq/client}/core/exceptions.py

@@ -1,6 +1,6 @@
-from httpx import Response, URL
+from httpx import URL, Response
 
-from pinexq_client.core.model.error import ProblemDetails
+from .model.error import ProblemDetails
 from .model.sirenmodels import TEntity
 
 

{pinexq_client → pinexq/client}/core/hco/action_hco.py

@@ -3,9 +3,9 @@ from typing import TypeVar, Self
 import httpx
 from httpx import URL
 
-from pinexq_client.core import Entity, Action, execute_action, raise_exception_on_error, ClientException
-from pinexq_client.core.hco.hco_base import ClientContainer
-from pinexq_client.core.hco.unavailable import UnavailableAction, HypermediaAvailability
+from .. import Entity, Action, execute_action, raise_exception_on_error, ClientException
+from ..hco.hco_base import ClientContainer
+from ..hco.unavailable import UnavailableAction, HypermediaAvailability
 
 TEntity = TypeVar('TEntity', bound=Entity)
 THcoEntity = TypeVar('THcoEntity', bound=Entity)

{pinexq_client → pinexq/client}/core/hco/action_with_parameters_hco.py

@@ -4,9 +4,9 @@ import httpx
 from httpx import URL
 from pydantic import BaseModel
 
-from pinexq_client.core import Entity, Action, execute_action, raise_exception_on_error, ClientException
-from pinexq_client.core.hco.hco_base import ClientContainer
-from pinexq_client.core.hco.unavailable import UnavailableAction, HypermediaAvailability
+from .. import Entity, Action, execute_action, raise_exception_on_error, ClientException
+from ..hco.hco_base import ClientContainer
+from ..hco.unavailable import UnavailableAction, HypermediaAvailability
 
 TParameters = TypeVar('TParameters', bound=BaseModel)
 
@@ -22,7 +22,7 @@ class ActionWithParametersHco(ClientContainer, Generic[TParameters], HypermediaA
 
         if not action.has_parameters():
             raise ClientException(
-                f"Error while mapping action: expected action with parameters but got none")
+                f"Error while mapping action '{action.name}': expected action with parameters but got none")
 
         instance = cls(client)
         instance._action = action

{pinexq_client → pinexq/client}/core/hco/download_link_hco.py

@@ -3,8 +3,8 @@ from typing import Self
 import httpx
 from httpx import Response
 
-from pinexq_client.core import Link, Entity, get_resource, ClientException
-from pinexq_client.core.hco.link_hco import LinkHco
+from .. import ClientException, Entity, Link, get_resource
+from ..hco.link_hco import LinkHco
 
 
 class DownloadLinkHco(LinkHco):

{pinexq_client → pinexq/client}/core/hco/hco_base.py

@@ -5,7 +5,7 @@ from typing import List, TypeVar, Generic, Callable, Any
 import httpx
 from httpx import URL
 
-from pinexq_client.core import Entity, BaseRelations, Link, ClientException
+from .. import Entity, BaseRelations, Link, ClientException
 
 TEntity = TypeVar('TEntity', bound=Entity)
 THcoEntity = TypeVar('THcoEntity', bound=Entity)

{pinexq_client → pinexq/client}/core/hco/link_hco.py

@@ -1,14 +1,12 @@
 from typing import Self, Type
 
 import httpx
-from httpx import URL
-from httpx import Response
-
-from pinexq_client.core import Link, Entity, navigate, ensure_siren_response, ClientException, raise_exception_on_error, \
-    ApiException
-from pinexq_client.core.hco.hco_base import ClientContainer, TEntity
-from pinexq_client.core.hco.unavailable import UnavailableLink, HypermediaAvailability
-from pinexq_client.core.model.error import ProblemDetails
+from httpx import URL, Response
+
+from .. import ApiException, ClientException, Entity, Link, ensure_siren_response, navigate, raise_exception_on_error
+from ..hco.hco_base import ClientContainer, TEntity
+from ..hco.unavailable import HypermediaAvailability, UnavailableLink
+from ..model.error import ProblemDetails
 
 
 class LinkHco(ClientContainer, HypermediaAvailability):

pinexq/client/core/hco/unavailable.py

@@ -0,0 +1,36 @@
+from abc import ABC, ABCMeta, abstractmethod
+
+from .. import NotAvailableException
+
+
+class HypermediaAvailability(ABC):
+    def __bool__(self) -> bool:
+        return self.is_available()
+
+    @staticmethod
+    @abstractmethod
+    def is_available() -> bool:
+        ...
+
+class UnavailableAction(HypermediaAvailability):
+    """This class is used to represent an action that is not available. It is used to avoid None
+    checks in the code."""
+
+    def execute(self, *args, **kwargs):
+        raise NotAvailableException(f"Error while executing action: action is not available")
+
+    @staticmethod
+    def is_available() -> bool:
+        return False
+
+
+class UnavailableLink(HypermediaAvailability):
+    """This class is used to represent a link that is not available. It is used to avoid None
+    checks in the code."""
+
+    def navigate(self):
+        raise NotAvailableException(f"Error while navigating: link is not available")
+
+    @staticmethod
+    def is_available() -> bool:
+        return False

{pinexq_client → pinexq/client}/core/hco/upload_action_hco.py

@@ -1,14 +1,13 @@
 from io import IOBase
-from typing import Iterable, AsyncIterable, Any, Self
+from typing import Any, AsyncIterable, Iterable, Self
 
 import httpx
 from httpx import URL
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
-from pinexq_client.core import upload_file, upload_binary, upload_json, MediaTypes, Action, Entity, \
-    SirenClasses, ClientException
-from pinexq_client.core.hco.action_with_parameters_hco import ActionWithParametersHco
-from pinexq_client.core.hco.unavailable import UnavailableAction
+from .. import Action, ClientException, Entity, MediaTypes, SirenClasses, upload_binary, upload_file, upload_json
+from ..hco.action_with_parameters_hco import ActionWithParametersHco
+from ..hco.unavailable import UnavailableAction
 
 
 class UploadParameters(BaseModel):

{pinexq_client → 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__ = [9, 0, 0]
+__jma_version__ = [9, 2, 0]

{pinexq_client → pinexq/client}/job_management/enterjma.py

@@ -1,18 +1,20 @@
-from typing import TypeVar, Type
+import warnings
+from typing import Type, TypeVar
 
 import httpx
 from httpx import Client, _config
+
 # from hishel.httpx import SyncCacheClient
 from httpx_caching import CachingClient
 
-import warnings
+import pinexq.client
+
+from ..core import Entity
+from ..core.enterapi import enter_api
+from ..core.hco.hco_base import Hco
+from .hcos import EntryPointHco
+from .model import EntryPointEntity
 
-from pinexq_client.core import Entity
-from pinexq_client.core.enterapi import enter_api
-from pinexq_client.core.hco.hco_base import Hco
-from pinexq_client.job_management.hcos.entrypoint_hco import EntryPointHco
-from pinexq_client.job_management.model.sirenentities import EntryPointEntity
-import pinexq_client.job_management
 
 THco = TypeVar("THco", bound=Hco)
 
@@ -78,7 +80,7 @@ def enter_jma(
     info = entry_point_hco.info_link.navigate()
 
     # Check for matching protocol versions
-    client_version = pinexq_client.job_management.__jma_version__
+    client_version = pinexq.client.job_management.__jma_version__
     jma_version = [int(i) for i in str.split(info.api_version, '.')]
     if not _version_match_major_minor(jma_version, client_version):
         warnings.warn(

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

@@ -3,15 +3,15 @@ from typing import Self
 
 import httpx
 
-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 UnavailableLink
-from pinexq_client.job_management.hcos.info_hco import InfoLink
-from pinexq_client.job_management.hcos.jobsroot_hco import JobsRootLink
-from pinexq_client.job_management.hcos.processingsteproot_hco import ProcessingStepsRootLink
-from pinexq_client.job_management.hcos.workdataroot_hco import WorkDataRootLink
-from pinexq_client.job_management.known_relations import Relations
-from pinexq_client.job_management.model.sirenentities import EntryPointEntity
+from ...core.hco.hco_base import Hco
+from ...core.hco.link_hco import LinkHco
+from ...core.hco.unavailable import UnavailableLink
+from ..known_relations import Relations
+from ..model.sirenentities import EntryPointEntity
+from .info_hco import InfoLink
+from .jobsroot_hco import JobsRootLink
+from .processingsteproot_hco import ProcessingStepsRootLink
+from .workdataroot_hco import WorkDataRootLink
 
 
 class EntryPointLink(LinkHco):

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

@@ -2,11 +2,11 @@ from typing import Self
 
 import httpx
 
-from pinexq_client.core.hco.hco_base import Hco, Property
-from pinexq_client.core.hco.link_hco import LinkHco
-from pinexq_client.job_management.hcos.user_hco import UserHco
-from pinexq_client.job_management.known_relations import Relations
-from pinexq_client.job_management.model.sirenentities import InfoEntity, UserEntity
+from ...core.hco.hco_base import Hco, Property
+from ...core.hco.link_hco import LinkHco
+from ..known_relations import Relations
+from ..model.sirenentities import InfoEntity, UserEntity
+from .user_hco import UserHco
 
 
 class InfoLink(LinkHco):

pinexq/client/job_management/hcos/input_dataslot_hco.py

@@ -0,0 +1,88 @@
+from typing import Self
+
+import httpx
+
+from ...core import Link, MediaTypes
+from ...core.hco.action_hco import ActionHco
+from ...core.hco.action_with_parameters_hco import ActionWithParametersHco
+from ...core.hco.hco_base import Hco, Property
+from ...core.hco.link_hco import LinkHco
+from ...core.hco.unavailable import UnavailableAction
+from ...core.hco.upload_action_hco import UploadAction, UploadParameters
+from ..hcos.workdata_hco import WorkDataHco, WorkDataLink
+from ..known_relations import Relations
+from ..model.open_api_generated import (
+    SelectWorkDataCollectionForDataSlotParameters,
+    SelectWorkDataForDataSlotParameters,
+)
+from ..model.sirenentities import InputDataSlotEntity, WorkDataEntity
+
+
+class InputDataSlotLink(LinkHco):
+    def navigate(self) -> 'InputDataSlotHco':
+        return InputDataSlotHco.from_entity(self._navigate_internal(InputDataSlotEntity), self._client)
+
+
+class InputDataSlotSelectWorkDataAction(ActionWithParametersHco[SelectWorkDataForDataSlotParameters]):
+    def execute(self, parameters: SelectWorkDataForDataSlotParameters):
+        self._execute(parameters)
+
+
+class InputDataSlotSelectWorkDataCollectionAction(
+    ActionWithParametersHco[SelectWorkDataCollectionForDataSlotParameters]):
+    def execute(self, parameters: SelectWorkDataCollectionForDataSlotParameters):
+        self._execute(parameters)
+
+
+class InputDataSlotUploadWorkDataAction(UploadAction):
+    def execute(self, parameters: UploadParameters) -> WorkDataLink:
+        url = self._upload(parameters)
+        link = Link.from_url(url, [str(Relations.CREATED_RESSOURCE)], "Uploaded workdata", MediaTypes.SIREN)
+        return WorkDataLink.from_link(self._client, link)
+
+
+class InputDataSlotClearDataAction(ActionHco):
+    def execute(self):
+        self._execute_internal()
+
+
+class InputDataSlotHco(Hco[InputDataSlotEntity]):
+
+    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
+    clear_workdata_action: InputDataSlotClearDataAction | UnavailableAction
+
+    @classmethod
+    def from_entity(cls, entity: InputDataSlotEntity, client: httpx.Client) -> Self:
+        instance = cls(client, entity)
+        Hco.check_classes(instance._entity.class_, ["InputDataSlot"])
+
+        # actions
+        instance.select_workdata_action = InputDataSlotSelectWorkDataAction.from_entity_optional(
+            client, instance._entity, "SelectWorkData")
+        instance.select_workdata_collection_action = InputDataSlotSelectWorkDataCollectionAction.from_entity_optional(
+            client, instance._entity, "SelectWorkDataCollection")
+        instance.clear_workdata_action = InputDataSlotClearDataAction.from_entity_optional(
+            client, instance._entity, "Clear")
+
+        instance._extract_workdata()
+
+        return instance
+
+    def _extract_workdata(self):
+        self.selected_workdatas = []
+
+        workdatas: list[WorkDataEntity] = self._entity.find_all_entities_with_relation(Relations.SELECTED,
+                                                                                       WorkDataEntity)
+        if not workdatas:
+            return
+
+        self.selected_workdatas = [WorkDataHco.from_entity(workdata, self._client)
+                                   for workdata in workdatas]

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

@@ -1,24 +1,30 @@
 from datetime import datetime
-from typing import Self, List, TYPE_CHECKING
+from typing import TYPE_CHECKING, List, Self
 
 import httpx
 from pydantic import BaseModel, ConfigDict
 
-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.hco_base import Hco, Property
-from pinexq_client.core.hco.link_hco import LinkHco
-from pinexq_client.core.hco.unavailable import UnavailableAction, UnavailableLink
-from pinexq_client.job_management.hcos.processing_step_hco import ProcessingStepLink
-from pinexq_client.job_management.known_relations import Relations
-from pinexq_client.job_management.model import SetJobErrorStateParameters
-from pinexq_client.job_management.model.open_api_generated import JobStates, ProcessingView, RenameJobParameters, \
-    SelectProcessingParameters, SetJobTagsParameters
-from pinexq_client.job_management.model.sirenentities import JobEntity, InputDataSlotEntity, OutputDataSlotEntity
+from ...core.hco.action_hco import ActionHco
+from ...core.hco.action_with_parameters_hco import ActionWithParametersHco
+from ...core.hco.hco_base import Hco, Property
+from ...core.hco.link_hco import LinkHco
+from ...core.hco.unavailable import UnavailableAction, UnavailableLink
+from ..hcos.processing_step_hco import ProcessingStepLink
+from ..known_relations import Relations
+from ..model import SetJobErrorStateParameters
+from ..model.open_api_generated import (
+    JobStates,
+    ProcessingView,
+    RenameJobParameters,
+    SelectProcessingParameters,
+    SetJobTagsParameters, TagDetailsHto,
+)
+from ..model.sirenentities import InputDataSlotEntity, JobEntity, OutputDataSlotEntity
+
 
 if TYPE_CHECKING:
-    from pinexq_client.job_management.hcos.input_dataslot_hco import InputDataSlotHco
-    from pinexq_client.job_management.hcos.output_dataslot_hco import OutputDataSlotHco
+    from pinexq.client.job_management.hcos.input_dataslot_hco import InputDataSlotHco
+    from pinexq.client.job_management.hcos.output_dataslot_hco import OutputDataSlotHco
 
 
 class JobRenameAction(ActionWithParametersHco[RenameJobParameters]):
@@ -115,6 +121,7 @@ class JobHco(Hco[JobEntity]):
     state: JobStates = Property()
     hidden: bool = Property()
     tags: list[str] | None = Property()
+    tag_details: List[TagDetailsHto] | None = Property()
     output_is_deletable: bool = Property()
     created_at: datetime = Property()
     started_at: datetime = Property()
@@ -186,7 +193,7 @@ class JobHco(Hco[JobEntity]):
         return instance
 
     def _extract_input_dataslots(self):
-        from pinexq_client.job_management.hcos.input_dataslot_hco import InputDataSlotHco
+        from pinexq.client.job_management.hcos.input_dataslot_hco import InputDataSlotHco
         self.input_dataslots = []
         input_dataslots = self._entity.find_all_entities_with_relation(Relations.INPUT_DATASLOT, InputDataSlotEntity)
         for input_dataslot in input_dataslots:
@@ -194,7 +201,7 @@ class JobHco(Hco[JobEntity]):
             self.input_dataslots.append(input_dataslot_hco)
 
     def _extract_output_dataslots(self):
-        from pinexq_client.job_management.hcos.output_dataslot_hco import OutputDataSlotHco
+        from pinexq.client.job_management.hcos.output_dataslot_hco import OutputDataSlotHco
         self.output_dataslots = []
         output_dataslots = self._entity.find_all_entities_with_relation(Relations.OUTPUT_DATASLOT, OutputDataSlotEntity)
         for output_dataslot in output_dataslots:

pinexq/client/job_management/hcos/job_query_result_hco.py

@@ -0,0 +1,89 @@
+from typing import Iterator, List, Self
+
+import httpx
+
+from ...core.hco.hco_base import Hco, Property
+from ...core.hco.link_hco import LinkHco
+from ...core.hco.unavailable import UnavailableLink
+from ..hcos.job_hco import JobHco
+from ..known_relations import Relations
+from ..model.sirenentities import JobEntity, JobQueryResultEntity
+
+
+class JobQueryResultPaginationLink(LinkHco):
+    def navigate(self) -> 'JobQueryResultHco':
+        return JobQueryResultHco.from_entity(self._client, self._navigate_internal(JobQueryResultEntity))
+
+
+class JobQueryResultLink(LinkHco):
+    def navigate(self) -> 'JobQueryResultHco':
+        return JobQueryResultHco.from_entity(self._client, self._navigate_internal(JobQueryResultEntity))
+
+
+class JobQueryResultHco(Hco[JobQueryResultEntity]):
+    self_link: JobQueryResultLink
+    all_link: JobQueryResultPaginationLink | UnavailableLink
+    first_link: JobQueryResultPaginationLink | UnavailableLink
+    last_link: JobQueryResultPaginationLink | UnavailableLink
+    next_link: JobQueryResultPaginationLink | UnavailableLink
+    previous_link: JobQueryResultPaginationLink | UnavailableLink
+
+    total_entities: int = Property()
+    current_entities_count: int = Property()
+    jobs: List[JobHco]
+    remaining_tags: List[str] | None = Property()
+
+    @classmethod
+    def from_entity(cls, client: httpx.Client, entity: JobQueryResultEntity) -> 'JobQueryResultHco':
+        instance = cls(client, entity)
+
+        Hco.check_classes(instance._entity.class_, ["JobQueryResult"])
+
+        # pagination links
+        instance.self_link = JobQueryResultLink.from_entity(instance._client, instance._entity, Relations.SELF)
+        instance.all_link = JobQueryResultPaginationLink.from_entity_optional(instance._client, instance._entity,
+                                                                              Relations.ALL)
+        instance.first_link = JobQueryResultPaginationLink.from_entity_optional(instance._client, instance._entity,
+                                                                                Relations.FIRST)
+        instance.last_link = JobQueryResultPaginationLink.from_entity_optional(instance._client, instance._entity,
+                                                                               Relations.LAST)
+        instance.next_link = JobQueryResultPaginationLink.from_entity_optional(instance._client, instance._entity,
+                                                                               Relations.NEXT)
+        instance.previous_link = JobQueryResultPaginationLink.from_entity_optional(instance._client, instance._entity,
+                                                                                   Relations.PREVIOUS)
+
+        # entities
+        instance._extract_jobs()
+
+        return instance
+
+    def _extract_jobs(self):
+        self.jobs = []
+        jobs = self._entity.find_all_entities_with_relation(Relations.ITEM, JobEntity)
+        for job in jobs:
+            job_hco: JobHco = JobHco.from_entity(job, self._client)
+            self.jobs.append(job_hco)
+
+    def iter(self) -> Iterator[Self]:
+        """
+        Returns an Iterator of `JobQueryResultHco` so that all pages can be processed in a loop.
+
+        Returns:
+            An iterator of `JobQueryResultHco` objects
+        """
+        result = self
+        while result is not None:
+            yield result
+            if isinstance(result.next_link, UnavailableLink):
+                return
+            result = result.next_link.navigate()
+
+    def iter_flat(self) -> Iterator[JobHco]:
+        """
+        Returns an Iterator of `JobHco` so that all jobs can be processed in a loop.
+
+        Returns:
+            An iterator of `JobHco` objects
+        """
+        for page in self.iter():
+            yield from page.jobs

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

@@ -2,11 +2,11 @@ from typing import List, Self
 
 import httpx
 
-from pinexq_client.core.hco.hco_base import Hco, Property
-from pinexq_client.core.hco.link_hco import LinkHco
-from pinexq_client.job_management.known_relations import Relations
-from pinexq_client.job_management.model import JobUsedTagsEntityAdmin
-from pinexq_client.job_management.model.sirenentities import JobUsedTagsEntity
+from ...core.hco.hco_base import Hco, Property
+from ...core.hco.link_hco import LinkHco
+from ..known_relations import Relations
+from ..model import JobUsedTagsEntityAdmin
+from ..model.sirenentities import JobUsedTagsEntity
 
 
 class JobUsedTagsHco(Hco[JobUsedTagsEntity]):

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

@@ -3,25 +3,22 @@ from typing import Self
 import httpx
 from httpx import URL
 
-from pinexq_client.core import MediaTypes, Link
-from pinexq_client.core.hco.action_with_parameters_hco import ActionWithParametersHco
-from pinexq_client.core.hco.hco_base import Hco
-from pinexq_client.core.hco.link_hco import LinkHco
-from pinexq_client.core.hco.unavailable import UnavailableAction, UnavailableLink
-from pinexq_client.job_management.hcos.job_hco import JobLink
-from pinexq_client.job_management.hcos.job_query_result_hco import (
-    JobQueryResultHco,
-    JobQueryResultLink
-)
-from pinexq_client.job_management.hcos.job_used_tags_hco import JobUsedTagsLink, JobUsedTagsAdminLink
-from pinexq_client.job_management.known_relations import Relations
-from pinexq_client.job_management.model import RapidJobSetupParameters
-from pinexq_client.job_management.model.open_api_generated import (
+from ...core import Link, MediaTypes
+from ...core.hco.action_with_parameters_hco import ActionWithParametersHco
+from ...core.hco.hco_base import Hco
+from ...core.hco.link_hco import LinkHco
+from ...core.hco.unavailable import UnavailableAction, UnavailableLink
+from ..hcos.job_hco import JobLink
+from ..hcos.job_query_result_hco import JobQueryResultHco, JobQueryResultLink
+from ..hcos.job_used_tags_hco import JobUsedTagsAdminLink, JobUsedTagsLink
+from ..known_relations import Relations
+from ..model import RapidJobSetupParameters
+from ..model.open_api_generated import (
     CreateJobParameters,
+    CreateSubJobParameters,
     JobQueryParameters,
-    CreateSubJobParameters
 )
-from pinexq_client.job_management.model.sirenentities import JobsRootEntity
+from ..model.sirenentities import JobsRootEntity
 
 
 class CreateJobAction(ActionWithParametersHco[CreateJobParameters]):

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

@@ -2,19 +2,16 @@ from typing import Self
 
 import httpx
 
-from pinexq_client.core.hco.hco_base import Hco, Property
-from pinexq_client.core.hco.link_hco import LinkHco
-from pinexq_client.job_management.hcos.workdata_hco import WorkDataHco
-from pinexq_client.job_management.known_relations import Relations
-from pinexq_client.job_management.model.sirenentities import (
-    OutputDataSlotEntity,
-    WorkDataEntity
-)
+from ...core.hco.hco_base import Hco, Property
+from ...core.hco.link_hco import LinkHco
+from ..hcos.workdata_hco import WorkDataHco
+from ..known_relations import Relations
+from ..model.sirenentities import OutputDataSlotEntity, WorkDataEntity
 
 
 class OutputDataSlotLink(LinkHco):
     def navigate(self) -> 'OutputDataSlotHco':
-        return OutputDataSlotHco.from_entity(self._navigate_internal(OutputDataSlotEntity), self._client)
+        return OutputDataSlotHco.from_entity(self._navigate_internal(OutputDataSlotEntity), self._pinexq.client)
 
 
 class OutputDataSlotHco(Hco[OutputDataSlotEntity]):