witrium 0.1.0__py3-none-any.whl

witrium/__init__.py

@@ -0,0 +1,20 @@
+from witrium.client import (
+    WitriumClient,
+    SyncWitriumClient,
+    AsyncWitriumClient,
+    WorkflowRunStatus,
+    WitriumClientException,
+    AgentExecutionStatus,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "WitriumClient",
+    "SyncWitriumClient",
+    "AsyncWitriumClient",
+    "WorkflowRunStatus",
+    "WitriumClientException",
+    "AgentExecutionStatus",
+    "__version__",
+]

witrium/client.py

@@ -0,0 +1,765 @@
+import time
+import asyncio
+import logging
+import httpx
+from typing import Dict, List, Optional, Any, Union, Callable
+from pydantic import BaseModel
+from tenacity import retry, stop_after_delay, wait_fixed, retry_if_result
+
+# Setup logger
+logger = logging.getLogger("witrium_client")
+
+
+class WitriumClientException(Exception):
+    """Base exception for Witrium Client errors."""
+
+    pass
+
+
+class WorkflowRunExecuteSchema(BaseModel):
+    args: Optional[dict[str, str | int | float]] = None
+    use_states: Optional[List[str]] = None
+    preserve_state: Optional[str] = None
+    no_intelligence: bool = False
+    record_session: bool = False
+    keep_session_alive: bool = False
+    use_existing_session: Optional[str] = None
+
+
+class WorkflowRunSubmittedSchema(BaseModel):
+    workflow_id: str
+    run_id: str
+    status: str
+
+
+class AgentExecutionSchema(BaseModel):
+    status: str
+    instruction_order: int
+    instruction: str
+    result: Optional[dict | list] = None
+    result_format: Optional[str] = None
+    error_message: Optional[str] = None
+
+
+class WorkflowRunExecutionSchema(BaseModel):
+    instruction_id: str
+    instruction: str
+    result: Optional[dict | list] = None
+    status: str
+    error_message: Optional[str] = None
+
+
+class WorkflowRunResultsSchema(BaseModel):
+    workflow_id: str
+    run_id: str
+    status: str
+    started_at: Optional[str] = None
+    completed_at: Optional[str] = None
+    message: Optional[str] = None
+    executions: List[AgentExecutionSchema] = None
+    result: Optional[dict | list] = None
+    result_format: Optional[str] = None
+    error_message: Optional[str] = None
+
+
+class WorkflowSchema(BaseModel):
+    uuid: str
+    name: str
+    description: Optional[str] = None
+
+
+class WorkflowRunSchema(BaseModel):
+    uuid: str
+    session_id: str
+    workflow: WorkflowSchema
+    run_type: str
+    triggered_by: str
+    status: str
+    session_active: bool
+    started_at: Optional[str] = None
+    completed_at: Optional[str] = None
+    error_message: Optional[str] = None
+    executions: List[WorkflowRunExecutionSchema] = None
+
+
+class WorkflowRunStatus:
+    """Constants for workflow run statuses."""
+
+    PENDING = "P"
+    RUNNING = "R"
+    COMPLETED = "C"
+    FAILED = "F"
+    CANCELLED = "X"
+
+    # Terminal statuses that should stop polling
+    TERMINAL_STATUSES = [COMPLETED, FAILED, CANCELLED]
+
+    # Reverse mapping for human-readable status names
+    STATUS_NAMES = {
+        PENDING: "pending",
+        RUNNING: "running",
+        COMPLETED: "completed",
+        FAILED: "failed",
+        CANCELLED: "cancelled",
+    }
+
+    @classmethod
+    def get_status_name(cls, status_code: str) -> str:
+        """Get human-readable status name from status code."""
+        return cls.STATUS_NAMES.get(status_code, status_code)
+
+
+class AgentExecutionStatus:
+    """Constants for agent execution statuses."""
+
+    PENDING = "P"
+    RUNNING = "R"
+    COMPLETED = "C"
+    FAILED = "F"
+    CANCELLED = "X"
+
+    STATUS_NAMES = {
+        PENDING: "pending",
+        RUNNING: "running",
+        COMPLETED: "completed",
+        FAILED: "failed",
+        CANCELLED: "cancelled",
+    }
+
+    @classmethod
+    def get_status_name(cls, status_code: str) -> str:
+        """Get human-readable status name from status code."""
+        return cls.STATUS_NAMES.get(status_code, status_code)
+
+
+class WitriumClient:
+    """
+    Base class for Witrium API Client.
+    Not meant to be used directly - use SyncWitriumClient or AsyncWitriumClient.
+    """
+
+    def __init__(
+        self, base_url: str, api_token: str, timeout: int = 60, verify_ssl: bool = True
+    ):
+        """
+        Initialize the Witrium client.
+        Args:
+            api_token: The API token for authentication.
+        """
+        self.base_url = base_url.rstrip("/")
+        self.api_token = api_token
+        self.timeout = timeout
+        self.verify_ssl = verify_ssl
+        self._headers = {"X-Witrium-Key": api_token, "Content-Type": "application/json"}
+
+
+class SyncWitriumClient(WitriumClient):
+    """Synchronous Witrium API client."""
+
+    def __init__(self, api_token: str, timeout: int = 60, verify_ssl: bool = True):
+        """Initialize the synchronous client."""
+        super().__init__(
+            "https://api.witrium.com", api_token, timeout, verify_ssl
+        )
+        self._client = httpx.Client(
+            timeout=self.timeout, verify=self.verify_ssl, headers=self._headers
+        )
+
+    def close(self):
+        """Close the underlying HTTP client."""
+        if self._client:
+            self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+    def run_workflow(
+        self,
+        workflow_id: str,
+        args: Optional[Dict[str, Union[str, int, float]]] = None,
+        use_states: Optional[List[str]] = None,
+        preserve_state: Optional[str] = None,
+        no_intelligence: bool = False,
+        record_session: Optional[bool] = False,
+        keep_session_alive: bool = False,
+        use_existing_session: Optional[str] = None,
+    ) -> WorkflowRunSubmittedSchema:
+        """
+        Run a workflow by ID.
+
+        Args:
+            workflow_id: The ID of the workflow to run.
+            args: Optional arguments to pass to the workflow.
+            use_states: Optional list of state names to use.
+            preserve_state: Optional state name to preserve.
+            no_intelligence: Whether to run without AI intelligence.
+            record_session: Whether to record the session.
+            keep_session_alive: Whether to keep the session alive.
+            use_existing_session: The ID of the existing session to use.
+
+        Returns:
+            Dict containing workflow_id, run_id and status.
+        """
+        url = f"{self.base_url}/v1/workflows/{workflow_id}/run"
+        payload = {
+            "args": args,
+            "use_states": use_states,
+            "preserve_state": preserve_state,
+            "no_intelligence": no_intelligence,
+            "record_session": record_session,
+            "keep_session_alive": keep_session_alive,
+            "use_existing_session": use_existing_session,
+        }
+
+        try:
+            response = self._client.post(url, json=payload)
+            response.raise_for_status()
+            return WorkflowRunSubmittedSchema.model_validate(response.json())
+        except httpx.HTTPStatusError as e:
+            error_detail = self._extract_error_detail(e.response)
+            raise WitriumClientException(
+                f"Error running workflow: {error_detail} (Status code: {e.response.status_code})"
+            )
+        except Exception as e:
+            raise WitriumClientException(f"Error running workflow: {str(e)}")
+
+    def get_workflow_results(self, run_id: str) -> WorkflowRunResultsSchema:
+        """
+        Get workflow run results.
+
+        Args:
+            run_id: The ID of the workflow run.
+
+        Returns:
+            Dict containing the workflow run results.
+        """
+        url = f"{self.base_url}/v1/runs/{run_id}/results"
+
+        try:
+            response = self._client.get(url)
+            response.raise_for_status()
+            return WorkflowRunResultsSchema.model_validate(response.json())
+        except httpx.HTTPStatusError as e:
+            error_detail = self._extract_error_detail(e.response)
+            raise WitriumClientException(
+                f"Error getting workflow results: {error_detail} (Status code: {e.response.status_code})"
+            )
+        except Exception as e:
+            raise WitriumClientException(f"Error getting workflow results: {str(e)}")
+
+    def run_workflow_and_wait(
+        self,
+        workflow_id: str,
+        args: Optional[Dict[str, Union[str, int, float]]] = None,
+        use_states: Optional[List[str]] = None,
+        preserve_state: Optional[str] = None,
+        no_intelligence: bool = False,
+        polling_interval: int = 5,
+        timeout: int = 300,
+        return_intermediate_results: bool = False,
+        on_progress: Optional[Callable[[WorkflowRunResultsSchema], Any]] = None,
+    ) -> Union[WorkflowRunResultsSchema, List[WorkflowRunResultsSchema]]:
+        """
+        Run a workflow and wait for results by polling until completion.
+
+        Args:
+            workflow_id: The ID of the workflow to run.
+            args: Optional arguments to pass to the workflow.
+            use_states: Optional list of session IDs to use.
+            preserve_state: Optional session ID to preserve.
+            no_intelligence: Whether to run without AI intelligence.
+            polling_interval: Seconds to wait between polling attempts.
+            timeout: Maximum seconds to poll before timing out.
+            return_intermediate_results: If True, returns a list of all polled results.
+            on_progress: Optional callback function that receives each intermediate result.
+                         This is called on each polling iteration with the current results.
+
+        Returns:
+            Dict containing the final workflow run results, or if return_intermediate_results=True,
+            a list of all polled result dictionaries.
+        """
+        # Run the workflow
+        run_response = self.run_workflow(
+            workflow_id=workflow_id,
+            args=args,
+            use_states=use_states,
+            preserve_state=preserve_state,
+            no_intelligence=no_intelligence,
+        )
+
+        run_id = run_response.run_id
+        start_time = time.time()
+        intermediate_results = []
+
+        # Poll for results
+        while time.time() - start_time < timeout:
+            results = self.get_workflow_results(run_id)
+
+            # Store intermediate results if requested
+            if return_intermediate_results:
+                intermediate_results.append(results)
+
+            # Call progress callback if provided
+            if on_progress:
+                on_progress(results)
+
+            # Check if workflow has completed
+            if results.status in WorkflowRunStatus.TERMINAL_STATUSES:
+                return intermediate_results if return_intermediate_results else results
+
+            # Wait before polling again
+            time.sleep(polling_interval)
+
+        raise WitriumClientException(
+            f"Workflow execution timed out after {timeout} seconds"
+        )
+
+    def wait_until_state(
+        self,
+        run_id: str,
+        target_status: str,
+        all_instructions_executed: bool = False,
+        min_wait_time: int = 0,
+        polling_interval: int = 2,
+        timeout: int = 60,
+    ) -> WorkflowRunResultsSchema:
+        """
+        Wait for a workflow run to reach a specific status by polling.
+
+        Args:
+            run_id: The ID of the workflow run to wait for.
+            target_status: The status to wait for (e.g., WorkflowRunStatus.RUNNING).
+            all_instructions_executed: If True, also wait for all executions to be completed.
+            min_wait_time: Minimum time in seconds to wait before starting polling. Useful when you know approximately how long the workflow will take.
+            polling_interval: Seconds to wait between polling attempts.
+            timeout: Maximum seconds to poll before timing out.
+
+        Returns:
+            WorkflowRunResultsSchema when the target status is reached.
+
+        Raises:
+            WitriumClientException: If timeout is reached or workflow reaches an unexpected terminal status.
+        """
+
+        # Wait for minimum time before starting to poll
+        if min_wait_time > 0:
+            time.sleep(min_wait_time)
+
+        def _check_all_executions_completed(results: WorkflowRunResultsSchema) -> bool:
+            """Check if all executions have completed status."""
+            if not results.executions:
+                return False
+            return results.executions[-1].status == AgentExecutionStatus.COMPLETED
+
+        def _should_continue_polling(results: WorkflowRunResultsSchema) -> bool:
+            """Determine if we should continue polling based on target status and execution completion."""
+            status_not_reached = results.status != target_status
+            terminal_status_reached = (
+                results.status in WorkflowRunStatus.TERMINAL_STATUSES
+            )
+
+            # If we've reached a terminal status but it's not our target, stop retrying
+            if terminal_status_reached and status_not_reached:
+                return False
+
+            # If target status is not reached, continue polling
+            if status_not_reached:
+                return True
+
+            # If target status is reached but we also need all instructions executed
+            if all_instructions_executed and not _check_all_executions_completed(
+                results
+            ):
+                return True
+
+            # All conditions met, stop polling
+            return False
+
+        @retry(
+            stop=stop_after_delay(timeout),
+            wait=wait_fixed(polling_interval),
+            retry=retry_if_result(_should_continue_polling),
+        )
+        def _poll_for_status():
+            results = self.get_workflow_results(run_id)
+
+            # Check if workflow has reached the target status
+            status_reached = results.status == target_status
+            all_executions_completed = (
+                _check_all_executions_completed(results)
+                if all_instructions_executed
+                else True
+            )
+
+            if status_reached and all_executions_completed:
+                return results
+
+            # Check if workflow has reached a terminal status that's not our target
+            if (
+                results.status in WorkflowRunStatus.TERMINAL_STATUSES
+                and results.status != target_status
+            ):
+                current_status_name = WorkflowRunStatus.get_status_name(results.status)
+                target_status_name = WorkflowRunStatus.get_status_name(target_status)
+                raise WitriumClientException(
+                    f"Workflow run reached terminal status '{current_status_name}' before reaching target status '{target_status_name}'"
+                )
+
+            # Return results for retry evaluation
+            return results
+
+        try:
+            return _poll_for_status()
+        except Exception as e:
+            if "retry" in str(e).lower():
+                target_status_name = WorkflowRunStatus.get_status_name(target_status)
+                condition_msg = f"status '{target_status_name}'"
+                if all_instructions_executed:
+                    condition_msg += " and all instructions executed"
+                raise WitriumClientException(
+                    f"Workflow run did not reach {condition_msg} within {timeout} seconds"
+                )
+            raise
+
+    def cancel_run(self, run_id: str) -> WorkflowRunSchema:
+        """
+        Cancel a workflow run and clean up associated resources.
+
+        Args:
+            run_id: The ID of the workflow run to cancel.
+
+        Returns:
+            Dict containing the workflow run results.
+        """
+        url = f"{self.base_url}/v1/runs/{run_id}/cancel"
+
+        try:
+            response = self._client.post(url)
+            response.raise_for_status()
+            return WorkflowRunSchema.model_validate(response.json())
+        except httpx.HTTPStatusError as e:
+            error_detail = self._extract_error_detail(e.response)
+            raise WitriumClientException(
+                f"Error cancelling workflow run: {error_detail} (Status code: {e.response.status_code})"
+            )
+        except Exception as e:
+            raise WitriumClientException(f"Error cancelling workflow run: {str(e)}")
+
+    def _extract_error_detail(self, response: httpx.Response) -> str:
+        """Extract error detail from response."""
+        try:
+            error_json = response.json()
+            if "detail" in error_json:
+                return error_json["detail"]
+            return str(error_json)
+        except Exception:
+            return response.text or "Unknown error"
+
+
+class AsyncWitriumClient(WitriumClient):
+    """Asynchronous Witrium API client."""
+
+    def __init__(self, api_token: str, timeout: int = 60, verify_ssl: bool = True):
+        """Initialize the asynchronous client."""
+        super().__init__(
+            "https://api.witrium.com", api_token, timeout, verify_ssl
+        )
+        self._client = httpx.AsyncClient(
+            timeout=self.timeout, verify=self.verify_ssl, headers=self._headers
+        )
+
+    async def close(self):
+        """Close the underlying HTTP client."""
+        if self._client:
+            await self._client.aclose()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        await self.close()
+
+    async def run_workflow(
+        self,
+        workflow_id: str,
+        args: Optional[Dict[str, Union[str, int, float]]] = None,
+        use_states: Optional[List[str]] = None,
+        preserve_state: Optional[str] = None,
+        no_intelligence: bool = False,
+        record_session: Optional[bool] = False,
+        keep_session_alive: bool = False,
+        use_existing_session: Optional[str] = None,
+    ) -> WorkflowRunSubmittedSchema:
+        """
+        Run a workflow by ID.
+
+        Args:
+            workflow_id: The ID of the workflow to run.
+            args: Optional arguments to pass to the workflow.
+            use_states: Optional list of state names to use.
+            preserve_state: Optional state name to preserve.
+            no_intelligence: Whether to run without AI intelligence.
+            record_session: Whether to record the session.
+            keep_session_alive: Whether to keep the session alive.
+            use_existing_session: The ID of the existing session to use.
+
+        Returns:
+            Dict containing workflow_id, run_id and status.
+        """
+        url = f"{self.base_url}/v1/workflows/{workflow_id}/run"
+        payload = {
+            "args": args,
+            "use_states": use_states,
+            "preserve_state": preserve_state,
+            "no_intelligence": no_intelligence,
+            "record_session": record_session,
+            "keep_session_alive": keep_session_alive,
+            "use_existing_session": use_existing_session,
+        }
+
+        try:
+            response = await self._client.post(url, json=payload)
+            response.raise_for_status()
+            return WorkflowRunSubmittedSchema.model_validate(response.json())
+        except httpx.HTTPStatusError as e:
+            error_detail = await self._extract_error_detail(e.response)
+            raise WitriumClientException(
+                f"Error running workflow: {error_detail} (Status code: {e.response.status_code})"
+            )
+        except Exception as e:
+            raise WitriumClientException(f"Error running workflow: {str(e)}")
+
+    async def get_workflow_results(self, run_id: str) -> WorkflowRunResultsSchema:
+        """
+        Get workflow run results.
+
+        Args:
+            run_id: The ID of the workflow run.
+
+        Returns:
+            Dict containing the workflow run results.
+        """
+        url = f"{self.base_url}/v1/runs/{run_id}/results"
+
+        try:
+            response = await self._client.get(url)
+            response.raise_for_status()
+            return WorkflowRunResultsSchema.model_validate(response.json())
+        except httpx.HTTPStatusError as e:
+            error_detail = await self._extract_error_detail(e.response)
+            raise WitriumClientException(
+                f"Error getting workflow results: {error_detail} (Status code: {e.response.status_code})"
+            )
+        except Exception as e:
+            raise WitriumClientException(f"Error getting workflow results: {str(e)}")
+
+    async def run_workflow_and_wait(
+        self,
+        workflow_id: str,
+        args: Optional[Dict[str, Union[str, int, float]]] = None,
+        use_states: Optional[List[str]] = None,
+        preserve_state: Optional[str] = None,
+        no_intelligence: bool = False,
+        polling_interval: int = 5,
+        timeout: int = 300,
+        return_intermediate_results: bool = False,
+        on_progress: Optional[Callable[[WorkflowRunResultsSchema], Any]] = None,
+    ) -> Union[WorkflowRunResultsSchema, List[WorkflowRunResultsSchema]]:
+        """
+        Run a workflow and wait for results by polling until completion.
+
+        Args:
+            workflow_id: The ID of the workflow to run.
+            args: Optional arguments to pass to the workflow.
+            use_states: Optional list of session IDs to use.
+            preserve_state: Optional session ID to preserve.
+            no_intelligence: Whether to run without AI intelligence.
+            polling_interval: Seconds to wait between polling attempts.
+            timeout: Maximum seconds to poll before timing out.
+            return_intermediate_results: If True, returns a list of all polled results.
+            on_progress: Optional callback function that receives each intermediate result.
+                         This is called on each polling iteration with the current results.
+
+        Returns:
+            Dict containing the final workflow run results, or if return_intermediate_results=True,
+            a list of all polled result dictionaries.
+        """
+        # Run the workflow
+        run_response = await self.run_workflow(
+            workflow_id=workflow_id,
+            args=args,
+            use_states=use_states,
+            preserve_state=preserve_state,
+            no_intelligence=no_intelligence,
+        )
+
+        run_id = run_response.run_id
+        start_time = time.time()
+        intermediate_results = []
+
+        # Poll for results
+        while time.time() - start_time < timeout:
+            results = await self.get_workflow_results(run_id)
+
+            # Store intermediate results if requested
+            if return_intermediate_results:
+                intermediate_results.append(results)
+
+            # Call progress callback if provided
+            if on_progress:
+                on_progress(results)
+
+            # Check if workflow run has completed
+            if results.status in WorkflowRunStatus.TERMINAL_STATUSES:
+                return intermediate_results if return_intermediate_results else results
+
+            # Wait before polling again
+            await asyncio.sleep(polling_interval)
+
+        raise WitriumClientException(
+            f"Workflow execution timed out after {timeout} seconds"
+        )
+
+    async def wait_until_state(
+        self,
+        run_id: str,
+        target_status: str,
+        all_instructions_executed: bool = False,
+        min_wait_time: int = 0,
+        polling_interval: int = 2,
+        timeout: int = 60,
+    ) -> WorkflowRunResultsSchema:
+        """
+        Wait for a workflow run to reach a specific status by polling.
+
+        Args:
+            run_id: The ID of the workflow run to wait for.
+            target_status: The status to wait for (e.g., WorkflowRunStatus.RUNNING).
+            all_instructions_executed: If True, also wait for all executions to be completed.
+            min_wait_time: Minimum time in seconds to wait before starting polling. Useful when you know approximately how long the workflow will take.
+            polling_interval: Seconds to wait between polling attempts.
+            timeout: Maximum seconds to poll before timing out.
+
+        Returns:
+            WorkflowRunResultsSchema when the target status is reached.
+
+        Raises:
+            WitriumClientException: If timeout is reached or workflow reaches an unexpected terminal status.
+        """
+
+        # Wait for minimum time before starting to poll
+        if min_wait_time > 0:
+            await asyncio.sleep(min_wait_time)
+
+        def _check_all_executions_completed(results: WorkflowRunResultsSchema) -> bool:
+            """Check if all executions have completed status."""
+            if not results.executions:
+                return False
+            return results.executions[-1].status == AgentExecutionStatus.COMPLETED
+
+        def _should_continue_polling(results: WorkflowRunResultsSchema) -> bool:
+            """Determine if we should continue polling based on target status and execution completion."""
+            status_not_reached = results.status != target_status
+            terminal_status_reached = (
+                results.status in WorkflowRunStatus.TERMINAL_STATUSES
+            )
+
+            # If we've reached a terminal status but it's not our target, stop retrying
+            if terminal_status_reached and status_not_reached:
+                return False
+
+            # If target status is not reached, continue polling
+            if status_not_reached:
+                return True
+
+            # If target status is reached but we also need all instructions executed
+            if all_instructions_executed and not _check_all_executions_completed(
+                results
+            ):
+                return True
+
+            # All conditions met, stop polling
+            return False
+
+        @retry(
+            stop=stop_after_delay(timeout),
+            wait=wait_fixed(polling_interval),
+            retry=retry_if_result(_should_continue_polling),
+        )
+        async def _poll_for_status():
+            results = await self.get_workflow_results(run_id)
+
+            # Check if workflow has reached the target status
+            status_reached = results.status == target_status
+            all_executions_completed = (
+                _check_all_executions_completed(results)
+                if all_instructions_executed
+                else True
+            )
+
+            if status_reached and all_executions_completed:
+                return results
+
+            # Check if workflow has reached a terminal status that's not our target
+            if (
+                results.status in WorkflowRunStatus.TERMINAL_STATUSES
+                and results.status != target_status
+            ):
+                current_status_name = WorkflowRunStatus.get_status_name(results.status)
+                target_status_name = WorkflowRunStatus.get_status_name(target_status)
+                raise WitriumClientException(
+                    f"Workflow run reached terminal status '{current_status_name}' before reaching target status '{target_status_name}'"
+                )
+
+            # Return results for retry evaluation
+            return results
+
+        try:
+            return await _poll_for_status()
+        except Exception as e:
+            if "retry" in str(e).lower():
+                target_status_name = WorkflowRunStatus.get_status_name(target_status)
+                condition_msg = f"status '{target_status_name}'"
+                if all_instructions_executed:
+                    condition_msg += " and all instructions executed"
+                raise WitriumClientException(
+                    f"Workflow run did not reach {condition_msg} within {timeout} seconds"
+                )
+            raise
+
+    async def cancel_run(self, run_id: str) -> WorkflowRunSchema:
+        """
+        Cancel a workflow run and clean up associated resources.
+
+        Args:
+            run_id: The ID of the workflow run to cancel.
+
+        Returns:
+            Dict containing the workflow run results.
+        """
+        url = f"{self.base_url}/v1/runs/{run_id}/cancel"
+
+        try:
+            response = await self._client.post(url)
+            response.raise_for_status()
+            return WorkflowRunSchema.model_validate(response.json())
+        except httpx.HTTPStatusError as e:
+            error_detail = await self._extract_error_detail(e.response)
+            raise WitriumClientException(
+                f"Error cancelling workflow run: {error_detail} (Status code: {e.response.status_code})"
+            )
+        except Exception as e:
+            raise WitriumClientException(f"Error cancelling workflow run: {str(e)}")
+
+    async def _extract_error_detail(self, response: httpx.Response) -> str:
+        """Extract error detail from response."""
+        try:
+            error_json = response.json()
+            if "detail" in error_json:
+                return error_json["detail"]
+            return str(error_json)
+        except Exception:
+            return response.text or "Unknown error"

