tzafon 2.3.0__py3-none-any.whl → 2.4.4__py3-none-any.whl

tzafon/__init__.py

@@ -88,6 +88,16 @@ if not _t.TYPE_CHECKING:
 
 _setup_logging()
 
+# Add convenience wrapper to Computer client
+from .lib.wrapper import ComputerSession
+
+def _create_wrapper(self: Computer, kind: str = "browser", **kwargs) -> ComputerSession:
+    """Create a computer and return a session wrapper with cleaner API."""
+    response = self.computers.create(kind=kind, **kwargs)
+    return ComputerSession(self, response.id)
+
+Computer.create = _create_wrapper  # type: ignore
+
 # Update the __module__ attribute for exported symbols so that
 # error messages point to this module instead of the module
 # it was originally defined in, e.g.

tzafon/_client.py

@@ -30,6 +30,24 @@ from ._base_client import (
     AsyncAPIClient,
 )
 
+
+def _load_env_file(filepath: str = ".env") -> None:
+    """Load environment variables from a .env file."""
+    try:
+        with open(filepath) as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith("#") and "=" in line:
+                    key, value = line.split("=", 1)
+                    key = key.strip()
+                    value = value.strip()
+                    # Strip quotes if present
+                    if len(value) >= 2 and value[0] == value[-1] and value[0] in ('"', "'"):
+                        value = value[1:-1]
+                    os.environ.setdefault(key, value)
+    except FileNotFoundError:
+        pass
+
 __all__ = [
     "Timeout",
     "Transport",
@@ -79,6 +97,12 @@ class Computer(SyncAPIClient):
         """
         if api_key is None:
             api_key = os.environ.get("TZAFON_API_KEY")
+
+        # Try to load from .env file if still not found
+        if api_key is None:
+            _load_env_file()
+            api_key = os.environ.get("TZAFON_API_KEY")
+
         if api_key is None:
             raise ComputerError(
                 "The api_key client option must be set either by passing api_key to the client or by setting the TZAFON_API_KEY environment variable"
@@ -90,6 +114,10 @@ class Computer(SyncAPIClient):
         if base_url is None:
             base_url = f"https://v2.tzafon.ai/v1"
 
+        # Strip trailing slash to prevent double-slash in URLs (httpx adds it back)
+        if isinstance(base_url, str):
+            base_url = base_url.rstrip('/')
+
         super().__init__(
             version=__version__,
             base_url=base_url,
@@ -247,6 +275,12 @@ class AsyncComputer(AsyncAPIClient):
         """
         if api_key is None:
             api_key = os.environ.get("TZAFON_API_KEY")
+
+        # Try to load from .env file if still not found
+        if api_key is None:
+            _load_env_file()
+            api_key = os.environ.get("TZAFON_API_KEY")
+
         if api_key is None:
             raise ComputerError(
                 "The api_key client option must be set either by passing api_key to the client or by setting the TZAFON_API_KEY environment variable"
@@ -258,6 +292,10 @@ class AsyncComputer(AsyncAPIClient):
         if base_url is None:
             base_url = f"https://v2.tzafon.ai/v1"
 
+        # Strip trailing slash to prevent double-slash in URLs (httpx adds it back)
+        if isinstance(base_url, str):
+            base_url = base_url.rstrip('/')
+
         super().__init__(
             version=__version__,
             base_url=base_url,

tzafon/_utils/_utils.py

@@ -133,7 +133,7 @@ def is_given(obj: _T | NotGiven | Omit) -> TypeGuard[_T]:
 # Type safe methods for narrowing types with TypeVars.
 # The default narrowing for isinstance(obj, dict) is dict[unknown, unknown],
 # however this cause Pyright to rightfully report errors. As we know we don't
-# care about the contained types we can safely use `object` in it's place.
+# care about the contained types we can safely use `object` in its place.
 #
 # There are two separate functions defined, `is_*` and `is_*_t` for different use cases.
 # `is_*` is for when you're dealing with an unknown input

tzafon/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "tzafon"
-__version__ = "2.3.0"  # x-release-please-version
+__version__ = "2.4.4"  # x-release-please-version

tzafon/lib/__init__.py

@@ -0,0 +1,21 @@
+"""Custom library extensions - safe from Stainless regeneration."""
+
+from .wrapper import ComputerSession
+from .result_types import (
+    ScreenshotResult,
+    HTMLResult,
+    DebugResult,
+    get_screenshot_url,
+    get_html_content,
+    get_debug_response,
+)
+
+__all__ = [
+    "ComputerSession",
+    "ScreenshotResult",
+    "HTMLResult",
+    "DebugResult",
+    "get_screenshot_url",
+    "get_html_content",
+    "get_debug_response",
+]

tzafon/lib/result_types.py

@@ -0,0 +1,77 @@
+"""Strongly-typed result helpers for better IntelliSense."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional, TypedDict
+
+if TYPE_CHECKING:
+    from ..types.action_result import ActionResult
+
+__all__ = [
+    "ScreenshotResult",
+    "HTMLResult",
+    "DebugResult",
+    "get_screenshot_url",
+    "get_html_content",
+    "get_debug_response",
+]
+
+
+class ScreenshotResult(TypedDict, total=False):
+    """Result from screenshot action containing the image URL."""
+    screenshot_url: str
+
+
+class HTMLResult(TypedDict, total=False):
+    """Result from html() action containing the page HTML."""
+    html_content: str
+
+
+class DebugResult(TypedDict, total=False):
+    """Result from debug command containing command output."""
+    debug_response: str
+
+
+def get_screenshot_url(result: ActionResult) -> Optional[str]:
+    """
+    Extract screenshot URL from action result.
+
+    Args:
+        result: ActionResult from screenshot() call
+
+    Returns:
+        Screenshot URL if available, None otherwise
+    """
+    if result.result:
+        return result.result.get("screenshot_url")  # type: ignore
+    return None
+
+
+def get_html_content(result: ActionResult) -> Optional[str]:
+    """
+    Extract HTML content from action result.
+
+    Args:
+        result: ActionResult from html() call
+
+    Returns:
+        HTML content if available, None otherwise
+    """
+    if result.result:
+        return result.result.get("html_content")  # type: ignore
+    return None
+
+
+def get_debug_response(result: ActionResult) -> Optional[str]:
+    """
+    Extract debug command output from action result.
+
+    Args:
+        result: ActionResult from debug() call
+
+    Returns:
+        Command output if available, None otherwise
+    """
+    if result.result:
+        return result.result.get("debug_response")  # type: ignore
+    return None

tzafon/lib/wrapper.py

@@ -0,0 +1,326 @@
+"""Lightweight wrapper for cleaner API - lives in lib/ to avoid Stainless regeneration."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from .._client import Computer as TzafonClient
+    from ..types.action_result import ActionResult
+
+__all__ = ["ComputerSession"]
+
+
+class ComputerSession:
+    """
+    High-level session wrapper with cleaner API and context manager support.
+
+    This wraps a computer instance and provides:
+    - Automatic ID management (no need to pass computer_id to each call)
+    - Context manager support for automatic cleanup
+    - Simplified method signatures
+    - Better IntelliSense through typed helper methods
+
+    Example:
+        ```python
+        from tzafon import Computer
+
+        client = Computer()
+        with client.create(kind="browser") as computer:
+            computer.navigate("https://example.com")
+            result = computer.screenshot()
+            url = computer.get_screenshot_url(result)
+            # Automatically terminates on exit
+        ```
+    """
+
+    def __init__(self, client: TzafonClient, computer_id: str) -> None:
+        """
+        Initialize session wrapper.
+
+        Args:
+            client: The Computer client instance
+            computer_id: The computer/session ID
+        """
+        self._client = client
+        self.id = computer_id
+
+    def navigate(self, url: str) -> ActionResult:
+        """
+        Navigate to a URL.
+
+        Args:
+            url: The URL to navigate to (e.g., "https://example.com")
+
+        Returns:
+            ActionResult with status and timestamp
+        """
+        return self._client.computers.navigate(self.id, url=url)
+
+    def type(self, text: str) -> ActionResult:
+        """
+        Type text into the currently focused element.
+
+        Args:
+            text: The text to type
+
+        Returns:
+            ActionResult with status and timestamp
+        """
+        return self._client.computers.type_text(self.id, text=text)
+
+    def click(self, x: float, y: float) -> ActionResult:
+        """
+        Click at specific coordinates.
+
+        Args:
+            x: X coordinate (pixels from left)
+            y: Y coordinate (pixels from top)
+
+        Returns:
+            ActionResult with status and timestamp
+        """
+        return self._client.computers.click(self.id, x=x, y=y)
+
+    def screenshot(self, base64: bool = False) -> ActionResult:
+        """
+        Capture a screenshot of the current viewport.
+
+        Args:
+            base64: If True, return base64-encoded image data instead of URL
+
+        Returns:
+            ActionResult with result.screenshot_url containing the image URL.
+            Use get_screenshot_url() helper to extract the URL with type safety.
+
+        Example:
+            ```python
+            result = computer.screenshot()
+            url = computer.get_screenshot_url(result)
+            ```
+        """
+        return self._client.computers.capture_screenshot(self.id, base64=base64)
+
+    def double_click(self, x: float, y: float) -> ActionResult:
+        """
+        Double-click at specific coordinates.
+
+        Args:
+            x: X coordinate (pixels from left)
+            y: Y coordinate (pixels from top)
+
+        Returns:
+            ActionResult with status and timestamp
+        """
+        return self._client.computers.double_click(self.id, x=x, y=y)
+
+    def right_click(self, x: float, y: float) -> ActionResult:
+        """
+        Right-click at specific coordinates.
+
+        Args:
+            x: X coordinate (pixels from left)
+            y: Y coordinate (pixels from top)
+
+        Returns:
+            ActionResult with status and timestamp
+        """
+        return self._client.computers.right_click(self.id, x=x, y=y)
+
+    def drag(self, x1: float, y1: float, x2: float, y2: float) -> ActionResult:
+        """
+        Perform click-and-drag from one point to another.
+
+        Args:
+            x1: Starting X coordinate
+            y1: Starting Y coordinate
+            x2: Ending X coordinate
+            y2: Ending Y coordinate
+
+        Returns:
+            ActionResult with status and timestamp
+        """
+        return self._client.computers.drag(self.id, x1=x1, y1=y1, x2=x2, y2=y2)
+
+    def hotkey(self, *keys: str) -> ActionResult:
+        """
+        Press a keyboard shortcut combination.
+
+        Args:
+            *keys: Keys to press together (e.g., "Control", "c" for Ctrl+C)
+                  Can be passed as separate arguments or as a single list/tuple
+
+        Returns:
+            ActionResult with status and timestamp
+
+        Example:
+            ```python
+            computer.hotkey("Control", "c")  # Copy - varargs style
+            computer.hotkey(["Control", "v"])  # Paste - list style
+            computer.hotkey("Control", "Shift", "p")  # Multiple modifiers
+            ```
+        """
+        # Handle both hotkey("a", "b") and hotkey(["a", "b"]) calling styles
+        if len(keys) == 1 and isinstance(keys[0], (list, tuple)):
+            keys_list = list(keys[0])
+        else:
+            keys_list = list(keys)
+        
+        return self._client.computers.execute_action(self.id, action={"type": "keypress", "keys": keys_list})
+
+    def scroll(self, dx: float = 0, dy: float = 0) -> ActionResult:
+        """
+        Scroll the viewport.
+
+        Args:
+            dx: Horizontal scroll delta (positive = right, negative = left)
+            dy: Vertical scroll delta (positive = down, negative = up)
+
+        Returns:
+            ActionResult with status and timestamp
+        """
+        return self._client.computers.scroll_viewport(self.id, dx=dx, dy=dy)
+
+    def wait(self, seconds: float) -> ActionResult:
+        """
+        Wait for a specified number of seconds on the remote computer.
+
+        Args:
+            seconds: Number of seconds to wait (can be fractional, e.g., 0.5 for half a second)
+
+        Returns:
+            ActionResult with status and timestamp
+
+        Example:
+            ```python
+            result = computer.wait(1)      # Wait 1 second
+            result = computer.wait(0.5)    # Wait 500 milliseconds
+            result = computer.wait(2.5)    # Wait 2.5 seconds
+            ```
+        """
+        ms = int(seconds * 1000)
+        return self._client.computers.execute_action(self.id, action={"type": "wait", "ms": ms})
+
+    def html(self, auto_detect_encoding: bool = False) -> ActionResult:
+        """
+        Get the HTML content of the current page.
+
+        Args:
+            auto_detect_encoding: Automatically detect and handle character encoding
+
+        Returns:
+            ActionResult with result.html_content containing the page HTML.
+            Use get_html_content() helper to extract the HTML with type safety.
+
+        Example:
+            ```python
+            result = computer.html()
+            html = computer.get_html_content(result)
+            ```
+        """
+        return self._client.computers.get_html(self.id, auto_detect_encoding=auto_detect_encoding)
+
+    def debug(self, command: str, timeout_seconds: int = 120, max_output_length: int = 65536) -> ActionResult:
+        """
+        Execute a shell command inside the session.
+
+        Args:
+            command: Shell command to execute
+            timeout_seconds: Command timeout in seconds (default: 120)
+            max_output_length: Maximum output length in bytes (default: 65536)
+
+        Returns:
+            ActionResult with result.debug_response containing command output.
+            Use get_debug_response() helper to extract output with type safety.
+
+        Example:
+            ```python
+            result = computer.debug("ls -la")
+            output = computer.get_debug_response(result)
+            ```
+        """
+        return self._client.computers.debug(
+            self.id,
+            command=command,
+            timeout_seconds=timeout_seconds,
+            max_output_length=max_output_length
+        )
+
+    def set_viewport(self, width: int, height: int, scale_factor: float = 1.0) -> ActionResult:
+        """
+        Change the browser viewport dimensions.
+
+        Args:
+            width: Viewport width in pixels
+            height: Viewport height in pixels
+            scale_factor: Device pixel ratio / zoom level (default: 1.0)
+
+        Returns:
+            ActionResult with status and timestamp
+        """
+        return self._client.computers.set_viewport(
+            self.id,
+            width=width,
+            height=height,
+            scale_factor=scale_factor
+        )
+
+    # Typed helper methods for extracting results
+
+    def get_screenshot_url(self, result: ActionResult) -> Optional[str]:
+        """
+        Extract screenshot URL from action result with type safety.
+
+        Args:
+            result: ActionResult from screenshot() call
+
+        Returns:
+            Screenshot URL if available, None otherwise
+        """
+        if result.result:
+            return result.result.get("screenshot_url")  # type: ignore
+        return None
+
+    def get_html_content(self, result: ActionResult) -> Optional[str]:
+        """
+        Extract HTML content from action result with type safety.
+
+        Args:
+            result: ActionResult from html() call
+
+        Returns:
+            HTML content if available, None otherwise
+        """
+        if result.result:
+            return result.result.get("html_content")  # type: ignore
+        return None
+
+    def get_debug_response(self, result: ActionResult) -> Optional[str]:
+        """
+        Extract debug command output from action result with type safety.
+
+        Args:
+            result: ActionResult from debug() call
+
+        Returns:
+            Command output if available, None otherwise
+        """
+        if result.result:
+            return result.result.get("debug_response")  # type: ignore
+        return None
+
+    def terminate(self) -> None:
+        """
+        Terminate the computer session and clean up resources.
+
+        Note: When using the context manager (with statement), this is called automatically.
+        """
+        self._client.computers.terminate(self.id)
+
+    def __enter__(self) -> ComputerSession:
+        """Context manager entry - returns self for use in with statement."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Context manager exit - automatically terminates the session."""
+        self.terminate()

tzafon-2.4.4.dist-info/METADATA

@@ -0,0 +1,229 @@
+Metadata-Version: 2.3
+Name: tzafon
+Version: 2.4.4
+Summary: The official Python library for the computer API
+Project-URL: Homepage, https://github.com/tzafon/computer-python
+Project-URL: Repository, https://github.com/tzafon/computer-python
+Author-email: Computer <atul.gavande@tzafon.ai>
+License: MIT
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Requires-Dist: anyio<5,>=3.5.0
+Requires-Dist: distro<2,>=1.7.0
+Requires-Dist: httpx<1,>=0.23.0
+Requires-Dist: pydantic<3,>=1.9.0
+Requires-Dist: sniffio
+Requires-Dist: typing-extensions<5,>=4.10
+Provides-Extra: aiohttp
+Requires-Dist: aiohttp; extra == 'aiohttp'
+Requires-Dist: httpx-aiohttp>=0.1.9; extra == 'aiohttp'
+Description-Content-Type: text/markdown
+
+# Tzafon Python SDK
+
+[![PyPI version](https://img.shields.io/pypi/v/tzafon.svg)](https://pypi.org/project/tzafon/)
+
+Remote browser and desktop automation. Control browsers and desktops programmatically through a simple Python API.
+
+## Installation
+
+```bash
+pip install tzafon
+```
+
+## Quick Start
+
+```python
+from tzafon import Computer
+
+client = Computer()  # Reads TZAFON_API_KEY from environment
+
+# Create and control a browser instance
+with client.create(kind="browser") as computer:
+    computer.navigate("https://wikipedia.com")
+
+    result = computer.screenshot()
+    url = computer.get_screenshot_url(result)
+    print(f"Screenshot: {url}")
+
+    computer.click(100, 200)
+    computer.type("Hello, world!")
+
+    # Automatically terminates when exiting context
+```
+
+Set your API key:
+```bash
+export TZAFON_API_KEY="your-api-key"
+```
+
+Or use a `.env` file with [python-dotenv](https://pypi.org/project/python-dotenv/).
+
+## Features
+
+**Session Management**
+- Context manager support for automatic cleanup
+- Manual session control when needed
+- Browser, desktop, and code environments
+
+**Browser Actions**
+- Navigation: `navigate(url)`
+- Mouse: `click()`, `double_click()`, `right_click()`, `drag()`
+- Keyboard: `type()`, `hotkey()`
+- Viewport: `scroll()`, `set_viewport()`
+- Capture: `screenshot()`, `html()`
+- Debug: Execute shell commands with `debug()`
+
+**Type Safety**
+- Full type annotations for IDE autocomplete
+- Pydantic models for responses
+- TypedDict for request parameters
+- Helper methods for result extraction
+
+## Examples
+
+### Browser Automation
+
+```python
+with client.create(kind="browser") as computer:
+    # Navigate and interact
+    computer.navigate("https://github.com/login")
+    computer.click(300, 400)
+    computer.type("username")
+    computer.hotkey("Control", "a")  # Select all
+
+    # Capture state
+    html_result = computer.html()
+    html = computer.get_html_content(html_result)
+
+    # Execute commands
+    debug_result = computer.debug("ls -la")
+    output = computer.get_debug_response(debug_result)
+```
+
+### Manual Session Management
+
+```python
+computer = client.create(kind="browser")
+try:
+    computer.navigate("https://example.com")
+    screenshot = computer.screenshot()
+finally:
+    computer.terminate()
+```
+
+### Async Support
+
+```python
+from tzafon import AsyncComputer
+
+async with AsyncComputer() as client:
+    computer = await client.computers.create(kind="browser")
+    await client.computers.navigate(computer.id, url="https://example.com")
+    await client.computers.terminate(computer.id)
+```
+
+## Advanced Usage
+
+### Raw SDK Access
+
+The simplified wrapper uses the generated SDK under the hood. You can access it directly:
+
+```python
+# Low-level API
+response = client.computers.create(kind="browser")
+client.computers.navigate(response.id, url="https://example.com")
+result = client.computers.capture_screenshot(response.id)
+client.computers.terminate(response.id)
+```
+
+### Error Handling
+
+```python
+import tzafon
+
+try:
+    with client.create(kind="browser") as computer:
+        computer.navigate("https://example.com")
+except tzafon.RateLimitError:
+    print("Rate limit exceeded, back off")
+except tzafon.AuthenticationError:
+    print("Invalid API key")
+except tzafon.APIError as e:
+    print(f"API error: {e}")
+```
+
+### Configuration
+
+```python
+from tzafon import Computer
+
+client = Computer(
+    api_key="your-api-key",       # Or use TZAFON_API_KEY env var
+    base_url="https://...",        # Optional: custom endpoint
+    timeout=120.0,                 # Request timeout in seconds
+    max_retries=2,                 # Retry failed requests
+)
+```
+
+## API Reference
+
+**Session Methods**
+- `navigate(url)` - Navigate to URL
+- `click(x, y)` - Click at coordinates
+- `double_click(x, y)` - Double-click
+- `right_click(x, y)` - Right-click
+- `drag(x1, y1, x2, y2)` - Click and drag
+- `type(text)` - Type text
+- `hotkey(*keys)` - Press key combination
+- `scroll(dx, dy)` - Scroll viewport
+- `screenshot(base64=False)` - Capture screenshot
+- `html(auto_detect_encoding=False)` - Get page HTML
+- `debug(command, timeout_seconds=120, max_output_length=65536)` - Run shell command
+- `set_viewport(width, height, scale_factor=1.0)` - Set viewport size
+- `terminate()` - End session
+
+**Helper Methods**
+- `get_screenshot_url(result)` - Extract screenshot URL from result
+- `get_html_content(result)` - Extract HTML from result
+- `get_debug_response(result)` - Extract command output from result
+
+## Error Codes
+
+| Status | Error Type |
+|--------|------------|
+| 400 | `BadRequestError` |
+| 401 | `AuthenticationError` |
+| 403 | `PermissionDeniedError` |
+| 404 | `NotFoundError` |
+| 422 | `UnprocessableEntityError` |
+| 429 | `RateLimitError` |
+| ≥500 | `InternalServerError` |
+
+## Documentation
+
+- REST API: [docs.tzafon.ai](https://docs.tzafon.ai)
+- Full API Reference: [api.md](https://github.com/tzafon/computer-python/tree/main/api.md)
+- Contributing: [CONTRIBUTING.md](https://github.com/tzafon/computer-python/tree/main/CONTRIBUTING.md)
+
+## Requirements
+
+Python 3.8+
+
+## License
+
+See [LICENSE](https://github.com/tzafon/computer-python/tree/main/LICENSE)

{tzafon-2.3.0.dist-info → tzafon-2.4.4.dist-info}/RECORD

@@ -1,6 +1,6 @@
-tzafon/__init__.py,sha256=syE3g8pMgaYuFNgAKOTQGdtTaQtOftIR4aVDXrifTeQ,2677
+tzafon/__init__.py,sha256=BsYQQO5iiBjiYdu7iJmKOVYBD1Pf26Uv8mSxboHHvno,3084
 tzafon/_base_client.py,sha256=5AX9s8UF-0wXUI15A1uiRcWhTNk_I4UBpt0Q-2r0aLU,67047
-tzafon/_client.py,sha256=EbENZoqN6ERd3PSISUi0jGCdmxC_5-P8sONVbZaqR9w,15066
+tzafon/_client.py,sha256=-WF1JpGVJvtf7Bq-CyhGYgcybdZcCptHCjGrFcYZd-s,16437
 tzafon/_compat.py,sha256=DQBVORjFb33zch24jzkhM14msvnzY7mmSmgDLaVFUM8,6562
 tzafon/_constants.py,sha256=S14PFzyN9-I31wiV7SmIlL5Ga0MLHxdvegInGdXH7tM,462
 tzafon/_exceptions.py,sha256=qi7R0qNzTGtKBt4fWynaQkMnUk3YGrIp01jis82aEdo,3224
@@ -11,7 +11,7 @@ tzafon/_resource.py,sha256=EseuwN0R4kKBVcQnyF4NgCeRtc6-OrR8yWVI5fOYGHM,1112
 tzafon/_response.py,sha256=Gaq-HHLZ76rKv515pCAMkfW4rbz_ManOH-7R640hrDE,28792
 tzafon/_streaming.py,sha256=HIbrsW_WdZZmR-vQP1ZJUHFluu4t90Zx0xa7y055CBo,10157
 tzafon/_types.py,sha256=1kStHPi-XwmomGBE0xKVtz0mdRF4Svxb8NWZR4FaSiY,7236
-tzafon/_version.py,sha256=S-LBQcXJ6ynX9WL_Oql5onrsOAKvY6Hcp3pQME2R0Kc,158
+tzafon/_version.py,sha256=XYHrS43oOJ5nnsnKv8aEguNPFhQDHewxA_3JB03X5Ro,158
 tzafon/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tzafon/_utils/__init__.py,sha256=7fch0GT9zpNnErbciSpUNa-SjTxxjY6kxHxKMOM4AGs,2305
 tzafon/_utils/_compat.py,sha256=D8gtAvjJQrDWt9upS0XaG9Rr5l1QhiAx_I_1utT_tt0,1195
@@ -24,8 +24,11 @@ tzafon/_utils/_streams.py,sha256=SMC90diFFecpEg_zgDRVbdR3hSEIgVVij4taD-noMLM,289
 tzafon/_utils/_sync.py,sha256=TpGLrrhRNWTJtODNE6Fup3_k7zrWm1j2RlirzBwre-0,2862
 tzafon/_utils/_transform.py,sha256=NjCzmnfqYrsAikUHQig6N9QfuTVbKipuP3ur9mcNF-E,15951
 tzafon/_utils/_typing.py,sha256=N_5PPuFNsaygbtA_npZd98SVN1LQQvFTKL6bkWPBZGU,4786
-tzafon/_utils/_utils.py,sha256=0dDqauUbVZEXV0NVl7Bwu904Wwo5eyFCZpQThhFNhyA,12253
+tzafon/_utils/_utils.py,sha256=ugfUaneOK7I8h9b3656flwf5u_kthY0gvNuqvgOLoSU,12252
 tzafon/lib/.keep,sha256=wuNrz-5SXo3jJaJOJgz4vFHM41YH_g20F5cRQo0vLes,224
+tzafon/lib/__init__.py,sha256=oIdVqWy0xUeoptWR5w-Y7gjJwV3uFsMUZQu7zRVTK6Y,436
+tzafon/lib/result_types.py,sha256=_iFGJ0dlwGDoVlWDwHJ3tHAhGQ-ZUtjpqywdVKx3Aws,1847
+tzafon/lib/wrapper.py,sha256=6b7fahveBAwyNtmOOFReIQ-_T8Tfn24zGC9AoTcTbRQ,10439
 tzafon/resources/__init__.py,sha256=2tbxQpPYxwl6BYAmWlSblYFfmeBEasXs9oxh3vXRG2M,591
 tzafon/resources/computers.py,sha256=mkRSD6pY8hCnks5_sTRHqL7cbbH3btM2C_z6wOlBz1E,79164
 tzafon/types/__init__.py,sha256=_WD0kMVrCQlZgEf3UgjzF2xkxsDZ-lT_58zjcVjXYAc,1912
@@ -49,7 +52,7 @@ tzafon/types/computer_right_click_params.py,sha256=Vv5iIcyA67C9q4G5RSSW4-KVY1Vjt
 tzafon/types/computer_scroll_viewport_params.py,sha256=MViBOU4FBhhaFVJ-IKcjjvm0iw3Mdv31muhWZb5Nevc,326
 tzafon/types/computer_set_viewport_params.py,sha256=Y54APyVdHCvFs0ppNnMfYSurG-zvD_cA-RPZO0fk4_c,320
 tzafon/types/computer_type_text_params.py,sha256=NtfxVoCF6GJhCeUWlyyCFf2XAowAKjZQAtlXntlSTIk,271
-tzafon-2.3.0.dist-info/METADATA,sha256=QhA_tYjesaPvcF3MuROgE6Z_XjcUWhzt4S7fnEudEpA,13902
-tzafon-2.3.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-tzafon-2.3.0.dist-info/licenses/LICENSE,sha256=ciLXi9zfEehb4Tnhy-M9I2WSRUpZjx-FK1TEChVqlDo,1048
-tzafon-2.3.0.dist-info/RECORD,,
+tzafon-2.4.4.dist-info/METADATA,sha256=YHZBZ09wEzP0GBGZkkZO-zYer9vkAnEcsdRJFz2snBI,6516
+tzafon-2.4.4.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+tzafon-2.4.4.dist-info/licenses/LICENSE,sha256=ciLXi9zfEehb4Tnhy-M9I2WSRUpZjx-FK1TEChVqlDo,1048
+tzafon-2.4.4.dist-info/RECORD,,

tzafon-2.3.0.dist-info/METADATA

@@ -1,429 +0,0 @@
-Metadata-Version: 2.3
-Name: tzafon
-Version: 2.3.0
-Summary: The official Python library for the computer API
-Project-URL: Homepage, https://github.com/tzafon/computer-python
-Project-URL: Repository, https://github.com/tzafon/computer-python
-Author-email: Computer <atul.gavande@tzafon.ai>
-License: MIT
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: MacOS
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Operating System :: OS Independent
-Classifier: Operating System :: POSIX
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Typing :: Typed
-Requires-Python: >=3.8
-Requires-Dist: anyio<5,>=3.5.0
-Requires-Dist: distro<2,>=1.7.0
-Requires-Dist: httpx<1,>=0.23.0
-Requires-Dist: pydantic<3,>=1.9.0
-Requires-Dist: sniffio
-Requires-Dist: typing-extensions<5,>=4.10
-Provides-Extra: aiohttp
-Requires-Dist: aiohttp; extra == 'aiohttp'
-Requires-Dist: httpx-aiohttp>=0.1.9; extra == 'aiohttp'
-Description-Content-Type: text/markdown
-
-# Computer Python API library
-
-<!-- prettier-ignore -->
-[![PyPI version](https://img.shields.io/pypi/v/tzafon.svg?label=pypi%20(stable))](https://pypi.org/project/tzafon/)
-
-The Computer Python library provides convenient access to the Computer REST API from any Python 3.8+
-application. The library includes type definitions for all request params and response fields,
-and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).
-
-It is generated with [Stainless](https://www.stainless.com/).
-
-## Documentation
-
-The REST API documentation can be found on [docs.tzafon.ai](http://docs.tzafon.ai). The full API of this library can be found in [api.md](https://github.com/tzafon/computer-python/tree/main/api.md).
-
-## Installation
-
-```sh
-# install from PyPI
-pip install tzafon
-```
-
-## Usage
-
-The full API of this library can be found in [api.md](https://github.com/tzafon/computer-python/tree/main/api.md).
-
-```python
-import os
-from tzafon import Computer
-
-client = Computer(
-    api_key=os.environ.get("TZAFON_API_KEY"),  # This is the default and can be omitted
-)
-
-computer_response = client.computers.create(
-    kind="browser",
-)
-print(computer_response.id)
-```
-
-While you can provide an `api_key` keyword argument,
-we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
-to add `TZAFON_API_KEY="My API Key"` to your `.env` file
-so that your API Key is not stored in source control.
-
-## Async usage
-
-Simply import `AsyncComputer` instead of `Computer` and use `await` with each API call:
-
-```python
-import os
-import asyncio
-from tzafon import AsyncComputer
-
-client = AsyncComputer(
-    api_key=os.environ.get("TZAFON_API_KEY"),  # This is the default and can be omitted
-)
-
-
-async def main() -> None:
-    computer_response = await client.computers.create(
-        kind="browser",
-    )
-    print(computer_response.id)
-
-
-asyncio.run(main())
-```
-
-Functionality between the synchronous and asynchronous clients is otherwise identical.
-
-### With aiohttp
-
-By default, the async client uses `httpx` for HTTP requests. However, for improved concurrency performance you may also use `aiohttp` as the HTTP backend.
-
-You can enable this by installing `aiohttp`:
-
-```sh
-# install from PyPI
-pip install tzafon[aiohttp]
-```
-
-Then you can enable it by instantiating the client with `http_client=DefaultAioHttpClient()`:
-
-```python
-import asyncio
-from tzafon import DefaultAioHttpClient
-from tzafon import AsyncComputer
-
-
-async def main() -> None:
-    async with AsyncComputer(
-        api_key="My API Key",
-        http_client=DefaultAioHttpClient(),
-    ) as client:
-        computer_response = await client.computers.create(
-            kind="browser",
-        )
-        print(computer_response.id)
-
-
-asyncio.run(main())
-```
-
-## Using types
-
-Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:
-
-- Serializing back into JSON, `model.to_json()`
-- Converting to a dictionary, `model.to_dict()`
-
-Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.
-
-## Nested params
-
-Nested parameters are dictionaries, typed using `TypedDict`, for example:
-
-```python
-from tzafon import Computer
-
-client = Computer()
-
-computer_response = client.computers.create(
-    display={},
-)
-print(computer_response.display)
-```
-
-## Handling errors
-
-When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `tzafon.APIConnectionError` is raised.
-
-When the API returns a non-success status code (that is, 4xx or 5xx
-response), a subclass of `tzafon.APIStatusError` is raised, containing `status_code` and `response` properties.
-
-All errors inherit from `tzafon.APIError`.
-
-```python
-import tzafon
-from tzafon import Computer
-
-client = Computer()
-
-try:
-    client.computers.create(
-        kind="browser",
-    )
-except tzafon.APIConnectionError as e:
-    print("The server could not be reached")
-    print(e.__cause__)  # an underlying Exception, likely raised within httpx.
-except tzafon.RateLimitError as e:
-    print("A 429 status code was received; we should back off a bit.")
-except tzafon.APIStatusError as e:
-    print("Another non-200-range status code was received")
-    print(e.status_code)
-    print(e.response)
-```
-
-Error codes are as follows:
-
-| Status Code | Error Type                 |
-| ----------- | -------------------------- |
-| 400         | `BadRequestError`          |
-| 401         | `AuthenticationError`      |
-| 403         | `PermissionDeniedError`    |
-| 404         | `NotFoundError`            |
-| 422         | `UnprocessableEntityError` |
-| 429         | `RateLimitError`           |
-| >=500       | `InternalServerError`      |
-| N/A         | `APIConnectionError`       |
-
-### Retries
-
-Certain errors are automatically retried 2 times by default, with a short exponential backoff.
-Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
-429 Rate Limit, and >=500 Internal errors are all retried by default.
-
-You can use the `max_retries` option to configure or disable retry settings:
-
-```python
-from tzafon import Computer
-
-# Configure the default for all requests:
-client = Computer(
-    # default is 2
-    max_retries=0,
-)
-
-# Or, configure per-request:
-client.with_options(max_retries=5).computers.create(
-    kind="browser",
-)
-```
-
-### Timeouts
-
-By default requests time out after 1 minute. You can configure this with a `timeout` option,
-which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/timeouts/#fine-tuning-the-configuration) object:
-
-```python
-from tzafon import Computer
-
-# Configure the default for all requests:
-client = Computer(
-    # 20 seconds (default is 1 minute)
-    timeout=20.0,
-)
-
-# More granular control:
-client = Computer(
-    timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
-)
-
-# Override per-request:
-client.with_options(timeout=5.0).computers.create(
-    kind="browser",
-)
-```
-
-On timeout, an `APITimeoutError` is thrown.
-
-Note that requests that time out are [retried twice by default](https://github.com/tzafon/computer-python/tree/main/#retries).
-
-## Advanced
-
-### Logging
-
-We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.
-
-You can enable logging by setting the environment variable `COMPUTER_LOG` to `info`.
-
-```shell
-$ export COMPUTER_LOG=info
-```
-
-Or to `debug` for more verbose logging.
-
-### How to tell whether `None` means `null` or missing
-
-In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:
-
-```py
-if response.my_field is None:
-  if 'my_field' not in response.model_fields_set:
-    print('Got json like {}, without a "my_field" key present at all.')
-  else:
-    print('Got json like {"my_field": null}.')
-```
-
-### Accessing raw response data (e.g. headers)
-
-The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,
-
-```py
-from tzafon import Computer
-
-client = Computer()
-response = client.computers.with_raw_response.create(
-    kind="browser",
-)
-print(response.headers.get('X-My-Header'))
-
-computer = response.parse()  # get the object that `computers.create()` would have returned
-print(computer.id)
-```
-
-These methods return an [`APIResponse`](https://github.com/tzafon/computer-python/tree/main/src/tzafon/_response.py) object.
-
-The async client returns an [`AsyncAPIResponse`](https://github.com/tzafon/computer-python/tree/main/src/tzafon/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.
-
-#### `.with_streaming_response`
-
-The above interface eagerly reads the full response body when you make the request, which may not always be what you want.
-
-To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.
-
-```python
-with client.computers.with_streaming_response.create(
-    kind="browser",
-) as response:
-    print(response.headers.get("X-My-Header"))
-
-    for line in response.iter_lines():
-        print(line)
-```
-
-The context manager is required so that the response will reliably be closed.
-
-### Making custom/undocumented requests
-
-This library is typed for convenient access to the documented API.
-
-If you need to access undocumented endpoints, params, or response properties, the library can still be used.
-
-#### Undocumented endpoints
-
-To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
-http verbs. Options on the client will be respected (such as retries) when making this request.
-
-```py
-import httpx
-
-response = client.post(
-    "/foo",
-    cast_to=httpx.Response,
-    body={"my_param": True},
-)
-
-print(response.headers.get("x-foo"))
-```
-
-#### Undocumented request params
-
-If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
-options.
-
-#### Undocumented response properties
-
-To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
-can also get all the extra fields on the Pydantic model as a dict with
-[`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).
-
-### Configuring the HTTP client
-
-You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:
-
-- Support for [proxies](https://www.python-httpx.org/advanced/proxies/)
-- Custom [transports](https://www.python-httpx.org/advanced/transports/)
-- Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality
-
-```python
-import httpx
-from tzafon import Computer, DefaultHttpxClient
-
-client = Computer(
-    # Or use the `COMPUTER_BASE_URL` env var
-    base_url="http://my.test.server.example.com:8083",
-    http_client=DefaultHttpxClient(
-        proxy="http://my.test.proxy.example.com",
-        transport=httpx.HTTPTransport(local_address="0.0.0.0"),
-    ),
-)
-```
-
-You can also customize the client on a per-request basis by using `with_options()`:
-
-```python
-client.with_options(http_client=DefaultHttpxClient(...))
-```
-
-### Managing HTTP resources
-
-By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.
-
-```py
-from tzafon import Computer
-
-with Computer() as client:
-  # make requests here
-  ...
-
-# HTTP client is now closed
-```
-
-## Versioning
-
-This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:
-
-1. Changes that only affect static types, without breaking runtime behavior.
-2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals.)_
-3. Changes that we do not expect to impact the vast majority of users in practice.
-
-We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.
-
-We are keen for your feedback; please open an [issue](https://www.github.com/tzafon/computer-python/issues) with questions, bugs, or suggestions.
-
-### Determining the installed version
-
-If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.
-
-You can determine the version that is being used at runtime with:
-
-```py
-import tzafon
-print(tzafon.__version__)
-```
-
-## Requirements
-
-Python 3.8 or higher.
-
-## Contributing
-
-See [the contributing documentation](https://github.com/tzafon/computer-python/tree/main/./CONTRIBUTING.md).