hackagent 0.3.1__py3-none-any.whl

hackagent/models/trace.py

@@ -0,0 +1,121 @@
+import datetime
+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 dateutil.parser import isoparse
+
+from ..models.step_type_enum import StepTypeEnum
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="Trace")
+
+
+@_attrs_define
+class Trace:
+    """Serializer for the Trace model.
+
+    Attributes:
+        id (int):
+        result (UUID):
+        sequence (int):
+        timestamp (datetime.datetime):
+        step_type (Union[Unset, StepTypeEnum]): * `TOOL_CALL` - Tool Call
+            * `TOOL_RESPONSE` - Tool Response
+            * `AGENT_THOUGHT` - Agent Thought/Reasoning
+            * `AGENT_RESPONSE_CHUNK` - Agent Response Chunk
+            * `OTHER` - Other
+            * `MCP_STEP` - Multi-Context Prompting Step
+            * `A2A_COMM` - Agent-to-Agent Communication
+        content (Union[Unset, Any]):
+    """
+
+    id: int
+    result: UUID
+    sequence: int
+    timestamp: datetime.datetime
+    step_type: Union[Unset, StepTypeEnum] = UNSET
+    content: Union[Unset, Any] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        result = str(self.result)
+
+        sequence = self.sequence
+
+        timestamp = self.timestamp.isoformat()
+
+        step_type: Union[Unset, str] = UNSET
+        if not isinstance(self.step_type, Unset):
+            step_type = self.step_type.value
+
+        content = self.content
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "result": result,
+                "sequence": sequence,
+                "timestamp": timestamp,
+            }
+        )
+        if step_type is not UNSET:
+            field_dict["step_type"] = step_type
+        if content is not UNSET:
+            field_dict["content"] = content
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        result = UUID(d.pop("result"))
+
+        sequence = d.pop("sequence")
+
+        timestamp = isoparse(d.pop("timestamp"))
+
+        _step_type = d.pop("step_type", UNSET)
+        step_type: Union[Unset, StepTypeEnum]
+        if isinstance(_step_type, Unset):
+            step_type = UNSET
+        else:
+            step_type = StepTypeEnum(_step_type)
+
+        content = d.pop("content", UNSET)
+
+        trace = cls(
+            id=id,
+            result=result,
+            sequence=sequence,
+            timestamp=timestamp,
+            step_type=step_type,
+            content=content,
+        )
+
+        trace.additional_properties = d
+        return trace
+
+    @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/trace_request.py

@@ -0,0 +1,94 @@
+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 ..models.step_type_enum import StepTypeEnum
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="TraceRequest")
+
+
+@_attrs_define
+class TraceRequest:
+    """Serializer for the Trace model.
+
+    Attributes:
+        sequence (int):
+        step_type (Union[Unset, StepTypeEnum]): * `TOOL_CALL` - Tool Call
+            * `TOOL_RESPONSE` - Tool Response
+            * `AGENT_THOUGHT` - Agent Thought/Reasoning
+            * `AGENT_RESPONSE_CHUNK` - Agent Response Chunk
+            * `OTHER` - Other
+            * `MCP_STEP` - Multi-Context Prompting Step
+            * `A2A_COMM` - Agent-to-Agent Communication
+        content (Union[Unset, Any]):
+    """
+
+    sequence: int
+    step_type: Union[Unset, StepTypeEnum] = UNSET
+    content: Union[Unset, Any] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        sequence = self.sequence
+
+        step_type: Union[Unset, str] = UNSET
+        if not isinstance(self.step_type, Unset):
+            step_type = self.step_type.value
+
+        content = self.content
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "sequence": sequence,
+            }
+        )
+        if step_type is not UNSET:
+            field_dict["step_type"] = step_type
+        if content is not UNSET:
+            field_dict["content"] = content
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        sequence = d.pop("sequence")
+
+        _step_type = d.pop("step_type", UNSET)
+        step_type: Union[Unset, StepTypeEnum]
+        if isinstance(_step_type, Unset):
+            step_type = UNSET
+        else:
+            step_type = StepTypeEnum(_step_type)
+
+        content = d.pop("content", UNSET)
+
+        trace_request = cls(
+            sequence=sequence,
+            step_type=step_type,
+            content=content,
+        )
+
+        trace_request.additional_properties = d
+        return trace_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/usage.py