witrium/py.typed

@@ -0,0 +1,2 @@
+
+

witrium-0.1.0.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: witrium
+Version: 0.1.0
+Summary: Python client for Witrium cloud browser automation API
+Author-email: Witrium <support@witrium.com>
+License-Expression: MIT
+Project-URL: Homepage, https://witrium.com
+Project-URL: Repository, https://github.com/witrium/witrium-py
+Project-URL: Issues, https://github.com/witrium/witrium-py/issues
+Keywords: automation,browser,web,api,client,witrium
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx<1.0,>=0.28
+Requires-Dist: pydantic<3,>=2.11
+Requires-Dist: tenacity<10,>=9.1
+Dynamic: license-file
+
+## witrium
+
+Python client for the Witrium cloud browser automation API.
+
+### Installation
+
+```bash
+pip install witrium
+```
+
+### Quick start
+
+```python
+from witrium import SyncWitriumClient, WorkflowRunStatus
+
+with SyncWitriumClient(api_token="your-api-token") as client:
+    run = client.run_workflow(
+        workflow_id="workflow-uuid",
+        args={"key": "value"}
+    )
+    result = client.wait_until_state(
+        run_id=run.run_id,
+        target_status=WorkflowRunStatus.COMPLETED
+    )
+    print(result.result)
+```
+
+For full documentation and advanced patterns, see `witrium/README.md` in this repository.
+
+

witrium-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+witrium/__init__.py,sha256=XJkDkgVN8UUQZlBf3G-sYcyAYPIkKdiwavaFTez-ZOE,386
+witrium/client.py,sha256=Aj_a909p22YRGYcOcbK2a-SNjU2FG5T65THd_im-0mo,28377
+witrium/py.typed,sha256=daEdpEyAJIa8b2VkCqSKcw8PaExcB6Qro80XNes_sHA,2
+witrium-0.1.0.dist-info/licenses/LICENSE,sha256=aYBbLVOK5jwybQuS8i_2XGurMLpQeRFo7z1p8q21cKQ,1064
+witrium-0.1.0.dist-info/METADATA,sha256=W6zXkrz6Lp8bdc92fmwf6ysPiGdV-pwu-pkuifISItE,1564
+witrium-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+witrium-0.1.0.dist-info/top_level.txt,sha256=03FKRXp2IwzH3hhHPmqRFi1Dh8QpLkVZIswZryS27Gw,8
+witrium-0.1.0.dist-info/RECORD,,

witrium-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

witrium-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Witrium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

witrium-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+witrium