hackagent 0.3.1__py3-none-any.whl

hackagent/models/paginated_run_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.run import Run
+
+
+T = TypeVar("T", bound="PaginatedRunList")
+
+
+@_attrs_define
+class PaginatedRunList:
+    """
+    Attributes:
+        count (int):  Example: 123.
+        results (list['Run']):
+        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["Run"]
+    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.run import Run
+
+        d = dict(src_dict)
+        count = d.pop("count")
+
+        results = []
+        _results = d.pop("results")
+        for results_item_data in _results:
+            results_item = Run.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_run_list = cls(
+            count=count,
+            results=results,
+            next_=next_,
+            previous=previous,
+        )
+
+        paginated_run_list.additional_properties = d
+        return paginated_run_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/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/paginated_user_profile_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_profile import UserProfile
+
+
+T = TypeVar("T", bound="PaginatedUserProfileList")
+
+
+@_attrs_define
+class PaginatedUserProfileList:
+    """
+    Attributes:
+        count (int):  Example: 123.
+        results (list['UserProfile']):
+        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["UserProfile"]
+    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_profile import UserProfile
+
+        d = dict(src_dict)
+        count = d.pop("count")
+
+        results = []
+        _results = d.pop("results")
+        for results_item_data in _results:
+            results_item = UserProfile.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_profile_list = cls(
+            count=count,
+            results=results,
+            next_=next_,
+            previous=previous,
+        )
+
+        paginated_user_profile_list.additional_properties = d
+        return paginated_user_profile_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,128 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+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.
+        agent_type (CharField): The type of the agent as a string
+                          (e.g., LITELLM, OPENAI_SDK, GOOGLE_ADK).
+
+    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, str]): The specific SDK, ADK, or API type the agent is built upon (e.g., OpenAI SDK,
+                Generic ADK).
+            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'}}
+    """
+
+    name: Union[Unset, str] = UNSET
+    endpoint: Union[Unset, str] = UNSET
+    agent_type: Union[Unset, str] = UNSET
+    description: Union[Unset, str] = UNSET
+    metadata: Union[Unset, Any] = 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 = self.agent_type
+
+        description = self.description
+
+        metadata = self.metadata
+
+        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
+
+        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)
+
+        description = d.pop("description", UNSET)
+
+        metadata = d.pop("metadata", UNSET)
+
+        patched_agent_request = cls(
+            name=name,
+            endpoint=endpoint,
+            agent_type=agent_type,
+            description=description,
+            metadata=metadata,
+        )
+
+        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_organization_request.py

@@ -0,0 +1,71 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from .. import types
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PatchedOrganizationRequest")
+
+
+@_attrs_define
+class PatchedOrganizationRequest:
+    """
+    Attributes:
+        name (Union[Unset, str]):
+    """
+
+    name: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if name is not UNSET:
+            field_dict["name"] = name
+
+        return field_dict
+
+    def to_multipart(self) -> types.RequestFiles:
+        files: types.RequestFiles = []
+
+        if not isinstance(self.name, Unset):
+            files.append(("name", (None, str(self.name).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)
+        name = d.pop("name", UNSET)
+
+        patched_organization_request = cls(
+            name=name,
+        )
+
+        patched_organization_request.additional_properties = d
+        return patched_organization_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