h2ogpte 1.6.41rc2__py3-none-any.whl → 1.6.41rc4__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.41rc2"
+__version__ = "1.6.41rc4"
 
 __all__ = [
     "H2OGPTE",

h2ogpte/h2ogpte.py

@@ -383,6 +383,129 @@ class H2OGPTE(H2OGPTESyncBase):
             raise SessionError(ret["error"])
         return ExtractionAnswer(**ret)
 
+    def list_extractors(
+        self,
+        offset: Optional[int] = None,
+        limit: Optional[int] = None,
+        name_filter: Optional[str] = None,
+    ) -> List[Extractor]:
+        """Lists available extractors.
+
+        Args:
+            offset: Number of extractors to skip. Defaults to server-side default (0).
+            limit: Maximum number of extractors to return. Defaults to server-side default.
+            name_filter: Filter extractors by name.
+
+        Returns:
+            List[Extractor]: A list of available extractors.
+        """
+        header = self._get_auth_header()
+
+        with self._RESTClient(self) as rest_client:
+            rest_response_items = _rest_to_client_exceptions(
+                lambda: rest_client.extractor_api.list_extractors(
+                    offset=offset, limit=limit, name_filter=name_filter, _headers=header
+                )
+            )
+
+        client_extractors = []
+        for rest_item in rest_response_items:
+            item_dict = rest_item.to_dict()
+            client_extractors.append(Extractor(**item_dict))
+        return client_extractors
+
+    def create_extractor(
+        self,
+        name: str,
+        llm: str,
+        extractor_schema: Dict[str, Any],
+        description: str = "",
+    ) -> Extractor:
+        """Creates a new extractor.
+
+        Args:
+            name: Name of the extractor.
+            llm: LLM to use for extraction.
+            extractor_schema: JSON schema defining the extraction structure.
+            description: Optional description of the extractor.
+
+        Returns:
+            Extractor: Details of the newly created extractor.
+        """
+        header = self._get_auth_header()
+
+        request_body = rest.ExtractorCreateRequest(
+            name=name,
+            description=description,
+            llm=llm,
+            schema=json.dumps(extractor_schema),
+        )
+
+        with self._RESTClient(self) as rest_client:
+            rest_response = _rest_to_client_exceptions(
+                lambda: rest_client.extractor_api.create_extractor(
+                    extractor_create_request=request_body, _headers=header
+                )
+            )
+
+        response_dict = rest_response.to_dict()
+        parsed_schema = {}
+        # The REST response gives 'schema' as a string
+        if response_dict.get("schema") and isinstance(response_dict["schema"], str):
+            try:
+                parsed_schema = json.loads(response_dict["schema"])
+            except json.JSONDecodeError:
+                pass
+        response_dict["extractor_schema"] = parsed_schema
+        response_dict.pop("schema", None)  # Remove original schema
+        return Extractor(**response_dict)
+
+    def get_extractor(self, extractor_id: str) -> Extractor:
+        """Fetches an extractor by its ID.
+
+        Args:
+            extractor_id: The ID of the extractor to retrieve.
+
+        Returns:
+            Extractor: Details of the extractor.
+
+        Raises:
+            ObjectNotFoundError: If the extractor is not found.
+        """
+        header = self._get_auth_header()
+        with self._RESTClient(self) as rest_client:
+            rest_response = _rest_to_client_exceptions(
+                lambda: rest_client.extractor_api.get_extractor(
+                    extractor_id=extractor_id, _headers=header
+                )
+            )
+
+        response_dict = rest_response.to_dict()
+        parsed_schema = {}
+        if response_dict.get("schema") and isinstance(response_dict["schema"], str):
+            try:
+                parsed_schema = json.loads(response_dict["schema"])
+            except json.JSONDecodeError:
+                pass
+        response_dict["extractor_schema"] = parsed_schema
+        response_dict.pop("schema", None)
+        return Extractor(**response_dict)
+
+    def delete_extractor(self, extractor_id: str):
+        """Deletes an extractor by its ID.
+
+        Args:
+            extractor_id: The ID of the extractor to delete.
+        """
+        header = self._get_auth_header()
+        with self._RESTClient(self) as rest_client:
+            result = _rest_to_client_exceptions(
+                lambda: rest_client.extractor_api.delete_extractor(
+                    extractor_id=extractor_id, _headers=header
+                )
+            )
+        return result
+
     def cancel_job(self, job_id: str) -> Result:
         """Stops a specific job from running on the server.
 
@@ -2889,6 +3012,26 @@ class H2OGPTE(H2OGPTESyncBase):
                 )
             )
 
+    def share_chat_session(
+        self, chat_session_id: str, expiration_days: Optional[int] = None
+    ) -> ChatShareUrl:
+        """Share a chat session and get a publicly accessible URL.
+
+        Args:
+            chat_session_id:
+                String id of the chat session to share.
+            expiration_days:
+                Number of days until the shared URL expires.
+                If not provided, defaults to 7 days.
+
+        Returns:
+            ChatShareUrl: Object containing the shareable URL and relative path.
+        """
+        response = self._sharing("share_chat", chat_session_id, expiration_days)
+        return ChatShareUrl(
+            url=response["url"], relative_path=response["relative_path"]
+        )
+
     def list_collections_for_document(
         self, document_id: str, offset: int, limit: int
     ) -> List[CollectionInfo]:

h2ogpte/h2ogpte_async.py

@@ -37,6 +37,7 @@ from h2ogpte.types import (
     ChatMessageReference,
     ChatSessionForCollection,
     ChatSessionInfo,
+    ChatShareUrl,
     Chunk,
     Collection,
     CollectionInfo,
@@ -75,7 +76,9 @@ from h2ogpte.types import (
     UserRole,
     UserGroup,
     APIKey,
+    ConfigItem,
     GlobalConfigItem,
+    Extractor,
 )
 from h2ogpte.utils import (
     _process_pdf_with_annotations,
@@ -200,6 +203,7 @@ class H2OGPTEAsync:
             self.configuration_api = rest.ConfigurationsApi(self._rest_client)
             self.agent_api = rest.AgentsApi(self._rest_client)
             self.secrets_api = rest.SecretsApi(self._rest_client)
+            self.extractor_api = rest.ExtractorsApi(self._rest_client)
             return self
 
         async def __aexit__(self, exc_type, exc_value, traceback):
@@ -583,6 +587,129 @@ class H2OGPTEAsync:
             raise SessionError(ret["error"])
         return ExtractionAnswer(**ret)
 
+    async def list_extractors(
+        self,
+        offset: Optional[int] = None,
+        limit: Optional[int] = None,
+        name_filter: Optional[str] = None,
+    ) -> List[Extractor]:
+        """Lists available extractors.
+
+        Args:
+            offset: Number of extractors to skip. Defaults to server-side default (0).
+            limit: Maximum number of extractors to return. Defaults to server-side default.
+            name_filter: Filter extractors by name.
+
+        Returns:
+            List[Extractor]: A list of available extractors.
+        """
+        header = await self._get_auth_header()
+
+        async with self._RESTClient(self) as rest_client:
+            rest_response_items = await _rest_to_client_exceptions(
+                rest_client.extractor_api.list_extractors(
+                    offset=offset, limit=limit, name_filter=name_filter, _headers=header
+                )
+            )
+
+        client_extractors = []
+        for rest_item in rest_response_items:
+            item_dict = rest_item.to_dict()
+            client_extractors.append(Extractor(**item_dict))
+        return client_extractors
+
+    async def create_extractor(
+        self,
+        name: str,
+        llm: str,
+        extractor_schema: Dict[str, Any],
+        description: str = "",
+    ) -> Extractor:
+        """Creates a new extractor.
+
+        Args:
+            name: Name of the extractor.
+            llm: LLM to use for extraction.
+            extractor_schema: JSON schema defining the extraction structure.
+            description: Optional description of the extractor.
+
+        Returns:
+            Extractor: Details of the newly created extractor.
+        """
+        header = await self._get_auth_header()
+
+        request_body = rest.ExtractorCreateRequest(
+            name=name,
+            description=description,
+            llm=llm,
+            schema=json.dumps(extractor_schema),
+        )
+
+        async with self._RESTClient(self) as rest_client:
+            rest_response = await _rest_to_client_exceptions(
+                rest_client.extractor_api.create_extractor(
+                    extractor_create_request=request_body, _headers=header
+                )
+            )
+
+        response_dict = rest_response.to_dict()
+        parsed_schema = {}
+        # The REST response gives 'schema' as a string
+        if response_dict.get("schema") and isinstance(response_dict["schema"], str):
+            try:
+                parsed_schema = json.loads(response_dict["schema"])
+            except json.JSONDecodeError:
+                pass
+        response_dict["extractor_schema"] = parsed_schema
+        response_dict.pop("schema", None)  # Remove original schema
+        return Extractor(**response_dict)
+
+    async def get_extractor(self, extractor_id: str) -> Extractor:
+        """Fetches an extractor by its ID.
+
+        Args:
+            extractor_id: The ID of the extractor to retrieve.
+
+        Returns:
+            Extractor: Details of the extractor.
+
+        Raises:
+            ObjectNotFoundError: If the extractor is not found.
+        """
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            rest_response = await _rest_to_client_exceptions(
+                rest_client.extractor_api.get_extractor(
+                    extractor_id=extractor_id, _headers=header
+                )
+            )
+
+        response_dict = rest_response.to_dict()
+        parsed_schema = {}
+        if response_dict.get("schema") and isinstance(response_dict["schema"], str):
+            try:
+                parsed_schema = json.loads(response_dict["schema"])
+            except json.JSONDecodeError:
+                pass
+        response_dict["extractor_schema"] = parsed_schema
+        response_dict.pop("schema", None)
+        return Extractor(**response_dict)
+
+    async def delete_extractor(self, extractor_id: str):
+        """Deletes an extractor by its ID.
+
+        Args:
+            extractor_id: The ID of the extractor to delete.
+        """
+        header = await self._get_auth_header()
+        async with self._RESTClient(self) as rest_client:
+            result = await _rest_to_client_exceptions(
+                rest_client.extractor_api.delete_extractor(
+                    extractor_id=extractor_id, _headers=header
+                )
+            )
+        return result
+
     async def cancel_job(self, job_id: str) -> Result:
         """Stops a specific job from running on the server.
 
@@ -3083,6 +3210,26 @@ class H2OGPTEAsync:
                 )
             )
 
