h2ogpte 1.6.43rc8__py3-none-any.whl → 1.6.44__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.43rc8"
+__version__ = "1.6.44"
 
 __all__ = [
     "H2OGPTE",

h2ogpte/connectors.py

@@ -49,22 +49,28 @@ def create_ingest_job_from_cloud_storage(
 class S3Credential:
     def __init__(
         self,
-        access_key_id: str,
-        secret_access_key: str,
+        access_key_id: str = None,
+        secret_access_key: str = None,
         session_token: str = None,
         role_arn: str = None,
+        external_id: str = None,
+        use_irsa: bool = False,
     ):
         """
         Creates an object with S3 credentials.
-        :param access_key_id: Access Key ID
-        :param secret_access_key: Secret Access Key
+        :param access_key_id: Access Key ID (not required when using IRSA)
+        :param secret_access_key: Secret Access Key (not required when using IRSA)
         :param session_token: Session Token (optional)
         :param role_arn: Role providing access to the S3 storage
+        :param external_id: External ID for cross-account role assumption (optional)
+        :param use_irsa: Enable IAM Roles for Service Accounts (IRSA) - set to True to use pod service account
         """
         self.access_key_id = access_key_id
         self.secret_access_key = secret_access_key
         self.session_token = session_token
         self.role_arn = role_arn
+        self.external_id = external_id
+        self.use_irsa = use_irsa
 
 
 def create_ingest_job_from_s3(

h2ogpte/h2ogpte.py

@@ -1249,6 +1249,22 @@ class H2OGPTE(H2OGPTESyncBase):
             )
         return collection_id
 
+    def reset_all_collection_expirations(self):
+        """
+        Reset any expiry dates and inactivity intervals that have been set for all collections (admin only). This will also reset any archived collections back to active.
+        """
+
+        header = self._get_auth_header()
+        with self._RESTClient(self) as rest_client:
+            result = _get_result(
+                lambda: _rest_to_client_exceptions(
+                    lambda: rest_client.collection_api.reset_all_collection_expirations(
+                        _headers=header,
+                    )
+                )
+            )
+        return result
+
     def set_collection_size_limit(
         self, collection_id: str, limit: Union[int, str]
     ) -> str:
@@ -6389,6 +6405,22 @@ class H2OGPTE(H2OGPTESyncBase):
             )
         return result
 
+    def remove_permissions_from_role(
+        self, role_id: str, permission_name: str
+    ) -> Result:
+        header = self._get_auth_header()
+        with self._RESTClient(self) as rest_client:
+            result = _get_result(
+                lambda: _rest_to_client_exceptions(
+                    lambda: rest_client.permission_api.remove_permission_from_role(
+                        role_id=role_id,
+                        permission_name=permission_name,
+                        _headers=header,
+                    )
+                )
+            )
+        return result
+
     def set_global_configuration(
         self,
         key_name: str,
@@ -6927,6 +6959,37 @@ class H2OGPTE(H2OGPTESyncBase):
             )
 
     def add_agent_key(self, agent_keys: List[dict]) -> List[dict]:
+        """Create one or more agent keys for use with agent tools.
+
+        Processes a list of agent key configurations and creates each key.
+        Continues processing remaining keys if individual key creation fails.
+
+        Args:
+            agent_keys: List of key configuration dictionaries.
+
+                Expected structure::
+
+                    [
+                        {
+                            "name": str,
+                                # Display name for the key
+
+                            "value": str,
+                                # The actual key/token value
+
+                            "key_type": str,
+                                # Type of key ("private" or "shared")
+
+                            "description": str,
+                                # (Optional) Description of the key's purpose
+                        }
+                    ]
+
+        Returns:
+            List[dict]: List of created key results. Each successful creation
+                returns {"agent_key_id": str}. Failed creations are logged but
+                don't appear in results.
+        """
         result = []
         header = self._get_auth_header()
         with self._RESTClient(self) as rest_client:
@@ -6993,6 +7056,29 @@ class H2OGPTE(H2OGPTESyncBase):
     def assign_agent_key_for_tool(
         self, tool_dict_list: List[dict]
     ) -> Optional[List[Tuple]]:
+        """Assign agent keys to tools by creating associations between them.
+
+        Args:
+            tool_dict_list: List of dictionaries containing tool association data.
+                Each dictionary should have a "tool_dict" key with the association
+                configuration data for creating agent tool key associations.
+
+                Expected tool_dict structure::
+
+                    {
+                        "tool": str,        # Name of the tool (for example, "test_tool").
+                        "keys": list[dict], # List of key definitions. Each item is a dictionary with:
+                                           #   - "name": str
+                                           #       Environment variable name (for example, "TEST_KEY").
+                                           #   - "key_id": Any
+                                           #       Identifier assigned to the key (for example, agent_key_id).
+                    }
+
+        Returns:
+            Optional[List[Tuple]]: List of tuples containing association details.
+                Each tuple contains (associate_id, tool, key_name, key_id, user_id).
+                Returns None if no associations were created.
+        """
         result = []
         header = self._get_auth_header()
         with self._RESTClient(self) as rest_client:

h2ogpte/h2ogpte_async.py

@@ -1449,6 +1449,22 @@ class H2OGPTEAsync:
             )
         return collection_id
 
