h2ogpte 1.6.39__py3-none-any.whl → 1.6.40rc1__py3-none-any.whl

h2ogpte/__init__.py

@@ -3,7 +3,7 @@ from h2ogpte.h2ogpte import H2OGPTE
 from h2ogpte.h2ogpte_async import H2OGPTEAsync
 from h2ogpte.session_async import SessionAsync
 
-__version__ = "1.6.39"
+__version__ = "1.6.40rc1"
 
 __all__ = [
     "H2OGPTE",

h2ogpte/errors.py

@@ -37,6 +37,10 @@ class InternalServerError(H2OGPTEError):
     pass
 
 
+class NotImplementedError(H2OGPTEError):
+    pass
+
+
 class FailedError(H2OGPTEError):
     pass
 

h2ogpte/h2ogpte.py

@@ -2286,6 +2286,111 @@ class H2OGPTE(H2OGPTESyncBase):
             )
         return self._wait_for_completion(response.id, timeout=timeout)
 
+    def list_secret_ids(self, connector_type: Optional[str] = None) -> List[str]:
+        """
+        List available secret IDs from the SecureStore for cloud storage connectors.
+
+        Args:
+            connector_type: Type of connector ('s3', 'gcs', 'azure_key', 'azure_sas')
+                           If None, returns secrets for all connector types.
+
+        Returns:
+            List of secret IDs available for the specified connector type
+        """
+        self._init_rest()
+        header = self._get_auth_header()
+        response = _rest_to_client_exceptions(
+            lambda: self._secrets_api.list_secret_ids(
+                connector_type=connector_type, _headers=header
+            )
+        )
+        return response.ids
+
+    def get_secret(self, secret_id: str) -> Union[Dict[str, Any], None]:
+        """Get a secret from the SecureStore by its ID.
+
+        Args:
+            secret_id: The ID of the secret to retrieve.
+
+        Returns:
+            The secret object corresponding to the provided ID.
+        """
+        self._init_rest()
+        header = self._get_auth_header()
+        response = _rest_to_client_exceptions(
+            lambda: self._secrets_api.get_secret(secret_id=secret_id, _headers=header)
+        )
+        return response.to_dict()
+
+    def get_secret_value(self, secret_id: str) -> Union[str, None]:
+        """Get the value of a secret from the SecureStore by its ID.
+
+        Args:
+            secret_id: The ID of the secret to retrieve.
+
+        Returns:
+            The value of the secret corresponding to the provided ID.
+        """
+        self._init_rest()
+        header = self._get_auth_header()
+        response = _rest_to_client_exceptions(
+            lambda: self._secrets_api.get_secret_value(
+                secret_id=secret_id, _headers=header
+            )
+        )
+        return response.value if response else None
+
+    def create_secret(self, secret: Dict[str, Any]) -> None:
+        """Create a new secret in the SecureStore.
+
+        Args:
+            secret: A dictionary containing the secret data to be stored.
+
+        Returns:
+            The ID of the newly created secret.
+        """
+        self._init_rest()
+        header = self._get_auth_header()
+        response = _rest_to_client_exceptions(
+            lambda: self._secrets_api.create_secret(secret=secret, _headers=header)
+        )
+        return response.id
+
+    def update_secret(self, secret_id: str, secret: Dict[str, Any]) -> None:
+        """Update an existing secret in the SecureStore.
+
+        Args:
+            secret_id: The ID of the secret to update.
+            secret: A dictionary containing the updated secret data.
+
+        Returns:
+            None
+        """
+        self._init_rest()
+        header = self._get_auth_header()
+        _rest_to_client_exceptions(
+            lambda: self._secrets_api.update_secret(
+                secret_id=secret_id, secret=secret, _headers=header
+            )
+        )
+
+    def delete_secret(self, secret_id: str) -> None:
+        """Delete a secret from the SecureStore by its ID.
+
+        Args:
+            secret_id: The ID of the secret to delete.
+
+        Returns:
+            None
+        """
+        self._init_rest()
+        header = self._get_auth_header()
+        _rest_to_client_exceptions(
+            lambda: self._secrets_api.delete_secret(
+                secret_id=secret_id, _headers=header
+            )
+        )
+
     def ingest_uploads(
         self,
         collection_id: str,
@@ -4278,6 +4383,78 @@ class H2OGPTE(H2OGPTESyncBase):
             )
         return [PromptTemplate(**d.to_dict()) for d in response]
 
