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

mercuto_client/client.py

@@ -1,121 +1,36 @@
-import base64
 import contextlib
+import json as json_stdlib
 import logging
-import mimetypes
 import os
 import time
-import urllib.parse
-from contextlib import nullcontext
-from datetime import datetime, timedelta
-from typing import (Any, BinaryIO, Iterable, Iterator, List, Literal, Mapping,
-                    Optional, Sequence, TextIO, Type, TypeVar)
+from typing import Any, Iterator, Mapping, Optional, Protocol, Type, TypeVar
 
 import requests
 import requests.cookies
 
-from ._util import timedelta_isoformat
+from ._authentication import (IAuthenticationMethod,
+                              create_authentication_method)
 from .exceptions import MercutoClientException, MercutoHTTPException
-from .types import (CHANNEL_CLASSIFICATION, AlertConfiguration,
-                    AuthHealthcheckResult, Camera, Channel, Condition,
-                    ContactGroup, Dashboards, Datalogger, DataRequest,
-                    DataSample, Device, DeviceType, Event, FatigueConnection,
-                    Image, ListAlertsResponseType, NewUserApiKey, Object,
-                    PermissionGroup, Project, RainflowConfiguration,
-                    ScheduledReport, ScheduledReportLog,
-                    SystemHealthcheckResult, Tenant, Units, User,
-                    UserContactMethod, UserDetails, VerifyMeResult, Video)
+from .modules.core import MercutoCoreService
+from .modules.data import MercutoDataService
+from .modules.fatigue import MercutoFatigueService
+from .modules.identity import MercutoIdentityService
 
 logger = logging.getLogger(__name__)
 
 
-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:
-        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:
+class _ModuleBase(Protocol):
+    def __init__(self, client: 'MercutoClient', *args: Any, **kwargs: Any) -> None:
         pass
 
-    def unique_key(self) -> str:
-        return 'null-authentication'
-
-
-def create_authentication_method(api_key: Optional[str] = None,
-                                 service_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:
-        raise MercutoClientException(
-            "Only one of api_key or service_token can be provided")
-    authorization_header = None
-    if headers is not None:
-        api_key = headers.get('X-Api-Key', None)
-        service_token = headers.get('X-Service-Token', None)
-        authorization_header = 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 authorization_header is not None:
-        return AuthorizationHeaderAuthentication(authorization_header)
-    else:
-        return NullAuthenticationMethod()
-
 
-class Module:
-    def __init__(self, client: 'MercutoClient') -> None:
-        self._client = client
-
-    @property
-    def client(self) -> 'MercutoClient':
-        return self._client
-
-
-T = TypeVar('T', bound='Module')
+_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')
+            url = os.environ.get('MERCUTO_API_URL', 'https://api.rockfieldcloud.com.au')
         assert isinstance(url, str)
 
         if url.endswith('/'):
@@ -135,7 +50,7 @@ class MercutoClient:
         self._auth_method: Optional[IAuthenticationMethod] = None
         self._cookies = requests.cookies.RequestsCookieJar()
 
-        self._modules: dict[str, Module] = {}
+        self._modules: dict[str, _ModuleBase] = {}
 
     def url(self) -> str:
         return self._url
@@ -157,20 +72,21 @@ class MercutoClient:
     @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)
+        other = MercutoClient(self._url, self._verify_ssl, self._current_session)
         try:
-            yield other.connect(api_key=api_key, service_token=service_token, headers=headers)
+            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.
@@ -180,8 +96,7 @@ class MercutoClient:
             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, headers=headers)
+        authentication = create_authentication_method(api_key=api_key, service_token=service_token, bearer_token=bearer_token, headers=headers)
         self.login(authentication)
         return self
 
@@ -193,14 +108,15 @@ class MercutoClient:
         base.update(headers)
         return base
 
-    def build_url(self, path: str, **params: Any) -> str:
-        if path.startswith('/'):
-            path = path[1:]
-        if path.endswith('/'):
-            path = path[:-1]
-        return f"{self._url}/{path}/?{urllib.parse.urlencode(params)}"
+    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}"
 
-    def _request_json(self, method: str, url: str, *args: Any, **kwargs: Any) -> Any:
         if 'timeout' not in kwargs:
             kwargs['timeout'] = 10
         kwargs['headers'] = self._update_headers(kwargs.get('headers', {}))
