hiddenlayer-sdk 2.0.9__py3-none-any.whl → 3.0.0__py3-none-any.whl

hiddenlayer/lib/scan_utils.py

@@ -0,0 +1,142 @@
+"""
+Shared utilities for scan functionality across different scanner types.
+
+This module provides common retry logic for handling scan retrieval operations
+that may initially return 404 errors due to timing issues.
+"""
+
+import time
+import random
+import asyncio
+import logging
+from typing import TYPE_CHECKING
+
+from .._exceptions import NotFoundError
+
+if TYPE_CHECKING:
+    from .. import HiddenLayer, AsyncHiddenLayer
+    from ..types.scans import ScanReport
+
+logger = logging.getLogger(__name__)
+
+
+class ScanStatus:
+    """Scan status constants."""
+
+    DONE = "done"
+    FAILED = "failed"
+    PENDING = "pending"
+    RUNNING = "running"
+    CANCELED = "canceled"
+
+
+def get_scan_results(client: "HiddenLayer", *, scan_id: str) -> "ScanReport":
+    """
+    Get scan results with retry logic for 404 errors.
+
+    Used when wait_for_results=False to handle initial scan availability.
+    """
+    retries = 0
+    max_retries = 5  # Fewer retries since we're not waiting for completion
+    base_delay = 0.5  # Slightly longer base delay
+
+    while retries < max_retries:
+        try:
+            return client.scans.jobs.retrieve(scan_id)
+        except NotFoundError:
+            retries += 1
+            if retries >= max_retries:
+                logger.error(f"Scan {scan_id} not found after {max_retries} attempts")
+                raise
+
+            delay = base_delay * retries + random.uniform(0, 0.5)
+            logger.info(f"Scan not yet available, retrying in {delay:.1f}s (attempt {retries + 1}/{max_retries})")
+            time.sleep(delay)
+
+    # Should never reach here due to raise above, but satisfy linter
+    raise RuntimeError(f"Scan {scan_id} not found after {max_retries} attempts")
+
+
+def wait_for_scan_results(client: "HiddenLayer", *, scan_id: str) -> "ScanReport":
+    """
+    Wait for scan results using exponential backoff polling.
+
+    Handles initial 404 errors when scan is not immediately available.
+    """
+    base_delay = 0.1  # seconds
+    retries = 0
+    scan_results = None
+
+    while True:
+        try:
+            scan_results = client.scans.jobs.retrieve(scan_id)
+            # If we got here, scan exists - check if it's done
+            if scan_results.status in [ScanStatus.DONE, ScanStatus.FAILED, ScanStatus.CANCELED]:
+                break
+            logger.info(f"scan status: {scan_results.status}")
+        except NotFoundError:
+            # Scan not found yet, treat it like any other retry condition
+            logger.info(f"scan not found yet, retrying...")
+
+        retries += 1
+        delay = base_delay * 2**retries + random.uniform(0, 1)  # exponential back off retry
+        delay = min(delay, 30)  # cap at 30 seconds
+        time.sleep(delay)
+
+    return scan_results
+
+
+async def get_scan_results_async(client: "AsyncHiddenLayer", *, scan_id: str) -> "ScanReport":
+    """
+    Async version of get_scan_results with retry logic for 404 errors.
+
+    Used when wait_for_results=False to handle initial scan availability.
+    """
+    retries = 0
+    max_retries = 5  # Fewer retries since we're not waiting for completion
+    base_delay = 0.5  # Slightly longer base delay
+
+    while retries < max_retries:
+        try:
+            return await client.scans.jobs.retrieve(scan_id)
+        except NotFoundError:
+            retries += 1
+            if retries >= max_retries:
+                logger.error(f"Scan {scan_id} not found after {max_retries} attempts")
+                raise
+
+            delay = base_delay * retries + random.uniform(0, 0.5)
+            logger.info(f"Scan not yet available, retrying in {delay:.1f}s (attempt {retries + 1}/{max_retries})")
+            await asyncio.sleep(delay)
+
+    # Should never reach here due to raise above, but satisfy linter
+    raise RuntimeError(f"Scan {scan_id} not found after {max_retries} attempts")
+
+
+async def wait_for_scan_results_async(client: "AsyncHiddenLayer", *, scan_id: str) -> "ScanReport":
+    """
+    Async version of wait_for_scan_results.
+
+    Handles initial 404 errors when scan is not immediately available.
+    """
+    base_delay = 0.1  # seconds
+    retries = 0
+    scan_results = None
+
+    while True:
+        try:
+            scan_results = await client.scans.jobs.retrieve(scan_id)
+            # If we got here, scan exists - check if it's done
+            if scan_results.status in [ScanStatus.DONE, ScanStatus.FAILED, ScanStatus.CANCELED]:
+                break
+            logger.info(f"scan status: {scan_results.status}")
+        except NotFoundError:
+            # Scan not found yet, treat it like any other retry condition
+            logger.info(f"scan not found yet, retrying...")
+
+        retries += 1
+        delay = base_delay * 2**retries + random.uniform(0, 1)  # exponential back off retry
+        delay = min(delay, 30)  # cap at 30 seconds
+        await asyncio.sleep(delay)
+
+    return scan_results