+    async def share_chat_session(
+        self, chat_session_id: str, expiration_days: Optional[int] = None
+    ) -> ChatShareUrl:
+        """Share a chat session and get a publicly accessible URL.
+
+        Args:
+            chat_session_id:
+                String id of the chat session to share.
+            expiration_days:
+                Number of days until the shared URL expires.
+                If not provided, defaults to 7 days.
+
+        Returns:
+            ChatShareUrl: Object containing the shareable URL and relative path.
+        """
+        response = await self._sharing("share_chat", chat_session_id, expiration_days)
+        return ChatShareUrl(
+            url=response["url"], relative_path=response["relative_path"]
+        )
+
     async def list_collections_for_document(
         self, document_id: str, offset: int, limit: int
     ) -> List[CollectionInfo]:
@@ -6820,6 +6967,14 @@ class H2OGPTEAsync:
         request_id = str(uuid.uuid4())
         return await self._post("/rpc/job", [method, kwargs, request_id])
 
+    async def _sharing(
+        self, method: str, chat_session_id: str, expiration_days: Optional[int] = None
+    ) -> Any:
+        args = [method, chat_session_id]
+        if expiration_days is not None:
+            args.append(expiration_days)
+        return await self._post("/rpc/sharing", args)
+
     async def _wait_for_completion(
         self, job_id: str, timeout: Optional[float] = None
     ) -> Job:

