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

pinexq_client/core/enterapi.py

@@ -1,17 +1,16 @@
-from typing import TypeVar, Type
-
 import httpx
 
-from pinexq_client.core import Entity
+from typing import TypeVar, Type
+from pinexq_client.core import Entity, get_resource, raise_exception_on_error
 from pinexq_client.core.hco.hco_base import Hco
 
 THco = TypeVar('THco', bound=Hco)
 
 
-def enter_api(client: httpx.Client, entrypoint_hco_type: Type[THco], entrypoint_entity_type: Type[Entity] = Entity,
+def enter_api(client: httpx.Client,
+              entrypoint_hco_type: Type[THco],
+              entrypoint_entity_type: Type[Entity] = Entity,
               entrypoint: str = "api/EntryPoint") -> THco:
-    entry_point_response = client.get(url=entrypoint)
-    entry_point_response.raise_for_status()
-    entrypoint_entity = entrypoint_entity_type.model_validate_json(entry_point_response.read())
-
-    return entrypoint_hco_type.from_entity(entrypoint_entity, client)
+    entry_point_response = get_resource(client=client, href=entrypoint, parse_type=entrypoint_entity_type)
+    raise_exception_on_error("Error accessing the API", entry_point_response)
+    return entrypoint_hco_type.from_entity(entry_point_response, client)

pinexq_client/core/exceptions.py

@@ -1,2 +1,73 @@
-class SirenException(Exception):
-    pass
+from httpx import Response, URL
+
+from pinexq_client.core.model.error import ProblemDetails
+from .model.sirenmodels import TEntity
+
+
+class ClientException(Exception):
+    """
+    Base class for all exceptions that are thrown by the PinexQ client.
+    """
+
+    def __init__(self, message: str):
+        self.message = message
+
+
+class NotAvailableException(ClientException):
+    """
+    Exception that is thrown when an action or a link is not available.
+    """
+
+
+class ApiException(Exception):
+    """
+    Base class for all exceptions that are thrown by the PinexQ API.
+    """
+    status: int = None  # default status code, can be overridden in subclasses
+    problem_details: ProblemDetails | None = None
+
+    def __init__(self, message: str, problem_details: ProblemDetails | None = None):
+        super().__init__(message)
+        self.problem_details = problem_details
+
+    def __str__(self) -> str:
+        message = super().__str__()
+        if self.problem_details:
+            message += f"\n{self.problem_details}"
+        return message
+
+
+class TemporarilyNotAvailableException(ApiException):
+    """
+    Exception that is thrown when the API returns a 503 status code.
+
+    """
+    status: int = 503
+
+
+class TooManyRequestsException(ApiException):
+    """
+    Exception that is thrown when the API returns a 429 status code.
+
+    """
+    status: int = 429
+
+
+def raise_exception_on_error(message: str, response: TEntity | Response | ProblemDetails | URL | None):
+    match response:
+        case ProblemDetails() as problem_details:
+            match problem_details.status:
+                case 429:
+                    raise TooManyRequestsException(message, problem_details)
+                case 503:
+                    raise TemporarilyNotAvailableException(message, problem_details)
+                case _:
+                    raise ApiException(message, problem_details)
+        case Response() as http_response:
+            match http_response.status_code:
+                case 429:
+                    raise TooManyRequestsException(message)
+                case 503:
+                    raise TemporarilyNotAvailableException(message)
+                case _:
+                    raise ApiException(message)

pinexq_client/core/hco/action_hco.py

@@ -1,11 +1,11 @@
 from typing import TypeVar, Self
 
 import httpx
-from httpx import Response
 from httpx import URL
 
-from pinexq_client.core import SirenException, Entity, Action, ProblemDetails, execute_action
+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
 
 TEntity = TypeVar('TEntity', bound=Entity)
 THcoEntity = TypeVar('THcoEntity', bound=Entity)
@@ -16,21 +16,21 @@ class ActionHco(ClientContainer):
     _action: Action
 
     @classmethod
-    def from_action_optional(cls, client: httpx.Client, action: Action | None) -> Self | None:
+    def from_action_optional(cls, client: httpx.Client, action: Action | None) -> Self | UnavailableAction:
         if action is None:
-            return None
+            return UnavailableAction()
 
         if action.has_parameters():
-            raise SirenException(f"Error while mapping action: expected action no parameters but got some")
+            raise ClientException(f"Error while mapping action: expected action no parameters but got some")
 
         instance = cls(client)
         instance._action = action
         return instance
 
     @classmethod
-    def from_entity_optional(cls, client: httpx.Client, entity: Entity, name: str) -> Self | None:
+    def from_entity_optional(cls, client: httpx.Client, entity: Entity, name: str) -> Self | UnavailableAction:
         if entity is None:
-            return None
+            return UnavailableAction()
 
         action = entity.find_first_action_with_name(name)
         return cls.from_action_optional(client, action)
@@ -38,33 +38,23 @@ class ActionHco(ClientContainer):
     @classmethod
     def from_action(cls, client: httpx.Client, action: Action) -> Self:
         action = cls.from_action_optional(client, action)
-        if action is None:
-            raise SirenException(
+        if isinstance(action, UnavailableAction):
+            raise ClientException(
                 f"Error while mapping mandatory action: does not exist")
         return action
 
     @classmethod
     def from_entity(cls, client: httpx.Client, entity: Entity, name: str) -> Self:
         result = cls.from_entity_optional(client, entity, name)
-        if result is None:
-            raise SirenException(
+        if isinstance(result, UnavailableAction):
+            raise ClientException(
                 f"Error while mapping mandatory action {name}: does not exist")
         return result
 
     def _execute_internal(self) -> None | URL:
         response = execute_action(self._client, self._action)
-
-        if isinstance(response, ProblemDetails):
-            raise SirenException(
-                f"Error while executing action: {response}")
-        if isinstance(response, Response):
-            raise SirenException(
-                f"Error while executing action, unexpected response: {response}")
+        raise_exception_on_error(f"Error while executing action, unexpected response", response)
         return response
 
     def __repr__(self):
         return f"<{self.__class__.__name__}: '{self._action.name}'>"
-
-
-
-

pinexq_client/core/hco/action_with_parameters_hco.py

@@ -1,12 +1,12 @@
 from typing import TypeVar, Type, Self, Generic
 
 import httpx
-from httpx import Response
 from httpx import URL
 from pydantic import BaseModel
 
-from pinexq_client.core import SirenException, Entity, Action, ProblemDetails, execute_action
+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
 
 TParameters = TypeVar('TParameters', bound=BaseModel)
 
@@ -16,12 +16,12 @@ class ActionWithParametersHco(ClientContainer, Generic[TParameters]):
     _action: Action
 
     @classmethod
-    def from_action_optional(cls, client: httpx.Client, action: Action | None) -> Self | None:
+    def from_action_optional(cls, client: httpx.Client, action: Action | None) -> Self | UnavailableAction:
         if action is None:
-            return None
+            return UnavailableAction()
 
         if not action.has_parameters():
-            raise SirenException(
+            raise ClientException(
                 f"Error while mapping action: expected action with parameters but got none")
 
         instance = cls(client)
@@ -29,9 +29,9 @@ class ActionWithParametersHco(ClientContainer, Generic[TParameters]):
         return instance
 
     @classmethod
-    def from_entity_optional(cls, client: httpx.Client, entity: Entity, name: str) -> Self | None:
+    def from_entity_optional(cls, client: httpx.Client, entity: Entity, name: str) -> Self | UnavailableAction:
         if entity is None:
-            return None
+            return UnavailableAction()
 
         action = entity.find_first_action_with_name(name)
         return cls.from_action_optional(client, action)
@@ -39,43 +39,37 @@ class ActionWithParametersHco(ClientContainer, Generic[TParameters]):
     @classmethod
     def from_action(cls, client: httpx.Client, action: Action) -> Self:
         action = cls.from_action_optional(client, action)
-        if action is None:
-            raise SirenException(
+        if isinstance(action, UnavailableAction):
+            raise ClientException(
                 f"Error while mapping mandatory action: action does not exist")
         return action
 
     @classmethod
     def from_entity(cls, client: httpx.Client, entity: Entity, name: str) -> Self:
         result = cls.from_entity_optional(client, entity, name)
-        if result is None:
-            raise SirenException(
+        if isinstance(result, UnavailableAction):
+            raise ClientException(
                 f"Error while mapping mandatory action {name}: action does not exist")
         return result
 
     def _execute_internal(self, parameters: BaseModel) -> None | URL:
         if parameters is None:
-            raise SirenException(f"Error while executing action: action requires parameters")
+            raise ClientException(f"Error while executing action: action requires parameters")
 
         response = execute_action(self._client, self._action, parameters)
-
-        if isinstance(response, ProblemDetails):
-            raise SirenException(
-                f"Error while executing action: {response}")
-        if isinstance(response, Response):
-            raise SirenException(
-                f"Error while executing action, unexpected response: {response}")
+        raise_exception_on_error(f"Error while executing action, unexpected response", response)
         return response
 
     def _execute(self, parameters: TParameters):
         result = self._execute_internal(parameters)
         if result is not None:
-            raise SirenException("Action did respond with unexpected URL")
+            raise ClientException("Action did respond with unexpected URL")
         return
 
     def _execute_returns_url(self, parameters: TParameters) -> URL:
         result = self._execute_internal(parameters)
         if result is None:
-            raise SirenException("Action did not respond with URL")
+            raise ClientException("Action did not respond with URL")
         return result
 
     def _get_default_parameters(self, parameter_type: Type[TParameters],

pinexq_client/core/hco/download_link_hco.py

@@ -1,10 +1,9 @@
-from io import BytesIO
 from typing import Self
 
 import httpx
 from httpx import Response
 
-from pinexq_client.core import Link, Entity, get_resource, SirenException
+from pinexq_client.core import Link, Entity, get_resource, ClientException
 from pinexq_client.core.hco.link_hco import LinkHco
 
 
@@ -29,7 +28,7 @@ class DownloadLinkHco(LinkHco):
     def download(self) -> bytes:
         response: Response = get_resource(self._client, self._link.href, self._link.type)
         if not isinstance(response, Response):
-            raise SirenException(
+            raise ClientException(
                 f"Error while downloading resource: did not get response type")
 
         return response.content

pinexq_client/core/hco/hco_base.py

@@ -4,7 +4,7 @@ from typing import List, TypeVar, Generic, Callable, Any
 import httpx
 from httpx import URL
 
-from pinexq_client.core import SirenException, Entity, BaseRelations, Link
+from pinexq_client.core import Entity, BaseRelations, Link, ClientException
 
 TEntity = TypeVar('TEntity', bound=Entity)
 THcoEntity = TypeVar('THcoEntity', bound=Entity)
@@ -64,7 +64,7 @@ class Hco(ClientContainer, Generic[THcoEntity]):
     def check_classes(existing_classes: List[str], expected_classes: List[str]):
         for expected_class in expected_classes:
             if expected_class not in existing_classes:
-                raise SirenException(
+                raise ClientException(
                     f"Error while mapping entity:expected hco class {expected_class} is not a class of generic entity "
                     f"with classes {existing_classes}")
 
@@ -88,4 +88,3 @@ class Hco(ClientContainer, Generic[THcoEntity]):
             if hco_property.converter:
                 property_value = hco_property.converter(property_value)
             setattr(self, var_name, property_value)
-

pinexq_client/core/hco/link_hco.py

@@ -3,8 +3,9 @@ from typing import Self, Type
 import httpx
 from httpx import URL
 
-from pinexq_client.core import Link, SirenException, Entity, navigate, ensure_siren_response
+from pinexq_client.core import Link, Entity, navigate, ensure_siren_response, ClientException
 from pinexq_client.core.hco.hco_base import ClientContainer, TEntity
+from pinexq_client.core.hco.unavailable import UnavailableLink
 
 
 class LinkHco(ClientContainer):
@@ -12,18 +13,18 @@ class LinkHco(ClientContainer):
     _link: Link
 
     @classmethod
-    def from_link_optional(cls, client: httpx.Client, link: Link | None) -> Self | None:
+    def from_link_optional(cls, client: httpx.Client, link: Link | None) -> Self | UnavailableLink:
         if link is None:
-            return None
+            return UnavailableLink()
 
         instance = cls(client)
         instance._link = link
         return instance
 
     @classmethod
-    def from_entity_optional(cls, client: httpx.Client, entity: Entity, link_relation: str) -> Self | None:
+    def from_entity_optional(cls, client: httpx.Client, entity: Entity, link_relation: str) -> Self | UnavailableLink:
         if entity is None:
-            return None
+            return UnavailableLink()
 
         link = entity.find_first_link_with_relation(link_relation)
         return cls.from_link_optional(client, link)
@@ -31,16 +32,16 @@ class LinkHco(ClientContainer):
     @classmethod
     def from_link(cls, client: httpx.Client, link: Link) -> Self:
         result = cls.from_link_optional(client, link)
-        if result is None:
-            raise SirenException(f"Error while mapping mandatory link: link is None")
+        if isinstance(result, UnavailableLink):
+            raise ClientException(f"Error while mapping mandatory link: link is None")
 
         return result
 
     @classmethod
     def from_entity(cls, client: httpx.Client, entity: Entity, link_relation: str) -> Self:
         result = cls.from_entity_optional(client, entity, link_relation)
-        if result is None:
-            raise SirenException(
+        if isinstance(result, UnavailableLink):
+            raise ClientException(
                 f"Error while mapping mandatory link: entity contains no link with relation {link_relation}")
 
         return result

pinexq_client/core/hco/unavailable.py

@@ -0,0 +1,17 @@
+from pinexq_client.core import NotAvailableException
+
+
+class UnavailableAction:
+	"""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")
+
+
+class UnavailableLink:
+	"""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")

pinexq_client/core/hco/upload_action_hco.py

@@ -1,13 +1,14 @@
 from io import IOBase
-from typing import BinaryIO, Iterable, AsyncIterable, Any, Self, List
+from typing import Iterable, AsyncIterable, Any, 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, SirenException, MediaTypes, Action, Entity, \
-    SirenClasses
+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
 
 
 class UploadParameters(BaseModel):
@@ -42,7 +43,7 @@ class UploadAction(ActionWithParametersHco[UploadParameters]):
     def from_action_optional(cls, client: httpx.Client, action: Action | None) -> Self | None:
         instance = super(UploadAction, cls).from_action_optional(client, action)
 
-        if instance:
+        if not isinstance(instance, UnavailableAction):
             cls.validate_file_upload_field(instance)
             cls.assign_upload_constraints(instance)
         return instance
@@ -51,7 +52,7 @@ class UploadAction(ActionWithParametersHco[UploadParameters]):
     def from_entity_optional(cls, client: httpx.Client, entity: Entity, name: str) -> Self | None:
         instance = super(UploadAction, cls).from_entity_optional(client, entity, name)
 
-        if instance:
+        if not isinstance(instance, UnavailableAction):
             cls.validate_file_upload_field(instance)
             cls.assign_upload_constraints(instance)
         return instance
@@ -80,17 +81,17 @@ class UploadAction(ActionWithParametersHco[UploadParameters]):
     def validate_file_upload_field(self):
         action = self._action
         if SirenClasses.FileUploadAction not in action.class_:
-            raise SirenException(
+            raise ClientException(
                 f"Upload action does not have expected class: {str(SirenClasses.FileUploadAction)}. Got: {action.class_}")
 
         if action.type != MediaTypes.MULTIPART_FORM_DATA.value:
-            raise SirenException(
+            raise ClientException(
                 f"Upload action does not have expected type: {str(MediaTypes.MULTIPART_FORM_DATA)}. Got: {action.type}")
 
         upload_fields = self._action.fields[0]
 
         if upload_fields.type != "file":
-            raise SirenException(
+            raise ClientException(
                 f"Upload action does not have expected field type: 'file'. Got: {upload_fields.type}")
 
     def _upload(self, parameters: UploadParameters) -> URL:
@@ -106,8 +107,8 @@ class UploadAction(ActionWithParametersHco[UploadParameters]):
         elif parameters.json_ is not None:
             result = upload_json(self._client, self._action, parameters.json_, parameters.filename)
         else:
-            raise SirenException("Did not execute upload, none selected")
+            raise ClientException("Did not execute upload, none selected")
 
         if not isinstance(result, URL):
-            raise SirenException("Upload did not respond with location")
+            raise ClientException("Upload did not respond with location")
         return result

pinexq_client/core/model/error.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel
+from pydantic import BaseModel, Field, ConfigDict
 
 
 class ProblemDetails(BaseModel):
@@ -7,3 +7,7 @@ class ProblemDetails(BaseModel):
     status: int | None = None
     detail: str | None = None
     instance: str | None = None
+
+    def __str__(self):
+        message = [f"  {key}: {value}" for key, value in self.model_dump().items() if value]
+        return str.join("\n", message)

pinexq_client/core/sirenaccess.py

@@ -1,22 +1,19 @@
 import json
-import logging
+import warnings
 from io import BytesIO
 from typing import Any, BinaryIO, Iterable, AsyncIterable
 
 import httpx
-from httpx import Response
-from httpx import URL
+from httpx import Response, URL
 from pydantic import BaseModel
 
-from .exceptions import SirenException
-from .http_headers import Headers
 from .base_relations import BaseRelations
+from .exceptions import raise_exception_on_error, ClientException
+from .http_headers import Headers
 from .media_types import MediaTypes
 from .model.error import ProblemDetails
 from .model.sirenmodels import Entity, Link, Action, TEntity
 
-logger = logging.getLogger(__name__)
-
 
 # for now, we do not support navigations to non siren links (e.g. external)
 def get_resource(client: httpx.Client, href: str, media_type: str = MediaTypes.SIREN,
@@ -25,13 +22,13 @@ def get_resource(client: httpx.Client, href: str, media_type: str = MediaTypes.S
         # assume get for links
         response = client.get(href)
     except (httpx.ConnectTimeout, httpx.ConnectError) as exc:
-        raise SirenException(f"Http-client error requesting resource: {href}") from exc
+        raise ClientException(f"Http-client error requesting resource: {href}") from exc
     expected_type = media_type or MediaTypes.SIREN  # if not specified expect siren
 
     if response.status_code == httpx.codes.OK:
         if (media_type := response.headers.get(Headers.CONTENT_TYPE, MediaTypes.SIREN)) != expected_type:
-            logger.warning(f"Expected type {expected_type} not matched by response: "
-                           f"' got: '{media_type}'")
+            warnings.warn(f"Expected type {expected_type} not matched by response: "
+                          f"' got: '{media_type}'")
 
         if media_type == MediaTypes.SIREN.value or media_type is None:  # assume siren if not specified
             resp = response.content.decode()
@@ -43,7 +40,7 @@ def get_resource(client: httpx.Client, href: str, media_type: str = MediaTypes.S
     elif response.status_code >= 400:
         return handle_error_response(response)
     else:
-        logger.warning(f"Unexpected return code: {response.status_code}")
+        warnings.warn(f"Unexpected return code: {response.status_code}")
         return response
 
 
@@ -53,12 +50,7 @@ def navigate(client: httpx.Client, link: Link,
 
 
 def ensure_siren_response(response: TEntity | ProblemDetails | Response) -> TEntity:
-    if isinstance(response, ProblemDetails):
-        raise SirenException(
-            f"Error while navigating: {response}")
-    if isinstance(response, Response):
-        raise SirenException(
-            f"Error while navigating, unexpected response: {response}")
+    raise_exception_on_error(f"Error while navigating, unexpected response", response)
     return response
 
 
@@ -70,7 +62,6 @@ def upload_json(client: httpx.Client, action: Action, json_payload: Any,
 def upload_binary(client: httpx.Client, action: Action, content: str | bytes | Iterable[bytes] | AsyncIterable[bytes],
                   filename: str,
                   mediatype: str = MediaTypes.OCTET_STREAM) -> None | URL | ProblemDetails | Response:
-
     if isinstance(content, str):
         payload = BytesIO(content.encode(encoding="utf-8"))
     elif isinstance(content, bytes):
@@ -86,21 +77,21 @@ def upload_binary(client: httpx.Client, action: Action, content: str | bytes | I
 def upload_file(client: httpx.Client, action: Action, file: BinaryIO, filename: str,
                 mediatype: str = MediaTypes.OCTET_STREAM) -> None | URL | ProblemDetails | Response:
     if action.type != MediaTypes.MULTIPART_FORM_DATA:
-        raise SirenException(
+        raise ClientException(
             f"Action with upload requires type: {MediaTypes.MULTIPART_FORM_DATA} but found: {action.type}")
 
     files = {'upload-file': (filename, file, mediatype)}
     try:
         response = client.request(method=action.method, url=action.href, files=files)
     except httpx.RequestError as exc:
-        raise SirenException(f"Error from httpx while uploading data to: {action.href}") from exc
+        raise ClientException(f"Error from httpx while uploading data to: {action.href}") from exc
     return handle_action_result(response)
 
 
 def execute_action_on_entity(client: httpx.Client, entity: Entity, name: str, parameters: BaseModel | None = None):
     action = entity.find_first_action_with_name(name)
     if action is None:
-        raise SirenException(f"Entity does not contain expected action: {name}")
+        raise ClientException(f"Entity does not contain expected action: {name}")
 
     return execute_action(client, action, parameters)
 
@@ -110,11 +101,11 @@ def execute_action(client: httpx.Client, action: Action,
     if action.has_parameters() is False:
         # no parameters required
         if parameters is not None:
-            raise SirenException(f"Action requires no parameters but got some")
+            raise ClientException(f"Action requires no parameters but got some")
     else:
         # parameters required
         if parameters is None:
-            raise SirenException(f"Action requires parameters but non provided")
+            raise ClientException(f"Action requires parameters but non provided")
 
     action_parameters = None
     if parameters is not None:
@@ -128,7 +119,7 @@ def execute_action(client: httpx.Client, action: Action,
             headers={Headers.CONTENT_TYPE.value: MediaTypes.APPLICATION_JSON.value}
         )
     except httpx.RequestError as exc:
-        raise SirenException(f"Error from httpx while executing action: {action.href}") from exc
+        raise ClientException(f"Error from httpx while executing action: {action.href}") from exc
 
     return handle_action_result(response)
 
@@ -139,7 +130,7 @@ def handle_action_result(response: Response) -> None | URL | ProblemDetails | Re
     if response.status_code == httpx.codes.CREATED:
         location_header = response.headers.get(Headers.LOCATION_HEADER, None)
         if location_header is None:
-            logger.warning(f"Got created response without location header")
+            warnings.warn(f"Got created response without location header")
             return
 
         return URL(location_header)
@@ -147,7 +138,7 @@ def handle_action_result(response: Response) -> None | URL | ProblemDetails | Re
     elif response.status_code >= 400:
         return handle_error_response(response)
     else:
-        logger.warning(f"Unexpected return code: {response.status_code}")
+        warnings.warn(f"Unexpected return code: {response.status_code}")
         return response
 
 
@@ -156,7 +147,7 @@ def handle_error_response(response: Response) -> ProblemDetails | Response:
     if content_type.startswith(MediaTypes.PROBLEM_DETAILS.value):
         return ProblemDetails.model_validate(response.json())
     else:
-        logger.warning(
+        warnings.warn(
             f"Error case did not return media type: '{MediaTypes.PROBLEM_DETAILS.value}', "
             f"got '{response.headers.get(Headers.CONTENT_TYPE, None)}' instead!")
         return response

pinexq_client/job_management/__init__.py

@@ -3,4 +3,4 @@ from .enterjma import enter_jma
 from .tool import Job, ProcessingStep, WorkData
 
 # Protocol version the JMA is using
-__jma_version__ = [6, 2, 0]
+__jma_version__ = [6, 2, 3]

pinexq_client/job_management/enterjma.py

@@ -2,7 +2,7 @@ from typing import TypeVar, Type
 
 import httpx
 
-import logging
+import warnings
 
 from pinexq_client.core import Entity
 from pinexq_client.core.enterapi import enter_api
@@ -11,8 +11,6 @@ from pinexq_client.job_management.hcos.entrypoint_hco import EntryPointHco
 from pinexq_client.job_management.model.sirenentities import EntryPointEntity
 import pinexq_client.job_management
 
-LOG = logging.getLogger(__name__)
-
 THco = TypeVar("THco", bound=Hco)
 
 
@@ -34,7 +32,7 @@ def enter_jma(
     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):
-        LOG.warning(
+        warnings.warn(
             f"Version mismatch between 'pinexq_client' (v{'.'.join(map(str ,client_version))}) "
             f"and 'JobManagementAPI' (v{'.'.join(map(str, jma_version))})! "
         )