superwise-api 4.13.2__tar.gz → 4.15.0__tar.gz

{superwise_api-4.13.2 → superwise_api-4.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: superwise-api
-Version: 4.13.2
+Version: 4.15.0
 Summary: Superwise SDK for Python
 License: MIT
 Keywords: OpenAPI,SuperwiseSDK
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: Pillow (>=10.0.0,<11.0.0)
 Requires-Dist: aenum (>=3.1.11)
 Requires-Dist: pydantic (>=2.10.4,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.7.0,<3.0.0)

{superwise_api-4.13.2 → superwise_api-4.15.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 packages = [{ include = "superwise_api", from = "." }]
-version = "4.13.2"
+version = "4.15.0"
 include = ["superwise_api/client/py.typed"]
 
 [tool.poetry.dependencies]
@@ -10,6 +10,7 @@ pydantic = "^2.10.4"
 aenum = ">=3.1.11"
 requests = "^2.32.0"
 pydantic-settings = "^2.7.0"
+Pillow = "^10.0.0"
 
 
 [tool.poetry.group.dev.dependencies]

{superwise_api-4.13.2 → superwise_api-4.15.0}/superwise_api/client/api_client.py

@@ -18,7 +18,9 @@ from superwise_api.client.configuration import Configuration
 from superwise_api.client.exceptions import ApiException
 from superwise_api.client.exceptions import ApiTypeError
 from superwise_api.client.exceptions import ApiValueError
+from superwise_api.client.exceptions import StreamingError
 from superwise_api.client.models.page import Page
+from superwise_api.models.agent.playground import StreamEventType
 
 
 class ApiClient:
@@ -1145,6 +1147,75 @@ class ApiClient:
             _request_auth=_params.get("_request_auth"),
         )
 
+    def post_stream(
+        self,
+        resource_path: str,
+        response_model,
+        data: Optional[dict] = None,
+        **kwargs,
+    ):
+        """Performs a streaming POST request and yields parsed response objects.
+
+        :param resource_path: Path to method endpoint.
+        :param response_model: Model class to deserialize each line to.
+        :param data: Request body data.
+        :param kwargs: Additional arguments (_headers, _request_timeout, _request_auth).
+        :yields: Parsed response_model instances.
+        :raises StreamingError: If an error event is received in the stream.
+        """
+        _params = kwargs
+
+        # Process header parameters
+        _header_params = dict(_params.get("_headers", {}))
+        _header_params.update(self.default_headers)
+        if self.cookie:
+            _header_params["Cookie"] = self.cookie
+        _header_params = self.sanitize_for_serialization(_header_params)
+        _header_params = dict(self.parameters_to_tuples(_header_params, {}))
+
+        # Set content type and accept headers
+        _header_params["Accept"] = "application/x-ndjson"
+        _header_params["Content-Type"] = "application/json"
+
+        # Handle authentication
+        _request_auth = _params.get("_request_auth")
+        auth_settings = ["implicit"]
+        self.update_params_for_auth(
+            _header_params, [], auth_settings, resource_path, "POST", data, request_auth=_request_auth
+        )
+
+        # Sanitize body
+        if data:
+            data = self.sanitize_for_serialization(data)
+
+        # Build URL
+        url = self.configuration.host + resource_path
+
+        # Make streaming request
+        streaming_response = self.rest_client.post_stream(
+            url,
+            headers=_header_params,
+            body=data,
+            _request_timeout=_params.get("_request_timeout"),
+        )
+
+        try:
+            for line in streaming_response.iter_lines():
+                try:
+                    parsed = json.loads(line)
+                    response_obj = response_model.from_dict(parsed)
+
+                    # Raise exception for error events
+                    if response_obj.event == StreamEventType.ERROR:
+                        raise StreamingError(response_obj.text)
+
+                    yield response_obj
+                except json.JSONDecodeError:
+                    # Skip malformed lines
+                    continue
+        finally:
+            streaming_response.release_conn()
+
     def get(
         self,
         resource_path: str,

{superwise_api-4.13.2 → superwise_api-4.15.0}/superwise_api/client/exceptions.py

@@ -134,6 +134,17 @@ class ServiceException(ApiException):
         super(ServiceException, self).__init__(status, reason, http_resp)
 
 
+class StreamingError(OpenApiException):
+    """Exception raised when a streaming response contains an error event."""
+
+    def __init__(self, message: str) -> None:
+        self.message = message
+        super().__init__(message)
+
+    def __str__(self):
+        return f"Streaming error: {self.message}"
+
+
 def render_path(path_to_item):
     """Returns a string representation of a path"""
     result = ""

{superwise_api-4.13.2 → superwise_api-4.15.0}/superwise_api/client/rest.py

@@ -46,6 +46,33 @@ class RESTResponse(io.IOBase):
         return self.urllib3_response.headers.get(name, default)
 
 
+class StreamingRESTResponse:
+    """A streaming response wrapper that yields lines from NDJSON responses."""
+
+    def __init__(self, resp) -> None:
+        self.urllib3_response = resp
+        self.status = resp.status
+        self.reason = resp.reason
+
+    def iter_lines(self):
+        """Iterate over response lines for NDJSON streaming."""
+        buffer = b""
+        for chunk in self.urllib3_response.stream(amt=1024):
+            buffer += chunk
+            while b"\n" in buffer:
+                line, buffer = buffer.split(b"\n", 1)
+                line = line.strip()
+                if line:
+                    yield line.decode("utf-8")
+        # Handle any remaining data in buffer
+        if buffer.strip():
+            yield buffer.strip().decode("utf-8")
+
+    def release_conn(self):
+        """Release the connection back to the pool."""
+        self.urllib3_response.release_conn()
+
+
 class RESTClientObject:
     def __init__(self, configuration, pools_size=4, maxsize=None) -> None:
         # urllib3.PoolManager will pass all kw parameters to connectionpool
@@ -371,3 +398,64 @@ class RESTClientObject:
             _request_timeout=_request_timeout,
             body=body,
         )
+
+    def post_stream(
+        self,
+        url,
+        headers=None,
+        body=None,
+        _request_timeout=None,
+    ):
+        """Perform a streaming POST request.
+
+        :param url: http request url
+        :param headers: http request headers
+        :param body: request json body
+        :param _request_timeout: timeout setting for this request
+        :return: StreamingRESTResponse object for iterating over lines
+        """
+        headers = headers or {}
+
+        timeout = None
+        if _request_timeout:
+            if isinstance(_request_timeout, (int, float)):
+                timeout = urllib3.Timeout(total=_request_timeout)
+            elif isinstance(_request_timeout, tuple) and len(_request_timeout) == 2:
+                timeout = urllib3.Timeout(connect=_request_timeout[0], read=_request_timeout[1])
+
+        try:
+            request_body = None
+            if body is not None:
+                request_body = json.dumps(body)
+
+            r = self.pool_manager.request(
+                "POST",
+                url,
+                body=request_body,
+                preload_content=False,
+                timeout=timeout,
+                headers=headers,
+            )
+        except urllib3.exceptions.SSLError as e:
+            msg = "{0}\n{1}".format(type(e).__name__, str(e))
+            raise ApiException(status=0, reason=msg)
+
+        if not 200 <= r.status <= 299:
+            # Read the error response body and wrap in RESTResponse
+            r._body = r.read()
+            r.release_conn()
+            rest_response = RESTResponse(r)
+
+            if r.status == 400:
+                raise BadRequestException(http_resp=rest_response)
+            if r.status == 401:
+                raise UnauthorizedException(http_resp=rest_response)
+            if r.status == 403:
+                raise ForbiddenException(http_resp=rest_response)
+            if r.status == 404:
+                raise NotFoundException(http_resp=rest_response)
+            if 500 <= r.status <= 599:
+                raise ServiceException(http_resp=rest_response)
+            raise ApiException(http_resp=rest_response)
+
+        return StreamingRESTResponse(r)

{superwise_api-4.13.2 → superwise_api-4.15.0}/superwise_api/entities/agent.py

@@ -1,25 +1,24 @@
+from typing import Iterator
 from typing import Optional
 from typing import Sequence
-from typing import Any
-from typing import Literal
 
 from pydantic import conint
 
 from superwise_api.client.api_client import ApiClient
 from superwise_api.client.models.page import Page
-from superwise_api.entities.base import BaseApi
-from superwise_api.models.agent.agent import AgentConfig, Version, ExtendedAgent
+from superwise_api.entities.base import BaseApi, CoreEntitiyApi
+from superwise_api.models.agent.agent import AgentConfig, Version, GuardrailConfig
 from superwise_api.models.agent.agent import Agent
 from superwise_api.models.agent.agent import ModelLLM
 from superwise_api.models.agent.agent import ToolDef
 from superwise_api.models.agent.flowise import FlowiseCredentialUserInput
 from superwise_api.models.agent.playground import AskResponsePayload
+from superwise_api.models.agent.playground import StreamedResponse
 from superwise_api.models.dataset.dataset import Dataset
 from superwise_api.models.agent.feedback import EventFeedbackData
-from superwise_api.models.utils import SearchParams
 
 
-class AgentApi(BaseApi):
+class AgentApi(CoreEntitiyApi):
     """
     This class provides methods to interact with the Agent API.
 
@@ -49,7 +48,6 @@ class AgentApi(BaseApi):
         description: str = None,
         authentication_enabled: bool = False,
         observability_enabled: bool = True,
-        block_guardrails_violations: bool = True,
         guardrails_violation_message: str | None = None,
         **kwargs,
     ) -> Agent:
@@ -70,7 +68,6 @@ class AgentApi(BaseApi):
             "name": name,
             "authentication_enabled": authentication_enabled,
             "observability_enabled": observability_enabled,
-            "block_guardrails_violations": block_guardrails_violations,
         }
         if description:
             payload["description"] = description
@@ -89,7 +86,7 @@ class AgentApi(BaseApi):
         agent_id: str,
         name: str,
         agent_config: AgentConfig,
-        guardrails: list[str] = None,
+        guardrails: list[GuardrailConfig] | list[str] = None,
         description: str = None,
         **kwargs,
     ) -> Version:
@@ -101,16 +98,21 @@ class AgentApi(BaseApi):
             name (str): The name of the version.
             description (str): The version's description.
             agent_config (AgentConfig): agent configuration for this version.
-            guardrails: set(str): set of guardrails ids to apply to this version.
+            guardrails: list(GuardrailConfig): list of guardrails ids and blocking configuration.
 
         Returns:
             Version: The created version.
         """
 
+        processed_guardrails = [
+            GuardrailConfig(id=guardrail) if not isinstance(guardrail, GuardrailConfig) else guardrail
+            for guardrail in (guardrails or [])
+        ]
+
         payload = {
             "name": name,
             "agent_config": agent_config,
-            "guardrails": guardrails if guardrails else [],
+            "guardrails": [guardrail.model_dump() for guardrail in processed_guardrails],
         }
         if description:
             payload["description"] = description
@@ -129,7 +131,6 @@ class AgentApi(BaseApi):
         description: str | None = None,
         authentication_enabled: bool | None = None,
         observability_enabled: bool | None = None,
-        block_guardrails_violations: bool | None = None,
         guardrails_violation_message: str | None = None,
         dataset_id: str | None = None,
         **kwargs,
@@ -143,7 +144,6 @@ class AgentApi(BaseApi):
             description (str, optional): Description for the agent.
             authentication_enabled (bool, optional): Whether the agent requires an api token for access or not.
             observability_enabled (bool, optional): Whether the agent logs conversation to the db or not.
-            block_guardrails_violations (bool, optional): Whether to block guardrails violations.
             guardrails_violation_message (str, optional): The message to show when guardrails are violated.
             dataset_id (str, optional): The id of the dataset to associate with the agent.
 
@@ -156,7 +156,6 @@ class AgentApi(BaseApi):
             "description": description,
             "authentication_enabled": authentication_enabled,
             "observability_enabled": observability_enabled,
-            "block_guardrails_violations": block_guardrails_violations,
             "guardrails_violation_message": guardrails_violation_message,
             "dataset_id": dataset_id,
         }
