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

hiddenlayer/types/prompt_analyzer_create_response.py

@@ -0,0 +1,381 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = [
+    "PromptAnalyzerCreateResponse",
+    "Categories",
+    "Frameworks",
+    "FrameworksMitre",
+    "FrameworksOwasp",
+    "FrameworksOwasp2025",
+    "Policy",
+    "Response",
+    "Results",
+    "ResultsGuardrailResults",
+    "ResultsGuardrailResultsRefusalClassifierResults",
+    "ResultsInputBlockListResults",
+    "ResultsInputCodeResults",
+    "ResultsInputDosResults",
+    "ResultsInputLanguageResults",
+    "ResultsInputPiiResults",
+    "ResultsInputURLResults",
+    "ResultsOutputCodeResults",
+    "ResultsOutputPiiResults",
+    "ResultsOutputURLResults",
+    "ResultsPromptInjectionClassifierResult",
+]
+
+
+class Categories(BaseModel):
+    guardrail: Optional[bool] = None
+    """The input activated the upstream guardrails"""
+
+    input_code: Optional[bool] = None
+    """The input contains code"""
+
+    input_dos: Optional[bool] = None
+    """The input contains a denial of service attack"""
+
+    input_language: Optional[bool] = None
+    """The input contains a disallowed language"""
+
+    input_pii: Optional[bool] = None
+    """The input contains personally identifiable information"""
+
+    output_code: Optional[bool] = None
+    """The output contains code"""
+
+    output_pii: Optional[bool] = None
+    """The output contains personally identifiable information"""
+
+    prompt_injection: Optional[bool] = None
+    """The input contains prompt injection"""
+
+    unsafe_input: Optional[bool] = None
+    """The input is unsafe"""
+
+    unsafe_output: Optional[bool] = None
+    """The output is unsafe"""
+
+
+class FrameworksMitre(BaseModel):
+    label: Optional[str] = None
+    """The label of the MITRE Atlas framework label"""
+
+    name: Optional[str] = None
+    """The name of the MITRE Atlas framework label"""
+
+
+class FrameworksOwasp(BaseModel):
+    label: Optional[str] = None
+    """The label of the OWASP framework label"""
+
+    name: Optional[str] = None
+    """The name of the OWASP framework label"""
+
+
+class FrameworksOwasp2025(BaseModel):
+    label: Optional[str] = None
+    """The label of the OWASP:2025 framework label"""
+
+    name: Optional[str] = None
+    """The name of the OWASP:2025 framework label"""
+
+
+class Frameworks(BaseModel):
+    mitre: Optional[List[FrameworksMitre]] = None
+
+    owasp: Optional[List[FrameworksOwasp]] = None
+
+    owasp_2025: Optional[List[FrameworksOwasp2025]] = FieldInfo(alias="owasp:2025", default=None)
+
+
+class Policy(BaseModel):
+    block_guardrail_detection: Optional[bool] = None
+    """Block guardrail detection"""
+
+    block_input_code_detection: Optional[bool] = None
+    """Block input code detection"""
+
+    block_input_dos_detection: Optional[bool] = None
+    """Block input denial of service detection"""
+
+    block_input_pii: Optional[bool] = None
+    """Block input personally identifiable information"""
+
+    block_output_code_detection: Optional[bool] = None
+    """Block output code detection"""
+
+    block_output_pii: Optional[bool] = None
+    """Block output personally identifiable information"""
+
+    block_prompt_injection: Optional[bool] = None
+    """Block prompt injection"""
+
+    block_unsafe: Optional[bool] = None
+    """Block unsafe input and output"""
+
+    block_unsafe_input: Optional[bool] = None
+    """Block unsafe input"""
+
+    block_unsafe_output: Optional[bool] = None
+    """Block unsafe output"""
+
+    entity_type: Optional[Literal["strict", "all"]] = None
+    """The type of entity to redact"""
+
+    input_dos_detection_threshold: Optional[float] = None
+    """The threshold for input denial of service detection"""
+
+    prompt_injection_scan_type: Optional[Literal["quick", "full"]] = None
+    """The type of prompt injection scan to use"""
+
+    redact_input_pii: Optional[bool] = None
+    """Redact input personally identifiable information"""
+
+    redact_output_pii: Optional[bool] = None
+    """Redact output personally identifiable information"""
+
+    redact_type: Optional[Literal["entity", "strict"]] = None
+    """The type of redaction to use"""
+
+    skip_guardrail_detection: Optional[bool] = None
+    """Skip guardrail detection"""
+
+    skip_input_code_detection: Optional[bool] = None
+    """Skip input code detection"""
+
+    skip_input_dos_detection: Optional[bool] = None
+    """Skip input denial of service detection"""
+
+    skip_input_pii_detection: Optional[bool] = None
+    """Skip input personally identifiable information detection"""
+
+    skip_input_url_detection: Optional[bool] = None
+    """Skip input URL detection"""
+
+    skip_output_code_detection: Optional[bool] = None
+    """Skip output code detection"""
+
+    skip_output_pii_detection: Optional[bool] = None
+    """Skip output personally identifiable information detection"""
+
+    skip_output_url_detection: Optional[bool] = None
+    """Skip output URL detection"""
+
+    skip_prompt_injection_detection: Optional[bool] = None
+    """Skip prompt injection detection"""
+
+
+class Response(BaseModel):
+    model: Optional[str] = None
+
+    output: Optional[str] = None
+
+    prompt: Optional[str] = None
+
+    provider: Optional[str] = None
+
+    unmodified_output: Optional[str] = None
+
+    unmodified_prompt: Optional[str] = None
+
+
+class ResultsGuardrailResultsRefusalClassifierResults(BaseModel):
+    elapsed_ms: Optional[float] = None
+    """The time in milliseconds it took to process the refusal classifier"""
+
+    probabilities: Optional[List[float]] = None
+
+    verdict: Optional[bool] = None
+    """The verdict of the refusal classifier"""
+
+    version: Optional[float] = None
+    """The version of the refusal classifier"""
+
+
+class ResultsGuardrailResults(BaseModel):
+    elapsed_ms: Optional[float] = None
+    """The time in milliseconds it took to process the guardrail"""
+
+    refusal_classifier_results: Optional[ResultsGuardrailResultsRefusalClassifierResults] = None
+    """The refusal classifier results"""
+
+    verdict: Optional[bool] = None
+    """The verdict of the guardrail analysis"""
+
+
+class ResultsInputBlockListResults(BaseModel):
+    elapsed_ms: Optional[float] = None
+    """The time in milliseconds it took to process the input block list"""
+
+    matches: Optional[List[str]] = None
+
+    verdict: Optional[bool] = None
+    """The verdict of the input block list analysis"""
+
+
+class ResultsInputCodeResults(BaseModel):
+    elapsed_ms: Optional[float] = None
+    """The time in milliseconds it took to process the input code"""
+
+    verdict: Optional[bool] = None
+    """The verdict of the input code analysis"""
+
+
+class ResultsInputDosResults(BaseModel):
+    elapsed_ms: Optional[float] = None
+    """The time in milliseconds it took to process the input denial of service"""
+
+    embeddings_length: Optional[float] = None
+    """The length of the embeddings analyzed"""
+
+    verdict: Optional[bool] = None
+    """The verdict of the input denial of service analysis"""
+
+
+class ResultsInputLanguageResults(BaseModel):
+    elapsed_ms: Optional[float] = None
+    """The time in milliseconds it took to process the input language detection"""
+
+    language: Optional[str] = None
+    """Language detected in the input"""
+
+    verdict: Optional[bool] = None
+    """The verdict of the input language analysis"""
+
+
+class ResultsInputPiiResults(BaseModel):
+    elapsed_ms: Optional[float] = None
+    """
+    The time in milliseconds it took to process the input personally identifiable
+    information
+    """
+
+    entities: Optional[List[str]] = None
+
+    verdict: Optional[bool] = None
+    """The verdict of the input personally identifiable information analysis"""
+
+
+class ResultsInputURLResults(BaseModel):
+    elapsed_ms: Optional[float] = None
+    """The time in milliseconds it took to process the guardrail"""
+
+    urls: Optional[List[str]] = None
+
+
+class ResultsOutputCodeResults(BaseModel):
+    elapsed_ms: Optional[float] = None
+    """The time in milliseconds it took to process the output code"""
+
+    verdict: Optional[bool] = None
+    """The verdict of the output code analysis"""
+
+
+class ResultsOutputPiiResults(BaseModel):
+    elapsed_ms: Optional[float] = None
+    """
+    The time in milliseconds it took to process the output personally identifiable
+    information
+    """
+
+    entities: Optional[List[str]] = None
+
+    verdict: Optional[bool] = None
+    """The verdict of the output personally identifiable information analysis"""
+
+
+class ResultsOutputURLResults(BaseModel):
+    elapsed_ms: Optional[float] = None
+    """The time in milliseconds it took to process the guardrail"""
+
+    urls: Optional[List[str]] = None
+
+
+class ResultsPromptInjectionClassifierResult(BaseModel):
+    allow_override: Optional[str] = None
+    """The allow override applied to the prompt"""
+
+    block_override: Optional[str] = None
+    """The block override applied to the prompt"""
+
+    elapsed_ms: Optional[float] = None
+    """The time in milliseconds it took to process the prompt injection classifier"""
+
+    probabilities: Optional[List[float]] = None
+
+    verdict: Optional[bool] = None
+    """The verdict of the prompt injection classifier"""
+
+    version: Optional[float] = None
+    """The version of the prompt injection classifier"""
+
+
+class Results(BaseModel):
+    guardrail_results: Optional[ResultsGuardrailResults] = None
+    """The guardrail results"""
+
+    input_block_list_results: Optional[ResultsInputBlockListResults] = None
+    """The input block list results"""
+
+    input_code_results: Optional[ResultsInputCodeResults] = None
+    """The input code results"""
+
+    input_dos_results: Optional[ResultsInputDosResults] = None
+    """The input denial of service results"""
+
+    input_language_results: Optional[ResultsInputLanguageResults] = None
+    """The input language results"""
+
+    input_pii_results: Optional[ResultsInputPiiResults] = None
+    """The input personally identifiable information results"""
+
+    input_url_results: Optional[ResultsInputURLResults] = None
+    """The input URL results"""
+
+    output_code_results: Optional[ResultsOutputCodeResults] = None
+    """The output code results"""
+
+    output_pii_results: Optional[ResultsOutputPiiResults] = None
+    """The output personally identifiable information results"""
+
+    output_url_results: Optional[ResultsOutputURLResults] = None
+    """The output URL results"""
+
+    prompt_injection_classifier_results: Optional[List[ResultsPromptInjectionClassifierResult]] = None
+
+
+class PromptAnalyzerCreateResponse(BaseModel):
+    categories: Optional[Categories] = None
+    """The analysis detection categories"""
+
+    elapsed_ms: Optional[float] = None
+    """The time in milliseconds it took to process the request"""
+
+    frameworks: Optional[Frameworks] = None
+    """The framework labels identified during analysis"""
+
+    model: Optional[str] = None
+
+    policy: Optional[Policy] = None
+    """The policy used during analysis"""
+
+    provider: Optional[str] = None
+
+    response: Optional[Response] = None
+
+    results: Optional[Results] = None
+    """The analysis results"""
+
+    upstream_elapsed_ms: Optional[float] = None
+    """The time in milliseconds the upstream LLM took to process the request"""
+
+    verdict: Optional[bool] = None
+    """The overall verdict of the analysis"""

