trismik 0.9.1__py3-none-any.whl → 0.9.4__py3-none-any.whl

trismik/__init__.py

@@ -1,21 +1,10 @@
-from .client import TrismikClient
-from .client_async import TrismikAsyncClient
-from .exceptions import (
-    TrismikError,
-    TrismikApiError
-)
-from .runner import TrismikRunner
-from .runner_async import TrismikAsyncRunner
-from .types import (
-    TrismikTest,
-    TrismikAuth,
-    TrismikSession,
-    TrismikItem,
-    TrismikMultipleChoiceTextItem,
-    TrismikChoice,
-    TrismikTextChoice,
-    TrismikResult,
-    TrismikResponse,
-    TrismikRunResults,
-    TrismikSessionMetadata,
-)
+"""
+Trismik Python Client.
+
+A Python client for the Trismik API.
+"""
+
+import importlib.metadata
+
+# get version from pyproject.toml
+__version__ = importlib.metadata.version(__package__ or __name__)

trismik/_mapper.py

@@ -1,79 +1,335 @@
-from typing import List, Any
+from datetime import datetime
+from typing import Any, Dict, List
 
-from dateutil.parser import parse as parse_date
-
-from .exceptions import TrismikApiError
-from .types import (
+from trismik.exceptions import TrismikApiError
+from trismik.types import (
+    TrismikClassicEvalResponse,
+    TrismikDataset,
     TrismikItem,
-    TrismikResult,
+    TrismikMeResponse,
     TrismikMultipleChoiceTextItem,
-    TrismikTextChoice,
-    TrismikAuth,
-    TrismikTest,
-    TrismikSession,
+    TrismikOrganization,
+    TrismikReplayResponse,
     TrismikResponse,
+    TrismikResult,
+    TrismikRun,
+    TrismikRunInfo,
+    TrismikRunResponse,
+    TrismikRunState,
+    TrismikRunSummary,
+    TrismikTextChoice,
+    TrismikUserInfo,
 )
 
 
 class TrismikResponseMapper:
+    """
+    Maps JSON responses from the Trismik API to Python objects.
 
-    @staticmethod
-    def to_auth(json: dict[str, Any]) -> TrismikAuth:
-        return TrismikAuth(
-                token=json["token"],
-                expires=parse_date(json["expires"]),
-        )
+    This class provides static methods to convert JSON responses from various
+    API endpoints into their corresponding Python object representations.
+    """
 
     @staticmethod
-    def to_tests(json: List[dict[str, Any]]) -> List[TrismikTest]:
+    def to_datasets(json: Dict[str, Any]) -> List[TrismikDataset]:
+        """
+        Convert JSON response to a list of TrismikDataset objects.
+
+        Args:
+            json (Dict[str, Any]): JSON response containing dataset data.
+
+        Returns:
+            List[TrismikDataset]: List of
+            dataset objects with IDs and names.
+        """
         return [
-            TrismikTest(
-                    id=item["id"],
-                    name=item["name"],
-            ) for item in json
+            TrismikDataset(
+                id=item["id"],
+                name=item["name"],
+            )
+            for item in json["data"]
         ]
 
     @staticmethod
-    def to_session(json: dict[str, Any]) -> TrismikSession:
-        return TrismikSession(
-                id=json["id"],
-                url=json["url"],
-                status=json["status"],
+    def to_run(json: Dict[str, Any]) -> TrismikRun:
+        """
+        Convert JSON response to a TrismikRun object.
+
+        Args:
+            json (Dict[str, Any]): JSON response containing run data.
+
+        Returns:
+            TrismikRun: Run object with ID, URL, and status.
+        """
+        return TrismikRun(
+            id=json["id"],
+            url=json["url"],
+            status=json["status"],
         )
 
     @staticmethod
-    def to_item(json: dict[str, Any]) -> TrismikItem:
-        if json["type"] == "multiple_choice_text":
+    def to_run_info(json: Dict[str, Any]) -> TrismikRunInfo:
+        """
+        Convert JSON response to a TrismikRunInfo object.
+
+        Args:
+            json (Dict[str, Any]): JSON response containing run info.
+
+        Returns:
+            TrismikRunInfo: Run info object with ID.
+        """
+        return TrismikRunInfo(id=json["id"])
+
+    @staticmethod
+    def to_run_state(json: Dict[str, Any]) -> TrismikRunState:
+        """
+        Convert JSON response to a TrismikRunState object.
+
+        Args:
+            json (Dict[str, Any]): JSON response containing run state.
+
+        Returns:
+            TrismikRunState: Run state object.
+        """
+        return TrismikRunState(
+            responses=json.get("responses", []),
+            thetas=json.get("thetas", []),
+            std_error_history=json.get("std_error_history", []),
+            kl_info_history=json.get("kl_info_history", []),
+            effective_difficulties=json.get("effective_difficulties", []),
+        )
+
+    @staticmethod
+    def to_run_response(json: Dict[str, Any]) -> TrismikRunResponse:
+        """
+        Convert JSON response to a TrismikRunResponse object.
+
+        Args:
+            json (Dict[str, Any]): JSON response from run endpoints.
+
+        Returns:
+            TrismikRunResponse: Run response.
+        """
+        return TrismikRunResponse(
+            run_info=TrismikResponseMapper.to_run_info(json["runInfo"]),
+            state=TrismikResponseMapper.to_run_state(json["state"]),
+            next_item=(
+                TrismikResponseMapper.to_item(json["nextItem"])
+                if json.get("nextItem")
+                else None
+            ),
+            completed=json.get("completed", False),
+        )
+
+    @staticmethod
+    def to_run_summary(json: Dict[str, Any]) -> TrismikRunSummary:
+        """
+        Convert JSON response to a TrismikRunSummary object.
+
+        Args:
+            json (Dict[str, Any]): JSON response from run summary endpoint.
+
+        Returns:
+            TrismikRunSummary: Complete run summary.
+        """
+        return TrismikRunSummary(
+            id=json["id"],
+            dataset_id=json["datasetId"],
+            state=TrismikResponseMapper.to_run_state(json["state"]),
+            dataset=[
+                TrismikResponseMapper.to_item(item)
+                for item in json.get("dataset", [])
+            ],
+            responses=TrismikResponseMapper.to_responses(
+                json.get("responses", [])
+            ),
+            metadata=json.get("metadata", {}),
+        )
+
+    @staticmethod
+    def to_item(json: Dict[str, Any]) -> TrismikItem:
+        """
+        Convert JSON response to a TrismikItem object.
+
+        Args:
+            json (Dict[str, Any]): JSON response containing item data.
+
+        Returns:
+            TrismikItem: Item object with question and choices.
+
+        Raises:
+            TrismikApiError: If the item type is not recognized.
+        """
+        if "question" in json and "choices" in json:
             return TrismikMultipleChoiceTextItem(
-                    id=json["id"],
-                    question=json["question"],
-                    choices=[
-                        TrismikTextChoice(
-                                id=choice["id"],
-                                text=choice["text"],
-                        ) for choice in json["choices"]
-                    ]
+                id=json["id"],
+                question=json["question"],
+                choices=[
+                    TrismikTextChoice(
+                        id=choice["id"],
+                        text=choice["value"],
+                    )
+                    for choice in json["choices"]
+                ],
             )
         else:
+            item_type = json.get("type", "unknown")
             raise TrismikApiError(
-                    f"API has returned unrecognized item type: {json['type']}")
+                f"API has returned unrecognized item type: {item_type}"
+            )
 
     @staticmethod
-    def to_results(json: List[dict[str, Any]]) -> List[TrismikResult]:
+    def to_results(json: List[Dict[str, Any]]) -> List[TrismikResult]:
+        """
+        Convert JSON response to a list of TrismikResult objects.
+
+        Args:
+            json (List[Dict[str, Any]]): JSON response containing result data.
+
+        Returns:
+            List[TrismikResult]: List of result objects with trait, name, and
+            value.
+        """
         return [
             TrismikResult(
-                    trait=item["trait"],
-                    name=item["name"],
-                    value=item["value"],
-            ) for item in json
+                trait=item["trait"],
+                name=item["name"],
+                value=item["value"],
+            )
+            for item in json
         ]
 
     @staticmethod
