sherlock-api 0.1.0__py3-none-any.whl

sherlock_api/__init__.py

@@ -0,0 +1,104 @@
+"""Python client for the Sherlock REST API.
+
+Quickstart::
+
+    from sherlock_api import SherlockAPIClient, CreateCaseRequest, RobotPlatform
+
+    with SherlockAPIClient(sherlock_port=8080) as client:
+        case = client.post_case(
+            CreateCaseRequest("My case", RobotPlatform.UNIVERSAL_ROBOTS, "inspect")
+        )
+
+When a script is launched by Sherlock itself, the connection details come from
+the ``SHERLOCK_*`` environment variables and ``SherlockAPIClient()`` needs no
+arguments at all.
+"""
+
+from __future__ import annotations
+
+import logging
+from importlib.metadata import PackageNotFoundError, version
+
+from .batches import CreateBatchRequest
+from .cases import CreateCaseRequest, RobotPlatform
+from .client import DEFAULT_TIMEOUT, DEFAULT_URL, SherlockAPIClient
+from .exceptions import (
+    SherlockAPIError,
+    SherlockBadRequestError,
+    SherlockConfigurationError,
+    SherlockError,
+    SherlockNotFoundError,
+    SherlockServerError,
+    SherlockTimeoutError,
+)
+from .files import guess_extension_by_magic
+from .images import CreateImageRequest, DecisionClass
+from .logs import (
+    CreateBatchLogRequest,
+    CreateCaseLogRequest,
+    CreateImageLogRequest,
+    LogRequest,
+    LogType,
+)
+from .measurements import CreateMeasurementRequest
+from .process import (
+    CreateNotificationRequest,
+    CreateProcessModalDialogRequest,
+    DialogResult,
+    DialogType,
+    Language,
+    NotificationAttachment,
+    ProcessState,
+)
+from .validation import is_valid_uuid32
+
+try:
+    __version__ = version("sherlock-api")
+except PackageNotFoundError:  # pragma: no cover - running from a source tree
+    __version__ = "0.0.0.dev0"
+
+# A library should not configure logging for its host application.
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
+__all__ = [
+    "__version__",
+    # Client
+    "SherlockAPIClient",
+    "DEFAULT_URL",
+    "DEFAULT_TIMEOUT",
+    # Exceptions
+    "SherlockError",
+    "SherlockConfigurationError",
+    "SherlockAPIError",
+    "SherlockBadRequestError",
+    "SherlockNotFoundError",
+    "SherlockTimeoutError",
+    "SherlockServerError",
+    # Cases
+    "CreateCaseRequest",
+    "RobotPlatform",
+    # Batches
+    "CreateBatchRequest",
+    # Images
+    "CreateImageRequest",
+    "DecisionClass",
+    # Logs
+    "LogType",
+    "LogRequest",
+    "CreateCaseLogRequest",
+    "CreateBatchLogRequest",
+    "CreateImageLogRequest",
+    # Measurements
+    "CreateMeasurementRequest",
+    # Processes
+    "ProcessState",
+    "DialogType",
+    "DialogResult",
+    "Language",
+    "CreateProcessModalDialogRequest",
+    "CreateNotificationRequest",
+    "NotificationAttachment",
+    # Helpers
+    "guess_extension_by_magic",
+    "is_valid_uuid32",
+]

sherlock_api/batches.py

@@ -0,0 +1,28 @@
+"""Request models for Sherlock batches."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+__all__ = ["CreateBatchRequest"]
+
+
+@dataclass
+class CreateBatchRequest:
+    """Payload for :meth:`sherlock_api.SherlockAPIClient.post_batch`.
+
+    Args:
+        case_id: Id of the case the batch belongs to.
+        batch_name: Human-readable name of the batch.
+    """
+
+    case_id: str
+    batch_name: str
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to the JSON body expected by ``POST /batch``."""
+        return {
+            "case_id": self.case_id,
+            "batch_name": self.batch_name,
+        }

sherlock_api/cases.py

@@ -0,0 +1,42 @@
+"""Request models for Sherlock cases."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+__all__ = ["RobotPlatform", "CreateCaseRequest"]
+
+
+class RobotPlatform(Enum):
+    """Robot platform a case runs on."""
+
+    UNIVERSAL_ROBOTS = "UniversalRobots"
+
+
+@dataclass
+class CreateCaseRequest:
+    """Payload for :meth:`sherlock_api.SherlockAPIClient.post_case`.
+
+    Args:
+        case_name: Human-readable name of the case.
+        robot_platform: Platform the case's procedure targets.
+        robot_procedure: Hash of the robot procedure to run.
+        thumbnail: Optional file hash of a thumbnail image, as returned by
+            :meth:`~sherlock_api.SherlockAPIClient.post_file`.
+    """
+
+    case_name: str
+    robot_platform: RobotPlatform
+    robot_procedure: str
+    thumbnail: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to the JSON body expected by ``POST /case``."""
+        return {
+            "case_name": self.case_name,
+            "robot_platform": self.robot_platform.value,
+            "robot_procedure": self.robot_procedure,
+            "thumbnail": self.thumbnail,
+        }