hiddenlayer/pagination.py

@@ -0,0 +1,127 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Generic, TypeVar, Optional
+from typing_extensions import override
+
+from ._models import BaseModel
+from ._base_client import BasePage, PageInfo, BaseSyncPage, BaseAsyncPage
+
+__all__ = ["CursorPaginationPage", "SyncCursorPagination", "AsyncCursorPagination", "SyncOffsetPage", "AsyncOffsetPage"]
+
+_T = TypeVar("_T")
+
+
+class CursorPaginationPage(BaseModel):
+    next: Optional[str] = None
+
+    prev: Optional[str] = None
+
+
+class SyncCursorPagination(BaseSyncPage[_T], BasePage[_T], Generic[_T]):
+    items: List[_T]
+    page: Optional[CursorPaginationPage] = None
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        items = self.items
+        if not items:
+            return []
+        return items
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        next = None
+        if self.page is not None:
+            if self.page.next is not None:
+                next = self.page.next
+        if not next:
+            return None
+
+        return PageInfo(params={"cursor": next})
+
+
+class AsyncCursorPagination(BaseAsyncPage[_T], BasePage[_T], Generic[_T]):
+    items: List[_T]
+    page: Optional[CursorPaginationPage] = None
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        items = self.items
+        if not items:
+            return []
+        return items
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        next = None
+        if self.page is not None:
+            if self.page.next is not None:
+                next = self.page.next
+        if not next:
+            return None
+
+        return PageInfo(params={"cursor": next})
+
+
+class SyncOffsetPage(BaseSyncPage[_T], BasePage[_T], Generic[_T]):
+    results: List[_T]
+    total_count: Optional[int] = None
+    page_size: Optional[int] = None
+    page_number: Optional[int] = None
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        results = self.results
+        if not results:
+            return []
+        return results
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        offset = self._options.params.get("offset") or 0
+        if not isinstance(offset, int):
+            raise ValueError(f'Expected "offset" param to be an integer but got {offset}')
+
+        length = len(self._get_page_items())
+        current_count = offset + length
+
+        total_count = self.total_count
+        if total_count is None:
+            return None
+
+        if current_count < total_count:
+            return PageInfo(params={"offset": current_count})
+
+        return None
+
+
+class AsyncOffsetPage(BaseAsyncPage[_T], BasePage[_T], Generic[_T]):
+    results: List[_T]
+    total_count: Optional[int] = None
+    page_size: Optional[int] = None
+    page_number: Optional[int] = None
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        results = self.results
+        if not results:
+            return []
+        return results
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        offset = self._options.params.get("offset") or 0
+        if not isinstance(offset, int):
+            raise ValueError(f'Expected "offset" param to be an integer but got {offset}')
+
+        length = len(self._get_page_items())
+        current_count = offset + length
+
+        total_count = self.total_count
+        if total_count is None:
+            return None
+
+        if current_count < total_count:
+            return PageInfo(params={"offset": current_count})
+
+        return None

