hackagent 0.3.1__py3-none-any.whl

hackagent/models/attack_request.py

@@ -0,0 +1,82 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="AttackRequest")
+
+
+@_attrs_define
+class AttackRequest:
+    """Serializer for the Attack model, which represents an Attack configuration.
+
+    Handles the conversion of Attack configuration instances to JSON (and vice-versa)
+    for API requests and responses. It includes read-only fields for related
+    object names (like agent_name, owner_username) for convenience in API outputs.
+
+        Attributes:
+            type_ (str): A string identifier for the type of attack being configured (e.g., 'PREFIX_GENERATION',
+                'PROMPT_INJECTION').
+            agent (UUID):
+            configuration (Any): JSON containing client-provided configuration for an attack using this definition.
+    """
+
+    type_: str
+    agent: UUID
+    configuration: Any
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_
+
+        agent = str(self.agent)
+
+        configuration = self.configuration
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+                "agent": agent,
+                "configuration": configuration,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        type_ = d.pop("type")
+
+        agent = UUID(d.pop("agent"))
+
+        configuration = d.pop("configuration")
+
+        attack_request = cls(
+            type_=type_,
+            agent=agent,
+            configuration=configuration,
+        )
+
+        attack_request.additional_properties = d
+        return attack_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

hackagent/models/checkout_session_request_request.py

@@ -0,0 +1,76 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from .. import types
+
+T = TypeVar("T", bound="CheckoutSessionRequestRequest")
+
+
+@_attrs_define
+class CheckoutSessionRequestRequest:
+    """
+    Attributes:
+        credits_to_purchase (int): Number of credits the user wants to purchase.
+    """
+
+    credits_to_purchase: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        credits_to_purchase = self.credits_to_purchase
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "credits_to_purchase": credits_to_purchase,
+            }
+        )
+
+        return field_dict
+
+    def to_multipart(self) -> types.RequestFiles:
+        files: types.RequestFiles = []
+
+        files.append(
+            (
+                "credits_to_purchase",
+                (None, str(self.credits_to_purchase).encode(), "text/plain"),
+            )
+        )
+
+        for prop_name, prop in self.additional_properties.items():
+            files.append((prop_name, (None, str(prop).encode(), "text/plain")))
+
+        return files
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        credits_to_purchase = d.pop("credits_to_purchase")
+
+        checkout_session_request_request = cls(
+            credits_to_purchase=credits_to_purchase,
+        )
+
+        checkout_session_request_request.additional_properties = d
+        return checkout_session_request_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

hackagent/models/checkout_session_response.py

@@ -0,0 +1,59 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="CheckoutSessionResponse")
+
+
+@_attrs_define
+class CheckoutSessionResponse:
+    """
+    Attributes:
+        checkout_url (str): The URL to redirect the user to for Stripe Checkout.
+    """
+
+    checkout_url: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        checkout_url = self.checkout_url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "checkout_url": checkout_url,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        checkout_url = d.pop("checkout_url")
+
+        checkout_session_response = cls(
+            checkout_url=checkout_url,
+        )
+
+        checkout_session_response.additional_properties = d
+        return checkout_session_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

hackagent/models/choice.py

@@ -0,0 +1,81 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.choice_message import ChoiceMessage
+
+
+T = TypeVar("T", bound="Choice")
+
+
+@_attrs_define
+class Choice:
+    """
+    Attributes:
+        index (int): Index of the choice
+        message (ChoiceMessage):
+        finish_reason (str): Reason for completion (stop, length, etc.)
+    """
+
+    index: int
+    message: "ChoiceMessage"
+    finish_reason: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        index = self.index
+
+        message = self.message.to_dict()
+
+        finish_reason = self.finish_reason
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "index": index,
+                "message": message,
+                "finish_reason": finish_reason,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.choice_message import ChoiceMessage
+
+        d = dict(src_dict)
+        index = d.pop("index")
+
+        message = ChoiceMessage.from_dict(d.pop("message"))
+
+        finish_reason = d.pop("finish_reason")
+
+        choice = cls(
+            index=index,
+            message=message,
+            finish_reason=finish_reason,
+        )
+
+        choice.additional_properties = d
+        return choice
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