h2ogpte/h2ogpte_sync_base.py

@@ -94,6 +94,7 @@ class H2OGPTESyncBase:
         self._configuration_api = rest.ConfigurationsApi(self._rest_client)
         self._agent_api = rest.AgentsApi(self._rest_client)
         self._secrets_api = rest.SecretsApi(self._rest_client)
+        self._extractor_api = rest.ExtractorsApi(self._rest_client)
 
     class _RESTClient:
         def __init__(self, h2ogpte):
@@ -112,6 +113,7 @@ class H2OGPTESyncBase:
             self.configuration_api = h2ogpte._configuration_api
             self.agent_api = h2ogpte._agent_api
             self.secrets_api = h2ogpte._secrets_api
+            self.extractor_api = h2ogpte._extractor_api
 
         def __enter__(self):
             return self
@@ -273,6 +275,14 @@ class H2OGPTESyncBase:
             marshal(dict(method=method, collection_id=collection_id, params=kwargs)),
         )
 
+    def _sharing(
+        self, method: str, chat_session_id: str, expiration_days: Optional[int] = None
+    ) -> Any:
+        args = [method, chat_session_id]
+        if expiration_days is not None:
+            args.append(expiration_days)
+        return self._post("/rpc/sharing", marshal(args))
+
     def _crawl_func(self, name: str, **kwargs: Any) -> Any:
         response = self._post("/rpc/crawl/func", marshal([name, kwargs]))
         return response