@@ -210,67 +126,46 @@ class MercutoClient:
 
         if 'cookies' not in kwargs:
             kwargs['cookies'] = self._cookies
-        return self._make_request(method, url, *args, **kwargs)
 
-    def _make_request(self, method: str, url: str, *args: Any, **kwargs: Any) -> Any:
-        if url.startswith('/'):
-            url = url[1:]
-        full_url = f"{self._url}/{url}"
+        # 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, *args, **kwargs)
+        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 not resp.ok:
-            raise MercutoHTTPException(resp.text, resp.status_code)
-        if resp.headers.get('Content-Type', '') != 'application/json':
-            raise MercutoClientException(f"Response is not JSON: {resp.text}")
+        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.json()
-
-    def request(self, method: str, url: str, *args: Any, **kwargs: Any) -> Any:
-        return self._request_json(method, url, *args, **kwargs)
+        return resp
 
-    def add_and_fetch_module(self, name: str, module: Type[T]) -> T:
+    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 projects(self) -> 'MercutoProjectService':
-        return self.add_and_fetch_module('projects', MercutoProjectService)
+        return self._add_and_fetch_module('identity', MercutoIdentityService)
 
     def fatigue(self) -> 'MercutoFatigueService':
-        return self.add_and_fetch_module('fatigue', MercutoFatigueService)
-
-    def channels(self) -> 'MercutoChannelService':
-        return self.add_and_fetch_module('channels', MercutoChannelService)
+        return self._add_and_fetch_module('fatigue', MercutoFatigueService)
 
     def data(self) -> 'MercutoDataService':
-        return self.add_and_fetch_module('data', MercutoDataService)
-
-    def events(self) -> 'MercutoEventService':
-        return self.add_and_fetch_module('events', MercutoEventService)
-
-    def alerts(self) -> 'MercutoAlertService':
-        return self.add_and_fetch_module('alerts', MercutoAlertService)
-
-    def devices(self) -> 'MercutoDeviceService':
-        return self.add_and_fetch_module('devices', MercutoDeviceService)
-
-    def notifications(self) -> 'MercutoNotificationsService':
-        return self.add_and_fetch_module('notifications', MercutoNotificationsService)
+        return self._add_and_fetch_module('data', MercutoDataService)
 
-    def reports(self) -> 'MercutoReportingService':
-        return self.add_and_fetch_module('reports', MercutoReportingService)
-
-    def objects(self) -> 'MercutoObjectService':
-        return self.add_and_fetch_module('objects', MercutoObjectService)
-
-    def media(self) -> 'MercutoMediaService':
-        return self.add_and_fetch_module('media', MercutoMediaService)
+    def core(self) -> 'MercutoCoreService':
+        return self._add_and_fetch_module('core', MercutoCoreService)
 
     def login(self, authentication: IAuthenticationMethod) -> None:
         self._auth_method = authentication
@@ -278,626 +173,5 @@ class MercutoClient:
     def logout(self) -> None:
         self._auth_method = None
 
