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

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}')"

mercuto_client/ingester/__main__.py

@@ -8,10 +8,10 @@ from typing import Callable, TypeVar
 
 import schedule
 
+from ..util import get_free_space_excluding_files
 from .ftp import simple_ftp_server
 from .mercuto import MercutoIngester
 from .processor import FileProcessor
-from .util import get_free_space_excluding_files
 
 logger = logging.getLogger(__name__)
 

mercuto_client/ingester/mercuto.py

@@ -1,13 +1,14 @@
 import fnmatch
-import itertools
 import logging
 import os
 from typing import Optional
 
 from .. import MercutoClient, MercutoHTTPException
-from ..types import Channel, DataSample, DatatableOut, Project
+from ..modules.core import Project
+from ..modules.data import (Channel, ChannelClassification, Datatable,
+                            SecondaryDataSample)
+from ..util import batched, get_my_public_ip
 from .parsers import detect_parser
-from .util import batched, get_my_public_ip
 
 logger = logging.getLogger(__name__)
 
@@ -22,19 +23,19 @@ class MercutoIngester:
 
         self._project: Optional[Project] = None
         self._secondary_channels: Optional[list[Channel]] = None
-        self._datatables: Optional[list[DatatableOut]] = None
+        self._datatables: Optional[list[Datatable]] = None
 
         self._channel_map: dict[str, str] = {}
 
     def _refresh_mercuto_data(self) -> None:
         with self._client.as_credentials(api_key=self._api_key) as client:
-            self._project = client.projects().get_project(self._project_code)
-            assert self._project['code'] == self._project_code
+            self._project = client.core().get_project(self._project_code)
+            assert self._project.code == self._project_code
 
-            self._secondary_channels = client.channels().get_channels(self._project_code, classification='SECONDARY')
-            self._datatables = list(itertools.chain.from_iterable([dt['datatables'] for dt in client.devices().list_dataloggers(self._project_code)]))
+            self._secondary_channels = client.data().list_channels(self._project_code, classification=ChannelClassification.SECONDARY)
+            self._datatables = client.data().list_datatables(self._project_code)
 
-        self._channel_map.update({c['label']: c['code'] for c in self._secondary_channels})
+        self._channel_map.update({c.label: c.code for c in self._secondary_channels})
 
     def _can_process(self) -> bool:
         return self._project is not None and self._secondary_channels is not None and self._datatables is not None
@@ -56,7 +57,7 @@ class MercutoIngester:
         """
         ip = get_my_public_ip()
         with self._client.as_credentials(api_key=self._api_key) as client:
-            client.projects().ping_project(self.project_code, ip_address=ip)
+            client.core().ping_project(self.project_code, ip_address=ip)
             logging.info(f"Pinged Mercuto server from IP: {ip} for project: {self.project_code}")
 
     def matching_datatable(self, filename: str) -> str | None:
@@ -85,20 +86,18 @@ class MercutoIngester:
 
         for dt in self._datatables:
             # Match using datatable pattern
-            if matches(dt['name']):
-                return dt['code']
-            if dt['src'] and matches(dt['src']):
-                return dt['code']
+            if matches(dt.name):
+                return dt.code
         return None
 
-    def _upload_samples(self, samples: list[DataSample]) -> bool:
+    def _upload_samples(self, samples: list[SecondaryDataSample]) -> bool:
         """
         Upload samples to the Mercuto project.
         """
         try:
             with self._client.as_credentials(api_key=self._api_key) as client:
                 for batch in batched(samples, 500):
-                    client.data().upload_samples(batch)
+                    client.data().insert_secondary_samples(self.project_code, batch)
             return True
         except MercutoHTTPException as e:
             if e.status_code in NON_RETRYABLE_ERRORS:

mercuto_client/ingester/parsers/__init__.py

@@ -2,7 +2,7 @@ from typing import Optional, Protocol
 
 import pytz
 
-from ...types import DataSample
+from ...modules.data import SecondaryDataSample
 from .campbell import parse_campbell_file
 from .worldsensing import (parse_worldsensing_compact_file,
                            parse_worldsensing_standard_file)
@@ -10,9 +10,9 @@ from .worldsensing import (parse_worldsensing_compact_file,
 
 class Parser(Protocol):
     def __call__(self, filename: str, label_to_channel_code: dict[str, str],
-                 timezone: Optional[pytz.BaseTzInfo] = None) -> list[DataSample]:
+                 timezone: Optional[pytz.BaseTzInfo] = None) -> list[SecondaryDataSample]:
         """