hiddenlayer/types/scans/__init__.py

@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .scan_job import ScanJob as ScanJob
+from .scan_report import ScanReport as ScanReport
+from .job_list_params import JobListParams as JobListParams
+from .job_list_response import JobListResponse as JobListResponse
+from .job_request_params import JobRequestParams as JobRequestParams
+from .job_retrieve_params import JobRetrieveParams as JobRetrieveParams
+from .upload_start_params import UploadStartParams as UploadStartParams
+from .result_sarif_response import ResultSarifResponse as ResultSarifResponse
+from .upload_start_response import UploadStartResponse as UploadStartResponse
+from .upload_complete_all_response import UploadCompleteAllResponse as UploadCompleteAllResponse

hiddenlayer/types/scans/job_list_params.py

@@ -0,0 +1,75 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union
+from datetime import datetime
+from typing_extensions import Literal, Annotated, TypedDict
+
+from ..._types import SequenceNotStr
+from ..._utils import PropertyInfo
+
+__all__ = ["JobListParams", "ModelName", "Source"]
+
+
+class JobListParams(TypedDict, total=False):
+    compliance_status: List[Literal["COMPLIANT", "NONCOMPLIANT"]]
+    """A comma separated list of rule set evaluation statuses to include"""
+
+    detection_category: str
+    """filter by a single detection category"""
+
+    end_time: Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]
+    """End Time"""
+
+    latest_per_model_version_only: bool
+    """only return latest result per model version"""
+
+    limit: int
+
+    model_ids: SequenceNotStr[str]
+    """Model ID"""
+
+    model_name: ModelName
+    """filter by the model name"""
+
+    model_version_ids: SequenceNotStr[str]
+    """Model Version IDs"""
+
+    offset: int
+
+    request_source: List[Literal["Hybrid Upload", "API Upload", "Integration", "UI Upload"]]
+    """Filter by request source using a comma-separated list"""
+
+    scanner_version: str
+    """filter by version of the scanner"""
+
+    severity: SequenceNotStr[str]
+    """Severities"""
+
+    sort: str
+    """
+    allow sorting by model name, status, severity or created at, ascending (+) or
+    the default descending (-)
+    """
+
+    source: Source
+    """source of model related to scans"""
+
+    start_time: Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]
+    """Start Time"""
+
+    status: SequenceNotStr[str]
+    """Statuses"""
+
+    x_correlation_id: Annotated[str, PropertyInfo(alias="X-Correlation-Id")]
+
+
+class ModelName(TypedDict, total=False):
+    contains: str
+
+    eq: str
+
+
+class Source(TypedDict, total=False):
+    eq: Literal["adhoc"]

