mercuto-client 0.2.7__py3-none-any.whl → 0.3.0a0__py3-none-any.whl

mercuto_client/__init__.py

@@ -1,30 +1,8 @@
-"""
-Copyright (C) 2025 Rockfield Technologies Australia Pty Ltd
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU Affero General Public License as published
-by the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Affero General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program.  If not, see <https://www.gnu.org/licenses/>.
-"""
-from typing import Mapping, Optional
-
 from .client import MercutoClient
 from .exceptions import MercutoClientException, MercutoHTTPException
 
 __all__ = ['MercutoClient', 'MercutoHTTPException', 'MercutoClientException']
 
 
-def connect(api_key: Optional[str] = None,
-            service_token: Optional[str] = None,
-            headers: Optional[Mapping[str, str]] = None) -> MercutoClient:
-    return MercutoClient().connect(api_key=api_key,
-                                   service_token=service_token,
-                                   headers=headers)
+def connect(*args, **kwargs) -> MercutoClient:
+    return MercutoClient().connect(*args, **kwargs)

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/_tests/test_ingester/test_parsers.py

@@ -19,21 +19,21 @@ def test_worldsensing_compacted_parser():
     }
     samples = parse_worldsensing_compact_file(file, mapper)
     assert len(samples) == 4
-    assert samples[0]['channel_code'] == "12345678"
-    assert math.isclose(samples[0]['value'], -10)
-    assert samples[0]['timestamp'] == '2025-05-20T15:00:00'
+    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_code'] == "abcdefgh"
-    assert math.isclose(samples[1]['value'], 5)
-    assert samples[0]['timestamp'] == '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_code'] == "12345678"
-    assert math.isclose(samples[2]['value'], -12)
-    assert samples[2]['timestamp'] == '2025-05-20T16: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_code'] == "abcdefgh"
-    assert math.isclose(samples[3]['value'], 10)
-    assert samples[3]['timestamp'] == '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():
@@ -44,21 +44,21 @@ def test_worldsensing_standard_parser():
     }
     samples = parse_worldsensing_standard_file(file, mapper)
     assert len(samples) == 10
-    assert samples[0]['channel_code'] == "12345678"
-    assert math.isclose(samples[0]['value'], 930.5)
-    assert samples[0]['timestamp'] == '2024-04-15T12:35:00'
+    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_code'] == "abcdefgh"
-    assert math.isclose(samples[1]['value'], 726.810811024)
-    assert samples[1]['timestamp'] == '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_code'] == "12345678"
-    assert math.isclose(samples[8]['value'], 930.4)
-    assert samples[8]['timestamp'] == '2024-04-15T12:39: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_code'] == "abcdefgh"
-    assert math.isclose(samples[9]['value'], 726.841502500)
-    assert samples[9]['timestamp'] == '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():
@@ -74,56 +74,56 @@ def test_campbells_parser():
     samples = parse_campbell_file(file, mapper)
     assert len(samples) == 6*4
 
-    assert samples[0]['channel_code'] == "aaaaaaaa"
-    assert math.isclose(samples[0]['value'], 1234.5)
-    assert samples[0]['timestamp'] == '2023-12-07T00:01:00'
+    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_code'] == list(mapper.values())[i]
-        assert math.isnan(samples[i]['value'])
-        assert samples[i]['timestamp'] == '2023-12-07T00:01:00'
+        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_code'] == "aaaaaaaa"
-    assert math.isclose(samples[6]['value'], 1234.5)
-    assert samples[6]['timestamp'] == '2023-12-07T00:02: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_code'] == list(mapper.values())[i-6]
-        assert math.isnan(samples[i]['value'])
-        assert samples[i]['timestamp'] == '2023-12-07T00:02:00'
+        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_code'] == "aaaaaaaa"
-    assert math.isclose(samples[12]['value'], 1234.5)
-    assert samples[12]['timestamp'] == '2023-12-07T00:03:00'
-    assert samples[13]['channel_code'] == "bbbbbbbb"
-    assert math.isclose(samples[13]['value'], 1234.5)
-    assert samples[13]['timestamp'] == '2023-12-07T00:03: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_code'] == list(mapper.values())[i-12]
-        assert math.isnan(samples[i]['value'])
-        assert samples[i]['timestamp'] == '2023-12-07T00:03:00'
-    assert samples[17]['channel_code'] == "ffffffff"
-    assert math.isclose(samples[17]['value'], 1537)
-    assert samples[17]['timestamp'] == '2023-12-07T00:03:00'
-
-    assert samples[18]['channel_code'] == "aaaaaaaa"
-    assert math.isclose(samples[18]['value'], 1234.5)
-    assert samples[18]['timestamp'] == '2023-12-07T00:04:00'
-    assert samples[19]['channel_code'] == "bbbbbbbb"
-    assert math.isclose(samples[19]['value'], 1234.5)
-    assert samples[19]['timestamp'] == '2023-12-07T00:04:00'
-    assert samples[20]['channel_code'] == "cccccccc"
-    assert math.isclose(samples[20]['value'], 27.5)
-    assert samples[20]['timestamp'] == '2023-12-07T00:04:00'
-    assert samples[21]['channel_code'] == "dddddddd"
-    assert math.isclose(samples[21]['value'], 25)
-    assert samples[21]['timestamp'] == '2023-12-07T00:04:00'
-    assert samples[22]['channel_code'] == "eeeeeeee"
-    assert math.isclose(samples[22]['value'], 255)
-    assert samples[22]['timestamp'] == '2023-12-07T00:04:00'
-    assert samples[23]['channel_code'] == "ffffffff"
-    assert math.isclose(samples[23]['value'], 0)
-    assert samples[23]['timestamp'] == '2023-12-07T00:04:00'
+        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():

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/_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/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