-        Parse the file and return a list of DataSample objects.
+        Parse the file and return a list of SecondaryDataSample objects.
         """
         pass
 

mercuto_client/ingester/parsers/campbell.py

@@ -2,11 +2,11 @@ from typing import Optional
 
 import pytz
 
-from ...types import DataSample
+from ...modules.data import SecondaryDataSample
 from .generic_csv import parse_generic_csv_file
 
 
 def parse_campbell_file(filename: str, label_to_channel_code: dict[str, str],
-                        timezone: Optional[pytz.BaseTzInfo] = None) -> list[DataSample]:
+                        timezone: Optional[pytz.BaseTzInfo] = None) -> list[SecondaryDataSample]:
     return parse_generic_csv_file(
         filename, label_to_channel_code, header_index=1, data_index=2, timezone=timezone)

mercuto_client/ingester/parsers/generic_csv.py

@@ -5,7 +5,7 @@ from typing import Optional
 import pytz
 from dateutil import parser
 
-from ...types import DataSample
+from ...modules.data import SecondaryDataSample
 
 logger = logging.getLogger(__name__)
 
@@ -56,7 +56,7 @@ def _parse_csv_line(line: str, sep: str = ',', timestamp_index: int = 0) -> tupl
 
 def parse_generic_csv_file(filename: str, label_to_channel_code: dict[str, str],
                            header_index: int, data_index: int,
-                           timezone: Optional[pytz.BaseTzInfo] = None) -> list[DataSample]:
+                           timezone: Optional[pytz.BaseTzInfo] = None) -> list[SecondaryDataSample]:
     """
     header index: Number of lines to skip before header
     data index: Number of lines to skip after the header before data