hackagent/models/choice_message.py

@@ -0,0 +1,67 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ChoiceMessage")
+
+
+@_attrs_define
+class ChoiceMessage:
+    """
+    Attributes:
+        role (str): Role of the message sender
+        content (str): Generated content
+    """
+
+    role: str
+    content: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        role = self.role
+
+        content = self.content
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "role": role,
+                "content": content,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        role = d.pop("role")
+
+        content = d.pop("content")
+
+        choice_message = cls(
+            role=role,
+            content=content,
+        )
+
+        choice_message.additional_properties = d
+        return choice_message
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

hackagent/models/evaluation_status_enum.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+
+class EvaluationStatusEnum(str, Enum):
+    ERROR_AGENT_RESPONSE = "ERROR_AGENT_RESPONSE"
+    ERROR_TEST_FRAMEWORK = "ERROR_TEST_FRAMEWORK"
+    FAILED_CRITERIA = "FAILED_CRITERIA"
+    FAILED_JAILBREAK = "FAILED_JAILBREAK"
+    NOT_EVALUATED = "NOT_EVALUATED"
+    PASSED_CRITERIA = "PASSED_CRITERIA"
+    SUCCESSFUL_JAILBREAK = "SUCCESSFUL_JAILBREAK"
+
+    def __str__(self) -> str:
+        return str(self.value)

hackagent/models/generate_error_response.py

@@ -0,0 +1,59 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="GenerateErrorResponse")
+
+
+@_attrs_define
+class GenerateErrorResponse:
+    """
+    Attributes:
+        error (str): Description of the error that occurred.
+    """
+
+    error: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        error = self.error
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "error": error,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        error = d.pop("error")
+
+        generate_error_response = cls(
+            error=error,
+        )
+
+        generate_error_response.additional_properties = d
+        return generate_error_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

hackagent/models/generate_request_request.py

