worqhat 3.10.0__py3-none-any.whl → 4.1.0__py3-none-any.whl

worqhat/__init__.py

@@ -1,92 +1,11 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+"""
+Worqhat Python SDK
 
-import typing as _t
+Official Python SDK for the Worqhat API.
+"""
 
-from . import types
-from ._types import NOT_GIVEN, Omit, NoneType, NotGiven, Transport, ProxiesTypes, omit, not_given
-from ._utils import file_from_path
-from ._client import Client, Stream, Timeout, Worqhat, Transport, AsyncClient, AsyncStream, AsyncWorqhat, RequestOptions
-from ._models import BaseModel
-from ._version import __title__, __version__
-from ._response import APIResponse as APIResponse, AsyncAPIResponse as AsyncAPIResponse
-from ._constants import DEFAULT_TIMEOUT, DEFAULT_MAX_RETRIES, DEFAULT_CONNECTION_LIMITS
-from ._exceptions import (
-    APIError,
-    WorqhatError,
-    ConflictError,
-    NotFoundError,
-    APIStatusError,
-    RateLimitError,
-    APITimeoutError,
-    BadRequestError,
-    APIConnectionError,
-    AuthenticationError,
-    InternalServerError,
-    PermissionDeniedError,
-    UnprocessableEntityError,
-    APIResponseValidationError,
-)
-from ._base_client import DefaultHttpxClient, DefaultAioHttpClient, DefaultAsyncHttpxClient
-from ._utils._logs import setup_logging as _setup_logging
+from .client import Worqhat
+from .exceptions import WorqhatError, APIError, AuthenticationError, ValidationError
 
-__all__ = [
-    "types",
-    "__version__",
-    "__title__",
-    "NoneType",
-    "Transport",
-    "ProxiesTypes",
-    "NotGiven",
-    "NOT_GIVEN",
-    "not_given",
-    "Omit",
-    "omit",
-    "WorqhatError",
-    "APIError",
-    "APIStatusError",
-    "APITimeoutError",
-    "APIConnectionError",
-    "APIResponseValidationError",
-    "BadRequestError",
-    "AuthenticationError",
-    "PermissionDeniedError",
-    "NotFoundError",
-    "ConflictError",
-    "UnprocessableEntityError",
-    "RateLimitError",
-    "InternalServerError",
-    "Timeout",
-    "RequestOptions",
-    "Client",
-    "AsyncClient",
-    "Stream",
-    "AsyncStream",
-    "Worqhat",
-    "AsyncWorqhat",
-    "file_from_path",
-    "BaseModel",
-    "DEFAULT_TIMEOUT",
-    "DEFAULT_MAX_RETRIES",
-    "DEFAULT_CONNECTION_LIMITS",
-    "DefaultHttpxClient",
-    "DefaultAsyncHttpxClient",
-    "DefaultAioHttpClient",
-]
-
-if not _t.TYPE_CHECKING:
-    from ._utils._resources_proxy import resources as resources
-
-_setup_logging()
-
-# 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.
-# worqhat._exceptions.NotFoundError -> worqhat.NotFoundError
-__locals = locals()
-for __name in __all__:
-    if not __name.startswith("__"):
-        try:
-            __locals[__name].__module__ = "worqhat"
-        except (TypeError, AttributeError):
-            # Some of our exported symbols are builtins which we can't set attributes for.
-            pass
+__version__ = "1.0.0"
+__all__ = ["Worqhat", "WorqhatError", "APIError", "AuthenticationError", "ValidationError"]

worqhat/client.py

