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

mercuto_client/mocks/mock_data.py

@@ -0,0 +1,402 @@
+import base64
+import io
+import logging
+import uuid
+from datetime import datetime, timedelta, timezone
+from typing import BinaryIO, Collection, Optional, TextIO
+
+import pandas as pd
+
+from ..client import MercutoClient
+from ..exceptions import MercutoHTTPException
+from ..modules.data import (AggregationOptions, Channel, ChannelClassification,
+                            ChannelFormat, Datatable, DatatableColumn,
+                            FileFormat, FrameFormat, GetStatusRequestResponse,
+                            LatestDataSample, MercutoDataService,
+                            MetricDataSample, SecondaryDataSample)
+from ._utility import EnforceOverridesMeta
+
+logger = logging.getLogger(__name__)
+
+
+class MockMercutoDataService(MercutoDataService, metaclass=EnforceOverridesMeta):
+    __exclude_enforce__ = {MercutoDataService.load_presigned_url,
+                           MercutoDataService.load_metric_sample,
+                           MercutoDataService.load_data_request}
+
+    def __init__(self, client: 'MercutoClient'):
+        super().__init__(client=client, path='/mock-data-service-method-not-implemented')
+        self._secondary_and_primary_buffer = pd.DataFrame(columns=['channel', 'timestamp', 'value']).set_index(['channel', 'timestamp'])
+        self._metric_buffer = pd.DataFrame(columns=['channel', 'timestamp', 'value', 'event']).set_index(['channel', 'timestamp'])
+
+        self._known_requests: dict[str, GetStatusRequestResponse] = {}
+
+        self._channels: dict[str, Channel] = {}
+        self._datatables: dict[str, Datatable] = {}
+
+    def _last_timestamp(self, channel: str) -> Optional[datetime]:
+        if channel in self._secondary_and_primary_buffer.index.get_level_values('channel'):
+            return self._secondary_and_primary_buffer.loc[channel, :].index.get_level_values('timestamp').max()
+        if channel in self._metric_buffer.index.get_level_values('channel'):
+            return self._metric_buffer.loc[channel, :].index.get_level_values('timestamp').max()
+        return None
+
+    def _update_last_valid_samples(self) -> None:
+        for channel in self._channels.values():
+            channel.last_valid_timestamp = self._last_timestamp(channel.code)
+
+    def list_channels(self,
+                      project: str,
+                      classification: Optional[ChannelClassification] = None,
+                      aggregate: Optional[str] = None, metric: Optional[str] = None,
+                      show_hidden: bool = False) -> list[Channel]:
+        selection = filter(lambda ch: ch.project == project, self._channels.values())
+        if classification is not None:
+            selection = filter(lambda ch: ch.classification == classification, selection)
+        if aggregate is not None:
+            selection = filter(lambda ch: ch.aggregate == aggregate, selection)
+        if metric is not None:
+            selection = filter(lambda ch: ch.metric == metric, selection)
+        return list(selection)
+
+    def get_channel(self, code: str) -> Optional[Channel]:
+        return self._channels.get(code)
+
+    def create_channel(self, project: str,
+                       label: str,
+                       classification: ChannelClassification = ChannelClassification.SECONDARY,
+                       sampling_period: Optional[timedelta] = None,
+                       multiplier: float = 1.0, offset: float = 0.0,
+                       value_range_min: Optional[float] = None, value_range_max: Optional[float] = None,
+                       delta_max: Optional[float] = None,
+                       units: Optional[str] = None,
+                       aggregate: Optional[str] = None,
+                       source: Optional[str] = None,
+                       metric: Optional[str] = None) -> Channel:
+
+        if multiplier != 1.0:
+            logger.warning("MockMercutoDataService does not support channel multiplier.")
+        if offset != 0.0:
+            logger.warning("MockMercutoDataService does not support channel offset.")
+        if value_range_min is not None:
+            logger.warning("MockMercutoDataService does not support channel value_range_min.")
+        if value_range_max is not None:
+            logger.warning("MockMercutoDataService does not support channel value_range_max.")
+        if delta_max is not None:
+            logger.warning("MockMercutoDataService does not support channel delta_max.")
+        if units is not None:
+            logger.warning("MockMercutoDataService does not support channel units.")
+
+        # Generate a unique UUID code
+        code = str(uuid.uuid4())
+        channel = Channel(code=code,
+                          project=project,
+                          units=None,
+                          sampling_period=sampling_period,
+                          classification=classification,
+                          label=label,
+                          metric=metric,
+                          source=source,
+                          aggregate=aggregate,
+                          value_range_min=None,
+                          value_range_max=None,
+                          multiplier=multiplier,
+                          offset=offset,
+                          last_valid_timestamp=None,
+                          is_wallclock_interval=False)
+        self._channels[code] = channel
+
+        return channel
+
+    def create_request(self,
+                       start_time: datetime,
+                       end_time: datetime,
+                       project: Optional[str] = None,
+                       channels: Optional[Collection[str]] = None,
+                       classification: Optional[ChannelClassification] = None,
+                       frame_format: FrameFormat = FrameFormat.SAMPLES,
+                       file_format: FileFormat = FileFormat.PARQUET,
+                       channel_format: ChannelFormat = ChannelFormat.CODE,
+                       aggregation: Optional[AggregationOptions] = None,
+                       timeout: float = 0) -> GetStatusRequestResponse:
+
+        if channel_format != ChannelFormat.CODE:
+            raise NotImplementedError(f"Unsupported channel format: {channel_format}")
+
+        if channels is None and project is None:
+            raise ValueError("Must supply either channels or project.")
+
+        if channels is None and classification is None:
+            raise ValueError("Must supply either channels or classification.")
+
+        if aggregation is not None:
+            raise NotImplementedError("MockMercutoDataService does not support aggregation.")
+
+        if channels is None:
+            assert classification is not None
+            assert project is not None
+            channels = [ch.code for ch in self._channels.values() if ch.classification == classification and ch.project == project]
+
+        assert channels is not None
+
+        def load_from_buffer(buffer: pd.DataFrame) -> pd.DataFrame:
+            # Filter by channels if provided
+            if channels is not None:
+                buffer = buffer[buffer.index.get_level_values('channel').isin(channels)]
+
+            # Filter by time range
+            buffer = buffer[
+                (buffer.index.get_level_values('timestamp') >= start_time) &
+                (buffer.index.get_level_values('timestamp') <= end_time)
+            ]
+            return buffer
+
+        secondary_part = load_from_buffer(self._secondary_and_primary_buffer)
+        metric_part = load_from_buffer(self._metric_buffer)[['value']]
+        ts = pd.concat([secondary_part, metric_part], axis=0).sort_index()
+
+        assert ts.columns == ['value']
+        assert ts.index.names == ['channel', 'timestamp']
+
+        if frame_format == FrameFormat.COLUMNS:
+            ts = ts.reset_index(drop=False).pivot(index='timestamp',
+                                                  columns='channel',
+                                                  values='value')
+
+        buffer = io.BytesIO()
+        if file_format == FileFormat.FEATHER:
+            ts.to_feather(buffer)
+            mime_type = 'application/feather'
+        elif file_format == FileFormat.PARQUET:
+            ts.to_parquet(buffer, index=True)
+            mime_type = 'application/parquet'
+        else:
+            raise NotImplementedError(f"Unsupported file format: {file_format}")
+        buffer.seek(0)
+        data = buffer.read()
+
+        first_timestamp = None if len(ts) == 0 else ts.index.get_level_values('timestamp').min()
+
+        # Encode as a data-url
+        b64_data = base64.b64encode(data).decode('utf-8')
+        url = f"data:{mime_type};base64,{b64_data}"
+
+        req = GetStatusRequestResponse(
+            request_id=str(uuid.uuid4()),
+            status_code=200,
+            message="Success",
+            requested_at=datetime.now(timezone.utc),
+            completed_at=datetime.now(timezone.utc),
+            result=GetStatusRequestResponse.GetDataRequestStatusCompletedResult(
+                result_url=url,
+                expires_at=datetime.now(timezone.utc) + timedelta(hours=1),
+                mime_type=mime_type,
+                file_size=len(data),
+                metadata=GetStatusRequestResponse.GetDataRequestStatusCompletedResult.ResultMetadata(
+                    first_timestamp=first_timestamp
+                )
+            )
+        )
+        self._known_requests[req.request_id] = req
+        return req
+
+    def get_request_status(self, request_id: str) -> GetStatusRequestResponse:
+        if request_id not in self._known_requests:
+            raise MercutoHTTPException(status_code=404, message="Not Found")
+        return self._known_requests[request_id]
+
+    def insert_metric_samples(
+        self,
+        project: str,
+        samples: Collection[MetricDataSample]
+    ) -> None:
+        if not samples:
+            return
+
+        # Ensure all channels are of type METRIC
+        if not all(
+            sample.channel in self._channels and (self._channels[sample.channel].classification == ChannelClassification.EVENT_METRIC or
+                                                  self._channels[sample.channel].classification == ChannelClassification.PRIMARY_EVENT_AGGREGATE)
+            and self._channels[sample.channel].project == project
+            for sample in samples
+        ):
+            return
+
+        df = pd.DataFrame([{
+            'channel': s.channel,
+            'timestamp': s.timestamp,
+            'value': s.value,
+            'event': s.event
+        } for s in samples])
+        df = df.set_index(['channel', 'timestamp'])
+
+        to_concat: list[pd.DataFrame] = []
+        if len(self._metric_buffer) > 0:
+            to_concat.append(self._metric_buffer)
+        if len(df) > 0:
+            to_concat.append(df)
+
+        self._metric_buffer = pd.concat(to_concat).sort_index()
+        self._update_last_valid_samples()
+
+    def insert_secondary_samples(
+        self,
+        project: str,
+        samples: Collection[SecondaryDataSample]
+    ) -> None:
+        if not samples:
+            return
+
+        # Ensure all channels are of type SECONDARY
+        if not all(
+            sample.channel in self._channels and self._channels[sample.channel].classification == ChannelClassification.SECONDARY
+            and self._channels[sample.channel].project == project
+            for sample in samples
+        ):
+            return
+
+        df = pd.DataFrame([{
+            'channel': s.channel,
+            'timestamp': s.timestamp,
+            'value': s.value,
+        } for s in samples])
+        df = df.set_index(['channel', 'timestamp'])
+
+        to_concat: list[pd.DataFrame] = []
+        if len(self._secondary_and_primary_buffer) > 0:
+            to_concat.append(self._secondary_and_primary_buffer)
+        if len(df) > 0:
+            to_concat.append(df)
+
+        self._secondary_and_primary_buffer = pd.concat(to_concat).sort_index()
+        self._update_last_valid_samples()
+
+    def delete_metric_samples(self, project: str, event: str, channels: Optional[Collection[str]] = None) -> None:
+        if channels is None:
+            channels = [c.code for c in self._channels.values() if c.project == project]
+        idx = self._metric_buffer.index
+
+        mask = (
+            idx.get_level_values('channel').isin(channels) &
+            (self._metric_buffer['event'] == event)
+        )
+        self._metric_buffer = self._metric_buffer[~mask]
+        self._update_last_valid_samples()
+
+    def load_metric_samples(
+        self,
+        channels: Optional[Collection[str]] = None,
+        start_time: Optional[datetime] = None,
+        end_time: Optional[datetime] = None,
+        events: Optional[Collection[str]] = None,
+        project: Optional[str] = None,
+        limit: int = 100
+    ) -> list[MetricDataSample]:
+        if channels is None and project is None:
+            raise ValueError("Must supply either channels or project.")
+
+        if channels is None:
+            channels = [c.code for c in self._channels.values() if c.project == project and c.classification in {
+                ChannelClassification.EVENT_METRIC, ChannelClassification.PRIMARY_EVENT_AGGREGATE
+            }]
+
+        # Ensure all channels exist are of type METRIC or PRIMARY_EVENT_AGGREGATE
+        if not all(
+            ch in self._channels and self._channels[ch].classification in {
+                ChannelClassification.EVENT_METRIC, ChannelClassification.PRIMARY_EVENT_AGGREGATE}
+            for ch in channels
+        ):
+            return []
+
+        idx = self._metric_buffer.index
+        mask = (
+            idx.get_level_values('channel').isin(channels) &
+            (start_time is None or idx.get_level_values('timestamp') >= start_time) &
+            (end_time is None or idx.get_level_values('timestamp') <= end_time) &
+            (events is None or self._metric_buffer['event'].isin(events))
+        )
+        filtered = self._metric_buffer[mask]
+        return [
+            MetricDataSample(
+                channel=channel,
+                timestamp=timestamp,
+                value=row['value'],
+                event=row['event']
+            )
+            for (channel, timestamp), row in filtered.iterrows()
+        ][:limit]
+
+    def create_datatable(self, project: str, name: str, sampling_period: timedelta, column_labels: Collection[str]) -> Datatable:
+        if sampling_period <= timedelta(seconds=1):
+            classification = ChannelClassification.PRIMARY
+        else:
+            classification = ChannelClassification.SECONDARY
+        channels = [self.create_channel(project=project, label=col, classification=classification,
+                                        sampling_period=sampling_period) for col in column_labels]
+        dt = Datatable(
+            code=str(uuid.uuid4()),
+            project=project,
+            name=name,
+            sampling_period=sampling_period,
+            columns=[DatatableColumn(column_label=ch.label, channel=ch.code) for ch in channels],
+            enabled=True
+        )
+        self._datatables[dt.code] = dt
+        return dt
+
+    def _dt_col_to_channel_code(self, dt: str, column_label: str) -> str:
+        for col in self._datatables[dt].columns:
+            if col.column_label == column_label:
+                return col.channel
+        raise ValueError(f"Column label '{column_label}' not found in datatable '{dt}'")
+
+    def upload_file(self, project: str, datatable: str, file: str | bytes | TextIO | BinaryIO,
+                    filename: Optional[str] = None,
+                    timezone: Optional[str] = None) -> None:
+        frame = pd.read_csv(file, header=1, skiprows=[2, 3],
+                            usecols=None, sep=',', index_col=0, na_values=['NAN', '"NAN"'])
+        frame.index = pd.to_datetime(frame.index, utc=False)
+        assert isinstance(frame.index, pd.DatetimeIndex)
+        if frame.index.tz is None:
+            frame.index = frame.index.tz_convert(timezone)
+        del frame['RECORD']
+
+        # Drop unknown channels
+        frame = frame[[col for col in frame.columns if col in {c.column_label for c in self._datatables[datatable].columns}]]
+
+        # rename from label to code
+        frame = frame.rename(columns=lambda x: self._dt_col_to_channel_code(datatable, x))
+
+        frame = frame.melt([], tuple(frame.columns), ignore_index=False, var_name='channel',
+                           value_name='value').sort_index()
+        frame.index.name = 'timestamp'
+        frame = frame.reset_index().set_index(['channel', 'timestamp'])
+        self._secondary_and_primary_buffer = pd.concat([self._secondary_and_primary_buffer, frame]).sort_index()
+        self._update_last_valid_samples()
+
+    def get_latest_samples(self, project: str, include_primary: bool = True) -> list[LatestDataSample]:
+        if include_primary:
+            channels = [c.code for c in self._channels.values() if c.project == project]
+        else:
+            channels = [ch for ch in channels if self._channels[ch].classification !=
+                        ChannelClassification.PRIMARY and self._channels[ch].project == project]
+
+        out: list[LatestDataSample] = []
+
+        # Get the last timestamp and value for each channel in the secondary_and_primary_buffer
+        latest = self._secondary_and_primary_buffer.groupby(level='channel').last()
+        for (channel, timestamp), row in latest.iterrows():
+            if channel not in channels:
+                continue
+            out.append(LatestDataSample(channel=channel,
+                                        timestamp=timestamp,
+                                        value=row['value']))
+
+        latest = self._metric_buffer.groupby(level='channel').last()
+        for (channel, timestamp), row in latest.iterrows():
+            if channel not in channels:
+                continue
+            out.append(LatestDataSample(channel=channel,
+                                        timestamp=timestamp,
+                                        value=row['value']))
+        return out