-    def to_responses(json: List[dict[str, Any]]) -> List[TrismikResponse]:
+    def to_responses(json: List[Dict[str, Any]]) -> List[TrismikResponse]:
+        """
+        Convert JSON response to a list of TrismikResponse objects.
+
+        Args:
+            json (List[Dict[str, Any]]): JSON response containing response data.
+
+        Returns:
+            List[TrismikResponse]: List of response objects with dataset item
+                ID, value, and correctness.
+        """
         return [
             TrismikResponse(
-                    item_id=response["itemId"],
-                    value=response["value"],
-                    score=response["score"],
-            ) for response in json
+                dataset_item_id=response["datasetItemId"],
+                value=response["value"],
+                correct=response["correct"],
+            )
+            for response in json
         ]
+
+    @staticmethod
+    def to_replay_response(json: Dict[str, Any]) -> TrismikReplayResponse:
+        """
+        Convert JSON response to a TrismikReplayResponse object.
+
+        Args:
+            json (Dict[str, Any]): JSON response from replay endpoint.
+
+        Returns:
+            TrismikReplayResponse: Replay response object.
+        """
+        # Parse datetime strings if they exist
+        completed_at = None
+        if "completedAt" in json and json["completedAt"]:
+            completed_at = datetime.fromisoformat(
+                json["completedAt"].replace("Z", "+00:00")
+            )
+
+        created_at = None
+        if "createdAt" in json and json["createdAt"]:
+            created_at = datetime.fromisoformat(
+                json["createdAt"].replace("Z", "+00:00")
+            )
+
+        return TrismikReplayResponse(
+            id=json["id"],
+            datasetId=json["datasetId"],
+            state=TrismikResponseMapper.to_run_state(json["state"]),
+            replay_of_run=json["replayOfRun"],
+            completedAt=completed_at,
+            createdAt=created_at,
+            metadata=json.get("metadata", {}),
+            dataset=[
+                TrismikResponseMapper.to_item(item)
+                for item in json.get("dataset", [])
+            ],
+            responses=TrismikResponseMapper.to_responses(
+                json.get("responses", [])
+            ),
+        )
+
+    @staticmethod
+    def to_me_response(json: Dict[str, Any]) -> TrismikMeResponse:
+        """
+        Convert JSON response to a TrismikMeResponse object.
+
+        Args:
+            json (Dict[str, Any]): JSON response from /admin/api-keys/me
+                endpoint.
+
+        Returns:
+            TrismikMeResponse: Me response object.
+        """
+        user_data = json["user"]
+        organization_data = json["organization"]
+
+        user_info = TrismikUserInfo(
+            id=user_data["id"],
+            email=user_data["email"],
+            firstname=user_data["firstname"],
+            lastname=user_data["lastname"],
+            createdAt=user_data.get("createdAt"),
+        )
+
+        organization = TrismikOrganization(
+            id=organization_data["id"],
+            name=organization_data["name"],
+            type=organization_data["type"],
+            role=organization_data["role"],
+        )
+
+        return TrismikMeResponse(
+            user=user_info,
+            organization=organization,
+        )
+
+    @staticmethod
+    def to_classic_eval_response(
+        json: Dict[str, Any]
+    ) -> TrismikClassicEvalResponse:
+        """
+        Convert JSON response to a TrismikClassicEvalResponse object.
+
+        Args:
+            json (Dict[str, Any]): JSON response from classic evaluation
+                endpoint.
+
+        Returns:
+            TrismikClassicEvalResponse: Classic evaluation response object.
+        """
+        user_data = json["user"]
+        user_info = TrismikUserInfo(
+            id=user_data["id"],
+            email=user_data["email"],
+            firstname=user_data["firstname"],
+            lastname=user_data["lastname"],
+        )
+
+        return TrismikClassicEvalResponse(
+            id=json["id"],
+            organizationId=json["organizationId"],
+            projectId=json["projectId"],
+            experimentId=json["experimentId"],
+            experimentName=json["experimentName"],
+            datasetId=json["datasetId"],
+            userId=json["userId"],
+            type=json["type"],
+            modelName=json["modelName"],
+            hyperparameters=json.get("hyperparameters", {}),
+            createdAt=json["createdAt"],
+            user=user_info,
+            responseCount=json["responseCount"],
+        )

trismik/_utils.py

@@ -1,44 +1,121 @@
 import os
+from typing import Optional, Union
 
 import httpx
 
-from .exceptions import TrismikError
+from trismik.exceptions import TrismikError
 
 
 class TrismikUtils:
+    """
+    Utility functions for the Trismik client.
+
+    This class provides helper methods for error handling and configuration
+    management.
+    """
 
     @staticmethod
     def get_error_message(response: httpx.Response) -> str:
+        """
+        Extract error message from an HTTP response.
+
+        Args:
+            response (httpx.Response): The HTTP response containing the error.
+
+        Returns:
+            str: The error message from the response JSON or content.
+        """
         try:
-            return (response.json()).get("message", "Unknown error")
+            json_data = response.json()
+            message = json_data.get("message", "Unknown error")
+            return str(message)  # Ensure we return a string
         except (httpx.RequestError, ValueError):
-            error_message = response.content.decode("utf-8", errors="ignore")
-        return error_message
+            error_message: str = response.content.decode(
+                "utf-8", errors="ignore"
+            )
+            return error_message
 
     @staticmethod
-    def required_option(
-            value: str | None,
-            name: str,
-            env: str
-    ) -> str:
+    def required_option(value: Optional[str], name: str, env: str) -> str:
+        """
+        Get a required configuration option.
+
+        Get a required configuration option from either the provided value or
+        environment variable.
+
+        Args:
+            value (Optional[str]): The provided value for the option.
+            name (str): The name of the option for error messages.
+            env (str): The environment variable name to check if value is None.
+
+        Returns:
+            str: The option value.
+
+        Raises:
+            TrismikError: If neither value nor environment variable is set.
+        """
         if value is None:
             value = os.environ.get(env)
         if value is None:
             raise TrismikError(
-                    f"The {name} client option must be set either by passing "
-                    f"{env} to the client or by setting the {env} "
-                    "environment variable"
+                f"The {name} client option must be set either by passing "
+                f"{env} to the client or by setting the {env} "
+                "environment variable"
             )
         return value
 
     @staticmethod
     def option(
-            value: str | None,
-            default: str,
-            env: str,
+        value: Optional[str],
+        default: str,
+        env: str,
     ) -> str:
