mercuto-client 0.3.0__py3-none-any.whl → 0.3.4a3__py3-none-any.whl

mercuto_client/mocks/_utility.py

@@ -1,3 +1,4 @@
+import base64
 import logging
 from types import FunctionType
 from typing import Any, Callable
@@ -67,3 +68,8 @@ class EnforceOverridesMeta(type):
                     return error_method
 
                 setattr(cls, attr, make_error_method(attr))
+
+
+def create_data_url(mime_type: str, data: bytes) -> str:
+    encoded_data = base64.b64encode(data).decode('utf-8')
+    return f"data:{mime_type};base64,{encoded_data}"

mercuto_client/mocks/mock_core.py

@@ -0,0 +1,44 @@
+import logging
+import uuid
+from datetime import datetime
+from typing import Optional
+
+from ..client import MercutoClient
+from ..exceptions import MercutoHTTPException
+from ..modules.core import Event, ItemCode, MercutoCoreService
+from ._utility import EnforceOverridesMeta
+
+logger = logging.getLogger(__name__)
+
+
+class MockMercutoCoreService(MercutoCoreService, metaclass=EnforceOverridesMeta):
+    def __init__(self, client: 'MercutoClient'):
+        super().__init__(client=client)
+        self._events: dict[str, Event] = {}
+
+    def create_event(self, project: str, start_time: datetime, end_time: datetime) -> Event:
+        event = Event(code=str(uuid.uuid4()), project=ItemCode(code=project), start_time=start_time, end_time=end_time, objects=[], tags=[])
+        self._events[event.code] = event
+        return event
+
+    def get_event(self, event: str) -> Event:
+        if event not in self._events:
+            raise MercutoHTTPException(status_code=404, message=f"Event {event} not found")
+        return self._events[event]
+
+    def list_events(self, project: str,
+                    start_time: Optional[datetime] = None,
+                    end_time: Optional[datetime] = None,
+                    limit: Optional[int] = None, offset: Optional[int] = 0,
+                    ascending: bool = True) -> list[Event]:
+        filtered = [event for event in self._events.values() if event.project.code == project]
+        if start_time is not None:
+            filtered = [event for event in filtered if event.start_time >= start_time]
+        if end_time is not None:
+            filtered = [event for event in filtered if event.end_time <= end_time]
+        filtered.sort(key=lambda e: e.start_time, reverse=not ascending)
+        if offset is not None:
+            filtered = filtered[offset:]
+        if limit is not None:
+            filtered = filtered[:limit]
+        return filtered

mercuto_client/mocks/mock_media.py

@@ -0,0 +1,117 @@
+import logging
+import mimetypes
+import os
+import uuid
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+from ..client import MercutoClient
+from ..exceptions import MercutoHTTPException
+from ..modules.media import Image, MercutoMediaService, Video
+from ._utility import EnforceOverridesMeta, create_data_url
+
+logger = logging.getLogger(__name__)
+
+
+class MockMercutoMediaService(MercutoMediaService, metaclass=EnforceOverridesMeta):
+    def __init__(self, client: 'MercutoClient'):
+        super().__init__(client=client)
+        self._events: dict[str, Image] = {}
+        self._videos: dict[str, Video] = {}
+
+    def upload_image(self, filename: str, project: str,
+                     camera: Optional[str] = None,
+                     timestamp: Optional[datetime] = None,
+                     event: Optional[str] = None,
+                     filedata: Optional[bytes] = None) -> Image:
+        code = str(uuid.uuid4())
+        mime_type, _ = mimetypes.guess_type(filename, strict=False)
+        if mime_type is None:
+            raise ValueError("Could not determine MIME type for file")
+        if mime_type not in ['image/jpeg', 'image/png', 'image/gif', 'image/bmp', 'image/tiff']:
+            raise MercutoHTTPException(f"Unsupported image MIME type: {mime_type}", 400)
+        if filedata is not None:
+            data = filedata
+        else:
+            with open(filename, 'rb') as f:
+                data = f.read()
+        data_url = create_data_url(mime_type, data)
+        image = Image(code=code, project=project, camera=camera, timestamp=timestamp, event=event, access_url=data_url,
+                      mime_type=mime_type, access_expires=datetime.now(timezone.utc) + timedelta(days=365),
+                      size_bytes=len(data), name=os.path.basename(filename))
+        self._events[code] = image
+        return image
+
+    def list_images(self, project: str,
+                    camera: Optional[str] = None,
+                    event: Optional[str] = None,
+                    start_time: Optional[datetime] = None,
+                    end_time: Optional[datetime] = None,
+                    limit: int = 10,
+                    offset: int = 0,
+                    ascending: bool = True) -> list[Image]:
+        results = [img for img in self._events.values() if img.project == project]
+        if camera:
+            results = [img for img in results if img.camera == camera]
+        if event:
+            results = [img for img in results if img.event == event]
+        if start_time:
+            results = [img for img in results if img.timestamp and img.timestamp >= start_time]
+        if end_time:
+            results = [img for img in results if img.timestamp and img.timestamp <= end_time]
+        results.sort(key=lambda img: img.timestamp or datetime.min, reverse=not ascending)
+        return results[offset:offset + limit]
+
+    def get_image(self, image_code: str) -> Image:
+        try:
+            return self._events[image_code]
+        except KeyError:
+            raise MercutoHTTPException(f"Image not found: {image_code}", 404)
+
+    def delete_image(self, image_code: str) -> None:
+        try:
+            del self._events[image_code]
+        except KeyError:
+            raise MercutoHTTPException(f"Image not found: {image_code}", 404)
+
+    def upload_video(self, filename: str, project: str, start_time: datetime, end_time: datetime,
+                     camera: str | None = None, event: str | None = None) -> str:
+        code = str(uuid.uuid4())
+        mime_type, _ = mimetypes.guess_type(filename, strict=False)
+        if mime_type is None:
+            raise ValueError("Could not determine MIME type for file")
+        with open(filename, 'rb') as f:
+            data = f.read()
+            data_url = create_data_url(mime_type, data)
+        video = Video(code=code, project=project, camera=camera, start_time=start_time, end_time=end_time, event=event,
+                      access_url=data_url, mime_type=mime_type,
+                      access_expires=datetime.now(timezone.utc) + timedelta(days=365),
+                      size_bytes=len(data), name=os.path.basename(filename))
+        self._videos[code] = video
+        return code
+
+    def list_videos(self, project: str,
+                    camera: Optional[str] = None,
+                    event: Optional[str] = None,
+                    start_time: Optional[datetime] = None,
+                    end_time: Optional[datetime] = None,
+                    limit: int = 10,
+                    offset: int = 0,
+                    ascending: bool = True) -> list[Video]:
+        results = [vid for vid in self._videos.values() if vid.project == project]
+        if camera:
+            results = [vid for vid in results if vid.camera == camera]
+        if event:
+            results = [vid for vid in results if vid.event == event]
+        if start_time:
+            results = [vid for vid in results if vid.start_time and vid.start_time >= start_time]
+        if end_time:
+            results = [vid for vid in results if vid.end_time and vid.end_time <= end_time]
+        results.sort(key=lambda vid: vid.start_time or datetime.min, reverse=not ascending)
+        return results[offset:offset + limit]
+
+    def get_video(self, video_code: str) -> Video:
+        try:
+            return self._videos[video_code]
+        except KeyError:
+            raise MercutoHTTPException(f"Video not found: {video_code}", 404)

