unique_sdk 0.10.19__py3-none-any.whl → 0.10.71__py3-none-any.whl

unique_sdk/api_resources/_space.py

@@ -1,4 +1,15 @@
-from typing import Any, ClassVar, Dict, List, Literal, Optional, TypedDict, Unpack, cast
+from typing import (
+    Any,
+    ClassVar,
+    Dict,
+    List,
+    Literal,
+    NotRequired,
+    Optional,
+    TypedDict,
+    Unpack,
+    cast,
+)
 
 from unique_sdk._api_resource import APIResource
 from unique_sdk._request_options import RequestOptions
@@ -7,16 +18,61 @@ from unique_sdk._request_options import RequestOptions
 class Space(APIResource["Space"]):
     OBJECT_NAME: ClassVar[Literal["space"]] = "space"
 
+    class ModuleParams(TypedDict):
+        name: str
+        description: NotRequired[Optional[str]]
+        weight: NotRequired[Optional[int]]
+        isExternal: NotRequired[Optional[bool]]
+        isCustomInstructionEnabled: NotRequired[Optional[bool]]
+        configuration: NotRequired[Optional[Dict[str, Any]]]
+        toolDefinition: NotRequired[Optional[Dict[str, Any]]]
+
+    class CreateSpaceParams(RequestOptions):
+        name: str
+        fallbackModule: str
+        modules: List["Space.ModuleParams"]
+        explanation: NotRequired[Optional[str]]
+        alert: NotRequired[Optional[str]]
+        chatUpload: NotRequired[Optional[Literal["ENABLED", "DISABLED"]]]
+        languageModel: NotRequired[Optional[str]]
+        isExternal: NotRequired[Optional[bool]]
+        isPinned: NotRequired[Optional[bool]]
+        uiType: NotRequired[
+            Optional[
+                Literal["MAGIC_TABLE", "UNIQUE_CUSTOM", "TRANSLATION", "UNIQUE_AI"]
+            ]
+        ]
+        settings: NotRequired[Optional[Dict[str, Any]]]
+
+    class AccessEntry(TypedDict):
+        entityId: str
+        entityType: Literal["USER", "GROUP"]
+        type: Literal["USE", "MANAGE", "UPLOAD"]
+
+    class AddSpaceAccessParams(RequestOptions):
+        access: List["Space.AccessEntry"]
+
+    class DeleteSpaceAccessParams(RequestOptions):
+        accessIds: List[str]
+
     class CreateMessageParams(RequestOptions):
         """
         Parameters for querying the assistant for a message.
         """
 
-        chatId: str | None = None
+        chatId: NotRequired[str | None]
         assistantId: str
-        text: str | None = None
-        toolChoices: List[str] = None
-        scopeRules: dict | None = None
+        text: NotRequired[str | None]
+        toolChoices: NotRequired[List[str] | None]
+        scopeRules: NotRequired[dict | None]
+
+    class GetChatMessagesParams(RequestOptions):
+        """
+        Parameters for getting chat messages.
+        """
+
+        skip: NotRequired[int]
+        take: NotRequired[int]
 
     class Reference(TypedDict):
         """
@@ -24,9 +80,10 @@ class Space(APIResource["Space"]):
         """
 
         name: str
-        url: str | None
+        description: Optional[str]
+        url: Optional[str]
         sequenceNumber: int
-        originalIndex: List[int] | None
+        originalIndex: Optional[list[int]]
         sourceId: str
         source: str
 
@@ -58,11 +115,13 @@ class Space(APIResource["Space"]):
         chatId: str
         text: str | None
         originalText: str | None
-        role: Literal["system", "user", "assistant"]
+        role: Literal["SYSTEM", "USER", "ASSISTANT"]
         debugInfo: Optional[Dict[str, Any]]
+        gptRequest: Optional[Dict[str, Any]]
         completedAt: str | None
         createdAt: str | None
         updatedAt: str | None
+        startedStreamingAt: str | None
         stoppedStreamingAt: str | None
         references: Optional[List["Space.Reference"]]
         assessment: Optional[List["Space.Assessment"]]
@@ -74,6 +133,96 @@ class Space(APIResource["Space"]):
 
         chat_id: str
 