hiddenlayer/types/scans/job_list_response.py

@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from ..._models import BaseModel
+from .scan_report import ScanReport
+
+__all__ = ["JobListResponse"]
+
+
+class JobListResponse(BaseModel):
+    items: List[ScanReport]
+    """List of items. If no matching items are found, then `[]` will be returned."""
+
+    limit: int
+    """Maximum number of items to return"""
+
+    offset: int
+    """Begin returning the results from this offset"""
+
+    total: float
+    """Total number of items available based on the query criteria."""

hiddenlayer/types/scans/job_request_params.py

@@ -0,0 +1,49 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["JobRequestParams", "Access", "Inventory"]
+
+
+class JobRequestParams(TypedDict, total=False):
+    access: Required[Access]
+
+    inventory: Required[Inventory]
+
+
+class Access(TypedDict, total=False):
+    source: Literal[
+        "LOCAL",
+        "AWS_PRESIGNED",
+        "AWS_IAM_ROLE",
+        "AZURE_BLOB_SAS",
+        "AZURE_BLOB_AD",
+        "GOOGLE_SIGNED",
+        "GOOGLE_OAUTH",
+        "HUGGING_FACE",
+    ]
+
+
+class Inventory(TypedDict, total=False):
+    model_name: Required[str]
+    """Name of the model"""
+
+    model_version: Required[str]
+    """If you do not provide a version, one will be generated for you."""
+
+    requested_scan_location: Required[str]
+    """Location to be scanned"""
+
+    requesting_entity: Required[str]
+    """Entity that requested the scan"""
+
+    origin: str
+    """
+    Specifies the platform or service where the model originated before being
+    scanned
+    """
+
+    request_source: Literal["Hybrid Upload", "API Upload", "Integration", "UI Upload"]
+    """Identifies the system that requested the scan"""