mercuto_client/mocks/mock_fatigue.py

@@ -0,0 +1,30 @@
+import logging
+from datetime import datetime
+from typing import Literal, Optional
+
+from ..client import MercutoClient
+from ..modules.fatigue import MercutoFatigueService
+from ._utility import EnforceOverridesMeta
+
+logger = logging.getLogger(__name__)
+
+
+class MockMercutoFatigueService(MercutoFatigueService, metaclass=EnforceOverridesMeta):
+    def __init__(self, client: 'MercutoClient'):
+        super().__init__(client=client, path='/mock-fatigue-service-method-not-implemented')
+
+    def delete_cycle_counts(
+        self, project: str, start_time: datetime, end_time: datetime, ignore_if_not_configured: bool = False
+    ) -> None:
+        pass
+
+    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:
+        pass

mercuto_client/mocks/mock_identity.py

@@ -0,0 +1,188 @@
+import logging
+import uuid
+from dataclasses import dataclass
+from typing import Callable, Optional
+
+from ..client import MercutoClient
+from ..exceptions import MercutoHTTPException
+from ..modules.identity import (CurrentUser, HiddenUserAPIKey,
+                                MercutoIdentityService, PermissionGroup,
+                                Tenant, User, UserDetails, VerifyMyPermissions,
+                                VisibleUserAPIKey)
+from ._utility import EnforceOverridesMeta
+
+logger = logging.getLogger(__name__)
+
+
+class MockMercutoIdentityService(MercutoIdentityService, metaclass=EnforceOverridesMeta):
+    @dataclass
+    class _GeneratedUserApiKey:
+        user: str
+        api_key: str
+        hidden: HiddenUserAPIKey
+
+    def __init__(self, client: 'MercutoClient', verify_service_token: Optional[Callable[[str], VerifyMyPermissions]] = None) -> None:
+        """
+        Initialize the mock identity service.
+        :param client: The MercutoClient instance.
+        :param verify_service_token: Optional callable to verify service tokens.
+        """
+
+        super().__init__(client=client, path='/mock-identity-service-method-not-implemented')
+        self._verify_service_token = verify_service_token
+
+        # In-memory stores for mock data
+        self._users: dict[str, User] = {}
+        self._user_details: dict[str, UserDetails] = {}
+        self._tenants: dict[str, Tenant] = {}
+        self._permission_groups: dict[str, PermissionGroup] = {}
+
+        # Maps API Key to User
+        self._api_keys: dict[str, MockMercutoIdentityService._GeneratedUserApiKey] = {}
+
+    def get_my_permissions(self) -> VerifyMyPermissions:
+        if self._client._auth_method is None:
+            raise MercutoHTTPException('Not authenticated', 401)
+        header: dict[str, str] = {}
+        self._client._auth_method.update_header(header)
+        if (api_key := header.get('X-Api-Key')) is not None:
+            known = self._api_keys.get(api_key)
+            if known is None:
+                raise MercutoHTTPException('Invalid API key', 403)
+            if known.hidden.custom_policy is not None:
+                return VerifyMyPermissions(user=known.user, acl_policy=known.hidden.custom_policy)
+            user = self._users[known.user]
+            group = self._permission_groups[user.permission_group]
+            return VerifyMyPermissions(user=user.code, acl_policy=group.acl_policy)
+        elif (service_token := header.get('X-Service-Token')) is not None:
+            if self._verify_service_token is None:
+                raise MercutoHTTPException('Service token verification not implemented', 501)
+            return self._verify_service_token(service_token)
+
+        raise MercutoHTTPException('Invalid authentication method for mock implementation', 403)
+
+    def list_users(self, tenant: Optional[str] = None) -> list[User]:
+        if tenant is None:
+            return list(self._users.values())
+        return [u for u in self._users.values() if u.tenant == tenant]
+
+    def create_user(
+        self,
+        username: str,
+        tenant: str,
+        description: str,
+        group: str,
+        default_password: Optional[str] = None
+    ) -> User:
+        code = str(uuid.uuid4())
+        user = User(code=code, username=username, description=description, tenant=tenant, permission_group=group)
+        self._users[code] = user
+        self._user_details[code] = UserDetails(code=code, username=username)
+        return user
+
+    def get_current_user(self) -> CurrentUser:
+        perms = self.get_my_permissions()
+        if perms.user is None:
+            raise MercutoHTTPException('Not authenticated', 401)
+        user = self._users[perms.user]
+        tenant = self._tenants[user.tenant]
+        group = self._permission_groups[user.permission_group]
+        return CurrentUser(
+            code=user.code,
+            username=user.username,
+            description=user.description,
+            tenant=tenant,
+            permission_group=group,
+            current_permission_policy=group.acl_policy
+        )
+
+    def get_user(self, code: str) -> User:
+        return self._users[code]
+
+    def delete_user(self, code: str) -> None:
+        if code in self._users:
+            del self._users[code]
+        if code in self._user_details:
+            del self._user_details[code]
+        for k, v in list(self._api_keys.items()):
+            if v.user == code:
+                del self._api_keys[k]
+
+    def get_user_details(self, code: str) -> UserDetails:
+        return self._user_details[code]
+
+    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:
+        user_details = self._user_details[code]
+        if email_address is not None:
+            user_details.email_address = email_address
+        if mobile_number is not None:
+            user_details.mobile_number = mobile_number
+        if first_name is not None:
+            user_details.first_name = first_name
+        if last_name is not None:
+            user_details.last_name = last_name
+        return user_details
+
+    def get_user_api_keys(self, user: str) -> list[HiddenUserAPIKey]:
+        return [v.hidden for v in self._api_keys.values() if v.user == user]
+
+    def generate_api_key_for_user(
+        self,
+        user: str,
+        description: str,
+        custom_policy: Optional[str] = None
+    ) -> VisibleUserAPIKey:
+        key_code = str(uuid.uuid4())
+        new_api_key = str(uuid.uuid4())
+        hidden_key = HiddenUserAPIKey(code=key_code, description=description, last_used=None, custom_policy=custom_policy)
+
+        if user not in self._users:
+            raise MercutoHTTPException('User not found', 404)
+
+        self._api_keys[new_api_key] = self._GeneratedUserApiKey(
+            user=user, api_key=new_api_key, hidden=hidden_key
+        )
+        return VisibleUserAPIKey(code=key_code, new_api_key=new_api_key, description=description, custom_policy=custom_policy)
+
+    def list_tenants(self) -> list[Tenant]:
+        return list(self._tenants.values())
+
+    def get_tenant(self, code: str) -> Tenant:
+        return self._tenants[code]
+
+    def create_tenant(
+        self,
+        name: str,
+        description: str,
+        logo_url: Optional[str] = None
+    ) -> Tenant:
+        code = str(uuid.uuid4())
+        tenant = Tenant(code=code, name=name, description=description, logo_url=logo_url)
+        self._tenants[code] = tenant
+        return tenant
+
+    def get_permission_groups(self, tenant: Optional[str] = None) -> list[PermissionGroup]:
+        if tenant is None:
+            return list(self._permission_groups.values())
+        return [g for g in self._permission_groups.values() if g.tenant == tenant]
+
+    def create_permission_group(
+        self,
+        tenant: str,
+        label: str,
+        acl_policy: str
+    ) -> PermissionGroup:
+        code = str(uuid.uuid4())
+        group = PermissionGroup(tenant=tenant, code=code, label=label, acl_policy=acl_policy)
+        self._permission_groups[code] = group
+        return group
+
+    def get_permission_group(self, group: str) -> PermissionGroup:
+        return self._permission_groups[group]

