mercuto-client 0.2.6.dev0__tar.gz → 0.3.2a0__tar.gz

mercuto_client-0.3.2a0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: mercuto-client
+Version: 0.3.2a0
+Summary: Library for interfacing with Rockfield's Mercuto API
+Author-email: Daniel Whipp <daniel.whipp@rocktech.com.au>
+License-Expression: AGPL-3.0-only
+Project-URL: Homepage, https://mercuto.rockfieldcloud.com.au
+Project-URL: Repository, https://github.com/RockfieldTechnologiesAustralia/mercuto-client
+Project-URL: Documentation, https://github.com/RockfieldTechnologiesAustralia/mercuto-client/blob/main/README.md
+Keywords: mercuto,rockfield,infratech
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.32
+Requires-Dist: pyftpdlib>=2.0.1
+Requires-Dist: python-dateutil>=2.9.0.post0
+Requires-Dist: pytz>=2025.2
+Requires-Dist: schedule>=1.2.2
+Requires-Dist: pydantic>=2.0
+Dynamic: license-file
+
+# Mercuto Client Python Library
+
+Library for interfacing with Rockfield's Mercuto public API.
+This library is in an early development state and is subject to major structural changes at any time.
+
+(Visit our Github Repository)[https://github.com/RockfieldTechnologiesAustralia/mercuto-client]
+
+## Installation
+Install from PyPi: `pip install mercuto-client` or adding the same line into your `requirements.txt`.
+
+## Basic Usage
+
+Use the `connect()` function exposed within the main package and provide your API key.
+
+```python
+from mercuto_client import connect
+
+client = connect(api_key="<YOUR API KEY>")
+print(client.core().list_projects())
+
+# Logout after finished.
+client.logout()
+
+```
+
+You can also use the client as a context manager. It will logout automatically.
+
+```python
+from mercuto_client import MercutoClient
+
+with MercutoClient.as_credentials(api_key='<YOUR API KEY>') as client:
+    print(client.core().list_projects())
+```
+
+## Current Status
+This library is incomplete and may not be fully compliant with the latest Mercuto version. It is only updated periodically and provided for use without any warranty or guarantees.
+
+- [x] API Based login (Completed)
+- [ ] Username/password login
+
+## Running tests
+Install test packages:
+`python -m uv sync --group tests`
+Run tests:
+`uv run pytest`

{mercuto_client-0.2.6.dev0 → mercuto_client-0.3.2a0}/README.md

@@ -3,10 +3,10 @@
 Library for interfacing with Rockfield's Mercuto public API.
 This library is in an early development state and is subject to major structural changes at any time.
 
+(Visit our Github Repository)[https://github.com/RockfieldTechnologiesAustralia/mercuto-client]
+
 ## Installation
-Currently this library is not available on any package repository. It can be installed directly from Github using:
-`pip install git+https://github.com/RockfieldTechnologiesAustralia/mercuto-client@0.1.0` or adding the same line into 
-your `requirements.txt`.
+Install from PyPi: `pip install mercuto-client` or adding the same line into your `requirements.txt`.
 
 ## Basic Usage
 
@@ -16,7 +16,7 @@ Use the `connect()` function exposed within the main package and provide your AP
 from mercuto_client import connect
 
 client = connect(api_key="<YOUR API KEY>")
-print(client.projects().get_projects())
+print(client.core().list_projects())
 
 # Logout after finished.
 client.logout()
@@ -29,11 +29,17 @@ You can also use the client as a context manager. It will logout automatically.
 from mercuto_client import MercutoClient
 
 with MercutoClient.as_credentials(api_key='<YOUR API KEY>') as client:
-    print(client.projects().get_projects())
+    print(client.core().list_projects())
 ```
 
 ## Current Status
 This library is incomplete and may not be fully compliant with the latest Mercuto version. It is only updated periodically and provided for use without any warranty or guarantees.
 
 - [x] API Based login (Completed)
-- [ ] Username/password login
+- [ ] Username/password login
+
+## Running tests
+Install test packages:
+`python -m uv sync --group tests`
+Run tests:
+`uv run pytest`

mercuto_client-0.3.2a0/mercuto_client/__init__.py

@@ -0,0 +1,8 @@
+from .client import MercutoClient
+from .exceptions import MercutoClientException, MercutoHTTPException
+
+__all__ = ['MercutoClient', 'MercutoHTTPException', 'MercutoClientException']
+
+
+def connect(*args, **kwargs) -> MercutoClient:
+    return MercutoClient().connect(*args, **kwargs)

mercuto_client-0.3.2a0/mercuto_client/_authentication.py

@@ -0,0 +1,72 @@
+from typing import Mapping, Optional
+
+
+class IAuthenticationMethod:
+    def update_header(self, header: dict[str, str]) -> None:
+        return
+
+    def unique_key(self) -> str:
+        raise NotImplementedError(f"unique_key not implemented for type {self.__class__.__name__}")
+
+
+class ApiKeyAuthentication(IAuthenticationMethod):
+    def __init__(self, api_key: str) -> None:
+        self.api_key = api_key
+
+    def update_header(self, header: dict[str, str]) -> None:
+        header['X-Api-Key'] = self.api_key
+
+    def unique_key(self) -> str:
+        return f'api-key:{self.api_key}'
+
+
+class ServiceTokenAuthentication(IAuthenticationMethod):
+    def __init__(self, service_token: str) -> None:
+        self.service_token = service_token
+
+    def update_header(self, header: dict[str, str]) -> None:
+        header['X-Service-Token'] = self.service_token
+
+    def unique_key(self) -> str:
+        return f'service-token:{self.service_token}'
+
+
+class AuthorizationHeaderAuthentication(IAuthenticationMethod):
+    def __init__(self, authorization_header: str) -> None:
+        if not authorization_header.startswith('Bearer '):
+            authorization_header = 'Bearer ' + authorization_header
+        self.authorization_header = authorization_header
+
+    def update_header(self, header: dict[str, str]) -> None:
+        header['Authorization'] = self.authorization_header
+
+    def unique_key(self) -> str:
+        return f'auth-bearer:{self.authorization_header}'
+
+
+class NullAuthenticationMethod(IAuthenticationMethod):
+    def update_header(self, header: dict[str, str]) -> None:
+        pass
+
+    def unique_key(self) -> str:
+        return 'null-authentication'
+
+
+def create_authentication_method(api_key: Optional[str] = None,
+                                 service_token: Optional[str] = None,
+                                 bearer_token: Optional[str] = None,
+                                 headers: Optional[Mapping[str, str]] = None) -> IAuthenticationMethod:
+    if api_key is not None and service_token is not None and headers is not None and bearer_token is not None:
+        raise ValueError("Only one of api_key or service_token or bearer_token can be provided")
+    if headers is not None:
+        api_key = headers.get('X-Api-Key', None)
+        service_token = headers.get('X-Service-Token', None)
+        bearer_token = headers.get('Authorization', None)
+    if api_key is not None:
+        return ApiKeyAuthentication(api_key)
+    elif service_token is not None:
+        return ServiceTokenAuthentication(service_token)
+    elif bearer_token is not None:
+        return AuthorizationHeaderAuthentication(bearer_token)
+    else:
+        return NullAuthenticationMethod()

{mercuto_client-0.2.6.dev0 → mercuto_client-0.3.2a0}/mercuto_client/_tests/test_ingester/test_file_processor.py

@@ -37,7 +37,7 @@ def temp_env() -> Generator[Tuple[FileProcessor, str, str], None, None]:
 
 def test_init_db(temp_env: Tuple[FileProcessor, str, str]) -> None:
     """Verify database initialization"""
-    processor, _, db_path = temp_env
+    _, _, db_path = temp_env
     conn: sqlite3.Connection = sqlite3.connect(db_path)
     cursor: sqlite3.Cursor = conn.cursor()
     cursor.execute(

mercuto_client-0.3.2a0/mercuto_client/_tests/test_ingester/test_parsers.py

@@ -0,0 +1,145 @@
+import math
+import os
+import tempfile
+
+import pytest
+
+from ...ingester.parsers import (detect_parser, parse_campbell_file,
+                                 parse_worldsensing_compact_file,
+                                 parse_worldsensing_standard_file)
+
+RESOURCES_DIR = os.path.join(os.path.dirname(__file__), "resources")
+
+
+def test_worldsensing_compacted_parser():
+    file = os.path.join(RESOURCES_DIR, "worldsensing-compacted-sample-file.dat")
+    mapper = {
+        "channel1": "12345678",
+        "channel2": "abcdefgh",
+    }
+    samples = parse_worldsensing_compact_file(file, mapper)
+    assert len(samples) == 4
+    assert samples[0].channel == "12345678"
+    assert math.isclose(samples[0].value, -10)
+    assert samples[0].timestamp.isoformat() == '2025-05-20T15:00:00'
+
+    assert samples[1].channel == "abcdefgh"
+    assert math.isclose(samples[1].value, 5)
+    assert samples[0].timestamp.isoformat() == '2025-05-20T15:00:00'
+
+    assert samples[2].channel == "12345678"
+    assert math.isclose(samples[2].value, -12)
+    assert samples[2].timestamp.isoformat() == '2025-05-20T16:00:00'
+
+    assert samples[3].channel == "abcdefgh"
+    assert math.isclose(samples[3].value, 10)
+    assert samples[3].timestamp.isoformat() == '2025-05-20T16:00:00'
+
+
+def test_worldsensing_standard_parser():
+    file = os.path.join(RESOURCES_DIR, "worldsensing-standard-sample-file.csv")
+    mapper = {
+        "AtmPressure-85544-in-mbar": "12345678",
+        "freqSqInDigit-85544-VW-Ch1": "abcdefgh",
+    }
+    samples = parse_worldsensing_standard_file(file, mapper)
+    assert len(samples) == 10
+    assert samples[0].channel == "12345678"
+    assert math.isclose(samples[0].value, 930.5)
+    assert samples[0].timestamp.isoformat() == '2024-04-15T12:35:00'
+
+    assert samples[1].channel == "abcdefgh"
+    assert math.isclose(samples[1].value, 726.810811024)
+    assert samples[1].timestamp.isoformat() == '2024-04-15T12:35:00'
+
+    assert samples[8].channel == "12345678"
+    assert math.isclose(samples[8].value, 930.4)
+    assert samples[8].timestamp.isoformat() == '2024-04-15T12:39:00'
+
+    assert samples[9].channel == "abcdefgh"
+    assert math.isclose(samples[9].value, 726.841502500)
+    assert samples[9].timestamp.isoformat() == '2024-04-15T12:39:00'
+
+
+def test_campbells_parser():
+    file = os.path.join(RESOURCES_DIR, "campbell-sample-file.dat")
+    mapper = {
+        "VWu_1": "aaaaaaaa",
+        "VWu_2": "bbbbbbbb",
+        "Therm(1)": "cccccccc",
+        "Therm(2)": "dddddddd",
+        "Diag_Max(1)": "eeeeeeee",
+        "Diag_Max(2)": "ffffffff",
+    }
+    samples = parse_campbell_file(file, mapper)
+    assert len(samples) == 6*4
+
+    assert samples[0].channel == "aaaaaaaa"
+    assert math.isclose(samples[0].value, 1234.5)
+    assert samples[0].timestamp.isoformat() == '2023-12-07T00:01:00'
+
+    for i in range(1, 6):
+        assert samples[i].channel == list(mapper.values())[i]
+        assert math.isnan(samples[i].value)
+        assert samples[i].timestamp.isoformat() == '2023-12-07T00:01:00'
+
+    assert samples[6].channel == "aaaaaaaa"
+    assert math.isclose(samples[6].value, 1234.5)
+    assert samples[6].timestamp.isoformat() == '2023-12-07T00:02:00'
+    for i in range(7, 12):
+        assert samples[i].channel == list(mapper.values())[i-6]
+        assert math.isnan(samples[i].value)
+        assert samples[i].timestamp.isoformat() == '2023-12-07T00:02:00'
+
+    assert samples[12].channel == "aaaaaaaa"
+    assert math.isclose(samples[12].value, 1234.5)
+    assert samples[12].timestamp.isoformat() == '2023-12-07T00:03:00'
+    assert samples[13].channel == "bbbbbbbb"
+    assert math.isclose(samples[13].value, 1234.5)
+    assert samples[13].timestamp.isoformat() == '2023-12-07T00:03:00'
+
+    for i in range(15, 17):
+        assert samples[i].channel == list(mapper.values())[i-12]
+        assert math.isnan(samples[i].value)
+        assert samples[i].timestamp.isoformat() == '2023-12-07T00:03:00'
+    assert samples[17].channel == "ffffffff"
+    assert math.isclose(samples[17].value, 1537)
+    assert samples[17].timestamp.isoformat() == '2023-12-07T00:03:00'
+
+    assert samples[18].channel == "aaaaaaaa"
+    assert math.isclose(samples[18].value, 1234.5)
+    assert samples[18].timestamp.isoformat() == '2023-12-07T00:04:00'
+    assert samples[19].channel == "bbbbbbbb"
+    assert math.isclose(samples[19].value, 1234.5)
+    assert samples[19].timestamp.isoformat() == '2023-12-07T00:04:00'
+    assert samples[20].channel == "cccccccc"
+    assert math.isclose(samples[20].value, 27.5)
+    assert samples[20].timestamp.isoformat() == '2023-12-07T00:04:00'
+    assert samples[21].channel == "dddddddd"
+    assert math.isclose(samples[21].value, 25)
+    assert samples[21].timestamp.isoformat() == '2023-12-07T00:04:00'
+    assert samples[22].channel == "eeeeeeee"
+    assert math.isclose(samples[22].value, 255)
+    assert samples[22].timestamp.isoformat() == '2023-12-07T00:04:00'
+    assert samples[23].channel == "ffffffff"
+    assert math.isclose(samples[23].value, 0)
+    assert samples[23].timestamp.isoformat() == '2023-12-07T00:04:00'
+
+
+def test_detect_file_type():
+    compacted_file = os.path.join(RESOURCES_DIR, "worldsensing-compacted-sample-file.dat")
+    standard_file = os.path.join(RESOURCES_DIR, "worldsensing-standard-sample-file.csv")
+    campbell_file = os.path.join(RESOURCES_DIR, "campbell-sample-file.dat")
+
+    assert detect_parser(compacted_file) == parse_worldsensing_compact_file
+    assert detect_parser(standard_file) == parse_worldsensing_standard_file
+    assert detect_parser(campbell_file) == parse_campbell_file
+
+    # Test with an unknown file type
+    with tempfile.TemporaryDirectory() as dir:
+        unknown_file = os.path.join(dir, "unknown-file.txt")
+        with open(unknown_file, "w") as f:
+            f.write("This is an unknown file format.")
+
+        with pytest.raises(ValueError):
+            detect_parser(unknown_file)

mercuto_client-0.3.2a0/mercuto_client/_tests/test_mocking/conftest.py

@@ -0,0 +1,13 @@
+from typing import Iterator
+
+import pytest
+
+from ... import MercutoClient
+from ...mocks import mock_mercuto
+
+
+@pytest.fixture
+def client() -> Iterator[MercutoClient]:
+    with mock_mercuto():
+        client = MercutoClient("https://testserver")
+        yield client

mercuto_client-0.3.2a0/mercuto_client/_tests/test_mocking/test_mock_identity.py

@@ -0,0 +1,8 @@
+from ... import MercutoClient
+
+
+def test_add_and_list_users(client: MercutoClient) -> None:
+    client.identity().create_user("test_user", "test-tenant", "Description", "Test Group")
+    users = client.identity().list_users()
+    assert len(users) == 1
+    assert "test_user" in [user.username for user in users]

{mercuto_client-0.2.6.dev0 → mercuto_client-0.3.2a0}/mercuto_client/acl.py

@@ -1,7 +1,5 @@
 import json
-from typing import TypeVar
-
-from .types import AccessControlListJson, AccessControlListJsonEntry
+from typing import TypedDict, TypeVar
 
 
 class ResourceTypes:
@@ -65,36 +63,44 @@ class ServiceTypes:
     WILDCARD = '*'
 
 
-T = TypeVar('T', bound='AclPolicyBuilder')
+_T = TypeVar('_T', bound='AclPolicyBuilder')
 
 
 class AclPolicyBuilder:
+    class _AclEntryType(TypedDict):
+        action: str
+        resource: str
+
+    class _AclPolicyType(TypedDict):
+        version: int
+        permissions: list['AclPolicyBuilder._AclEntryType']
+
     def __init__(self) -> None:
-        self._permissions: list[AccessControlListJsonEntry] = []
+        self._permissions: list[AclPolicyBuilder._AclEntryType] = []
 
-    def allow(self: T, action: str, resource: str) -> T:
+    def allow(self: _T, action: str, resource: str) -> _T:
         self._permissions.append({
             'action': action,
             'resource': resource
         })
         return self
 
-    def allow_all(self: T, action: str) -> T:
+    def allow_all(self: _T, action: str) -> _T:
         self.allow(action, f"mrn:{ServiceTypes.WILDCARD}:{ResourceTypes.WILDCARD}/{ResourceTypes.WILDCARD}")
         return self
 
-    def allow_project(self: T, action: str, project_code: str) -> T:
+    def allow_project(self: _T, action: str, project_code: str) -> _T:
         self.allow(action, f"mrn:{ServiceTypes.MERCUTO}:{ResourceTypes.Mercuto.PROJECT}/{project_code}")
         return self
 
-    def allow_tenant(self: T, action: str, tenant_code: str) -> T:
+    def allow_tenant(self: _T, action: str, tenant_code: str) -> _T:
         self.allow(action, f"mrn:{ServiceTypes.IDENTITY}:{ResourceTypes.Identity.TENANT}/{tenant_code}")
         return self
 
     def as_string(self) -> str:
         return json.dumps(self.as_dict())
 
-    def as_dict(self) -> AccessControlListJson:
+    def as_dict(self) -> _AclPolicyType:
         return {
             'version': 1,
             'permissions': self._permissions

mercuto_client-0.3.2a0/mercuto_client/client.py

@@ -0,0 +1,202 @@
+import contextlib
+import json as json_stdlib
+import logging
+import os
+import time
+from typing import (Any, Iterator, Literal, Mapping, Optional, Protocol, Type,
+                    TypeVar)
+
+import requests
+import requests.cookies
+
+from ._authentication import (IAuthenticationMethod,
+                              create_authentication_method)
+from .exceptions import MercutoClientException, MercutoHTTPException
+from .modules.core import MercutoCoreService
+from .modules.data import MercutoDataService
+from .modules.fatigue import MercutoFatigueService
+from .modules.identity import MercutoIdentityService
+from .modules.media import MercutoMediaService
+
+logger = logging.getLogger(__name__)
+
+
+class _ModuleBase(Protocol):
+    def __init__(self, client: 'MercutoClient', *args: Any, **kwargs: Any) -> None:
+        pass
+
+
+_T = TypeVar('_T', bound=_ModuleBase)
+
+
+class MercutoClient:
+    def __init__(self, url: Optional[str] = None, verify_ssl: bool = True, active_session: Optional[requests.Session] = None) -> None:
+        if url is None:
+            url = os.environ.get('MERCUTO_API_URL', 'https://api.rockfieldcloud.com.au')
+        assert isinstance(url, str)
+
+        if url.endswith('/'):
+            url = url[:-1]
+
+        if not url.startswith('https://'):
+            raise ValueError(f'Url must be https, is {url}')
+
+        self._url = url
+        self.verify_ssl = verify_ssl
+
+        if active_session is None:
+            self._current_session = requests.Session()
+        else:
+            self._current_session = active_session
+
+        self._auth_method: Optional[IAuthenticationMethod] = None
+        self._cookies = requests.cookies.RequestsCookieJar()
+
+        self._modules: dict[str, _ModuleBase] = {}
+
+    def url(self) -> str:
+        return self._url
+
+    def credentials_key(self) -> str:
+        """
+        Generate a unique key that identifies the current credentials set.
+        """
+        if self._auth_method is None:
+            raise MercutoClientException("No credentials set")
+        return self._auth_method.unique_key()
+
+    def setverify_ssl(self, verify_ssl: bool) -> None:
+        self.verify_ssl = verify_ssl
+
+    def copy(self) -> 'MercutoClient':
+        return MercutoClient(self._url, self.verify_ssl, self._current_session)
+
+    @contextlib.contextmanager
+    def as_credentials(self, api_key: Optional[str] = None,
+                       service_token: Optional[str] = None,
+                       bearer_token: Optional[str] = None,
+                       headers: Optional[Mapping[str, str]] = None) -> Iterator['MercutoClient']:
+        """
+        Same as .connect(), but as a context manager. Will automatically logout when exiting the context.
+        """
+        # TODO: We are passing the current session along to re-use connections for speed. Will this cause security issues?
+        other = MercutoClient(self._url, self.verify_ssl, self._current_session)
+        try:
+            yield other.connect(api_key=api_key, service_token=service_token, bearer_token=bearer_token, headers=headers)
+        finally:
+            other.logout()
+
+    def connect(self, *, api_key: Optional[str] = None,
+                service_token: Optional[str] = None,
+                bearer_token: Optional[str] = None,
+                headers: Optional[Mapping[str, str]] = None) -> 'MercutoClient':
+        """
+        Attempt to connect using any available method.
+        if api_key is provided, use the api_key.
+        if service_token is provided, use the service_token.
+        if headers is provided, attempt to extract either api_key or service_token from given header set.
+            headers should be a dictionary of headers that would be sent in a request. Useful for using existing authenation mechanism for forwarding.
+
+        """
+        authentication = create_authentication_method(api_key=api_key, service_token=service_token, bearer_token=bearer_token, headers=headers)
+        self.login(authentication)
+        return self
+
+    def _update_headers(self, headers: dict[str, str]) -> dict[str, str]:
+        base: dict[str, str] = {}
+
+        if self._auth_method is not None:
+            self._auth_method.update_header(base)
+        base.update(headers)
+        return base
+
+    def session(self) -> requests.Session:
+        return self._current_session
+
+    def request(self, url: str, method: Literal['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'],
+                params: Optional[dict[str, Any]] = None,
+                json: Optional[dict[str, Any]] = None,
+                raise_for_status: bool = True,
+                **kwargs: Any) -> requests.Response:
+        """
+        Make an HTTP request to the Mercuto API.
+        :param url: The URL path (relative to the base API URL) to make the request to.
+        :param method: The HTTP method to use (e.g., 'GET', 'POST', etc.).
+        :param params: Optional dictionary of query parameters to include in the request.
+        :param json: Optional dictionary to send as a JSON payload in the request body.
+        :param raise_for_status: Whether to raise an exception for HTTP error responses.
+        :param kwargs: Additional keyword arguments to pass to the requests method.
+        :return: The HTTP response object.
+        """
+        return self._http_request(url, method, params=params, json=json, raise_for_status=raise_for_status, **kwargs)
+
+    def _http_request(self, url: str, method: str,
+                      params: Optional[dict[str, Any]] = None,
+                      json: Optional[dict[str, Any]] = None,
+                      raise_for_status: bool = True,
+                      **kwargs: Any) -> requests.Response:
+        if url.startswith('/'):
+            url = url[1:]
+        full_url = f"{self._url}/{url}"
+
+        if 'timeout' not in kwargs:
+            kwargs['timeout'] = 10
+        kwargs['headers'] = self._update_headers(kwargs.get('headers', {}))
+
+        if 'verify' not in kwargs:
+            kwargs['verify'] = self.verify_ssl
+
+        if 'cookies' not in kwargs:
+            kwargs['cookies'] = self._cookies
+
+        # Custom parsing json to support NAN
+        if json is not None and kwargs.get('data') is None:
+            kwargs['data'] = json_stdlib.dumps(json, allow_nan=True)
+            kwargs['headers']['Content-Type'] = 'application/json'
+            json = None
+
+        start = time.time()
+        resp = self._current_session.request(method, full_url, params=params, json=json, **kwargs)
+        duration = time.time() - start
+        logger.debug("Made request to %s %s in %.2f seconds (code=%s)", method, full_url, duration, resp.status_code)
+        if raise_for_status and not resp.ok:
+            try:
+                error_json = resp.json()
+            except Exception:
+                raise MercutoHTTPException(resp.text, resp.status_code)
+            else:
+                if 'detail' in error_json and isinstance(error_json['detail'], str):
+                    raise MercutoHTTPException(error_json['detail'], resp.status_code)
+                else:
+                    raise MercutoHTTPException(resp.text, resp.status_code)
+        resp.cookies.update(self._cookies)
+        return resp
+
+    def _add_and_fetch_module(self, name: str, module: Type[_T]) -> _T:
+        if name not in self._modules:
+            self._modules[name] = module(self)
+        return self._modules[name]  # type: ignore
+
+    def identity(self) -> 'MercutoIdentityService':
+        return self._add_and_fetch_module('identity', MercutoIdentityService)
+
+    def fatigue(self) -> 'MercutoFatigueService':
+        return self._add_and_fetch_module('fatigue', MercutoFatigueService)
+
+    def data(self) -> 'MercutoDataService':
+        return self._add_and_fetch_module('data', MercutoDataService)
+
+    def core(self) -> 'MercutoCoreService':
+        return self._add_and_fetch_module('core', MercutoCoreService)
+
+    def media(self) -> 'MercutoMediaService':
+        return self._add_and_fetch_module('media', MercutoMediaService)
+
+    def login(self, authentication: IAuthenticationMethod) -> None:
+        self._auth_method = authentication
+
+    def logout(self) -> None:
+        self._auth_method = None
+
+    def is_logged_in(self) -> bool:
+        return self._auth_method is not None

{mercuto_client-0.2.6.dev0 → mercuto_client-0.3.2a0}/mercuto_client/exceptions.py

@@ -1,4 +1,5 @@
 import json
+from typing import Any
 
 
 class MercutoClientException(Exception):
@@ -11,5 +12,8 @@ class MercutoHTTPException(MercutoClientException):
         self.status_code = status_code
         self.message = message
 
-    def json(self) -> dict:
+    def json(self) -> Any:
         return json.loads(self.message)
+
+    def __str__(self) -> str:
+        return f"MercutoHTTPException(status_code='{self.status_code}', message='{self.message}')"