hiddenlayer/types/scans/job_retrieve_params.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Annotated, TypedDict
+
+from ..._utils import PropertyInfo
+
+__all__ = ["JobRetrieveParams"]
+
+
+class JobRetrieveParams(TypedDict, total=False):
+    has_detections: bool
+    """Filter file_results to only those that have detections (and parents)"""
+
+    x_correlation_id: Annotated[str, PropertyInfo(alias="X-Correlation-Id")]

hiddenlayer/types/scans/result_sarif_response.py

@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import TypeAlias
+
+__all__ = ["ResultSarifResponse"]
+
+ResultSarifResponse: TypeAlias = str

hiddenlayer/types/scans/scan_job.py

@@ -0,0 +1,46 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._compat import PYDANTIC_V1, ConfigDict
+from ..._models import BaseModel
+
+__all__ = ["ScanJob", "Inventory"]
+
+
+class Inventory(BaseModel):
+    model_name: str
+    """Name of the model"""
+
+    model_version: str
+    """If you do not provide a version, one will be generated for you."""
+
+    requested_scan_location: str
+    """Location to be scanned"""
+
+    requesting_entity: str
+    """Entity that requested the scan"""
+
+    origin: Optional[str] = None
+    """
+    Specifies the platform or service where the model originated before being
+    scanned
+    """
+
+    request_source: Optional[Literal["Hybrid Upload", "API Upload", "Integration", "UI Upload"]] = None
+    """Identifies the system that requested the scan"""
+
+    if not PYDANTIC_V1:
+        # allow fields with a `model_` prefix
+        model_config = ConfigDict(protected_namespaces=tuple())
+
+
+class ScanJob(BaseModel):
+    inventory: Inventory
+
+    scan_id: Optional[str] = None
+    """unique identifier for the scan"""
+
+    status: Optional[Literal["pending", "running", "done", "failed", "canceled"]] = None
+    """Status of the scan"""