+    async def reset_all_collection_expirations(self):
+        """
+        Reset any expiry dates and inactivity intervals that have been set for all collections (admin only). This will also reset any archived collections back to active.
+        """
+
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            result = _get_result(
+                await _rest_to_client_exceptions(
+                    rest_client.collection_api.reset_all_collection_expirations(
+                        _headers=header,
+                    )
+                )
+            )
+        return result
+
     async def set_collection_size_limit(
         self, collection_id: str, limit: Union[int, str]
     ) -> str:
@@ -6650,6 +6666,22 @@ class H2OGPTEAsync:
             )
         return result
 
+    async def remove_permissions_from_role(
+        self, role_id: str, permission_name: str
+    ) -> Result:
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            result = await _get_result(
+                _rest_to_client_exceptions(
+                    rest_client.permission_api.remove_permission_from_role(
+                        role_id=role_id,
+                        permission_name=permission_name,
+                        _headers=header,
+                    )
+                )
+            )
+        return result
+
     async def set_global_configuration(
         self,
         key_name: str,
@@ -7184,6 +7216,37 @@ class H2OGPTEAsync:
             )
 
     async def add_agent_key(self, agent_keys: List[dict]) -> List[dict]:
+        """Create one or more agent keys for use with agent tools.
+
+        Processes a list of agent key configurations and creates each key.
+        Continues processing remaining keys if individual key creation fails.
+
+        Args:
+            agent_keys: List of key configuration dictionaries.
+
+                Expected structure::
+
+                    [
+                        {
+                            "name": str,
+                                # Display name for the key
+
+                            "value": str,
+                                # The actual key/token value
+
+                            "key_type": str,
+                                # Type of key ("private" or "shared")
+
+                            "description": str,
+                                # (Optional) Description of the key's purpose
+                        }
+                    ]
+
+        Returns:
+            List[dict]: List of created key results. Each successful creation
+                returns {"agent_key_id": str}. Failed creations are logged but
+                don't appear in results.
+        """
         result = []
         header = await self._get_auth_header()
         async with self._RESTClient(self) as rest_client:
@@ -7250,6 +7313,29 @@ class H2OGPTEAsync:
     async def assign_agent_key_for_tool(
         self, tool_dict_list: List[dict]
     ) -> Optional[List[Tuple]]:
+        """Assign agent keys to tools by creating associations between them.
+
+        Args:
+            tool_dict_list: List of dictionaries containing tool association data.
+                Each dictionary should have a "tool_dict" key with the association
+                configuration data for creating agent tool key associations.
+
+                Expected tool_dict structure::
+
+                    {
+                        "tool": str,        # Name of the tool (for example, "test_tool").
+                        "keys": list[dict], # List of key definitions. Each item is a dictionary with:
+                                           #   - "name": str
+                                           #       Environment variable name (for example, "TEST_KEY").
+                                           #   - "key_id": Any
+                                           #       Identifier assigned to the key (for example, agent_key_id).
+                    }
+
+        Returns:
+            Optional[List[Tuple]]: List of tuples containing association details.
+                Each tuple contains (associate_id, tool, key_name, key_id, user_id).
+                Returns None if no associations were created.
+        """
         result = []
         header = await self._get_auth_header()
         async with self._RESTClient(self) as rest_client:

h2ogpte/rest_async/__init__.py