mercuto_client/mocks/mock_notifications.py

@@ -0,0 +1,65 @@
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Optional
+
+from pydantic import BaseModel
+
+from ..client import MercutoClient
+from ..exceptions import MercutoHTTPException
+from ..modules.notifications import (ContactGroup, ContactMethod,
+                                     MercutoNotificationService,
+                                     NotificationAttachment)
+from ._utility import EnforceOverridesMeta
+
+logger = logging.getLogger(__name__)
+
+
+class IssuedNotification(BaseModel):
+    contact_group: ContactGroup
+    subject: str
+    html: str
+    alternative_plaintext: Optional[str] = None
+    attachments: Optional[list[NotificationAttachment]] = None
+    unsubscribe_placeholder_text: Optional[str] = None
+
+    issued_on: datetime
+
+
+class MockMercutoNotificationService(MercutoNotificationService, metaclass=EnforceOverridesMeta):
+    def __init__(self, client: 'MercutoClient'):
+        super().__init__(client=client)
+        self.contact_groups: dict[str, ContactGroup] = {}
+        self.issued_notifications: list[IssuedNotification] = []
+
+    def list_contact_groups(self, project: str) -> list[ContactGroup]:
+        return [group for group in self.contact_groups.values() if group.project == project]
+
+    def get_contact_group(self, code: str) -> ContactGroup:
+        if code not in self.contact_groups:
+            raise MercutoHTTPException(
+                f"Contact group with code {code} not found", 404)
+        return self.contact_groups[code]
+
+    def create_contact_group(self, project: str, label: str, users: dict[str, list[ContactMethod]]) -> ContactGroup:
+        code = str(uuid.uuid4())
+        contact_group = ContactGroup(
+            code=code, project=project, label=label, users=users)
+        self.contact_groups[code] = contact_group
+        return contact_group
+
+    def issue_notification(self, contact_group: str, subject: str, html: str,
+                           alternative_plaintext: Optional[str] = None,
+                           attachments: Optional[list[NotificationAttachment]] = None,
+                           unsubscribe_placeholder_text: Optional[str] = None) -> None:
+        group = self.get_contact_group(contact_group)
+        issued_notification = IssuedNotification(
+            contact_group=group,
+            subject=subject,
+            html=html,
+            alternative_plaintext=alternative_plaintext,
+            attachments=attachments,
+            unsubscribe_placeholder_text=unsubscribe_placeholder_text,
+            issued_on=datetime.now(timezone.utc)
+        )
+        self.issued_notifications.append(issued_notification)

mercuto_client/modules/__init__.py

@@ -2,13 +2,14 @@ import requests
 
 from ..exceptions import MercutoClientException, MercutoHTTPException
 
-_PayloadValueType = str | float | int | None
+_PayloadValueType = str | float | int | None | bool
 _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]
+_PayloadDictType = dict[str, '_PayloadValueType | _PayloadListType | _PayloadDictType']
+PayloadType = dict[str, _PayloadValueType | _PayloadListType | _PayloadDictType]
+_PayloadType = PayloadType  # For backwards compatibility
 
 
-def _raise_for_response(r: requests.Response) -> None:
+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):
@@ -17,3 +18,6 @@ def _raise_for_response(r: requests.Response) -> None:
         except Exception:
             detail = str(r)
         raise MercutoHTTPException(detail, r.status_code)
+
+
+_raise_for_response = raise_for_response  # For backwards compatibility