@@ -0,0 +1,75 @@
+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="Usage")
+
+
+@_attrs_define
+class Usage:
+    """
+    Attributes:
+        prompt_tokens (int): Number of tokens in the prompt
+        completion_tokens (int): Number of tokens in the completion
+        total_tokens (int): Total tokens used
+    """
+
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        prompt_tokens = self.prompt_tokens
+
+        completion_tokens = self.completion_tokens
+
+        total_tokens = self.total_tokens
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "prompt_tokens": prompt_tokens,
+                "completion_tokens": completion_tokens,
+                "total_tokens": total_tokens,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        prompt_tokens = d.pop("prompt_tokens")
+
+        completion_tokens = d.pop("completion_tokens")
+
+        total_tokens = d.pop("total_tokens")
+
+        usage = cls(
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+            total_tokens=total_tokens,
+        )
+
+        usage.additional_properties = d
+        return usage
+
+    @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/user_api_key.py

@@ -0,0 +1,201 @@
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+if TYPE_CHECKING:
+    from ..models.organization_minimal import OrganizationMinimal
+    from ..models.user_profile_minimal import UserProfileMinimal
+
+
+T = TypeVar("T", bound="UserAPIKey")
+
+
+@_attrs_define
+class UserAPIKey:
+    """Serializer for User API Keys.
+    Exposes read-only information about the key, including its prefix.
+    The full key is only shown once upon creation by the ViewSet.
+
+        Attributes:
+            id (str):
+            name (str): A human-readable name for the API key.
+            prefix (str):
+            created (datetime.datetime):
+            revoked (bool): If the API key is revoked, clients cannot use it anymore. (This cannot be undone.)
+            expiry_date (Union[None, datetime.datetime]): Once API key expires, clients cannot use it anymore.
+            user (int):
+            user_detail (Union['UserProfileMinimal', None]):
+            organization (UUID):
+            organization_detail (Union['OrganizationMinimal', None]):
+    """
+
+    id: str
+    name: str
+    prefix: str
+    created: datetime.datetime
+    revoked: bool
+    expiry_date: Union[None, datetime.datetime]
+    user: int
+    user_detail: Union["UserProfileMinimal", None]
+    organization: UUID
+    organization_detail: Union["OrganizationMinimal", None]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.organization_minimal import OrganizationMinimal
+        from ..models.user_profile_minimal import UserProfileMinimal
+
+        id = self.id
+
+        name = self.name
+
+        prefix = self.prefix
+
+        created = self.created.isoformat()
+
+        revoked = self.revoked
+
+        expiry_date: Union[None, str]
+        if isinstance(self.expiry_date, datetime.datetime):
+            expiry_date = self.expiry_date.isoformat()
+        else:
+            expiry_date = self.expiry_date
+
+        user = self.user
+
+        user_detail: Union[None, dict[str, Any]]
+        if isinstance(self.user_detail, UserProfileMinimal):
+            user_detail = self.user_detail.to_dict()
+        else:
+            user_detail = self.user_detail
+
+        organization = str(self.organization)
+
+        organization_detail: Union[None, dict[str, Any]]
+        if isinstance(self.organization_detail, OrganizationMinimal):
+            organization_detail = self.organization_detail.to_dict()
+        else:
+            organization_detail = self.organization_detail
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "name": name,
+                "prefix": prefix,
+                "created": created,
+                "revoked": revoked,
+                "expiry_date": expiry_date,
+                "user": user,
+                "user_detail": user_detail,
+                "organization": organization,
+                "organization_detail": organization_detail,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.organization_minimal import OrganizationMinimal
+        from ..models.user_profile_minimal import UserProfileMinimal
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        name = d.pop("name")
+
+        prefix = d.pop("prefix")
+
+        created = isoparse(d.pop("created"))
+
+        revoked = d.pop("revoked")
+
+        def _parse_expiry_date(data: object) -> Union[None, datetime.datetime]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                expiry_date_type_0 = isoparse(data)
+
+                return expiry_date_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, datetime.datetime], data)
+
+        expiry_date = _parse_expiry_date(d.pop("expiry_date"))
+
+        user = d.pop("user")
+
+        def _parse_user_detail(data: object) -> Union["UserProfileMinimal", None]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                user_detail_type_1 = UserProfileMinimal.from_dict(data)
+
+                return user_detail_type_1
+            except:  # noqa: E722
+                pass
+            return cast(Union["UserProfileMinimal", None], data)
+
+        user_detail = _parse_user_detail(d.pop("user_detail"))
+
+        organization = UUID(d.pop("organization"))
+
+        def _parse_organization_detail(
+            data: object,
+        ) -> Union["OrganizationMinimal", None]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                organization_detail_type_1 = OrganizationMinimal.from_dict(data)
+
+                return organization_detail_type_1
+            except:  # noqa: E722
+                pass
+            return cast(Union["OrganizationMinimal", None], data)
+
+        organization_detail = _parse_organization_detail(d.pop("organization_detail"))
+
+        user_api_key = cls(
+            id=id,
+            name=name,
+            prefix=prefix,
+            created=created,
+            revoked=revoked,
+            expiry_date=expiry_date,
+            user=user,
+            user_detail=user_detail,
+            organization=organization,
+            organization_detail=organization_detail,
+        )
+
+        user_api_key.additional_properties = d
+        return user_api_key
+
+    @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/user_api_key_request.py