+    class GetAllMessagesResponse(TypedDict):
+        """
+        Response for getting all messages in a chat.
+        """
+
+        messages: List["Space.Message"]
+        totalCount: int
+
+    class McpServer(TypedDict):
+        """
+        Represents an MCP server associated with a space.
+        """
+
+        id: str
+        name: str
+        assistantId: str
+        mcpServerId: str
+        isEnabled: bool
+        createdAt: str
+        updatedAt: str
+
+    class Module(TypedDict):
+        """
+        Represents a module configured for a space.
+        """
+
+        id: str
+        name: str
+        description: Optional[str]
+        toolDefinition: Optional[Dict[str, Any]]
+        configuration: Dict[str, Any]
+        assistantId: str
+        weight: int
+        isExternal: bool
+        isCustomInstructionEnabled: bool
+        moduleTemplateId: Optional[str]
+        createdAt: str
+        updatedAt: str
+
+    class ScopeRule(TypedDict):
+        """
+        Represents a scope rule for a space.
+        """
+
+        id: str
+        assistantId: str
+        title: str
+        companyId: str
+        rule: Dict[str, Any]
+        isAdvanced: bool
+        createdAt: str
+        updatedAt: str
+
+    class Access(TypedDict):
+        id: str
+        entityId: str
+        entityType: str
+        type: str
+
+    class SpaceAccessResponse(TypedDict):
+        access: List["Space.Access"]
+
+    class DeleteSpaceAccessResponse(TypedDict):
+        success: bool
+
+    id: str
+    name: str
+    defaultForCompanyId: Optional[str]
+    title: Optional[str]
+    subtitle: Optional[str]
+    explanation: Optional[str]
+    alert: Optional[str]
+    inputLimit: Optional[int]
+    inputPlaceholder: Optional[str]
+    chatUpload: str
+    goals: List[str]
+    languageModel: Optional[str]
+    fallbackModule: str
+    access: List[str]
+    isExternal: bool
+    isPinned: bool
+    uiType: str
+    settings: Optional[Dict[str, Any]]
+    assistantMcpServers: List["Space.McpServer"]
+    modules: List["Space.Module"]
+    scopeRules: List["Space.ScopeRule"]
+    assistantAccess: List["Space.Access"]
+    createdAt: str
+    updatedAt: str
+
     @classmethod
     def create_message(
         cls,
@@ -118,6 +267,50 @@ class Space(APIResource["Space"]):
             ),
         )
 