hiddenlayer/resources/__init__.py

@@ -0,0 +1,75 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .scans import (
+    ScansResource,
+    AsyncScansResource,
+    ScansResourceWithRawResponse,
+    AsyncScansResourceWithRawResponse,
+    ScansResourceWithStreamingResponse,
+    AsyncScansResourceWithStreamingResponse,
+)
+from .models import (
+    ModelsResource,
+    AsyncModelsResource,
+    ModelsResourceWithRawResponse,
+    AsyncModelsResourceWithRawResponse,
+    ModelsResourceWithStreamingResponse,
+    AsyncModelsResourceWithStreamingResponse,
+)
+from .sensors import (
+    SensorsResource,
+    AsyncSensorsResource,
+    SensorsResourceWithRawResponse,
+    AsyncSensorsResourceWithRawResponse,
+    SensorsResourceWithStreamingResponse,
+    AsyncSensorsResourceWithStreamingResponse,
+)
+from .interactions import (
+    InteractionsResource,
+    AsyncInteractionsResource,
+    InteractionsResourceWithRawResponse,
+    AsyncInteractionsResourceWithRawResponse,
+    InteractionsResourceWithStreamingResponse,
+    AsyncInteractionsResourceWithStreamingResponse,
+)
+from .prompt_analyzer import (
+    PromptAnalyzerResource,
+    AsyncPromptAnalyzerResource,
+    PromptAnalyzerResourceWithRawResponse,
+    AsyncPromptAnalyzerResourceWithRawResponse,
+    PromptAnalyzerResourceWithStreamingResponse,
+    AsyncPromptAnalyzerResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "ModelsResource",
+    "AsyncModelsResource",
+    "ModelsResourceWithRawResponse",
+    "AsyncModelsResourceWithRawResponse",
+    "ModelsResourceWithStreamingResponse",
+    "AsyncModelsResourceWithStreamingResponse",
+    "PromptAnalyzerResource",
+    "AsyncPromptAnalyzerResource",
+    "PromptAnalyzerResourceWithRawResponse",
+    "AsyncPromptAnalyzerResourceWithRawResponse",
+    "PromptAnalyzerResourceWithStreamingResponse",
+    "AsyncPromptAnalyzerResourceWithStreamingResponse",
+    "InteractionsResource",
+    "AsyncInteractionsResource",
+    "InteractionsResourceWithRawResponse",
+    "AsyncInteractionsResourceWithRawResponse",
+    "InteractionsResourceWithStreamingResponse",
+    "AsyncInteractionsResourceWithStreamingResponse",
+    "SensorsResource",
+    "AsyncSensorsResource",
+    "SensorsResourceWithRawResponse",
+    "AsyncSensorsResourceWithRawResponse",
+    "SensorsResourceWithStreamingResponse",
+    "AsyncSensorsResourceWithStreamingResponse",
+    "ScansResource",
+    "AsyncScansResource",
+    "ScansResourceWithRawResponse",
+    "AsyncScansResourceWithRawResponse",
+    "ScansResourceWithStreamingResponse",
+    "AsyncScansResourceWithStreamingResponse",
+]

hiddenlayer/resources/interactions.py

