hackagent 0.1.0__py3-none-any.whl

hackagent/models/paginated_user_api_key_list.py

@@ -0,0 +1,123 @@
+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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.user_api_key import UserAPIKey
+
+
+T = TypeVar("T", bound="PaginatedUserAPIKeyList")
+
+
+@_attrs_define
+class PaginatedUserAPIKeyList:
+    """
+    Attributes:
+        count (int):  Example: 123.
+        results (list['UserAPIKey']):
+        next_ (Union[None, Unset, str]):  Example: http://api.example.org/accounts/?page=4.
+        previous (Union[None, Unset, str]):  Example: http://api.example.org/accounts/?page=2.
+    """
+
+    count: int
+    results: list["UserAPIKey"]
+    next_: Union[None, Unset, str] = UNSET
+    previous: Union[None, Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        count = self.count
+
+        results = []
+        for results_item_data in self.results:
+            results_item = results_item_data.to_dict()
+            results.append(results_item)
+
+        next_: Union[None, Unset, str]
+        if isinstance(self.next_, Unset):
+            next_ = UNSET
+        else:
+            next_ = self.next_
+
+        previous: Union[None, Unset, str]
+        if isinstance(self.previous, Unset):
+            previous = UNSET
+        else:
+            previous = self.previous
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "count": count,
+                "results": results,
+            }
+        )
+        if next_ is not UNSET:
+            field_dict["next"] = next_
+        if previous is not UNSET:
+            field_dict["previous"] = previous
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.user_api_key import UserAPIKey
+
+        d = dict(src_dict)
+        count = d.pop("count")
+
+        results = []
+        _results = d.pop("results")
+        for results_item_data in _results:
+            results_item = UserAPIKey.from_dict(results_item_data)
+
+            results.append(results_item)
+
+        def _parse_next_(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        next_ = _parse_next_(d.pop("next", UNSET))
+
+        def _parse_previous(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        previous = _parse_previous(d.pop("previous", UNSET))
+
+        paginated_user_api_key_list = cls(
+            count=count,
+            results=results,
+            next_=next_,
+            previous=previous,
+        )
+
+        paginated_user_api_key_list.additional_properties = d
+        return paginated_user_api_key_list
+
+    @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/patched_agent_request.py

@@ -0,0 +1,176 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.agent_type_enum import AgentTypeEnum
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PatchedAgentRequest")
+
+
+@_attrs_define
+class PatchedAgentRequest:
+    """Serializes Agent model instances to JSON and validates data for creating
+    or updating Agent instances.
+
+    This serializer provides a comprehensive representation of an Agent,
+    including its type, endpoint, and nested details for related 'organization'
+    and 'owner' for read operations, while allowing 'organization' and 'owner' IDs
+    for write operations.
+
+    Attributes:
+        organization_detail (OrganizationMinimalSerializer): Read-only nested
+            serializer for the agent's organization. Displays minimal details.
+        owner_detail (UserProfileMinimalSerializer): Read-only nested serializer
+            for the agent's owner's user profile. Displays minimal details.
+            Can be null if the agent has no owner or the owner has no profile.
+        type (CharField): The type of the agent (e.g., GENERIC_ADK, OPENAI_SDK).
+                          Uses the choices defined in the Agent model's AgentType enum.
+
+    Meta:
+        model (Agent): The model class that this serializer works with.
+        fields (tuple): The fields to include in the serialized output.
+            Includes standard Agent fields like 'endpoint', 'type',
+            and the read-only nested details.
+        read_only_fields (tuple): Fields that are read-only and cannot be
+            set during create/update operations through this serializer.
+            This includes 'id', 'created_at', 'updated_at', and the
+            nested detail fields.
+
+        Attributes:
+            name (Union[Unset, str]):
+            endpoint (Union[Unset, str]): The primary API endpoint URL for interacting with the agent.
+            agent_type (Union[Unset, AgentTypeEnum]): * `LITELMM` - LiteLLM
+                * `OPENAI_SDK` - OpenAI SDK/API
+                * `GOOGLE_ADK` - Google ADK
+                * `OTHER` - Other/Proprietary
+                * `UNKNOWN` - Unknown
+            description (Union[Unset, str]):
+            metadata (Union[Unset, Any]): Optional JSON data providing specific details and configuration. Structure depends
+                heavily on Agent Type. Examples:
+                - For GENERIC_ADK: {'adk_app_name': 'my_adk_app', 'protocol_version': '1.0'}
+                - For OPENAI_SDK: {'model': 'gpt-4-turbo', 'api_key_secret_name': 'MY_OPENAI_KEY', 'instructions': 'You are a
+                helpful assistant.'}
+                - For GOOGLE_ADK: {'project_id': 'my-gcp-project', 'location': 'us-central1'}
+                - General applicable: {'version': '1.2.0', 'custom_headers': {'X-Custom-Header': 'value'}}
+            organization (Union[Unset, UUID]):
+            owner (Union[None, Unset, int]):
+    """
+
+    name: Union[Unset, str] = UNSET
+    endpoint: Union[Unset, str] = UNSET
+    agent_type: Union[Unset, AgentTypeEnum] = UNSET
+    description: Union[Unset, str] = UNSET
+    metadata: Union[Unset, Any] = UNSET
+    organization: Union[Unset, UUID] = UNSET
+    owner: Union[None, Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        endpoint = self.endpoint
+
+        agent_type: Union[Unset, str] = UNSET
+        if not isinstance(self.agent_type, Unset):
+            agent_type = self.agent_type.value
+
+        description = self.description
+
+        metadata = self.metadata
+
+        organization: Union[Unset, str] = UNSET
+        if not isinstance(self.organization, Unset):
+            organization = str(self.organization)
+
+        owner: Union[None, Unset, int]
+        if isinstance(self.owner, Unset):
+            owner = UNSET
+        else:
+            owner = self.owner
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if name is not UNSET:
+            field_dict["name"] = name
+        if endpoint is not UNSET:
+            field_dict["endpoint"] = endpoint
+        if agent_type is not UNSET:
+            field_dict["agent_type"] = agent_type
+        if description is not UNSET:
+            field_dict["description"] = description
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+        if organization is not UNSET:
+            field_dict["organization"] = organization
+        if owner is not UNSET:
+            field_dict["owner"] = owner
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name", UNSET)
+
+        endpoint = d.pop("endpoint", UNSET)
+
+        _agent_type = d.pop("agent_type", UNSET)
+        agent_type: Union[Unset, AgentTypeEnum]
+        if isinstance(_agent_type, Unset):
+            agent_type = UNSET
+        else:
+            agent_type = AgentTypeEnum(_agent_type)
+
+        description = d.pop("description", UNSET)
+
+        metadata = d.pop("metadata", UNSET)
+
+        _organization = d.pop("organization", UNSET)
+        organization: Union[Unset, UUID]
+        if isinstance(_organization, Unset):
+            organization = UNSET
+        else:
+            organization = UUID(_organization)
+
+        def _parse_owner(data: object) -> Union[None, Unset, int]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, int], data)
+
+        owner = _parse_owner(d.pop("owner", UNSET))
+
+        patched_agent_request = cls(
+            name=name,
+            endpoint=endpoint,
+            agent_type=agent_type,
+            description=description,
+            metadata=metadata,
+            organization=organization,
+            owner=owner,
+        )
+
+        patched_agent_request.additional_properties = d
+        return patched_agent_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/patched_attack_request.py

@@ -0,0 +1,92 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PatchedAttackRequest")
+
+
+@_attrs_define
+class PatchedAttackRequest:
+    """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_ (Union[Unset, str]): A string identifier for the type of attack being configured (e.g.,
+                'PREFIX_GENERATION', 'PROMPT_INJECTION').
+            agent (Union[Unset, UUID]):
+            configuration (Union[Unset, Any]): JSON containing client-provided configuration for an attack using this
+                definition.
+    """
+
+    type_: Union[Unset, str] = UNSET
+    agent: Union[Unset, UUID] = UNSET
+    configuration: Union[Unset, Any] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_
+
+        agent: Union[Unset, str] = UNSET
+        if not isinstance(self.agent, Unset):
+            agent = str(self.agent)
+
+        configuration = self.configuration
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if agent is not UNSET:
+            field_dict["agent"] = agent
+        if configuration is not UNSET:
+            field_dict["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", UNSET)
+
+        _agent = d.pop("agent", UNSET)
+        agent: Union[Unset, UUID]
+        if isinstance(_agent, Unset):
+            agent = UNSET
+        else:
+            agent = UUID(_agent)
+
+        configuration = d.pop("configuration", UNSET)
+
+        patched_attack_request = cls(
+            type_=type_,
+            agent=agent,
+            configuration=configuration,
+        )
+
+        patched_attack_request.additional_properties = d
+        return patched_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/patched_prompt_request.py

@@ -0,0 +1,162 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PatchedPromptRequest")
+
+
+@_attrs_define
+class PatchedPromptRequest:
+    """Serializer for the Prompt model.
+
+    Attributes:
+        name (Union[Unset, str]):
+        prompt_text (Union[Unset, str]):
+        category (Union[Unset, str]): Primary category for grouping prompts (e.g., Evasion, Harmful Content).
+        tags (Union[Unset, Any]): Optional JSON list of tags for classification (e.g., ["PII", "Malware"])
+        evaluation_criteria (Union[Unset, str]): Description of how success/failure should be judged for this specific
+            prompt.
+        expected_tool_calls (Union[Unset, Any]): JSON list of expected tool calls, e.g., [{"tool_name": "...",
+            "tool_input": {...}}]
+        expected_output_pattern (Union[Unset, str]): Optional regex pattern to match against the final response.
+        reference_output (Union[Unset, str]): Optional ideal/reference final output text.
+        organization (Union[Unset, UUID]):
+        owner (Union[None, Unset, int]):
+    """
+
+    name: Union[Unset, str] = UNSET
+    prompt_text: Union[Unset, str] = UNSET
+    category: Union[Unset, str] = UNSET
+    tags: Union[Unset, Any] = UNSET
+    evaluation_criteria: Union[Unset, str] = UNSET
+    expected_tool_calls: Union[Unset, Any] = UNSET
+    expected_output_pattern: Union[Unset, str] = UNSET
+    reference_output: Union[Unset, str] = UNSET
+    organization: Union[Unset, UUID] = UNSET
+    owner: Union[None, Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        prompt_text = self.prompt_text
+
+        category = self.category
+
+        tags = self.tags
+
+        evaluation_criteria = self.evaluation_criteria
+
+        expected_tool_calls = self.expected_tool_calls
+
+        expected_output_pattern = self.expected_output_pattern
+
+        reference_output = self.reference_output
+
+        organization: Union[Unset, str] = UNSET
+        if not isinstance(self.organization, Unset):
+            organization = str(self.organization)
+
+        owner: Union[None, Unset, int]
+        if isinstance(self.owner, Unset):
+            owner = UNSET
+        else:
+            owner = self.owner
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if name is not UNSET:
+            field_dict["name"] = name
+        if prompt_text is not UNSET:
+            field_dict["prompt_text"] = prompt_text
+        if category is not UNSET:
+            field_dict["category"] = category
+        if tags is not UNSET:
+            field_dict["tags"] = tags
+        if evaluation_criteria is not UNSET:
+            field_dict["evaluation_criteria"] = evaluation_criteria
+        if expected_tool_calls is not UNSET:
+            field_dict["expected_tool_calls"] = expected_tool_calls
+        if expected_output_pattern is not UNSET:
+            field_dict["expected_output_pattern"] = expected_output_pattern
+        if reference_output is not UNSET:
+            field_dict["reference_output"] = reference_output
+        if organization is not UNSET:
+            field_dict["organization"] = organization
+        if owner is not UNSET:
+            field_dict["owner"] = owner
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name", UNSET)
+
+        prompt_text = d.pop("prompt_text", UNSET)
+
+        category = d.pop("category", UNSET)
+
+        tags = d.pop("tags", UNSET)
+
+        evaluation_criteria = d.pop("evaluation_criteria", UNSET)
+
+        expected_tool_calls = d.pop("expected_tool_calls", UNSET)
+
+        expected_output_pattern = d.pop("expected_output_pattern", UNSET)
+
+        reference_output = d.pop("reference_output", UNSET)
+
+        _organization = d.pop("organization", UNSET)
+        organization: Union[Unset, UUID]
+        if isinstance(_organization, Unset):
+            organization = UNSET
+        else:
+            organization = UUID(_organization)
+
+        def _parse_owner(data: object) -> Union[None, Unset, int]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, int], data)
+
+        owner = _parse_owner(d.pop("owner", UNSET))
+
+        patched_prompt_request = cls(
+            name=name,
+            prompt_text=prompt_text,
+            category=category,
+            tags=tags,
+            evaluation_criteria=evaluation_criteria,
+            expected_tool_calls=expected_tool_calls,
+            expected_output_pattern=expected_output_pattern,
+            reference_output=reference_output,
+            organization=organization,
+            owner=owner,
+        )
+
+        patched_prompt_request.additional_properties = d
+        return patched_prompt_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