+        """
+        Get an optional configuration value.
+
+        Get an optional configuration value from either the provided value,
+        environment variable, or default value.
+
+        Args:
+            value (Optional[str]): The provided value for the option.
+            default (str): The default value to use if neither value nor env var
+                is set.
+            env (str): The environment variable name to check if value is None.
+
+        Returns:
+            str: The option value, falling back to default if not set.
+        """
         if value is None:
             value = os.environ.get(env)
         if value is None:
             return default
         return value
+
+    @staticmethod
+    def metric_value_to_type(value: Union[str, float, int, bool]) -> str:
+        """
+        Automatically determine valueType from Python value type.
+
+        Args:
+            value (Union[str, float, int, bool]): The metric value to analyze.
+
+        Returns:
+            str: The corresponding valueType string for the API.
+
+        Raises:
+            TypeError: If the value type is not supported.
+        """
+        if isinstance(value, bool):
+            # Handle bool first since bool is a subclass of int in Python
+            return "Boolean"
+        elif isinstance(value, str):
+            return "String"
+        elif isinstance(value, float):
+            return "Float"
+        elif isinstance(value, int):
+            return "Integer"
+        else:
+            raise TypeError(
+                f"Unsupported metric value type: {type(value).__name__}. "
+                f"Supported types: str, float, int, bool"
+            )