+    def list_all_recent_prompt_templates(
+        self, offset: int, limit: int
+    ) -> List[PromptTemplate]:
+        """Fetch user's prompt templates sorted by last update time.
+
+        Note: Users with permission to manage prompt templates can use this to list hidden default prompt templates.
+
+        Args:
+            offset:
+                How many prompt templates to skip before returning.
+            limit:
+                How many prompt templates to return.
+
+        Returns:
+            list of PromptTemplate: set of prompts
+        """
+        header = self._get_auth_header()
+        with self._RESTClient(self) as rest_client:
+            response = _rest_to_client_exceptions(
+                lambda: rest_client.prompt_template_api.list_all_prompt_templates(
+                    offset=offset,
+                    limit=limit,
+                    _headers=header,
+                )
+            )
+        return [PromptTemplate(**d.to_dict()) for d in response]
+
+    def list_all_recent_prompt_templates_sort(
+        self,
+        offset: int,
+        limit: int,
+        sort_column: str,
+        ascending: bool,
+        template_type: str = "all",
+        filter: str = "",
+    ) -> List[PromptTemplate]:
+        """Fetch user's prompt templates sorted by last update time.
+
+        Note: Users with permission to manage prompt templates can use this to list hidden default prompt templates.
+
+        Args:
+            offset:
+                How many prompt templates to skip before returning.
+            limit:
+                How many prompt templates to return.
+            sort_column:
+                Sort column.
+            ascending:
+                When True, return sorted by sort_column in ascending order.
+            template_type:
+                When set, will be used as a type filter, possible values are: all, user, system.
+            filter:
+                When set, will be used as a filter on some prompt template columns.
+
+        Returns:
+            list of PromptTemplate: set of prompts
+        """
+        header = self._get_auth_header()
+        with self._RESTClient(self) as rest_client:
+            response = _rest_to_client_exceptions(
+                lambda: rest_client.prompt_template_api.list_all_prompt_templates(
+                    offset=offset,
+                    limit=limit,
+                    sort_column=sort_column,
+                    ascending=ascending,
+                    template_type=template_type,
+                    filter=filter,
+                    _headers=header,
+                )
+            )
+        return [PromptTemplate(**d.to_dict()) for d in response]
+
     def get_prompt_template(self, id: Optional[str] = None) -> PromptTemplate:
         """Get a prompt template
 
@@ -4745,6 +4922,49 @@ class H2OGPTE(H2OGPTESyncBase):
             )
         return result
 
+    def make_prompt_template_public(self, prompt_template_id: str):
+        """Make a prompt template public
+
+        Once a prompt template is public, it can be seen and used by all users.
+
+        Args:
+            prompt_template_id:
+                ID of the prompt template to make public.
+        """
+        header = self._get_auth_header()
+        with self._RESTClient(self) as rest_client:
+            _rest_to_client_exceptions(
+                lambda: rest_client.prompt_template_api.update_prompt_template_privacy(
+                    prompt_template_id=prompt_template_id,
+                    update_prompt_template_privacy_request=rest.UpdatePromptTemplatePrivacyRequest(
+                        is_public=True
+                    ),
+                    _headers=header,
+                )
+            )
+
+    def make_prompt_template_private(self, prompt_template_id: str):
+        """Make a prompt template private
+
+        Once a prompt template is private, other users will no longer
+        be able to see or use it unless it has been shared individually or by group.
+
+        Args:
+            prompt_template_id:
+                ID of the prompt template to make private.
+        """
+        header = self._get_auth_header()
+        with self._RESTClient(self) as rest_client:
+            _rest_to_client_exceptions(
+                lambda: rest_client.prompt_template_api.update_prompt_template_privacy(
+                    prompt_template_id=prompt_template_id,
+                    update_prompt_template_privacy_request=rest.UpdatePromptTemplatePrivacyRequest(
+                        is_public=False
+                    ),
+                    _headers=header,
+                )
+            )
+
     def list_prompt_permissions(self, prompt_id: str) -> List[SharePermission]:
         """Returns a list of access permissions for a given prompt template.
 
@@ -4791,6 +5011,32 @@ class H2OGPTE(H2OGPTESyncBase):
             )
         return [GroupSharePermission(**d.to_dict()) for d in response]
 