@@ -0,0 +1,62 @@
+"""Main Worqhat client."""
+
+from typing import Optional
+
+from .http_client import HTTPClient
+from .resources import DatabaseResource, FlowsResource, StorageResource
+
+
+class Worqhat:
+    """
+    Worqhat API client.
+
+    Example:
+        >>> from worqhat import Worqhat
+        >>> client = Worqhat(api_key="your-api-key")
+        >>> response = client.db.execute_query(query="SELECT * FROM users")
+        >>> print(response["data"])
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = "https://api.worqhat.app",
+        target: Optional[str] = None,
+        timeout: int = 60,
+    ):
+        """
+        Initialize the Worqhat client.
+
+        Args:
+            api_key: API key for authentication. Defaults to WORQHAT_API_KEY environment variable.
+            base_url: Base URL for the API (default: https://api.worqhat.app).
+            target: Backend target ('app' or 'fyi').
+            timeout: Request timeout in seconds (default: 60).
+
+        Raises:
+            AuthenticationError: If no API key is provided.
+        """
+        self._http_client = HTTPClient(
+            api_key=api_key, base_url=base_url, target=target, timeout=timeout
+        )
+
+        # Initialize resources
+        self.db = DatabaseResource(self._http_client)
+        self.flows = FlowsResource(self._http_client)
+        self.storage = StorageResource(self._http_client)
+
+    def close(self) -> None:
+        """Close the HTTP client session."""
+        self._http_client.close()
+
+    def __enter__(self) -> "Worqhat":
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        """Context manager exit."""
+        self.close()
+
+    def __repr__(self) -> str:
+        """String representation."""
+        return f"Worqhat(base_url='{self._http_client.base_url}')"

worqhat/exceptions.py

@@ -0,0 +1,43 @@
+"""Exception classes for the Worqhat SDK."""
+
+from typing import Optional, Dict, Any
+
+
+class WorqhatError(Exception):
+    """Base exception for all Worqhat SDK errors."""
+
+    def __init__(self, message: str, code: Optional[int] = None, details: Optional[Dict[str, Any]] = None):
+        super().__init__(message)
+        self.message = message
+        self.code = code
+        self.details = details or {}
+
+
+class APIError(WorqhatError):
+    """Raised when the API returns an error response."""
+
+    pass
+
+
+class AuthenticationError(WorqhatError):
+    """Raised when authentication fails."""
+
+    pass
+
+
+class ValidationError(WorqhatError):
+    """Raised when request validation fails."""
+
+    pass
+
+
+class NotFoundError(WorqhatError):
+    """Raised when a resource is not found."""
+
+    pass
+
+
+class RateLimitError(WorqhatError):
+    """Raised when rate limit is exceeded."""
+
+    pass

worqhat/http_client.py

@@ -0,0 +1,171 @@
+"""HTTP client for making requests to the Worqhat API."""
+
+import os
+from typing import Optional, Dict, Any, Union
+import requests
+
+from .exceptions import APIError, AuthenticationError, NotFoundError, RateLimitError
+
+
+class HTTPClient:
+    """HTTP client for the Worqhat API."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = "https://api.worqhat.app",
+        target: Optional[str] = None,
+        timeout: int = 60,
+    ):
+        """
+        Initialize the HTTP client.
+
+        Args:
+            api_key: API key for authentication. Defaults to WORQHAT_API_KEY environment variable.
+            base_url: Base URL for the API.
+            target: Backend target ('app' or 'fyi').
+            timeout: Request timeout in seconds.
+        """
+        self.api_key = api_key or os.environ.get("WORQHAT_API_KEY")
+        if not self.api_key:
+            raise AuthenticationError(
+                "API key is required. Provide it via api_key parameter or WORQHAT_API_KEY environment variable."
+            )
+
+        self.base_url = base_url.rstrip("/")
+        self.target = target
+        self.timeout = timeout
+        self.session = requests.Session()
+
+        # Set default headers
+        self.session.headers.update(
+            {
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+            }
+        )
+
+        # Add target header if specified
+        if self.target:
+            self.session.headers["x-worqhat-target"] = self.target
+
+    def _handle_error(self, response: requests.Response) -> None:
+        """Handle error responses from the API."""
+        try:
+            error_data = response.json()
+            error_message = error_data.get("message", response.text)
+            error_code = response.status_code
+        except ValueError:
+            error_message = response.text
+            error_code = response.status_code
+
+        if response.status_code == 401:
+            raise AuthenticationError(error_message, code=error_code)
+        elif response.status_code == 404:
+            raise NotFoundError(error_message, code=error_code)
+        elif response.status_code == 429:
+            raise RateLimitError(error_message, code=error_code)
+        else:
+            raise APIError(error_message, code=error_code)
+
+    def get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Make a GET request.
+
+        Args:
+            path: API endpoint path.
+            params: Query parameters.
+
+        Returns:
+            Response data as a dictionary.
+        """
+        url = f"{self.base_url}{path}"
+        response = self.session.get(url, params=params, timeout=self.timeout)
+
+        if not response.ok:
+            self._handle_error(response)
+
+        return response.json()
+
+    def post(
+        self,
+        path: str,
+        json: Optional[Dict[str, Any]] = None,
+        data: Optional[Any] = None,
+        files: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Make a POST request.
+
+        Args:
+            path: API endpoint path.
+            json: JSON data to send.
+            data: Form data to send.
+            files: Files to upload.
+
+        Returns:
+            Response data as a dictionary.
+        """
+        url = f"{self.base_url}{path}"
+
+        # Remove Content-Type header for multipart/form-data
+        headers = {}
+        if files:
+            headers = {"Content-Type": None}
+
+        response = self.session.post(
+            url, json=json, data=data, files=files, headers=headers or None, timeout=self.timeout
+        )
+
+        if not response.ok:
+            self._handle_error(response)
+
+        return response.json()
+
+    def put(self, path: str, json: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Make a PUT request.
+
+        Args:
+            path: API endpoint path.
+            json: JSON data to send.
+
+        Returns:
+            Response data as a dictionary.
+        """
+        url = f"{self.base_url}{path}"
+        response = self.session.put(url, json=json, timeout=self.timeout)
+
+        if not response.ok:
+            self._handle_error(response)
+
+        return response.json()
+
+    def delete(self, path: str, json: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Make a DELETE request.
+
+        Args:
+            path: API endpoint path.
+            json: JSON data to send.
+
+        Returns:
+            Response data as a dictionary.
+        """
+        url = f"{self.base_url}{path}"
+        response = self.session.delete(url, json=json, timeout=self.timeout)
+
+        if not response.ok:
+            self._handle_error(response)
+
+        return response.json()
+
+    def close(self) -> None:
+        """Close the HTTP session."""
+        self.session.close()
+
+    def __enter__(self) -> "HTTPClient":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()

worqhat/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

worqhat/resources/__init__.py

@@ -1,61 +1,7 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+"""Resources for the Worqhat SDK."""
 
-from .db import (
-    DBResource,
-    AsyncDBResource,
-    DBResourceWithRawResponse,
-    AsyncDBResourceWithRawResponse,
-    DBResourceWithStreamingResponse,
-    AsyncDBResourceWithStreamingResponse,
-)
-from .flows import (
-    FlowsResource,
-    AsyncFlowsResource,
-    FlowsResourceWithRawResponse,
-    AsyncFlowsResourceWithRawResponse,
-    FlowsResourceWithStreamingResponse,
-    AsyncFlowsResourceWithStreamingResponse,
-)
-from .health import (
-    HealthResource,
-    AsyncHealthResource,
-    HealthResourceWithRawResponse,
-    AsyncHealthResourceWithRawResponse,
-    HealthResourceWithStreamingResponse,
-    AsyncHealthResourceWithStreamingResponse,
-)
-from .storage import (
-    StorageResource,
-    AsyncStorageResource,
-    StorageResourceWithRawResponse,
-    AsyncStorageResourceWithRawResponse,
-    StorageResourceWithStreamingResponse,
-    AsyncStorageResourceWithStreamingResponse,
-)
+from .database import DatabaseResource
+from .flows import FlowsResource
+from .storage import StorageResource
 
-__all__ = [
-    "DBResource",
-    "AsyncDBResource",
-    "DBResourceWithRawResponse",
-    "AsyncDBResourceWithRawResponse",
-    "DBResourceWithStreamingResponse",
-    "AsyncDBResourceWithStreamingResponse",
-    "HealthResource",
-    "AsyncHealthResource",
-    "HealthResourceWithRawResponse",
-    "AsyncHealthResourceWithRawResponse",
-    "HealthResourceWithStreamingResponse",
-    "AsyncHealthResourceWithStreamingResponse",
-    "FlowsResource",
-    "AsyncFlowsResource",
-    "FlowsResourceWithRawResponse",
-    "AsyncFlowsResourceWithRawResponse",
-    "FlowsResourceWithStreamingResponse",
-    "AsyncFlowsResourceWithStreamingResponse",
-    "StorageResource",
-    "AsyncStorageResource",
-    "StorageResourceWithRawResponse",
-    "AsyncStorageResourceWithRawResponse",
-    "StorageResourceWithStreamingResponse",
-    "AsyncStorageResourceWithStreamingResponse",
-]
+__all__ = ["DatabaseResource", "FlowsResource", "StorageResource"]