@@ -64,7 +64,7 @@ def parse_generic_csv_file(filename: str, label_to_channel_code: dict[str, str],
     We are avoiding using pandas here to keep dependencies minimal as this is often run on edge devices.
     """
 
-    output: list[DataSample] = []
+    output: list[SecondaryDataSample] = []
     with open(filename, "r") as f:
         for _ in range(header_index):
             next(f, None)
@@ -109,6 +109,6 @@ def parse_generic_csv_file(filename: str, label_to_channel_code: dict[str, str],
 
                 logger.debug(
                     f"Adding entry for label: {header} with value: {value} and timestamp: {timestamp}")
-                output.append(DataSample(timestamp=timestamp.isoformat(),
-                              channel_code=channel_code, value=value))
+                output.append(SecondaryDataSample(timestamp=timestamp,
+                              channel=channel_code, value=value))
     return output

mercuto_client/ingester/parsers/worldsensing.py

@@ -2,11 +2,12 @@ from typing import Optional
 
 import pytz
 
-from .generic_csv import DataSample, parse_generic_csv_file
+from ...modules.data import SecondaryDataSample
+from .generic_csv import parse_generic_csv_file
 
 
 def parse_worldsensing_standard_file(filename: str, label_to_channel_code: dict[str, str],
-                                     timezone: Optional[pytz.BaseTzInfo] = None) -> list[DataSample]:
+                                     timezone: Optional[pytz.BaseTzInfo] = None) -> list[SecondaryDataSample]:
     """
     Parse a worldsensing standard CSV file provided when downloading data or using standard CSV export.
     """
@@ -15,7 +16,7 @@ def parse_worldsensing_standard_file(filename: str, label_to_channel_code: dict[
 
 
 def parse_worldsensing_compact_file(filename: str, label_to_channel_code: dict[str, str],
-                                    timezone: Optional[pytz.BaseTzInfo] = None) -> list[DataSample]:
+                                    timezone: Optional[pytz.BaseTzInfo] = None) -> list[SecondaryDataSample]:
     """
     Parse a worldsensing custom CSV file. These are generated when using compacted CSV mechanism.
     """

mercuto_client/mocks/__init__.py

@@ -0,0 +1,92 @@
+import contextlib
+from typing import Callable, Iterator, Optional
+
+from mercuto_client.modules.identity import VerifyMyPermissions
+
+from ..client import MercutoClient
+
+
+@contextlib.contextmanager
+def mock_mercuto(data: bool = True,
+                 identity: bool = True,
+                 fatigue: bool = True,
+                 verify_service_token: Optional[Callable[[str], VerifyMyPermissions]] = None) -> Iterator[None]:
+    """
+    While this context is active, all calls to MercutoClient will use mocked services.
+
+    :param data: Whether to mock the data module.
+    :param identity: Whether to mock the identity module.
+    :param fatigue: Whether to mock the fatigue module.
+    :param verify_service_token: Optional function to mock the verify_service_token behavior. Only used for the mock identity service.
+    """
+    with contextlib.ExitStack() as stack:
+        if data:
+            stack.enter_context(mock_data_module())
+        if identity:
+            stack.enter_context(mock_identity_module(verify_service_token=verify_service_token))
+        if fatigue:
+            stack.enter_context(mock_fatigue_module())
+        yield
+
+
+@contextlib.contextmanager
+def mock_data_module() -> Iterator[None]:
+    from .mock_data import MockMercutoDataService
+    original = MercutoClient.data
+
+    _cache: Optional[MockMercutoDataService] = None
+
+    def stub(self: MercutoClient) -> MockMercutoDataService:
+        nonlocal _cache
+        if _cache is None:
+            _cache = MockMercutoDataService(self)
+        _cache._client = self
+        return _cache
+
+    try:
+        setattr(MercutoClient, 'data', stub)
+        yield
+    finally:
+        setattr(MercutoClient, 'data', original)
+
+
+@contextlib.contextmanager
+def mock_identity_module(verify_service_token: Optional[Callable[[str], VerifyMyPermissions]] = None) -> Iterator[None]:
+    from .mock_identity import MockMercutoIdentityService
+    original = MercutoClient.identity
+
+    _cache: Optional[MockMercutoIdentityService] = None
+
+    def stub(self: MercutoClient) -> MockMercutoIdentityService:
+        nonlocal _cache
+        if _cache is None:
+            _cache = MockMercutoIdentityService(self, verify_service_token=verify_service_token)
+        _cache._client = self
+        return _cache
+
+    try:
+        setattr(MercutoClient, 'identity', stub)
+        yield
+    finally:
+        setattr(MercutoClient, 'identity', original)
+
+
+@contextlib.contextmanager
+def mock_fatigue_module() -> Iterator[None]:
+    from .mock_fatigue import MockMercutoFatigueService
+    original = MercutoClient.fatigue
+
+    _cache: Optional[MockMercutoFatigueService] = None
+
+    def stub(self: MercutoClient) -> MockMercutoFatigueService:
+        nonlocal _cache
+        if _cache is None:
+            _cache = MockMercutoFatigueService(self)
+        _cache._client = self
+        return _cache
+
+    try:
+        setattr(MercutoClient, 'fatigue', stub)
+        yield
+    finally:
+        setattr(MercutoClient, 'fatigue', original)

mercuto_client/mocks/_utility.py

@@ -0,0 +1,69 @@
+import logging
+from types import FunctionType
+from typing import Any, Callable
+
+logger = logging.getLogger(__name__)
+
+
+class EnforceOverridesMeta(type):
+    """
+    Helper for patching mock implementations.
+
+    Assign this as a metaclass when overriding a single base class, and all of the base class' methods
+    must be overridden and cannot be called.
+
+    Example usage:
+
+    ```
+    class BaseClass():
+        def method1(self):
+            pass
+        def method2(self):
+            pass
+
+    class MockClass(BaseClass, metaclass=EnforceOverridesMeta):
+        def method1(self):
+            return "Mocked!"
+
+    mock = MockClass()
+    mock.method1() # Okay
+    mock.method2() # Raises NotImplementedError
+    ```
+
+    To exclude specific methods from requiring overrides, add them to the `__exclude_enforce__` set:
+
+    ```
+    class MockClass(BaseClass, metaclass=EnforceOverridesMeta):
+        __exclude_enforce__ = {BaseClass.method2}
+
+        def method1(self):
+            return "Mocked!"
+
+    mock = MockClass()
+    mock.method1() # Okay
+    mock.method2() # Okay
+    ```
+    """
+    def __init__(cls: type[Any], name: str, bases: tuple[type, ...], namespace: dict[str, Any]) -> None:
+        type.__init__(cls, name, bases, namespace)
+
+        # Assumes single inheritance from Base
+        if len(bases) != 1:
+            raise TypeError("EnforceOverridesMeta can only be used with a single base class.")
+
+        base = bases[0]
+
+        excluded: set[FunctionType] = getattr(cls, "__exclude_enforce__", set())
+
+        for attr in dir(base):
+            if attr.startswith('__'):
+                continue
+
+            base_method = getattr(base, attr)
+            if isinstance(base_method, FunctionType) and base_method not in excluded and attr not in namespace:
+                def make_error_method(attr_name: str) -> Callable[..., None]:
+                    def error_method(self: Any, *args: Any, **kwargs: Any) -> None:
+                        raise NotImplementedError(f"Mocker '{cls.__name__}' does not currently support method '{attr_name}'")
+                    return error_method
+
+                setattr(cls, attr, make_error_method(attr))