@@ -398,6 +397,80 @@ class AgentApi(BaseApi):
             **kwargs,
         )
 
+    def ask_playground_stream(
+        self,
+        input: str,
+        agent_config: AgentConfig,
+        chat_history: Optional[Sequence[dict]] = None,
+        guardrails: Optional[list[str]] = None,
+        **kwargs,
+    ) -> Iterator[StreamedResponse]:
+        """
+        Performs streaming ask request in playground mode.
+
+        Args:
+            input (str): The input to the model.
+            agent_config (AgentConfig): The type of the agent and connected tools/context.
+            chat_history (Sequence[dict], optional): The chat history.
+            guardrails (list[str], optional): List of guardrail IDs to apply.
+
+        Yields:
+            StreamedResponse: Individual streaming events (system, guardrails, llm, tool, response).
+
+        Raises:
+            StreamingError: If an error event is received in the stream.
+        """
+        payload = {
+            "config": agent_config,
+            "input": input,
+            "chat_history": chat_history or [],
+        }
+        if guardrails:
+            payload["guardrails"] = guardrails
+        return self.api_client.post_stream(
+            resource_path=self._playground_resource_path + "/ask/stream",
+            response_model=StreamedResponse,
+            data=payload,
+            **kwargs,
+        )
+
+    def ask_worker_stream(
+        self,
+        agent_id: str,
+        input: str,
+        api_token: str | None = None,
+        chat_history: Optional[Sequence[dict]] = None,
+        context_id: str | None = None,
+        metadata: dict | None = None,
+        **kwargs,
+    ) -> Iterator[StreamedResponse]:
+        """
+        Performs streaming ask request to the specified worker.
+
+        Args:
+            agent_id (str): The agent asked.
+            input (str): The input to the model.
+            api_token (str): The API token of the agent.
+            chat_history (Sequence[dict], optional): The chat history.
+            context_id (str, optional): The context ID for the conversation.
+            metadata (dict, optional): Additional metadata.
+
+        Yields:
+            StreamedResponse: Individual streaming events (system, guardrails, llm, tool, response).
+
+        Raises:
+            StreamingError: If an error event is received in the stream.
+        """
+        payload = {"input": input, "chat_history": chat_history or [], "context_id": context_id, "metadata": metadata}
+        headers = {"x-api-token": api_token} if api_token else {}
+        return self.api_client.post_stream(
+            resource_path=f"/v1/app-worker/{agent_id}/v1/ask/stream",
+            response_model=StreamedResponse,
+            data=payload,
+            _headers=headers,
+            **kwargs,
+        )
+
     def get_flowise_credential_schema(self, url: str, api_key: str, flow_id, **kwargs) -> FlowiseCredentialUserInput:
         """
         Get credential schema.
@@ -527,87 +600,5 @@ class AgentApi(BaseApi):
             **kwargs,
         )
 
-    def add_tags(
-        self,
-        agent_id: str,
-        tag_ids: list[str],
-        **kwargs,
-    ):
-        """
-        Add tags to an agent.
-
-        Args:
-            agent_id (str): The id of the agent.
-            tag_ids list(str): List of tag ids to add the agent
-        Returns:
-            None
-        """
-        return self.api_client.post(
-            resource_path=self._resource_path + f"/{agent_id}/tags",
-            data=tag_ids,
-            **kwargs,
-        )
-
-    def remove_tags(
-        self,
-        agent_id: str,
-        tag_ids: list[str],
-        **kwargs,
-    ):
-        """
-        Delete tags from an agent.
-
-        Args:
-            agent_id (str): The id of the agent.
-            tag_ids list(str): List of tag ids to remove from the agent
-        Returns:
-            None
-        """
-        return self.api_client.delete(
-            resource_path=self._resource_path + "/{agent_id}/tags",
-            model_name=self._model_name,
-            entity_id=agent_id,
-            path_params={"agent_id": agent_id},
-            query_params=[("ids", id) for id in tag_ids],
-            **kwargs,
-        )
-
-    def search(
-        self,
-        filters: list[Any] | None = None,
-        search: str | None = None,
-        sort_by: str | None = None,
-        sort_direction: Literal["asc", "desc"] = "desc",
-        **kwargs,
-    ) -> Page:
-        """
-        Searches for agents based on a prefix.
-
-        Args:
-            filters (list[Any]): Filter on db columns, list of tuples.
-                e.g. [[["id", "eq", "5c05dc9f-f04a-4ce8-9d57-2ec63ee76aac"], "and", ["description", "ilike", "Construction"]], "or", ["name", "ilike", "active"]]
-            search (str): Free text search on searchable fields
-            sort_by (str): Field to sort by
-            sort_direction (Literal["asc", "desc"]): Sort direction (ascending or descending)
-            query_params can be passed as part of the kwargs for pagination
-
-        Returns:
-            Page: A page of enriched agents.
-        """
-        data = SearchParams(
-            filters=filters,
-            search=search,
-            sort_by=sort_by,
-            sort_direction=sort_direction,
-        ).model_dump(exclude_none=True)
-        response_types_map = {
-            "200": Page.set_model(ExtendedAgent),
-            "422": None,
-            "500": None,
-        }
-        return self.api_client.post(
-            resource_path="/v1/enriched-agents/search",
-            data=data,
-            response_types_map=response_types_map,
-            **kwargs,
-        )
+    def unpublish(self, agent_id: str, **kwargs):
+        return self.api_client.post(f"{self._resource_path}/{agent_id}/unpublish", **kwargs)