@@ -14,7 +14,7 @@
 """  # noqa: E501
 
 
-__version__ = "1.6.43-dev8"
+__version__ = "1.6.44"
 
 # import apis into sdk package
 from h2ogpte.rest_async.api.api_keys_api import APIKeysApi

h2ogpte/rest_async/api/collections_api.py

@@ -9559,6 +9559,255 @@ class CollectionsApi:
 
 
 
+    @validate_call
+    async def reset_all_collection_expirations(
+        self,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> None:
+        """Reset all collection expiry dates and inactivity intervals that have been set.
+
+        Reset any expiry dates and inactivity intervals that have been set for all collections (admin only). This will also reset any archived collections back to active.
+
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._reset_all_collection_expirations_serialize(
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '204': None,
+            '401': "EndpointError",
+        }
+        response_data = await self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        await response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    async def reset_all_collection_expirations_with_http_info(
+        self,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[None]:
+        """Reset all collection expiry dates and inactivity intervals that have been set.
+
+        Reset any expiry dates and inactivity intervals that have been set for all collections (admin only). This will also reset any archived collections back to active.
+
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._reset_all_collection_expirations_serialize(
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '204': None,
+            '401': "EndpointError",
+        }
+        response_data = await self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        await response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    async def reset_all_collection_expirations_without_preload_content(
+        self,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Reset all collection expiry dates and inactivity intervals that have been set.
+
+        Reset any expiry dates and inactivity intervals that have been set for all collections (admin only). This will also reset any archived collections back to active.
+
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._reset_all_collection_expirations_serialize(
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '204': None,
+            '401': "EndpointError",
+        }
+        response_data = await self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _reset_all_collection_expirations_serialize(
+        self,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearerAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/collections/reset_all_collection_expirations',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
     @validate_call
     async def reset_collection_prompt_settings(
         self,

h2ogpte/rest_async/api/permissions_api.py

@@ -7082,7 +7082,7 @@ class PermissionsApi:
     @validate_call
     async def remove_permission_from_role(
         self,
-        role_id: Annotated[StrictStr, Field(description="The unique identifier of an user.")],
+        role_id: Annotated[StrictStr, Field(description="The unique identifier of the role.")],
         permission_name: Annotated[StrictStr, Field(description="The permission name.")],
         _request_timeout: Union[
             None,
@@ -7101,7 +7101,7 @@ class PermissionsApi:
 
         Removes permission from a given role.
 
-        :param role_id: The unique identifier of an user. (required)
+        :param role_id: The unique identifier of the role. (required)
         :type role_id: str
         :param permission_name: The permission name. (required)
         :type permission_name: str
@@ -7155,7 +7155,7 @@ class PermissionsApi:
     @validate_call
     async def remove_permission_from_role_with_http_info(
         self,
-        role_id: Annotated[StrictStr, Field(description="The unique identifier of an user.")],
+        role_id: Annotated[StrictStr, Field(description="The unique identifier of the role.")],
         permission_name: Annotated[StrictStr, Field(description="The permission name.")],
         _request_timeout: Union[
             None,
@@ -7174,7 +7174,7 @@ class PermissionsApi:
 
         Removes permission from a given role.
 
-        :param role_id: The unique identifier of an user. (required)
+        :param role_id: The unique identifier of the role. (required)
         :type role_id: str
         :param permission_name: The permission name. (required)
         :type permission_name: str
@@ -7228,7 +7228,7 @@ class PermissionsApi:
     @validate_call
     async def remove_permission_from_role_without_preload_content(
         self,
-        role_id: Annotated[StrictStr, Field(description="The unique identifier of an user.")],
+        role_id: Annotated[StrictStr, Field(description="The unique identifier of the role.")],
         permission_name: Annotated[StrictStr, Field(description="The permission name.")],
         _request_timeout: Union[
             None,
@@ -7247,7 +7247,7 @@ class PermissionsApi:
 
         Removes permission from a given role.
 
-        :param role_id: The unique identifier of an user. (required)
+        :param role_id: The unique identifier of the role. (required)
         :type role_id: str
         :param permission_name: The permission name. (required)
         :type permission_name: str

h2ogpte/rest_async/api_client.py

@@ -90,7 +90,7 @@ class ApiClient:
             self.default_headers[header_name] = header_value
         self.cookie = cookie
         # Set default User-Agent.
-        self.user_agent = 'OpenAPI-Generator/1.6.43-dev8/python'
+        self.user_agent = 'OpenAPI-Generator/1.6.44/python'
         self.client_side_validation = configuration.client_side_validation
 
     async def __aenter__(self):

h2ogpte/rest_async/configuration.py

@@ -499,7 +499,7 @@ class Configuration:
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
                "Version of the API: v1.0.0\n"\
-               "SDK Package Version: 1.6.43-dev8".\
+               "SDK Package Version: 1.6.44".\
                format(env=sys.platform, pyversion=sys.version)
 
     def get_host_settings(self) -> List[HostSetting]:

h2ogpte/rest_async/models/global_configuration_item.py

@@ -32,7 +32,11 @@ class GlobalConfigurationItem(BaseModel):
     can_overwrite: StrictBool
     upper_bound: Optional[Union[StrictFloat, StrictInt]] = None
     is_public: StrictBool
-    __properties: ClassVar[List[str]] = ["key_name", "string_value", "value_type", "can_overwrite", "upper_bound", "is_public"]
+    is_read_only: Optional[StrictBool] = None
+    is_encrypted: Optional[StrictBool] = None
+    description: Optional[StrictStr] = None
+    category: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["key_name", "string_value", "value_type", "can_overwrite", "upper_bound", "is_public", "is_read_only", "is_encrypted", "description", "category"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -90,7 +94,11 @@ class GlobalConfigurationItem(BaseModel):
             "value_type": obj.get("value_type"),
             "can_overwrite": obj.get("can_overwrite"),
             "upper_bound": obj.get("upper_bound"),
-            "is_public": obj.get("is_public")
+            "is_public": obj.get("is_public"),
+            "is_read_only": obj.get("is_read_only"),
+            "is_encrypted": obj.get("is_encrypted"),
+            "description": obj.get("description"),
+            "category": obj.get("category")
         })
         return _obj