+    def set_default_prompt_template_visibility(self, prompt_id: str, is_visible: bool):
+        """
+        Updates a flag specifying whether a default prompt template is visible or hidden to users.
+
+        Once you hide a default prompt template, users will no longer be able to use this prompt template.
+        This will also affect collections and chats that have this as a default prompt template.
+        Once you show a default prompt template, all users will be able to see and use this prompt template.
+
+        Args:
+            prompt_id:
+                ID of the default prompt template you would like to change the visibility of.
+            is_visible:
+                Whether the default prompt template should be visible.
+        """
+        header = self._get_auth_header()
+        with self._RESTClient(self) as rest_client:
+            _rest_to_client_exceptions(
+                lambda: rest_client.prompt_template_api.update_default_prompt_template_visibility(
+                    prompt_template_id=prompt_id,
+                    update_default_prompt_template_visibility_request=rest.UpdateDefaultPromptTemplateVisibilityRequest(
+                        is_visible=is_visible
+                    ),
+                    _headers=header,
+                )
+            )
+
     def set_collection_prompt_template(
         self,
         collection_id: str,
@@ -5511,7 +5757,7 @@ class H2OGPTE(H2OGPTESyncBase):
         can_overwrite: bool,
         is_public: bool,
         value_type: str = None,
-    ) -> List[ConfigItem]:
+    ) -> List[GlobalConfigItem]:
         """Set a global configuration.
 
         Note: Both default collection size limit and inactivity interval can be disabled. To do so, pass '-1' as the string_value.
@@ -5529,7 +5775,7 @@ class H2OGPTE(H2OGPTESyncBase):
                 The type of the value to be set for the global config.
 
         Returns:
-            List[ConfigItem]: List of global configurations.
+            List[GlobalConfigItem]: List of global configurations.
         """
         header = self._get_auth_header()
         with self._RESTClient(self) as rest_client:
@@ -5545,9 +5791,9 @@ class H2OGPTE(H2OGPTESyncBase):
                     _headers=header,
                 )
             )
-        return [ConfigItem(**c.to_dict()) for c in response]
+        return [GlobalConfigItem(**c.to_dict()) for c in response]
 
-    def get_global_configurations_by_admin(self) -> List[ConfigItem]:
+    def get_global_configurations_by_admin(self) -> List[GlobalConfigItem]:
         header = self._get_auth_header()
         with self._RESTClient(self) as rest_client:
             response = _rest_to_client_exceptions(
@@ -5556,9 +5802,9 @@ class H2OGPTE(H2OGPTESyncBase):
                     _headers=header,
                 )
             )
-        return [ConfigItem(**c.to_dict()) for c in response]
+        return [GlobalConfigItem(**c.to_dict()) for c in response]
 
-    def get_global_configurations(self) -> List[ConfigItem]:
+    def get_global_configurations(self) -> List[GlobalConfigItem]:
         header = self._get_auth_header()
         with self._RESTClient(self) as rest_client:
             response = _rest_to_client_exceptions(
@@ -5567,11 +5813,11 @@ class H2OGPTE(H2OGPTESyncBase):
                     _headers=header,
                 )
             )
-        return [ConfigItem(**c.to_dict()) for c in response]
+        return [GlobalConfigItem(**c.to_dict()) for c in response]
 
     def bulk_delete_global_configurations(
         self, key_names: List[str]
-    ) -> List[ConfigItem]:
+    ) -> List[GlobalConfigItem]:
         header = self._get_auth_header()
         with self._RESTClient(self) as rest_client:
             response = _rest_to_client_exceptions(
@@ -5580,11 +5826,11 @@ class H2OGPTE(H2OGPTESyncBase):
                     _headers=header,
                 )
             )
-        return [ConfigItem(**c.to_dict()) for c in response]
+        return [GlobalConfigItem(**c.to_dict()) for c in response]
 
     def set_user_configuration_for_user(
         self, key_name: str, string_value: str, user_id: str, value_type: str = None
-    ) -> List[UserConfigItem]:
+    ) -> List[ConfigItem]:
         """Set a user configuration for a specific user (overrides the global configuration and to be used by admins only).
 
         Note: Both default collection size limit and inactivity interval can be disabled. To do so, pass '-1' as the string_value.
@@ -5600,7 +5846,7 @@ class H2OGPTE(H2OGPTESyncBase):
                 The type of the value to be set for the config.
 
         Returns:
-            List[UserConfigItem]: List of user configurations.
+            List[ConfigItem]: List of user configurations.
         """
         header = self._get_auth_header()
         with self._RESTClient(self) as rest_client:
@@ -5615,9 +5861,9 @@ class H2OGPTE(H2OGPTESyncBase):
                     _headers=header,
                 )
             )
-        return [UserConfigItem(**c.to_dict()) for c in response]
+        return [ConfigItem(**c.to_dict()) for c in response]
 
-    def get_user_configurations_for_user(self, user_id: str) -> List[UserConfigItem]:
+    def get_user_configurations_for_user(self, user_id: str) -> List[ConfigItem]:
         """Gets the user configurations for a specific user (to be used by admins only).
 
         Args:
@@ -5625,7 +5871,7 @@ class H2OGPTE(H2OGPTESyncBase):
                 The unique identifier of the user.
 
         Returns:
-            List[UserConfigItem]: List of user configurations.
+            List[ConfigItem]: List of user configurations.
         """
         header = self._get_auth_header()
         with self._RESTClient(self) as rest_client:
@@ -5635,13 +5881,13 @@ class H2OGPTE(H2OGPTESyncBase):
                     _headers=header,
                 )
             )
-        return [UserConfigItem(**c.to_dict()) for c in response]
+        return [ConfigItem(**c.to_dict()) for c in response]
 
-    def get_user_configurations(self) -> List[UserConfigItem]:
+    def get_user_configurations(self) -> List[ConfigItem]:
         """Gets the user configurations for the current user.
 
         Returns:
-            List[UserConfigItem]: List of user configurations.
+            List[ConfigItem]: List of user configurations.
         """
         header = self._get_auth_header()
         with self._RESTClient(self) as rest_client:
@@ -5650,11 +5896,11 @@ class H2OGPTE(H2OGPTESyncBase):
                     _headers=header
                 )
             )
-        return [UserConfigItem(**c.to_dict()) for c in response]
+        return [ConfigItem(**c.to_dict()) for c in response]
 
     def bulk_delete_user_configurations_for_user(
         self, user_id: str, key_names: List[str]
-    ) -> List[UserConfigItem]:
+    ) -> List[ConfigItem]:
         header = self._get_auth_header()
         with self._RESTClient(self) as rest_client:
             response = _rest_to_client_exceptions(
@@ -5664,15 +5910,15 @@ class H2OGPTE(H2OGPTESyncBase):
                     _headers=header,
                 )
             )
-        return [UserConfigItem(**c.to_dict()) for c in response]
+        return [ConfigItem(**c.to_dict()) for c in response]
 
     def reset_user_configurations_for_user(
         self, key_name: str, user_id: str
-    ) -> List[UserConfigItem]:
+    ) -> List[ConfigItem]:
         """Reset a user configuration for a specific user (to be used by admins only).
 
         Returns:
-            List[UserConfigItem]: List of user configurations.
+            List[ConfigItem]: List of user configurations.
         """
         header = self._get_auth_header()
         with self._RESTClient(self) as rest_client:
@@ -5683,7 +5929,7 @@ class H2OGPTE(H2OGPTESyncBase):
                     _headers=header,
                 )
             )
-        return [UserConfigItem(**c.to_dict()) for c in response]
+        return [ConfigItem(**c.to_dict()) for c in response]
 
     def delete_agent_directories(self, chat_session_id: str) -> bool:
         header = self._get_auth_header()
@@ -5698,6 +5944,82 @@ class H2OGPTE(H2OGPTESyncBase):
             )
         return result.status == "completed"
 
+    def set_role_configuration(
+        self, key_name: str, role_id: str, string_value: str, value_type: str = None
+    ) -> List[ConfigItem]:
+        """Set a role configuration, overrides the global configuration.
+        Args:
+            role_id:
+                The role id you want to apply the config for.
+            key_name:
+                The name of the global config key.
+            string_value:
+                The value to be set for the config.
+            value_type:
+                The type of the value to be set for the config.
+
+        Returns:
+            List[ConfigItem]: List of role configurations.
+        """
+        header = self._get_auth_header()
+        with self._RESTClient(self) as rest_client:
+            response = _rest_to_client_exceptions(
+                lambda: rest_client.configuration_api.set_role_configuration(
+                    key_name=key_name,
+                    role_id=role_id,
+                    user_configuration_item=rest.UserConfigurationItem(
+                        key_name=key_name,
+                        string_value=string_value,
+                        value_type=value_type,
+                    ),
+                    _headers=header,
+                )
+            )
+        return [ConfigItem(**c.to_dict()) for c in response]
+
+    def list_role_configurations(self, role_id: str) -> List[ConfigItem]:
+        """Lists role configurations for a given role.
+        Args:
+            role_id:
+                The role id to get configurations for.
+
+        Returns:
+            List[ConfigItem]: List of role configurations.
+        """
+        header = self._get_auth_header()
+        with self._RESTClient(self) as rest_client:
+            response = _rest_to_client_exceptions(
+                lambda: rest_client.configuration_api.list_role_configurations(
+                    role_id=role_id,
+                    _headers=header,
+                )
+            )
+        return [ConfigItem(**c.to_dict()) for c in response]
+
+    def bulk_delete_role_configurations(
+        self, role_id: str, keys: List[str]
+    ) -> List[ConfigItem]:
+        """Delete role configuration items for a given role.
+        Args:
+            role_id:
+                The role id to delete configurations for.
+            keys:
+                List of configuration keys to delete.
+
+        Returns:
+            List[ConfigItem]: List of remaining role configurations.
+        """
+        header = self._get_auth_header()
+        with self._RESTClient(self) as rest_client:
+            response = _rest_to_client_exceptions(
+                lambda: rest_client.configuration_api.delete_role_configurations(
+                    key_names=keys,
+                    role_id=role_id,
+                    _headers=header,
+                )
+            )
+        return [ConfigItem(**c.to_dict()) for c in response]
+
     def delete_multiple_agent_directories(
         self, chat_session_ids: List[str], dir_types: List[str]
     ) -> bool:
@@ -6077,3 +6399,101 @@ class H2OGPTE(H2OGPTESyncBase):
                 )
             )
         return response.count
+
+    def add_custom_agent_tool(
+        self, tool_type: str, tool_args: dict, custom_tool_path: Optional[str] = None
+    ) -> list:
+        header = self._get_auth_header()
+        custom_tool_path = str(custom_tool_path) if custom_tool_path else None
+        with self._RESTClient(self) as rest_client:
+            response = _rest_to_client_exceptions(
+                lambda: rest_client.agent_api.add_custom_agent_tool(
+                    file=custom_tool_path,
+                    tool_type=tool_type,
+                    tool_args=json.dumps(tool_args),
+                    custom_tool_path=custom_tool_path,
+                    filename=os.path.basename(custom_tool_path)
+                    if custom_tool_path
+                    else None,
+                    _headers=header,
+                )
+            )
+        return [obj.agent_custom_tool_id for obj in response]
+
+    def delete_custom_agent_tool(self, tool_ids: List[str]) -> int:
+        header = self._get_auth_header()
+        with self._RESTClient(self) as rest_client:
+            response = _rest_to_client_exceptions(
+                lambda: rest_client.agent_api.delete_custom_agent_tool(
+                    tool_ids=tool_ids,
+                    _headers=header,
+                )
+            )
+        return response.count
+
+    def update_custom_agent_tool(
+        self,
+        tool_id: str,
+        tool_args: dict,
+    ) -> str:
+        """Updates a custom agent tool's arguments.
+
+        Args:
+            tool_id: The ID of the tool to update
+            tool_args: New tool arguments
+
+        Returns:
+            The updated tool ID
+        """
+        header = self._get_auth_header()
+
+        # Build request body with only tool_args
+        request_obj = rest.UpdateCustomAgentToolRequest(tool_args=tool_args)
+
+        with self._RESTClient(self) as rest_client:
+            response = _rest_to_client_exceptions(
+                lambda: rest_client.agent_api.update_custom_agent_tool(
+                    tool_id=tool_id,
+                    update_custom_agent_tool_request=request_obj,
+                    _headers=header,
+                )
+            )
+        return response.agent_custom_tool_id
+
+    def get_custom_agent_tools(self) -> List[dict]:
+        """Gets all custom agent tools for the current user.
+
+        Returns:
+            List[dict]: A list of custom agent tools with their details.
+                Each tool contains: id, tool_name, tool_type, tool_args, owner_email
+        """
+        header = self._get_auth_header()
+        with self._RESTClient(self) as rest_client:
+            response = _rest_to_client_exceptions(
+                lambda: rest_client.agent_api.list_custom_agent_tools(_headers=header)
+            )
+        return response
+
+    def set_role_priority(self, role_id: str, priority: int) -> UserRole:
+        """Sets the priority for a role.
+        Args:
+            role_id:
+                String: The id of the role to set the priority for.
+            priority:
+                Int: The priority value to set for the role. ex: 100, 200, 300...etc.
+                The lower the number, the higher the priority.
+        Returns:
+            UserRole: The updated user role with the new priority.
+        """
+        header = self._get_auth_header()
+        with self._RESTClient(self) as rest_client:
+            response = _rest_to_client_exceptions(
+                lambda: rest_client.permission_api.set_role_priority(
+                    role_id=role_id,
+                    set_role_priority_request=rest.SetRolePriorityRequest(
+                        priority=priority
+                    ),
+                    _headers=header,
+                )
+            )
+        return UserRole(**response.to_dict())