trismik 0.9.12__py3-none-any.whl → 1.0.0__py3-none-any.whl

trismik/_async/helpers.py

@@ -0,0 +1,23 @@
+"""Async helper functions for Trismik client."""
+
+import asyncio
+from typing import Any, Callable
+
+from trismik.types import TrismikItem
+
+
+async def process_item(item_processor: Callable[[TrismikItem], Any], item: TrismikItem) -> Any:
+    """
+    Process a test item with either sync or async processor.
+
+    Args:
+        item_processor: Function to process the item (can be sync or async)
+        item: The test item to process
+
+    Returns:
+        The processor's response
+    """
+    if asyncio.iscoroutinefunction(item_processor):
+        return await item_processor(item)
+    # Run sync processor in thread pool to avoid blocking
+    return await asyncio.to_thread(item_processor, item)

trismik/_mapper.py

@@ -115,9 +115,7 @@ class TrismikResponseMapper:
             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
+                TrismikResponseMapper.to_item(json["nextItem"]) if json.get("nextItem") else None
             ),
             completed=json.get("completed", False),
         )
@@ -137,13 +135,8 @@ class TrismikResponseMapper:
             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", [])
-            ),
+            dataset=[TrismikResponseMapper.to_item(item) for item in json.get("dataset", [])],
+            responses=TrismikResponseMapper.to_responses(json.get("responses", [])),
             metadata=json.get("metadata", {}),
         )
 
@@ -175,9 +168,7 @@ class TrismikResponseMapper:
             )
         else:
             item_type = json.get("type", "unknown")
-            raise TrismikApiError(
-                f"API has returned unrecognized item type: {item_type}"
-            )
+            raise TrismikApiError(f"API has returned unrecognized item type: {item_type}")
 
     @staticmethod
     def to_results(json: List[Dict[str, Any]]) -> List[TrismikResult]:
@@ -235,15 +226,11 @@ class TrismikResponseMapper:
         # 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")
-            )
+            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")
-            )
+            created_at = datetime.fromisoformat(json["createdAt"].replace("Z", "+00:00"))
 
         return TrismikReplayResponse(
             id=json["id"],
@@ -253,13 +240,8 @@ class TrismikResponseMapper:
             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", [])
-            ),
+            dataset=[TrismikResponseMapper.to_item(item) for item in json.get("dataset", [])],
+            responses=TrismikResponseMapper.to_responses(json.get("responses", [])),
         )
 
     @staticmethod
@@ -299,9 +281,7 @@ class TrismikResponseMapper:
         return TrismikMeResponse(user=user_info, teams=teams)
 
     @staticmethod
-    def to_classic_eval_response(
-        json: Dict[str, Any]
-    ) -> TrismikClassicEvalResponse:
+    def to_classic_eval_response(json: Dict[str, Any]) -> TrismikClassicEvalResponse:
         """
         Convert JSON response to a TrismikClassicEvalResponse object.
 

trismik/_sync/__init__.py

@@ -0,0 +1 @@
+"""Async implementation of Trismik client (source of truth)."""

trismik/_sync/_test_transform.py

@@ -0,0 +1,58 @@
+"""
+Minimal test file to validate unasync transformation pipeline.
+
+This file tests that unasync correctly transforms:
+- async def -> def
+- await -> (removed)
+- httpx.AsyncClient -> httpx.Client
+- TrismikAsyncClient -> TrismikClient
+- __aenter__/__aexit__ -> __enter__/__exit__
+- _async -> _sync in imports
+"""
+
+from typing import Optional
+
+import httpx
+
+
+class TrismikClient:
+    """Test async client to validate transformation."""
+
+    def __init__(
+        self,
+        api_key: str,
+        http_client: Optional[httpx.Client] = None,
+    ) -> None:
+        """Initialize test client."""
+        self._api_key = api_key
+        self._owns_client = http_client is None
+        self._http_client = http_client or httpx.Client(headers={"x-api-key": api_key})
+
+    def __enter__(self) -> "TrismikClient":
+        """Enter async context manager."""
+        return self
+
+    def __exit__(self, exc_type: object, exc_val: object, exc_tb: object) -> None:
+        """Exit async context manager."""
+        if self._owns_client:
+            self._http_client.close()
+
+    def close(self) -> None:
+        """Close the HTTP client."""
+        if self._owns_client:
+            self._http_client.close()
+
+    def get_data(self) -> str:
+        """Test async method with await."""
+        response = self._http_client.get("/test")
+        response.raise_for_status()
+        return str(response.text)
+
+    def process_items(self) -> int:
+        """Test async method with multiple awaits."""
+        count = 0
+        with self._http_client as client:
+            response = client.get("/items")
+            data = response.json()
+            count = len(data)
+        return count