@@ -0,0 +1,212 @@
+import json
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from .. import types
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.message_request import MessageRequest
+
+
+T = TypeVar("T", bound="GenerateRequestRequest")
+
+
+@_attrs_define
+class GenerateRequestRequest:
+    """
+    Attributes:
+        messages (list['MessageRequest']): Array of conversation messages
+        model (Union[Unset, str]): Client-specified model (will be overridden by server)
+        stream (Union[Unset, bool]): Whether to stream the response Default: False.
+        temperature (Union[Unset, float]): Sampling temperature (0-2)
+        max_tokens (Union[Unset, int]): Maximum tokens to generate
+        top_p (Union[Unset, float]): Nucleus sampling threshold
+        frequency_penalty (Union[Unset, float]): Frequency penalty (-2.0 to 2.0)
+        presence_penalty (Union[Unset, float]): Presence penalty (-2.0 to 2.0)
+        stop (Union[Unset, list[str]]): Sequences where the API will stop generating
+    """
+
+    messages: list["MessageRequest"]
+    model: Union[Unset, str] = UNSET
+    stream: Union[Unset, bool] = False
+    temperature: Union[Unset, float] = UNSET
+    max_tokens: Union[Unset, int] = UNSET
+    top_p: Union[Unset, float] = UNSET
+    frequency_penalty: Union[Unset, float] = UNSET
+    presence_penalty: Union[Unset, float] = UNSET
+    stop: Union[Unset, list[str]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        messages = []
+        for messages_item_data in self.messages:
+            messages_item = messages_item_data.to_dict()
+            messages.append(messages_item)
+
+        model = self.model
+
+        stream = self.stream
+
+        temperature = self.temperature
+
+        max_tokens = self.max_tokens
+
+        top_p = self.top_p
+
+        frequency_penalty = self.frequency_penalty
+
+        presence_penalty = self.presence_penalty
+
+        stop: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.stop, Unset):
+            stop = self.stop
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "messages": messages,
+            }
+        )
+        if model is not UNSET:
+            field_dict["model"] = model
+        if stream is not UNSET:
+            field_dict["stream"] = stream
+        if temperature is not UNSET:
+            field_dict["temperature"] = temperature
+        if max_tokens is not UNSET:
+            field_dict["max_tokens"] = max_tokens
+        if top_p is not UNSET:
+            field_dict["top_p"] = top_p
+        if frequency_penalty is not UNSET:
+            field_dict["frequency_penalty"] = frequency_penalty
+        if presence_penalty is not UNSET:
+            field_dict["presence_penalty"] = presence_penalty
+        if stop is not UNSET:
+            field_dict["stop"] = stop
+
+        return field_dict
+
+    def to_multipart(self) -> types.RequestFiles:
+        files: types.RequestFiles = []
+
+        for messages_item_element in self.messages:
+            files.append(
+                (
+                    "messages",
+                    (
+                        None,
+                        json.dumps(messages_item_element.to_dict()).encode(),
+                        "application/json",
+                    ),
+                )
+            )
+
+        if not isinstance(self.model, Unset):
+            files.append(("model", (None, str(self.model).encode(), "text/plain")))
+
+        if not isinstance(self.stream, Unset):
+            files.append(("stream", (None, str(self.stream).encode(), "text/plain")))
+
+        if not isinstance(self.temperature, Unset):
+            files.append(
+                ("temperature", (None, str(self.temperature).encode(), "text/plain"))
+            )
+
+        if not isinstance(self.max_tokens, Unset):
+            files.append(
+                ("max_tokens", (None, str(self.max_tokens).encode(), "text/plain"))
+            )
+
+        if not isinstance(self.top_p, Unset):
+            files.append(("top_p", (None, str(self.top_p).encode(), "text/plain")))
+
+        if not isinstance(self.frequency_penalty, Unset):
+            files.append(
+                (
+                    "frequency_penalty",
+                    (None, str(self.frequency_penalty).encode(), "text/plain"),
+                )
+            )
+
+        if not isinstance(self.presence_penalty, Unset):
+            files.append(
+                (
+                    "presence_penalty",
+                    (None, str(self.presence_penalty).encode(), "text/plain"),
+                )
+            )
+
+        if not isinstance(self.stop, Unset):
+            for stop_item_element in self.stop:
+                files.append(
+                    ("stop", (None, str(stop_item_element).encode(), "text/plain"))
+                )
+
+        for prop_name, prop in self.additional_properties.items():
+            files.append((prop_name, (None, str(prop).encode(), "text/plain")))
+
+        return files
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.message_request import MessageRequest
+
+        d = dict(src_dict)
+        messages = []
+        _messages = d.pop("messages")
+        for messages_item_data in _messages:
+            messages_item = MessageRequest.from_dict(messages_item_data)
+
+            messages.append(messages_item)
+
+        model = d.pop("model", UNSET)
+
+        stream = d.pop("stream", UNSET)
+
+        temperature = d.pop("temperature", UNSET)
+
+        max_tokens = d.pop("max_tokens", UNSET)
+
+        top_p = d.pop("top_p", UNSET)
+
+        frequency_penalty = d.pop("frequency_penalty", UNSET)
+
+        presence_penalty = d.pop("presence_penalty", UNSET)
+
+        stop = cast(list[str], d.pop("stop", UNSET))
+
+        generate_request_request = cls(
+            messages=messages,
+            model=model,
+            stream=stream,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            top_p=top_p,
+            frequency_penalty=frequency_penalty,
+            presence_penalty=presence_penalty,
+            stop=stop,
+        )
+
+        generate_request_request.additional_properties = d
+        return generate_request_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties