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

mercuto_client/modules/fatigue.py

@@ -0,0 +1,189 @@
+from datetime import datetime
+from typing import TYPE_CHECKING, Literal, Optional
+
+from pydantic import Field, TypeAdapter
+
+if TYPE_CHECKING:
+    from ..client import MercutoClient
+
+from . import _PayloadType
+from ._util import BaseModel
+
+
+class RainflowConfiguration(BaseModel):
+    project: str
+    max_bins: int
+    bin_size: float
+    multiplier: float
+    reservoir_adjustment: bool
+    sources: list[str]
+
+
+class FatigueConnection(BaseModel):
+    project: str
+    code: str
+    label: str
+    multiplier: float
+    c_d: float
+    m: float
+    s_0: float
+    bs7608_failure_probability: Optional[float]
+    bs7608_detail_category: Optional[str]
+    initial_date: datetime
+    initial_damage: float
+    sources: list[str]
+
+
+class ConnectionRemnantCapacity(BaseModel):
+    connection: FatigueConnection
+    remaining_life_years: float = Field(description="Remaining life of the connection in years")
+    total_damage: float = Field(description="Total damage accumulated in the connection up to the 'end_time' specified")
+
+
+class Healthcheck(BaseModel):
+    status: str
+
+
+_RainflowConfigurationlistAdapter = TypeAdapter(list[RainflowConfiguration])
+_FatigueConnectionlistAdapter = TypeAdapter(list[FatigueConnection])
+_ConnectionRemnantCapacitylistAdapter = TypeAdapter(list[ConnectionRemnantCapacity])
+
+
+class MercutoFatigueService:
+    def __init__(self, client: 'MercutoClient', path: str = '/fatigue') -> None:
+        self._client = client
+        self._path = path
+
+    def healthcheck(self) -> Healthcheck:
+        r = self._client._http_request(f"{self._path}/healthcheck", "GET")
+        return Healthcheck.model_validate_json(r.text)
+
+    # --- Rainflow routes ---
+
+    def list_rainflow_config(self, project: str) -> list[RainflowConfiguration]:
+        params: _PayloadType = {"project": project}
+        r = self._client._http_request(f"{self._path}/rainflow/setup", "GET", params=params)
+        return _RainflowConfigurationlistAdapter.validate_json(r.text)
+
+    def setup_rainflow(
+        self,
+        project: str,
+        max_bins: int,
+        bin_size: float,
+        multiplier: float,
+        reservoir_adjustment: bool,
+        sources: list[str]
+    ) -> RainflowConfiguration:
+        payload: _PayloadType = {
+            "project": project,
+            "max_bins": max_bins,
+            "bin_size": bin_size,
+            "multiplier": multiplier,
+            "reservoir_adjustment": reservoir_adjustment,
+            "sources": sources,
+        }
+        r = self._client._http_request(f"{self._path}/rainflow/setup", "PUT", json=payload)
+        return RainflowConfiguration.model_validate_json(r.text)
+
+    def get_cycle_counts(
+        self, project: str, start_time: datetime, end_time: datetime
+    ) -> bytes:
+        params: _PayloadType = {
+            "project": project,
+            "start_time": start_time.isoformat(),
+            "end_time": end_time.isoformat(),
+        }
+        r = self._client._http_request(
+            f"{self._path}/rainflow/cycle_counts", "GET", params=params, stream=True
+        )
+        return r.content
+
+    def delete_cycle_counts(
+        self, project: str, start_time: datetime, end_time: datetime, ignore_if_not_configured: bool = False
+    ) -> None:
+        params: _PayloadType = {
+            "project": project,
+            "start_time": start_time.isoformat(),
+            "end_time": end_time.isoformat(),
+            "ignore_if_not_configured": ignore_if_not_configured,
+        }
+        self._client._http_request(
+            f"{self._path}/rainflow/cycle_counts", "DELETE", params=params
+        )
+
+    def calculate_cycle_counts(
+        self,
+        project: str,
+        event: str,
+        presigned_url: str,
+        mime_type: Literal['application/feather'],
+        url_expiry: Optional[datetime] = None,
+        ignore_if_not_configured: bool = False
+    ) -> None:
+        payload: _PayloadType = {
+            "project": project,
+            "event": event,
+            "presigned_url": presigned_url,
+            "mime_type": mime_type,
+        }
+        if url_expiry is not None:
+            payload["url_expiry"] = url_expiry.isoformat()
+        params = {"ignore_if_not_configured": ignore_if_not_configured}
+        self._client._http_request(
+            f"{self._path}/rainflow/cycle_counts/calculate", "PUT", json=payload, params=params
+        )
+
+    # --- Fatigue Connections routes ---
+
+    def get_connections(self, project: str) -> list[FatigueConnection]:
+        params: _PayloadType = {"project": project}
+        r = self._client._http_request(f"{self._path}/connections", "GET", params=params)
+        return _FatigueConnectionlistAdapter.validate_json(r.text)
+
+    def add_connection(
+        self,
+        project: str,
+        label: str,
+        multiplier: float,
+        c_d: float,
+        m: float,
+        s_0: float,
+        bs7608_failure_probability: float,
+        bs7608_detail_category: str,
+        initial_date: datetime,
+        initial_damage: float,
+        sources: list[str]
+    ) -> FatigueConnection:
+        payload: _PayloadType = {
+            "project": project,
+            "label": label,
+            "multiplier": multiplier,
+            "c_d": c_d,
+            "m": m,
+            "s_0": s_0,
+            "bs7608_failure_probability": bs7608_failure_probability,
+            "bs7608_detail_category": bs7608_detail_category,
+            "initial_date": initial_date.isoformat(),
+            "initial_damage": initial_damage,
+            "sources": sources,
+        }
+        r = self._client._http_request(f"{self._path}/connections", "PUT", json=payload)
+        return FatigueConnection.model_validate_json(r.text)
+
+    def delete_connection(self, connection_code: str) -> None:
+        self._client._http_request(f"{self._path}/connections/{connection_code}", "DELETE")
+
+    # --- Connection Data routes ---
+
+    def get_connection_remnant_capacity(
+        self, project: str, start_time: datetime, end_time: datetime
+    ) -> list[ConnectionRemnantCapacity]:
+        params: _PayloadType = {
+            "project": project,
+            "start_time": start_time.isoformat(),
+            "end_time": end_time.isoformat(),
+        }
+        r = self._client._http_request(
+            f"{self._path}/connection_data/remnant-capacity", "GET", params=params
+        )
+        return _ConnectionRemnantCapacitylistAdapter.validate_json(r.text)

mercuto_client/modules/identity.py

@@ -0,0 +1,254 @@
+from typing import TYPE_CHECKING, Optional
+
+from pydantic import TypeAdapter
+
+if TYPE_CHECKING:
+    from ..client import MercutoClient
+
+from . import _PayloadType
+from ._util import BaseModel
+
+
+class PermissionGroup(BaseModel):
+    tenant: str
+    code: str
+    label: str
+    acl_policy: str
+
+
+class Tenant(BaseModel):
+    code: str
+    name: str
+    description: str
+    logo_url: Optional[str] = None
+
+
+class HiddenUserAPIKey(BaseModel):
+    code: str
+    description: str
+    last_used: Optional[str]
+    custom_policy: Optional[str] = None
+
+
+class UserDetails(BaseModel):
+    code: str
+    username: Optional[str] = None
+    email_address: Optional[str] = None
+    mobile_number: Optional[str] = None
+    first_name: Optional[str] = None
+    last_name: Optional[str] = None
+    api_keys: list[HiddenUserAPIKey] = []
+
+
+class User(BaseModel):
+    code: str
+    username: Optional[str] = None
+    description: str
+    tenant: str
+    permission_group: str
+
+
+class CurrentUser(BaseModel):
+    code: str
+    username: Optional[str] = None
+    description: str
+    tenant: Tenant
+    permission_group: PermissionGroup
+    current_permission_policy: str
+
+
+class VisibleUserAPIKey(BaseModel):
+    code: str
+    new_api_key: str
+    description: str
+    custom_policy: Optional[str]
+
+
+class VerifyMyPermissions(BaseModel):
+    user: Optional[str]
+    acl_policy: str
+
+
+class Healthcheck(BaseModel):
+    status: str
+
+
+# --- TypeAdapters for lists ---
+_PermissionGrouplistAdapter = TypeAdapter(list[PermissionGroup])
+_TenantlistAdapter = TypeAdapter(list[Tenant])
+_UserlistAdapter = TypeAdapter(list[User])
+_HiddenUserAPIKeylistAdapter = TypeAdapter(list[HiddenUserAPIKey])
+
+
+class MercutoIdentityService:
+    def __init__(self, client: 'MercutoClient', path: str = '/identity') -> None:
+        self._client = client
+        self._path = path
+
+    def healthcheck(self) -> Healthcheck:
+        r = self._client._http_request(f"{self._path}/healthcheck", "GET")
+        return Healthcheck.model_validate_json(r.text)
+
+    # --- Verify routes ---
+
+    def get_my_permissions(self) -> VerifyMyPermissions:
+        r = self._client._http_request(f"{self._path}/verify/me", "GET")
+        return VerifyMyPermissions.model_validate_json(r.text)
+
+    # --- User routes ---
+
+    def list_users(self, tenant: Optional[str] = None) -> list[User]:
+        params: _PayloadType = {}
+        if tenant is not None:
+            params["tenant"] = tenant
+        r = self._client._http_request(f"{self._path}/users", "GET", params=params)
+        return _UserlistAdapter.validate_json(r.text)
+
+    def create_user(
+        self,
+        username: str,
+        tenant: str,
+        description: str,
+        group: str,
+        default_password: Optional[str] = None
+    ) -> User:
+        payload: _PayloadType = {
+            "username": username,
+            "tenant_code": tenant,
+            "description": description,
+            "group_code": group,
+            "default_password": default_password,
+        }
+        r = self._client._http_request(f"{self._path}/users", "PUT", json=payload)
+        return User.model_validate_json(r.text)
+
+    def get_current_user(self) -> CurrentUser:
+        r = self._client._http_request(f"{self._path}/users/me", "GET")
+        return CurrentUser.model_validate_json(r.text)
+
+    def get_user(self, code: str) -> User:
+        r = self._client._http_request(f"{self._path}/users/{code}", "GET")
+        return User.model_validate_json(r.text)
+
+    def delete_user(self, code: str) -> None:
+        self._client._http_request(f"{self._path}/users/{code}", "DELETE")
+
+    def edit_user(
+        self,
+        code: str,
+        description: str,
+        group: str
+    ) -> User:
+        payload: _PayloadType = {
+            "description": description,
+            "group_code": group,
+        }
+        r = self._client._http_request(f"{self._path}/users/{code}", "PATCH", json=payload)
+        return User.model_validate_json(r.text)
+
+    def get_user_details(self, code: str) -> UserDetails:
+        r = self._client._http_request(f"{self._path}/users/{code}/details", "GET")
+        return UserDetails.model_validate_json(r.text)
+
+    def set_user_details(
+        self,
+        code: str,
+        email_address: Optional[str] = None,
+        mobile_number: Optional[str] = None,
+        first_name: Optional[str] = None,
+        last_name: Optional[str] = None
+    ) -> UserDetails:
+        payload: _PayloadType = {
+            "email_address": email_address,
+            "mobile_number": mobile_number,
+            "first_name": first_name,
+            "last_name": last_name,
+        }
+        r = self._client._http_request(f"{self._path}/users/{code}/details", "PATCH", json=payload)
+        return UserDetails.model_validate_json(r.text)
+
+    def get_user_api_keys(self, user: str) -> list[HiddenUserAPIKey]:
+        r = self._client._http_request(f"{self._path}/users/{user}/api_keys", "GET")
+        return _HiddenUserAPIKeylistAdapter.validate_json(r.text)
+
+    def generate_api_key_for_user(
+        self,
+        user: str,
+        description: str,
+        custom_policy: Optional[str] = None
+    ) -> VisibleUserAPIKey:
+        payload: _PayloadType = {
+            "description": description,
+            "custom_policy": custom_policy,
+        }
+        r = self._client._http_request(f"{self._path}/users/{user}/api_keys", "POST", json=payload)
+        return VisibleUserAPIKey.model_validate_json(r.text)
+
+    def delete_api_key(self, user: str, key_code: str) -> None:
+        self._client._http_request(f"{self._path}/users/{user}/api_keys/{key_code}", "DELETE")
+
+    # --- Tenants routes ---
+
+    def list_tenants(self) -> list[Tenant]:
+        r = self._client._http_request(f"{self._path}/tenants", "GET")
+        return _TenantlistAdapter.validate_json(r.text)
+
+    def get_tenant(self, code: str) -> Tenant:
+        r = self._client._http_request(f"{self._path}/tenants/{code}", "GET")
+        return Tenant.model_validate_json(r.text)
+
+    def create_tenant(
+        self,
+        name: str,
+        description: str,
+        logo_url: Optional[str] = None
+    ) -> Tenant:
+        payload: _PayloadType = {
+            "name": name,
+            "description": description,
+            "logo_url": logo_url,
+        }
+        r = self._client._http_request(f"{self._path}/tenants", "PUT", json=payload)
+        return Tenant.model_validate_json(r.text)
+
+    # --- Permission Groups routes ---
+
+    def get_permission_groups(self, tenant: Optional[str] = None) -> list[PermissionGroup]:
+        params = {}
+        if tenant is not None:
+            params["tenant"] = tenant
+        r = self._client._http_request(f"{self._path}/permissions", "GET", params=params)
+        return _PermissionGrouplistAdapter.validate_json(r.text)
+
+    def create_permission_group(
+        self,
+        tenant: str,
+        label: str,
+        acl_policy: str
+    ) -> PermissionGroup:
+        payload: _PayloadType = {
+            "tenant": tenant,
+            "label": label,
+            "acl_policy": acl_policy,
+        }
+        r = self._client._http_request(f"{self._path}/permissions", "PUT", json=payload)
+        return PermissionGroup.model_validate_json(r.text)
+
+    def get_permission_group(self, group: str) -> PermissionGroup:
+        r = self._client._http_request(f"{self._path}/permissions/{group}", "GET")
+        return PermissionGroup.model_validate_json(r.text)
+
+    def delete_permission_group(self, group: str) -> None:
+        self._client._http_request(f"{self._path}/permissions/{group}", "DELETE")
+
+    def modify_permission_group(
+        self,
+        group: str,
+        label: str,
+        acl_policy: str
+    ) -> None:
+        payload: _PayloadType = {
+            "label": label,
+            "acl_policy": acl_policy,
+        }
+        self._client._http_request(f"{self._path}/permissions/{group}", "PATCH", json=payload)

mercuto_client/{ingester/util.py → util.py}

@@ -1,11 +1,24 @@
 import itertools
 import shutil
+from datetime import timedelta
 from pathlib import Path
 from typing import Iterable, Iterator, TypeVar
 
 import requests
 
 
+def timedelta_isoformat(td: timedelta) -> str:
+    """
+    ISO 8601 encoding for Python timedelta object.
+    Taken from pydantic source:
+        https://github.com/pydantic/pydantic/blob/3704eccce4661455acdda1cdcf716bd4b3382e08/pydantic/deprecated/json.py#L135-L140
+
+    """
+    minutes, seconds = divmod(td.seconds, 60)
+    hours, minutes = divmod(minutes, 60)
+    return f'{"-" if td.days < 0 else ""}P{abs(td.days)}DT{hours:d}H{minutes:d}M{seconds:d}.{td.microseconds:06d}S'
+
+
 def get_my_public_ip() -> str:
     """
     Fetches the public IP address of the machine making the request.
@@ -51,14 +64,17 @@ def get_free_space_excluding_files(directory: str) -> int:
 
 T = TypeVar('T')
 
-
-def batched(iterable: Iterable[T], n: int) -> Iterator[tuple[T, ...]]:
-    """
-    Implementation of itertools.batched for < Python 3.12
-    """
-    it = iter(iterable)
-    while True:
-        chunk = tuple(itertools.islice(it, n))
-        if not chunk:
-            break
-        yield chunk
+try:
+    from itertools import batched  # type: ignore
+except ImportError:
+    # Python < 3.12
+    def batched(iterable: Iterable[T], n: int) -> Iterator[tuple[T, ...]]:  # type: ignore[no-redef]
+        """
+        Implementation of itertools.batched for < Python 3.12
+        """
+        it = iter(iterable)
+        while True:
+            chunk = tuple(itertools.islice(it, n))
+            if not chunk:
+                break
+            yield chunk

{mercuto_client-0.2.8.dist-info → mercuto_client-0.3.0a0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mercuto-client
-Version: 0.2.8
+Version: 0.3.0a0
 Summary: Library for interfacing with Rockfield's Mercuto API
 Author-email: Daniel Whipp <daniel.whipp@rocktech.com.au>
 License-Expression: AGPL-3.0-only
@@ -22,6 +22,7 @@ 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
@@ -42,7 +43,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()
@@ -55,7 +56,7 @@ 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
@@ -63,3 +64,9 @@ This library is incomplete and may not be fully compliant with the latest Mercut
 
 - [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.3.0a0.dist-info/RECORD

@@ -0,0 +1,41 @@
+mercuto_client/__init__.py,sha256=wsBZ73gKjbKLHfJD0nSSl1xOY69HxwALGX73vm7m6iA,283
+mercuto_client/_authentication.py,sha256=M213OBPYs7x5anK9PL92K_8w-orh9QNYm1-Rsdze6gQ,2700
+mercuto_client/acl.py,sha256=_1ogLx62JrYe3igqZwgop-m5NbLoUZPXCo0pEpSR6pc,2927
+mercuto_client/client.py,sha256=GnKB-q0IWPcMkLYr4WL_Mu8p8IzRRYY2FCNO1pi3JvM,6931
+mercuto_client/exceptions.py,sha256=xyUXVSUOXKoMV23hh0qHrRtQuojDBv5e-I0dU7x6a0c,507
+mercuto_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mercuto_client/util.py,sha256=PWNp8BU9wa_sKMPxW0R1yveEF1XslZXG8sw6BZvUoO8,2603
+mercuto_client/_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mercuto_client/_tests/conftest.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mercuto_client/_tests/test_ingester/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mercuto_client/_tests/test_ingester/test_file_processor.py,sha256=kC1DC0phmjl7jBMMBJYrs9Tx4NL9xKJNmqVX5FNH59s,7399
+mercuto_client/_tests/test_ingester/test_ftp.py,sha256=w1CHAGcZy88D2-nY61Gj16l1nHcer9LIKaMc_DXk23o,1318
+mercuto_client/_tests/test_ingester/test_parsers.py,sha256=R9GnzAaGu_tva0s23VpwEVfEsEUcto3kN3EloIxZvVY,5917
+mercuto_client/_tests/test_mocking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mercuto_client/_tests/test_mocking/conftest.py,sha256=M-HikiSj_uuYAEYQnFA0uDtSBpZjO2YXjzxNbluQdMQ,266
+mercuto_client/_tests/test_mocking/test_mock_identity.py,sha256=394r6A_xK78tse4CZA345JpIlIKF_GnPz2xXEjc_Nho,313
+mercuto_client/ingester/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mercuto_client/ingester/__main__.py,sha256=HZisjXuj5wzdUJ9vLqjhCDqLobflLLVLuI-7PclvVgw,6762
+mercuto_client/ingester/ftp.py,sha256=3-gMzoRCWjLZWeynjkwOXV59B4f0F2VnWp97fuUFTX4,4441
+mercuto_client/ingester/mercuto.py,sha256=djlP9HVoBoB2R-pQVogyMvHpPpbWEjCX5vbMhlEhc8U,6077
+mercuto_client/ingester/processor.py,sha256=XlMMM0taSHZzth39qVMsUkPO0g_ahC7Xcb01rOjQp3I,11906
+mercuto_client/ingester/parsers/__init__.py,sha256=lOt4TyP08hK56wl7XHMlqmj62mDE0Idx8UJL0wljtwM,1398
+mercuto_client/ingester/parsers/campbell.py,sha256=S5enYbajVTm3zSQYkEP6JRVUw94Z7ky100j8p5qLCls,441
+mercuto_client/ingester/parsers/generic_csv.py,sha256=v4rwO4oJb1Ue6zirO0TGtvewOSp9f6ZUT_sWvozvQHo,4051
+mercuto_client/ingester/parsers/worldsensing.py,sha256=rY3Io4mh8htfV4TghnCDkehPZIVoMqGWxEWnDVmZM6I,1028
+mercuto_client/mocks/__init__.py,sha256=Y01V4eyzC5hGX3A9XwqPC82glTSIaWLAPB3lOyBymqg,2988
+mercuto_client/mocks/_utility.py,sha256=YiUm_LzDOdHEhgkve_A5AEUAr9FmcPdVJi3R_izO8yw,2174
+mercuto_client/mocks/mock_data.py,sha256=PqVtKe6eShkfAvMUkZyf_w4-yed2TEx3CncwGIRmxWA,17964
+mercuto_client/mocks/mock_fatigue.py,sha256=GYcud-Rmpyz9wTYY9rsePvCUviIvu6c8wGXqe3L0MDk,940
+mercuto_client/mocks/mock_identity.py,sha256=2Qc9hze9lpPnfa8aj25NDYdDii15hgqej0ymBc3DWQQ,7318
+mercuto_client/modules/__init__.py,sha256=oPbPfkgL0JfCYRITS8O7uL8Zh8pjJTTPoEpK-nHmRuU,747
+mercuto_client/modules/_util.py,sha256=edPLMJsdxd3oIqMDYNtUIAbg_wKypmr-C8ilBzmafDY,403
+mercuto_client/modules/core.py,sha256=KzSmKH71qK9wDM6I-LvXY9oA2nBJFLoQXawK2ei3uCY,22828
+mercuto_client/modules/data.py,sha256=hMhzkkr0f7N9kVKvUQE65uXDpcCxGILcNUhZLSD3nD4,20742
+mercuto_client/modules/fatigue.py,sha256=SPftwW5rMk6LcsIGWO8OHc9r6DA99qt0AyAVOaNRt_8,6397
+mercuto_client/modules/identity.py,sha256=VeMGsq-s5B9xorP9G2TxwIDYUSyyDGuFAJ8Ilg7_mn4,7898
+mercuto_client-0.3.0a0.dist-info/licenses/LICENSE,sha256=0R2QbX4pr5XSiwUc2JoGS7Ja4npcQHyZlGJsR-E73I8,32386
+mercuto_client-0.3.0a0.dist-info/METADATA,sha256=u2Yn0V3LiTyZaMtKoJenocAtWXKsqvHN-7BrVBa7YGc,2423
+mercuto_client-0.3.0a0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mercuto_client-0.3.0a0.dist-info/top_level.txt,sha256=ecV4spooVaOU8AlclvojxY1LzLW1byDywh-ayLHvKCs,15
+mercuto_client-0.3.0a0.dist-info/RECORD,,

mercuto_client/_tests/test_mocking.py

@@ -1,93 +0,0 @@
-import pytest
-
-from .. import MercutoClient
-from ..mocks import mock_client
-
-
-def test_mock_injection_before_client_creation():
-    count = 0
-
-    def on_get_healthcheck(*args, **kwargs):
-        nonlocal count
-        count += 1
-        return 'mocked'
-    with mock_client() as mock:
-        mock.on('GET', '/healthcheck', on_get_healthcheck)
-        client = MercutoClient()
-        assert client.healthcheck() == 'mocked'
-    assert count == 1
-
-
-def test_mock_injection_after_client_creation():
-    count = 0
-    client = MercutoClient()
-
-    def on_get_healthcheck(*args, **kwargs):
-        nonlocal count
-        count += 1
-        return 'mocked'
-    with mock_client() as mock:
-        mock.on('GET', '/healthcheck', on_get_healthcheck)
-        assert client.healthcheck() == 'mocked'
-    assert count == 1
-
-
-def test_mock_releases_after_end_of_context():
-    client = MercutoClient()
-    with mock_client() as mock:
-        key = mock.add_user(user='this is a test')
-        client.connect(api_key=key)
-        assert client.identity().verify_me()['user'] == 'this is a test'
-
-    with pytest.raises(Exception):
-        client.identity().verify_me()
-
-
-def test_mock_verify_me():
-    client = MercutoClient()
-    with mock_client() as mock:
-        with pytest.raises(Exception):
-            client.identity().verify_me()
-
-        client.connect(api_key='bad api key')
-        with pytest.raises(Exception):
-            client.identity().verify_me()
-
-        key = mock.add_user(user='this is a test user',
-                            tenant='test-tenant', permission_group='test-group')
-        client.connect(api_key=key)
-        assert client.identity().verify_me()['user'] == 'this is a test user'
-        assert client.identity().verify_me()['tenant'] == 'test-tenant'
-        assert client.identity().verify_me()[
-            'permission_group'] == 'test-group'
-
-        mock.delete_user(key)
-        with pytest.raises(Exception):
-            client.identity().verify_me()
-
-
-def test_mock_get_user():
-    client = MercutoClient()
-    with mock_client() as mock:
-        client.connect(api_key='bad api key')
-        with pytest.raises(Exception):
-            client.identity().get_user('12345')
-
-        key = mock.add_user(user='code1', tenant='test-tenant', permission_group='test-group',
-                            username='testing@example.com')
-        client.connect(api_key=key)
-
-        assert client.identity().get_user('code1')['code'] == 'code1'
-        assert client.identity().get_user(
-            'code1')['username'] == 'testing@example.com'
-
-        mock.delete_user(key)
-        with pytest.raises(Exception):
-            client.identity().verify_me()
-
-
-def test_mock_unsupported_endpoint():
-    client = MercutoClient()
-    with mock_client():
-        with pytest.raises(NotImplementedError):
-            client.identity().list_tenants()

mercuto_client/_util.py

@@ -1,13 +0,0 @@
-from datetime import timedelta
-
-
-def timedelta_isoformat(td: timedelta) -> str:
-    """
-    ISO 8601 encoding for Python timedelta object.
-    Taken from pydantic source:
-        https://github.com/pydantic/pydantic/blob/3704eccce4661455acdda1cdcf716bd4b3382e08/pydantic/deprecated/json.py#L135-L140
-
-    """
-    minutes, seconds = divmod(td.seconds, 60)
-    hours, minutes = divmod(minutes, 60)
-    return f'{"-" if td.days < 0 else ""}P{abs(td.days)}DT{hours:d}H{minutes:d}M{seconds:d}.{td.microseconds:06d}S'