+    @classmethod
+    def get_chat_messages(
+        cls,
+        user_id: str,
+        company_id: str,
+        chat_id: str,
+        **params: Unpack["Space.GetChatMessagesParams"],
+    ) -> "Space.GetAllMessagesResponse":
+        """
+        Get all messages in a space chat.
+        """
+        return cast(
+            "Space.GetAllMessagesResponse",
+            cls._static_request(
+                "get",
+                f"/space/chat/{chat_id}/messages",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    async def get_chat_messages_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        chat_id: str,
+        **params: Unpack["Space.GetChatMessagesParams"],
+    ) -> "Space.GetAllMessagesResponse":
+        """
+        Async get all messages in a space chat.
+        """
+        return cast(
+            "Space.GetAllMessagesResponse",
+            await cls._static_request_async(
+                "get",
+                f"/space/chat/{chat_id}/messages",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
     @classmethod
     def get_latest_message(
         cls, user_id: str, company_id: str, chat_id: str
@@ -191,3 +384,189 @@ class Space(APIResource["Space"]):
                 company_id,
             ),
         )
+
+    @classmethod
+    def get_space(
+        cls,
+        user_id: str,
+        company_id: str,
+        space_id: str,
+    ) -> "Space":
+        """
+        Get detailed information about a space (assistant).
+        """
+        return cast(
+            "Space",
+            cls._static_request(
+                "get",
+                f"/space/{space_id}",
+                user_id,
+                company_id,
+            ),
+        )
+
+    @classmethod
+    async def get_space_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        space_id: str,
+    ) -> "Space":
+        """
+        Async get detailed information about a space (assistant).
+        """
+        return cast(
+            "Space",
+            await cls._static_request_async(
+                "get",
+                f"/space/{space_id}",
+                user_id,
+                company_id,
+            ),
+        )
+
+    @classmethod
+    def create_space(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["Space.CreateSpaceParams"],
+    ) -> "Space":
+        return cast(
+            "Space",
+            cls._static_request(
+                "post",
+                "/space",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    async def create_space_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["Space.CreateSpaceParams"],
+    ) -> "Space":
+        return cast(
+            "Space",
+            await cls._static_request_async(
+                "post",
+                "/space",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    def get_space_access(
+        cls,
+        user_id: str,
+        company_id: str,
+        space_id: str,
+    ) -> "Space.SpaceAccessResponse":
+        return cast(
+            "Space.SpaceAccessResponse",
+            cls._static_request(
+                "get",
+                f"/space/{space_id}/access",
+                user_id,
+                company_id,
+            ),
+        )
+
+    @classmethod
+    async def get_space_access_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        space_id: str,
+    ) -> "Space.SpaceAccessResponse":
+        return cast(
+            "Space.SpaceAccessResponse",
+            await cls._static_request_async(
+                "get",
+                f"/space/{space_id}/access",
+                user_id,
+                company_id,
+            ),
+        )
+
+    @classmethod
+    def add_space_access(
+        cls,
+        user_id: str,
+        company_id: str,
+        space_id: str,
+        **params: Unpack["Space.AddSpaceAccessParams"],
+    ) -> "Space.SpaceAccessResponse":
+        return cast(
+            "Space.SpaceAccessResponse",
+            cls._static_request(
+                "post",
+                f"/space/{space_id}/access",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    async def add_space_access_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        space_id: str,
+        **params: Unpack["Space.AddSpaceAccessParams"],
+    ) -> "Space.SpaceAccessResponse":
+        return cast(
+            "Space.SpaceAccessResponse",
+            await cls._static_request_async(
+                "post",
+                f"/space/{space_id}/access",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    def delete_space_access(
+        cls,
+        user_id: str,
+        company_id: str,
+        space_id: str,
+        **params: Unpack["Space.DeleteSpaceAccessParams"],
+    ) -> "Space.DeleteSpaceAccessResponse":
+        return cast(
+            "Space.DeleteSpaceAccessResponse",
+            cls._static_request(
+                "delete",
+                f"/space/{space_id}/access",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    async def delete_space_access_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        space_id: str,
+        **params: Unpack["Space.DeleteSpaceAccessParams"],
+    ) -> "Space.DeleteSpaceAccessResponse":
+        return cast(
+            "Space.DeleteSpaceAccessResponse",
+            await cls._static_request_async(
+                "delete",
+                f"/space/{space_id}/access",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )

unique_sdk/api_resources/_user.py

@@ -0,0 +1,195 @@
+from typing import (
+    Any,
+    ClassVar,
+    Dict,
+    List,
+    NotRequired,
+    Optional,
+    TypedDict,
+    Unpack,
+    cast,
+)
+
+from unique_sdk._api_resource import APIResource
+from unique_sdk._request_options import RequestOptions
+
+
+class User(APIResource["User"]):
+    OBJECT_NAME: ClassVar[str] = "users"
+
+    class GetParams(RequestOptions):
+        """
+        Parameters for getting users in a company.
+        """
+
+        skip: NotRequired[Optional[int]]
+        take: NotRequired[Optional[int]]
+        email: NotRequired[Optional[str]]
+        displayName: NotRequired[Optional[str]]
+        userName: NotRequired[Optional[str]]
+
+    class UpdateUserConfigurationParams(RequestOptions):
+        """
+        Parameters for updating user configuration.
+        """
+
+        userConfiguration: Dict[str, Any]
+
+    class UserGroup(TypedDict):
+        id: str
+        name: str
+        externalId: Optional[str]
+        parentId: Optional[str]
+        createdAt: str
+        updatedAt: str
+
+    class UserGroupsResponse(TypedDict):
+        groups: List["User.UserGroup"]
+
+    class User(TypedDict):
+        """
+        Represents a user in the company.
+        """
+
+        id: str
+        externalId: Optional[str]
+        firstName: str
+        lastName: str
+        displayName: str
+        userName: str
+        email: str
+        updatedAt: str
+        createdAt: str
+        active: bool
+
+    class UserWithConfiguration(User):
+        """
+        Represents a user in the company with configuration.
+        """
+
+        userConfiguration: Dict[str, Any]
+
+    class Users(TypedDict):
+        """
+        Response for getting users.
+        """
+
+        users: List["User.User"]
+
+    @classmethod
+    def get_users(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["User.GetParams"],
+    ) -> "User.Users":
+        """
+        Get users in a company.
+        """
+        return cast(
+            "User.Users",
+            cls._static_request(
+                "get",
+                "/users",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    async def get_users_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["User.GetParams"],
+    ) -> "User.Users":
+        """
+        Async get users in a company.
+        """
+        return cast(
+            "User.Users",
+            await cls._static_request_async(
+                "get",
+                "/users",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    def update_user_configuration(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["User.UpdateUserConfigurationParams"],
+    ) -> "User.UserWithConfiguration":
+        """
+        Update user configuration for the current user.
+        """
+        return cast(
+            "User.UserWithConfiguration",
+            cls._static_request(
+                "patch",
+                f"/users/{user_id}/configuration",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    async def update_user_configuration_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["User.UpdateUserConfigurationParams"],
+    ) -> "User.UserWithConfiguration":
+        """
+        Async update user configuration for the current user.
+        """
+        return cast(
+            "User.UserWithConfiguration",
+            await cls._static_request_async(
+                "patch",
+                f"/users/{user_id}/configuration",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    def get_user_groups(
+        cls,
+        user_id: str,
+        company_id: str,
+        target_user_id: str,
+    ) -> "User.UserGroupsResponse":
+        return cast(
+            "User.UserGroupsResponse",
+            cls._static_request(
+                "get",
+                f"/users/{target_user_id}/groups",
+                user_id,
+                company_id,
+            ),
+        )
+
+    @classmethod
+    async def get_user_groups_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        target_user_id: str,
+    ) -> "User.UserGroupsResponse":
+        return cast(
+            "User.UserGroupsResponse",
+            await cls._static_request_async(
+                "get",
+                f"/users/{target_user_id}/groups",
+                user_id,
+                company_id,
+            ),
+        )