h2ogpte/rest_async/__init__.py

@@ -14,7 +14,7 @@
 """  # noqa: E501
 
 
-__version__ = "1.6.41-dev2"
+__version__ = "1.6.41-dev4"
 
 # import apis into sdk package
 from h2ogpte.rest_async.api.api_keys_api import APIKeysApi
@@ -24,6 +24,7 @@ from h2ogpte.rest_async.api.collections_api import CollectionsApi
 from h2ogpte.rest_async.api.configurations_api import ConfigurationsApi
 from h2ogpte.rest_async.api.document_ingestion_api import DocumentIngestionApi
 from h2ogpte.rest_async.api.documents_api import DocumentsApi
+from h2ogpte.rest_async.api.extractors_api import ExtractorsApi
 from h2ogpte.rest_async.api.jobs_api import JobsApi
 from h2ogpte.rest_async.api.models_api import ModelsApi
 from h2ogpte.rest_async.api.permissions_api import PermissionsApi
@@ -97,6 +98,8 @@ from h2ogpte.rest_async.models.embedding_model import EmbeddingModel
 from h2ogpte.rest_async.models.encode_chunks_for_retrieval_request import EncodeChunksForRetrievalRequest
 from h2ogpte.rest_async.models.endpoint_error import EndpointError
 from h2ogpte.rest_async.models.extraction_request import ExtractionRequest
+from h2ogpte.rest_async.models.extractor import Extractor
+from h2ogpte.rest_async.models.extractor_create_request import ExtractorCreateRequest
 from h2ogpte.rest_async.models.gcs_credentials import GCSCredentials
 from h2ogpte.rest_async.models.global_configuration_item import GlobalConfigurationItem
 from h2ogpte.rest_async.models.group_create_request import GroupCreateRequest

h2ogpte/rest_async/api/__init__.py

@@ -8,6 +8,7 @@ from h2ogpte.rest_async.api.collections_api import CollectionsApi
 from h2ogpte.rest_async.api.configurations_api import ConfigurationsApi
 from h2ogpte.rest_async.api.document_ingestion_api import DocumentIngestionApi
 from h2ogpte.rest_async.api.documents_api import DocumentsApi
+from h2ogpte.rest_async.api.extractors_api import ExtractorsApi
 from h2ogpte.rest_async.api.jobs_api import JobsApi
 from h2ogpte.rest_async.api.models_api import ModelsApi
 from h2ogpte.rest_async.api.permissions_api import PermissionsApi