-    def healthcheck(self) -> SystemHealthcheckResult:
-        return self._request_json('GET', '/healthcheck')  # type: ignore[no-any-return]
-
-
-class MercutoDataService(Module):
-    def __init__(self, client: 'MercutoClient') -> None:
-        super().__init__(client)
-
-    def upload_samples(self, samples: Sequence[DataSample]) -> None:
-        self._client._request_json(
-            'POST', '/data/upload/samples', json=samples)
-
-    def upload_file(self, project: str, datatable: str, file: str | bytes | TextIO | BinaryIO, filename: Optional[str] = None) -> None:
-        if isinstance(file, str):
-            ctx = open(file, 'rb')
-            filename = filename or os.path.basename(file)
-        else:
-            ctx = nullcontext(file)  # type: ignore
-            filename = filename or 'file.dat'
-
-        with ctx as f:
-            self._client._request_json('POST', '/files/upload/small', params={'project_code': project, 'datatable_code': datatable},
-                                       files={'file': (filename, f, 'text/csv')})
-
-    def get_data_url(
-        self,
-        project_code: str,
-        start_time: datetime | str | None = None,
-        end_time: datetime | str | None = None,
-        event_code: str | None = None,
-        channel_codes: Iterable[str] | None = None,
-        primary_channels: bool | None = None,
-        channels_like: str | None = None,
-        file_format: Literal['DAT', 'CSV', 'PARQUET', 'FEATHER'] = 'DAT',
-        frame_format: Literal['RECORDS', 'COLUMNS'] = 'COLUMNS',
-        channel_format: Literal['CODE', 'LABEL'] = 'LABEL',
-        timeout: timedelta | None = timedelta(seconds=20),
-    ) -> str:
-        request = self.get_data_request(
-            project_code=project_code,
-            start_time=start_time,
-            end_time=end_time,
-            event_code=event_code,
-            channel_codes=channel_codes,
-            primary_channels=primary_channels,
-            channels_like=channels_like,
-            file_format=file_format,
-            frame_format=frame_format,
-            channel_format=channel_format,
-            timeout=timeout,
-        )
-        if request['presigned_url'] is None:
-            raise MercutoClientException("No presigned URL available")
-
-        return request['presigned_url']
-
-    def get_data_request(
-        self,
-        project_code: str,
-        start_time: datetime | str | None = None,
-        end_time: datetime | str | None = None,
-        event_code: str | None = None,
-        channel_codes: Iterable[str] | None = None,
-        primary_channels: bool | None = None,
-        channels_like: str | None = None,
-        file_format: Literal['DAT', 'CSV', 'PARQUET', 'FEATHER'] = 'DAT',
-        frame_format: Literal['RECORDS', 'COLUMNS'] = 'COLUMNS',
-        channel_format: Literal['CODE', 'LABEL'] = 'LABEL',
-        timeout: timedelta | None = timedelta(seconds=20),
-    ) -> DataRequest:
-        params = {
-            'timeout': 0
-        }
-
-        body = {
-            'project_code': project_code,
-            'start_time': start_time.isoformat() if isinstance(start_time, datetime) else start_time,
-            'end_time': end_time.isoformat() if isinstance(end_time, datetime) else end_time,
-            'event_code': event_code,
-            'channel_codes': channel_codes,
-            'primary_channels': primary_channels,
-            'channels_like': channels_like,
-            'data_format': file_format,
-            'frame_format': frame_format,
-            'channel_format': channel_format,
-        }
-
-        request: DataRequest = self._client._request_json(
-            'POST',
-            '/data/requests',
-            params=params,
-            json=body)
-
-        start = time.time()
-        while True:
-            if timeout is not None and time.time() - start > timeout.total_seconds():
-                raise MercutoClientException(
-                    "Timeout waiting for data request")
-            if request['completed_at'] is not None:
-                return request
-
-            time.sleep(1)
-            request = self._client._request_json(
-                'GET', f'/data/requests/{request["code"]}')
-
-
-class MercutoEventService(Module):
-    def __init__(self, client: 'MercutoClient') -> None:
-        super().__init__(client)
-
-    def list_events(self, project: str) -> list[Event]:
-        params: dict[str, str] = {'project_code': project}
-        return self._client._request_json('GET', '/events', params=params)
-
-    def get_nearest_event(
-        self,
-        project_code: str,
-        to: datetime | str,
-        maximum_delta: timedelta | None = None,
-    ) -> Event:
-        params = {
-            'project_code': project_code,
-            'to': to.isoformat() if isinstance(to, datetime) else to,
-            'maximum_delta': timedelta_isoformat(maximum_delta) if maximum_delta is not None else None,
-        }
-
-        return self.client._request_json('GET', '/events/nearest', params=params)
-
-    def get_nearest_event_url(
-            self,
-            project_code: str,
-            to: datetime | str,
-            maximum_delta: timedelta | None = None,
-            file_format: Literal['DAT', 'CSV', 'PARQUET', 'FEATHER'] = 'DAT',
-            frame_format: Literal['COLUMNS', 'RECORDS'] = 'COLUMNS',
-    ) -> str:
-        event = self.get_nearest_event(project_code, to, maximum_delta)
-
-        return self.client.data().get_data_url(
-            project_code=project_code,
-            event_code=event['code'],
-            primary_channels=True,
-            file_format=file_format,
-            frame_format=frame_format)
-
-
-class MercutoAlertService(Module):
-    def __init__(self, client: 'MercutoClient') -> None:
-        super().__init__(client)
-
-    def get_condition(self, code: str) -> Condition:
-        return self._client._request_json('GET', f'/alerts/conditions/{code}')
-
-    def create_condition(self, source: str, description: str, *,
-                         lower_bound: Optional[float] = None,
-                         upper_bound: Optional[float] = None,
-                         neutral_position: float = 0) -> Condition:
-        json = {
-            'source_channel_code': source,
-            'description': description,
-            'neutral_position': neutral_position
-        }
-        if lower_bound is not None:
-            json['lower_inclusive_bound'] = lower_bound
-        if upper_bound is not None:
-            json['upper_exclusive_bound'] = upper_bound
-        return self._client._request_json('PUT', '/alerts/conditions', json=json)
-
-    def create_configuration(self, label: str, conditions: list[str], contact_group: Optional[str] = None) -> AlertConfiguration:
-        json = {
-            'label': label,
-            'conditions': conditions,
-
-        }
-        if contact_group is not None:
-            json['contact_group'] = contact_group
-        return self._client._request_json('PUT', '/alerts/configurations', json=json)
-
-    def get_alert_configuration(self, code: str) -> AlertConfiguration:
-        return self._client._request_json('GET', f'/alerts/configurations/{code}')
-
-    def list_logs(
-            self,
-            project: str | None = None,
-            configuration: str | None = None,
-            channels: list[str] | None = None,
-            start_time: datetime | str | None = None,
-            end_time: datetime | str | None = None,
-            limit: int = 10,
-            offset: int = 0,
-            latest_only: bool = False,
-    ) -> ListAlertsResponseType:
-        params = {
-            'project': project,
-            'configuration_code': configuration,
-            'channels': channels,
-            'start_time': start_time.isoformat() if isinstance(start_time, datetime) else start_time,
-            'end_time': end_time.isoformat() if isinstance(end_time, datetime) else end_time,
-            'limit': limit,
-            'offset': offset,
-            'latest_only': latest_only,
-        }
-
-        return self._client._request_json('GET', '/alerts/logs', params=params)
-
-
-class MercutoProjectService(Module):
-    def __init__(self, client: 'MercutoClient') -> None:
-        super().__init__(client)
-
-    def get_project(self, code: str) -> Project:
-        return self._client._request_json('GET', f'/projects/{code}')
-
-    def get_projects(self) -> list[Project]:
-        return self._client._request_json('GET', '/projects')
-
-    def create_project(self, name: str, project_number: str, description: str, tenant: str,
-                       timezone: str, latitude: Optional[float] = None,
-                       longitude: Optional[float] = None) -> Project:
-
-        return self._client._request_json('PUT', '/projects',
-                                          json={'name': name, 'project_number': project_number, 'description': description,
-                                                'tenant_code': tenant,
-                                                'timezone': timezone,
-                                                'latitude': latitude,
-                                                'longitude': longitude,
-                                                'project_type': 1,
-                                                'channels': []})
-
-    def ping_project(self, project: str, ip_address: str) -> None:
-        self._client._request_json(
-            'POST', f'/projects/{project}/ping', json={'ip_address': ip_address})
-
-    def create_channel(self, project: str, label: str,  sampling_period: timedelta) -> Channel:
-        return self._client._request_json('PUT', '/channels', json={
-            'project_code': project,
-            'label': label,
-            'classification': 'SECONDARY',
-            'sampling_period': timedelta_isoformat(sampling_period),
-        })
-
-    def create_dashboard(self, project_code: str, dashboards: Dashboards) -> bool:
-        return self._client._request_json('POST', f'/projects/{project_code}/dashboard', json=dashboards) is None
-
-
-class MercutoFatigueService(Module):
-    def __init__(self, client: 'MercutoClient') -> None:
-        super().__init__(client)
-
-    def setup_rainflow(self, project: str,
-                       max_bins: int,
-                       bin_size: float,
-                       multiplier: float,
-                       channels: list[str],
-                       reservoir_adjustment: bool = True,
-                       enable_root_mean_cubed: bool = True,
-                       enable_root_sum_cubed: bool = True) -> RainflowConfiguration:
-        return self.client._request_json('PUT', '/fatigue/rainflow/setup', json=dict(
-            project=project,
-            max_bins=max_bins,
-            bin_size=bin_size,
-            multiplier=multiplier,
-            reservoir_adjustment=reservoir_adjustment,
-            channels=channels,
-            enable_root_mean_cubed=enable_root_mean_cubed,
-            enable_root_sum_cubed=enable_root_sum_cubed
-        ))
-
-    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:
-        """
-        Sources should be a list of Primary Channel codes.
-        """
-        return self.client._request_json('PUT', '/fatigue/connections', json=dict(
-            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
-        ))
-
-
-class MercutoChannelService(Module):
-    def __init__(self, client: MercutoClient) -> None:
-        super().__init__(client)
-
-    def get_units(self) -> List[Units]:
-        return self._client._request_json('GET', '/channels/units')
-
-    def create_units(self, name: str, unit: str) -> Units:
-        return self._client._request_json('PUT', '/channels/units', json=dict(name=name, unit=unit))
-
-    def create_channel(self, project_code: str, label: str, classification: CHANNEL_CLASSIFICATION, sampling_period: timedelta) -> Channel:
-        return self._client._request_json('PUT', '/channels', json=dict(
-            project_code=project_code,
-            label=label,
-            classification=classification,
-            sampling_period=timedelta_isoformat(sampling_period)))
-
-    def modify_channel(self,
-                       channel: str,
-                       label:  Optional[str] = None,
-                       units_code:  Optional[str] = None,
-                       device_code:  Optional[str] = None,
-                       metric:  Optional[str] = None,
-                       multiplier: float = 1,
-                       offset: float = 0) -> Channel:
-        data: dict = {}
-        if label is not None:
-            data['label'] = label
-        if units_code is not None:
-            data['units_code'] = units_code
-        if metric is not None:
-            data['metric'] = metric
-        if device_code is not None:
-            data['device_code'] = device_code
-        data['multiplier'] = multiplier
-        data['offset'] = offset
-        return self._client._request_json('PATCH', f'/channels/{channel}', json=data)
-
-    def get_channels(
-        self,
-        project_code: str | None = None,
-        classification: CHANNEL_CLASSIFICATION | None = None,
-        aggregate: str | None = None,
-        metric: str | None = None,
-    ) -> list[Channel]:
-        limit = 200
-        offset = 0
-        channels: list[Channel] = []
-
-        while True:
-            params = {
-                'project_code': project_code,
-                'classification': classification,
-                'aggregate': aggregate,
-                'metric': metric,
-                'limit': limit,
-                'offset': offset,
-            }
-
-            resp = self._client._request_json(
-                'GET', '/channels', params=params)
-            channels.extend(resp)
-
-            if len(resp) < limit:
-                break
-
-            offset += limit
-
-        return channels
-
-
-class MercutoDeviceService(Module):
-    def __init__(self, client: MercutoClient) -> None:
-        super().__init__(client)
-
-    def get_device_types(self) -> list[DeviceType]:
-        return self._client._request_json('GET', '/devices/types')
-
-    def create_device_type(self, description: str, manufacturer: str, model_number: str) -> DeviceType:
-        return self._client._request_json('PUT', '/devices/types', json=dict(
-            description=description,
-            manufacturer=manufacturer,
-            model_number=model_number))
-
-    def get_devices(self, project_code: str, limit: int, offset: int) -> list[Device]:
-        return self._client._request_json('GET', '/devices', params=dict(project_code=project_code, limit=limit, offset=offset))
-
-    def get_device(self, device_code: str) -> Device:
-        return self._client._request_json('GET', f'/devices/{device_code}')
-
-    def create_device(self,
-                      project_code: str,
-                      label: str,
-                      device_type_code: str,
-                      groups: list[str],
-                      location_description: Optional[str] = None) -> Device:
-        return self._client._request_json('PUT', '/devices', json=dict(
-            project_code=project_code,
-            label=label,
-            device_type_code=device_type_code,
-            groups=groups,
-            location_description=location_description))
-
-    def list_dataloggers(self, project: str) -> list[Datalogger]:
-        return self._client._request_json('GET', '/dataloggers', params={'project_code': project})
-
-
-class MercutoIdentityService(Module):
-    def __init__(self, client: 'MercutoClient') -> None:
-        super().__init__(client)
-
-    def create_tenant(self, name: str, description: str, logo_url: Optional[str] = None) -> Tenant:
-        return self._client._request_json('PUT', '/identity/tenants',
-                                          json={'name': name, 'description': description, 'logo_url': logo_url})
-
-    def list_tenants(self) -> list[Tenant]:
-        return self._client._request_json('GET', '/identity/tenants')
-
-    def get_tenant(self, code: str) -> Tenant:
-        return self._client._request_json('GET', f'/identity/tenants/{code}')
-
-    def create_user(self, username: str, tenant: str, description: str,
-                    group: str, password: Optional[str] = None) -> User:
-        return self._client._request_json('PUT', '/identity/users',
-                                          json={'username': username, 'tenant_code': tenant, 'description': description,
-                                                'group_code': group, 'default_password': password})
-
-    def list_users(self, project: Optional[str] = None,
-                   tenant: Optional[str] = None) -> list[User]:
-        params = {}
-        if project is not None:
-            params['project'] = project
-        if tenant is not None:
-            params['tenant'] = tenant
-        return self._client._request_json('GET', '/identity/users', params=params)
-
-    def get_user(self, code: str) -> User:
-        return self._client._request_json('GET', f'/identity/users/{code}')
-
-    def get_user_details(self, code: str) -> UserDetails:
-        return self._client._request_json('GET', f'/identity/users/{code}/details')
-
-    def edit_user_details(self, code: str, first_name: Optional[str], last_name: Optional[str],
-                          email_address: Optional[str], mobile_number: Optional[str]) -> UserDetails:
-        return self._client._request_json('PATCH', f'/identity/users/{code}/details', json={
-            'first_name': first_name,
-            'last_name': last_name,
-            'email_address': email_address,
-            'mobile_number': mobile_number
-        })
-
-    def generate_api_key(self, user: str, description: str) -> NewUserApiKey:
-        return self._client._request_json('POST', f'/identity/users/{user}/api_keys',
-                                          json={'description': description})
-
-    def grant_user_permission(self, user: str, resource: str, action: str) -> None:
-        return self._client._request_json('POST', f'/identity/users/{user}/grant',
-                                          json={'resource': resource, 'action': action})
-
-    def create_permission_group(self, tenant: str, label: str,
-                                acl_json: str) -> PermissionGroup:
-        return self._client._request_json('PUT', '/identity/permissions', json={
-            'tenant': tenant,
-            'label': label,
-            'acl_policy': acl_json
-        })
-
-    def list_permission_groups(self) -> list[PermissionGroup]:
-        return self._client._request_json('GET', '/identity/permissions')
-
-    def get_permission_group(self, code: str) -> PermissionGroup:
-        return self._client._request_json('GET', f'/identity/permissions/{code}')
-
-    def update_permission_group(self, code: str, label: str,
-                                acl_json: str) -> None:
-        return self._client._request_json('PATCH', f'/identity/permissions/{code}', json={
-            'label': label,
-            'acl_policy': acl_json
-        })
-
-    def verify_me(self) -> VerifyMeResult:
-        return self._client._request_json('GET', '/identity/verify/me')
-
-    def healthcheck(self) -> AuthHealthcheckResult:
-        return self._client._request_json('GET', '/identity/healthcheck')
-
-
-class MercutoNotificationsService(Module):
-    def __init__(self, client: 'MercutoClient') -> None:
-        super().__init__(client)
-
-    def list_contact_groups(self, project: Optional[str] = None) -> list[ContactGroup]:
-        params = {}
-        if project is not None:
-            params['project'] = project
-        return self._client._request_json('GET', '/notifications/contact_groups', params=params)
-
-    def get_contact_group(self, code: str) -> ContactGroup:
-        return self._client._request_json('GET', f'/notifications/contact_groups/{code}')
-
-    def create_contact_group(self, project: str, label: str, users: dict[str, list[UserContactMethod]]) -> ContactGroup:
-        return self._client._request_json('PUT', '/notifications/contact_groups',
-                                          json={
-                                              'project': project,
-                                              'label': label,
-                                              'users': users
-                                          })
-
-
-class MercutoReportingService(Module):
-    def __init__(self, client: 'MercutoClient') -> None:
-        super().__init__(client)
-
-    def list_reports(self, project: Optional[str] = None) -> list['ScheduledReport']:
-        params = {}
-        if project is not None:
-            params['project'] = project
-        return self._client._request_json('GET', '/reports/scheduled', params=params)
-
-    def create_report(self, project: str, label: str, schedule: str, revision: str,
-                      api_key: Optional[str] = None, contact_group: Optional[str] = None) -> ScheduledReport:
-        return self._client._request_json('PUT', '/reports/scheduled', json={
-            'project': project,
-            'label': label,
-            'schedule': schedule,
-            'revision': revision,
-            'execution_role_api_key': api_key,
-            'contact_group': contact_group
-        })
-
-    def generate_report(self, report: str, timestamp: datetime, mark_as_scheduled: bool = False) -> ScheduledReportLog:
-        return self._client._request_json('PUT', f'/reports/scheduled/{report}/generate', json={
-            'timestamp': timestamp.isoformat(),
-            'mark_as_scheduled': mark_as_scheduled
-        })
-
-    def list_report_logs(self, report: str, project: Optional[str] = None) -> list[ScheduledReportLog]:
-        params: dict[str, str] = {}
-        if project is not None:
-            params['project'] = project
-        return self._client._request_json('GET', f'/reports/scheduled/{report}/logs', params=params)
-
-    def get_report_log(self, report: str, log: str) -> ScheduledReportLog:
-        return self._client._request_json('GET', f'/reports/scheduled/{report}/logs/{log}')
-
-
-class MercutoObjectService(Module):
-    def __init__(self, client: 'MercutoClient') -> None:
-        super().__init__(client)
-
-    def upload_file(self, project_code: str, file: str, event_code: Optional[str] = None,
-                    mime_type: Optional[str] = None) -> Object:
-        with open(file, 'rb') as f:
-            if mime_type is None:
-                mime_type = mimetypes.guess_type(file, strict=False)[0]
-                if mime_type is None:
-                    raise MercutoClientException(
-                        f"Could not determine mime type for {file}")
-            base64_data = base64.b64encode(f.read()).decode('utf-8')
-            data_url = f'data:{mime_type};base64,{base64_data}'
-
-            return self._client._request_json('POST', '/objects/upload', params={
-                'project_code': project_code,
-                'event_code': event_code
-            }, json={
-                'filename': os.path.basename(file),
-                'mime_type': mime_type,
-                'data_url': data_url
-            })
-
-
-class MercutoMediaService(Module):
-    def __init__(self, client: 'MercutoClient') -> None:
-        super().__init__(client)
-
-    def list_cameras(self, project: str) -> list[Camera]:
-        params = {}
-        params['project_code'] = project
-        return self._client._request_json('GET', '/media/cameras', params=params)
-
-    def list_videos(self, project: Optional[str] = None, event: Optional[str] = None, camera: Optional[str] = None) -> list[Video]:
-        params = {}
-        if project is not None:
-            params['project'] = project
-        if event is not None:
-            params['event'] = event
-        if camera is not None:
-            params['camera'] = camera
-        return self._client._request_json('GET', '/media/videos', params=params)
-
-    def list_images(self, project: Optional[str] = None, event: Optional[str] = None, camera: Optional[str] = None) -> list[Image]:
-        params = {}
-        if project is not None:
-            params['project'] = project
-        if event is not None:
-            params['event'] = event
-        if camera is not None:
-            params['camera'] = camera
-        return self._client._request_json('GET', '/media/images', params=params)
-
-    def get_image(self, code: str) -> Image:
-        return self._client._request_json('GET', f'/media/images/{code}')  # type: ignore[no-any-return]
-
-    def upload_image(self, project: str, file: str, event: Optional[str] = None,
-                     camera: Optional[str] = None, timestamp: Optional[datetime] = None,
-                     filename: Optional[str] = None) -> Image:
-        if timestamp is not None and timestamp.tzinfo is None:
-            raise MercutoClientException("Timestamp must be timezone aware")
-
-        mimetype, _ = mimetypes.guess_type(file, strict=False)
-        if mimetype is None or not mimetype.startswith('image/'):
-            raise MercutoClientException(f"File {file} is not an image")
-
-        if os.stat(file).st_size > 5_000_000:
-            raise MercutoClientException(f"File {file} is too large")
-
-        if filename is None:
-            filename = os.path.basename(file)
-
-        params = {}
-        params['project'] = project
-        if event is not None:
-            params['event'] = event
-        if camera is not None:
-            params['camera'] = camera
-        if timestamp is not None:
-            params['timestamp'] = timestamp.isoformat()
-
-        with open(file, 'rb') as f:
-            return self._client._request_json('PUT', '/media/images', params=params, files={
-                'file': (filename, f, mimetype)
-            })
+    def is_logged_in(self) -> bool:
+        return self._auth_method is not None