mercuto_client/modules/__init__.py

@@ -0,0 +1,19 @@
+import requests
+
+from ..exceptions import MercutoClientException, MercutoHTTPException
+
+_PayloadValueType = str | float | int | None
+_PayloadListType = list[str] | list[float] | list[int] | list[_PayloadValueType]
+_PayloadDictType = dict[str, str] | dict[str, float] | dict[str, int] | dict[str, _PayloadValueType]
+_PayloadType = dict[str, _PayloadValueType | _PayloadListType | _PayloadDictType]
+
+
+def _raise_for_response(r: requests.Response) -> None:
+    if 500 <= r.status_code < 600:
+        raise MercutoClientException(f"Server error: {r.text}")
+    if not (200 <= r.status_code < 300):
+        try:
+            detail = r.text
+        except Exception:
+            detail = str(r)
+        raise MercutoHTTPException(detail, r.status_code)

mercuto_client/modules/_util.py

@@ -0,0 +1,18 @@
+from datetime import timedelta
+
+from pydantic import BaseModel as _BaseModel
+from pydantic import ConfigDict, TypeAdapter
+
+_TimedeltaAdapter = TypeAdapter(timedelta)
+
+
+def serialise_timedelta(td: timedelta) -> str:
+    s = _TimedeltaAdapter.dump_python(td, mode='json')
+    assert isinstance(s, str)
+    return s
+
+
+class BaseModel(_BaseModel):
+    model_config = ConfigDict(
+        extra='allow'
+    )