@@ -0,0 +1,205 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..types import interaction_analyze_params
+from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from .._utils import maybe_transform, strip_not_given, async_maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .._base_client import make_request_options
+from ..types.interaction_analyze_response import InteractionAnalyzeResponse
+
+__all__ = ["InteractionsResource", "AsyncInteractionsResource"]
+
+
+class InteractionsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> InteractionsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/hiddenlayerai/hiddenlayer-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return InteractionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> InteractionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/hiddenlayerai/hiddenlayer-sdk-python#with_streaming_response
+        """
+        return InteractionsResourceWithStreamingResponse(self)
+
+    def analyze(
+        self,
+        *,
+        metadata: interaction_analyze_params.Metadata,
+        input: interaction_analyze_params.Input | Omit = omit,
+        output: interaction_analyze_params.Output | Omit = omit,
+        hl_project_id: str | Omit = omit,
+        x_correlation_id: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> InteractionAnalyzeResponse:
+        """
+        Performs a detailed security analysis of the input and/or output of LLM
+        interactions.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "HL-Project-Id": hl_project_id,
+                    "X-Correlation-Id": x_correlation_id,
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        return self._post(
+            "/detection/v1/interactions",
+            body=maybe_transform(
+                {
+                    "metadata": metadata,
+                    "input": input,
+                    "output": output,
+                },
+                interaction_analyze_params.InteractionAnalyzeParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=InteractionAnalyzeResponse,
+        )
+
+
+class AsyncInteractionsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncInteractionsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/hiddenlayerai/hiddenlayer-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncInteractionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncInteractionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/hiddenlayerai/hiddenlayer-sdk-python#with_streaming_response
+        """
+        return AsyncInteractionsResourceWithStreamingResponse(self)
+
+    async def analyze(
+        self,
+        *,
+        metadata: interaction_analyze_params.Metadata,
+        input: interaction_analyze_params.Input | Omit = omit,
+        output: interaction_analyze_params.Output | Omit = omit,
+        hl_project_id: str | Omit = omit,
+        x_correlation_id: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> InteractionAnalyzeResponse:
+        """
+        Performs a detailed security analysis of the input and/or output of LLM
+        interactions.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "HL-Project-Id": hl_project_id,
+                    "X-Correlation-Id": x_correlation_id,
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        return await self._post(
+            "/detection/v1/interactions",
+            body=await async_maybe_transform(
+                {
+                    "metadata": metadata,
+                    "input": input,
+                    "output": output,
+                },
+                interaction_analyze_params.InteractionAnalyzeParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=InteractionAnalyzeResponse,
+        )
+
+
+class InteractionsResourceWithRawResponse:
+    def __init__(self, interactions: InteractionsResource) -> None:
+        self._interactions = interactions
+
+        self.analyze = to_raw_response_wrapper(
+            interactions.analyze,
+        )
+
+
+class AsyncInteractionsResourceWithRawResponse:
+    def __init__(self, interactions: AsyncInteractionsResource) -> None:
+        self._interactions = interactions
+
+        self.analyze = async_to_raw_response_wrapper(
+            interactions.analyze,
+        )
+
+
+class InteractionsResourceWithStreamingResponse:
+    def __init__(self, interactions: InteractionsResource) -> None:
+        self._interactions = interactions
+
+        self.analyze = to_streamed_response_wrapper(
+            interactions.analyze,
+        )
+
+
+class AsyncInteractionsResourceWithStreamingResponse:
+    def __init__(self, interactions: AsyncInteractionsResource) -> None:
+        self._interactions = interactions
+
+        self.analyze = async_to_streamed_response_wrapper(
+            interactions.analyze,
+        )

hiddenlayer/resources/models/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .cards import (
+    CardsResource,
+    AsyncCardsResource,
+    CardsResourceWithRawResponse,
+    AsyncCardsResourceWithRawResponse,
+    CardsResourceWithStreamingResponse,
+    AsyncCardsResourceWithStreamingResponse,
+)
+from .models import (
+    ModelsResource,
+    AsyncModelsResource,
+    ModelsResourceWithRawResponse,
+    AsyncModelsResourceWithRawResponse,
+    ModelsResourceWithStreamingResponse,
+    AsyncModelsResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "CardsResource",
+    "AsyncCardsResource",
+    "CardsResourceWithRawResponse",
+    "AsyncCardsResourceWithRawResponse",
+    "CardsResourceWithStreamingResponse",
+    "AsyncCardsResourceWithStreamingResponse",
+    "ModelsResource",
+    "AsyncModelsResource",
+    "ModelsResourceWithRawResponse",
+    "AsyncModelsResourceWithRawResponse",
+    "ModelsResourceWithStreamingResponse",
+    "AsyncModelsResourceWithStreamingResponse",
+]