@@ -0,0 +1,73 @@
+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="UserAPIKeyRequest")
+
+
+@_attrs_define
+class UserAPIKeyRequest:
+    """Serializer for User API Keys.
+    Exposes read-only information about the key, including its prefix.
+    The full key is only shown once upon creation by the ViewSet.
+
+        Attributes:
+            name (str): A human-readable name for the API key.
+            key (Union[Unset, str]):
+    """
+
+    name: str
+    key: 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
+
+        key = self.key
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if key is not UNSET:
+            field_dict["key"] = key
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        key = d.pop("key", UNSET)
+
+        user_api_key_request = cls(
+            name=name,
+            key=key,
+        )
+
+        user_api_key_request.additional_properties = d
+        return user_api_key_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/user_profile.py

@@ -0,0 +1,135 @@
+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="UserProfile")
+
+
+@_attrs_define
+class UserProfile:
+    """
+    Attributes:
+        id (UUID):
+        user (int):
+        username (str):
+        organization (UUID):
+        organization_name (str):
+        auth0_user_id (Union[None, str]): The unique user identifier (sub claim) provided by Auth0.
+        email (Union[Unset, str]):
+        first_name (Union[Unset, str]):
+        last_name (Union[Unset, str]):
+    """
+
+    id: UUID
+    user: int
+    username: str
+    organization: UUID
+    organization_name: str
+    auth0_user_id: Union[None, str]
+    email: Union[Unset, str] = UNSET
+    first_name: Union[Unset, str] = UNSET
+    last_name: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = str(self.id)
+
+        user = self.user
+
+        username = self.username
+
+        organization = str(self.organization)
+
+        organization_name = self.organization_name
+
+        auth0_user_id: Union[None, str]
+        auth0_user_id = self.auth0_user_id
+
+        email = self.email
+
+        first_name = self.first_name
+
+        last_name = self.last_name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "user": user,
+                "username": username,
+                "organization": organization,
+                "organization_name": organization_name,
+                "auth0_user_id": auth0_user_id,
+            }
+        )
+        if email is not UNSET:
+            field_dict["email"] = email
+        if first_name is not UNSET:
+            field_dict["first_name"] = first_name
+        if last_name is not UNSET:
+            field_dict["last_name"] = last_name
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = UUID(d.pop("id"))
+
+        user = d.pop("user")
+
+        username = d.pop("username")
+
+        organization = UUID(d.pop("organization"))
+
+        organization_name = d.pop("organization_name")
+
+        def _parse_auth0_user_id(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        auth0_user_id = _parse_auth0_user_id(d.pop("auth0_user_id"))
+
+        email = d.pop("email", UNSET)
+
+        first_name = d.pop("first_name", UNSET)
+
+        last_name = d.pop("last_name", UNSET)
+
+        user_profile = cls(
+            id=id,
+            user=user,
+            username=username,
+            organization=organization,
+            organization_name=organization_name,
+            auth0_user_id=auth0_user_id,
+            email=email,
+            first_name=first_name,
+            last_name=last_name,
+        )
+
+        user_profile.additional_properties = d
+        return user_profile
+
+    @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