groundx 2.0.17__py3-none-any.whl → 2.0.19__py3-none-any.whl

groundx/__init__.py

@@ -22,6 +22,7 @@ from .types import (
     HealthResponseHealth,
     HealthService,
     HealthServiceStatus,
+    IngestDocument,
     IngestLocalDocument,
     IngestRemoteDocument,
     IngestResponse,
@@ -77,6 +78,7 @@ __all__ = [
     "HealthResponseHealth",
     "HealthService",
     "HealthServiceStatus",
+    "IngestDocument",
     "IngestLocalDocument",
     "IngestRemoteDocument",
     "IngestResponse",

groundx/core/client_wrapper.py

@@ -16,7 +16,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "groundx",
-            "X-Fern-SDK-Version": "2.0.17",
+            "X-Fern-SDK-Version": "2.0.19",
         }
         headers["X-API-Key"] = self.api_key
         return headers

groundx/documents/client.py

@@ -2,24 +2,25 @@
 
 import typing
 from ..core.client_wrapper import SyncClientWrapper
-from ..types.ingest_remote_document import IngestRemoteDocument
+from ..types.sort import Sort
+from ..types.sort_order import SortOrder
+from ..types.processing_status import ProcessingStatus
 from ..core.request_options import RequestOptions
+from ..types.document_list_response import DocumentListResponse
+from ..core.pydantic_utilities import parse_obj_as
+from json.decoder import JSONDecodeError
+from ..core.api_error import ApiError
+from ..types.ingest_document import IngestDocument
 from ..types.ingest_response import IngestResponse
 from ..core.serialization import convert_and_respect_annotation_metadata
-from ..core.pydantic_utilities import parse_obj_as
 from ..errors.bad_request_error import BadRequestError
 from ..errors.unauthorized_error import UnauthorizedError
-from json.decoder import JSONDecodeError
-from ..core.api_error import ApiError
+from ..types.ingest_remote_document import IngestRemoteDocument
 from ..types.ingest_local_document import IngestLocalDocument
 from ..types.crawl_website_source import CrawlWebsiteSource
 from ..types.process_status_response import ProcessStatusResponse
 from ..core.jsonable_encoder import jsonable_encoder
-from ..types.sort import Sort
-from ..types.sort_order import SortOrder
-from ..types.processing_status import ProcessingStatus
 from ..types.document_lookup_response import DocumentLookupResponse
-from ..types.document_list_response import DocumentListResponse
 from ..types.document_response import DocumentResponse
 from ..core.client_wrapper import AsyncClientWrapper
 
@@ -31,6 +32,248 @@ class DocumentsClient:
     def __init__(self, *, client_wrapper: SyncClientWrapper):
         self._client_wrapper = client_wrapper
 
+    def list(
+        self,
+        *,
+        n: typing.Optional[int] = None,
+        filter: typing.Optional[str] = None,
+        sort: typing.Optional[Sort] = None,
+        sort_order: typing.Optional[SortOrder] = None,
+        status: typing.Optional[ProcessingStatus] = None,
+        next_token: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> DocumentListResponse:
+        """
+        lookup all documents across all resources which are currently on GroundX
+
+        Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
+
+        Parameters
+        ----------
+        n : typing.Optional[int]
+            The maximum number of returned documents. Accepts 1-100 with a default of 20.
+
+        filter : typing.Optional[str]
+            Only documents with names that contain the filter string will be returned in the results.
+
+        sort : typing.Optional[Sort]
+            The document attribute that will be used to sort the results.
+
+        sort_order : typing.Optional[SortOrder]
+            The order in which to sort the results. A value for sort must also be set.
+
+        status : typing.Optional[ProcessingStatus]
+            A status filter on the get documents query. If this value is set, then only documents with this status will be returned in the results.
+
+        next_token : typing.Optional[str]
+            A token for pagination. If the number of documents for a given query is larger than n, the response will include a "nextToken" value. That token can be included in this field to retrieve the next batch of n documents.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        DocumentListResponse
+            Look up success
+
+        Examples
+        --------
+        from groundx import GroundX
+
+        client = GroundX(
+            api_key="YOUR_API_KEY",
+        )
+        client.documents.list()
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "v1/ingest/documents",
+            method="GET",
+            params={
+                "n": n,
+                "filter": filter,
+                "sort": sort,
+                "sortOrder": sort_order,
+                "status": status,
+                "nextToken": next_token,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    DocumentListResponse,
+                    parse_obj_as(
+                        type_=DocumentListResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def ingest(
+        self, *, documents: typing.Sequence[IngestDocument], request_options: typing.Optional[RequestOptions] = None
+    ) -> IngestResponse:
+        """
+        Ingest documents hosted on public URLs or a local file system for ingestion into a GroundX bucket.
+
+        Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
+
+        Parameters
+        ----------
+        documents : typing.Sequence[IngestDocument]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        IngestResponse
+            Documents successfully uploaded
+
+        Examples
+        --------
+        from groundx import GroundX, IngestDocument
+
+        client = GroundX(
+            api_key="YOUR_API_KEY",
+        )
+        client.documents.ingest(
+            documents=[
+                IngestDocument(
+                    bucket_id=1234,
+                    file_name="my_file.txt",
+                    file_path="https://my.source.url.com/file.txt",
+                    file_type="txt",
+                    search_data={"key": "value"},
+                )
+            ],
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "v1/ingest/documents",
+            method="POST",
+            json={
+                "documents": convert_and_respect_annotation_metadata(
+                    object_=documents, annotation=typing.Sequence[IngestDocument], direction="write"
+                ),
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    IngestResponse,
+                    parse_obj_as(
+                        type_=IngestResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def delete(
+        self,
+        *,
+        document_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> IngestResponse:
+        """
+        Delete multiple documents hosted on GroundX
+
+        Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
+
+        Parameters
+        ----------
+        document_ids : typing.Optional[typing.Union[str, typing.Sequence[str]]]
+            A list of documentIds which correspond to documents ingested by GroundX
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        IngestResponse
+            Documents are queued to be deleted
+
+        Examples
+        --------
+        from groundx import GroundX
+
+        client = GroundX(
+            api_key="YOUR_API_KEY",
+        )
+        client.documents.delete()
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "v1/ingest/documents",
+            method="DELETE",
+            params={
+                "documentIds": document_ids,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    IngestResponse,
+                    parse_obj_as(
+                        type_=IngestResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
     def ingest_remote(
         self,
         *,
@@ -471,48 +714,23 @@ class DocumentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def list(
-        self,
-        *,
-        n: typing.Optional[int] = None,
-        filter: typing.Optional[str] = None,
-        sort: typing.Optional[Sort] = None,
-        sort_order: typing.Optional[SortOrder] = None,
-        status: typing.Optional[ProcessingStatus] = None,
-        next_token: typing.Optional[str] = None,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> DocumentListResponse:
+    def get(self, document_id: str, *, request_options: typing.Optional[RequestOptions] = None) -> DocumentResponse:
         """
-        lookup all documents across all resources which are currently on GroundX
+        Look up an existing document by documentId.
 
         Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
 
         Parameters
         ----------
-        n : typing.Optional[int]
-            The maximum number of returned documents. Accepts 1-100 with a default of 20.
-
-        filter : typing.Optional[str]
-            Only documents with names that contain the filter string will be returned in the results.
-
-        sort : typing.Optional[Sort]
-            The document attribute that will be used to sort the results.
-
-        sort_order : typing.Optional[SortOrder]
-            The order in which to sort the results. A value for sort must also be set.
-
-        status : typing.Optional[ProcessingStatus]
-            A status filter on the get documents query. If this value is set, then only documents with this status will be returned in the results.
-
-        next_token : typing.Optional[str]
-            A token for pagination. If the number of documents for a given query is larger than n, the response will include a "nextToken" value. That token can be included in this field to retrieve the next batch of n documents.
+        document_id : str
+            The documentId of the document for which GroundX information will be provided.
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        DocumentListResponse
+        DocumentResponse
             Look up success
 
         Examples
@@ -522,50 +740,61 @@ class DocumentsClient:
         client = GroundX(
             api_key="YOUR_API_KEY",
         )
-        client.documents.list()
+        client.documents.get(
+            document_id="documentId",
+        )
         """
         _response = self._client_wrapper.httpx_client.request(
-            "v1/ingest/documents",
+            f"v1/ingest/document/{jsonable_encoder(document_id)}",
             method="GET",
-            params={
-                "n": n,
-                "filter": filter,
-                "sort": sort,
-                "sortOrder": sort_order,
-                "status": status,
-                "nextToken": next_token,
-            },
             request_options=request_options,
         )
         try:
             if 200 <= _response.status_code < 300:
                 return typing.cast(
-                    DocumentListResponse,
+                    DocumentResponse,
                     parse_obj_as(
-                        type_=DocumentListResponse,  # type: ignore
+                        type_=DocumentResponse,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def delete(
-        self,
-        *,
-        document_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
-        request_options: typing.Optional[RequestOptions] = None,
+    def delete_by_id(
+        self, document_id: str, *, request_options: typing.Optional[RequestOptions] = None
     ) -> IngestResponse:
         """
-        Delete multiple documents hosted on GroundX
+        Delete a single document hosted on GroundX
 
         Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
 
         Parameters
         ----------
-        document_ids : typing.Optional[typing.Union[str, typing.Sequence[str]]]
-            A list of documentIds which correspond to documents ingested by GroundX
+        document_id : str
+            A documentId which correspond to a document ingested by GroundX
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -573,7 +802,7 @@ class DocumentsClient:
         Returns
         -------
         IngestResponse
-            Documents are queued to be deleted
+            Document successfully deleted
 
         Examples
         --------
@@ -582,14 +811,13 @@ class DocumentsClient:
         client = GroundX(
             api_key="YOUR_API_KEY",
         )
-        client.documents.delete()
+        client.documents.delete_by_id(
+            document_id="documentId",
+        )
         """
         _response = self._client_wrapper.httpx_client.request(
-            "v1/ingest/documents",
+            f"v1/ingest/document/{jsonable_encoder(document_id)}",
             method="DELETE",
-            params={
-                "documentIds": document_ids,
-            },
             request_options=request_options,
         )
         try:
@@ -626,47 +854,166 @@ class DocumentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def get(self, document_id: str, *, request_options: typing.Optional[RequestOptions] = None) -> DocumentResponse:
+
+class AsyncDocumentsClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    async def list(
+        self,
+        *,
+        n: typing.Optional[int] = None,
+        filter: typing.Optional[str] = None,
+        sort: typing.Optional[Sort] = None,
+        sort_order: typing.Optional[SortOrder] = None,
+        status: typing.Optional[ProcessingStatus] = None,
+        next_token: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> DocumentListResponse:
         """
-        Look up an existing document by documentId.
+        lookup all documents across all resources which are currently on GroundX
 
         Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
 
         Parameters
         ----------
-        document_id : str
-            The documentId of the document for which GroundX information will be provided.
+        n : typing.Optional[int]
+            The maximum number of returned documents. Accepts 1-100 with a default of 20.
+
+        filter : typing.Optional[str]
+            Only documents with names that contain the filter string will be returned in the results.
+
+        sort : typing.Optional[Sort]
+            The document attribute that will be used to sort the results.
+
+        sort_order : typing.Optional[SortOrder]
+            The order in which to sort the results. A value for sort must also be set.
+
+        status : typing.Optional[ProcessingStatus]
+            A status filter on the get documents query. If this value is set, then only documents with this status will be returned in the results.
+
+        next_token : typing.Optional[str]
+            A token for pagination. If the number of documents for a given query is larger than n, the response will include a "nextToken" value. That token can be included in this field to retrieve the next batch of n documents.
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        DocumentResponse
+        DocumentListResponse
             Look up success
 
         Examples
         --------
-        from groundx import GroundX
+        import asyncio
+
+        from groundx import AsyncGroundX
+
+        client = AsyncGroundX(
+            api_key="YOUR_API_KEY",
+        )
+
+
+        async def main() -> None:
+            await client.documents.list()
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "v1/ingest/documents",
+            method="GET",
+            params={
+                "n": n,
+                "filter": filter,
+                "sort": sort,
+                "sortOrder": sort_order,
+                "status": status,
+                "nextToken": next_token,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    DocumentListResponse,
+                    parse_obj_as(
+                        type_=DocumentListResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def ingest(
+        self, *, documents: typing.Sequence[IngestDocument], request_options: typing.Optional[RequestOptions] = None
+    ) -> IngestResponse:
+        """
+        Ingest documents hosted on public URLs or a local file system for ingestion into a GroundX bucket.
+
+        Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
+
+        Parameters
+        ----------
+        documents : typing.Sequence[IngestDocument]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        IngestResponse
+            Documents successfully uploaded
+
+        Examples
+        --------
+        import asyncio
 
-        client = GroundX(
+        from groundx import AsyncGroundX, IngestDocument
+
+        client = AsyncGroundX(
             api_key="YOUR_API_KEY",
         )
-        client.documents.get(
-            document_id="documentId",
-        )
+
+
+        async def main() -> None:
+            await client.documents.ingest(
+                documents=[
+                    IngestDocument(
+                        bucket_id=1234,
+                        file_name="my_file.txt",
+                        file_path="https://my.source.url.com/file.txt",
+                        file_type="txt",
+                        search_data={"key": "value"},
+                    )
+                ],
+            )
+
+
+        asyncio.run(main())
         """
-        _response = self._client_wrapper.httpx_client.request(
-            f"v1/ingest/document/{jsonable_encoder(document_id)}",
-            method="GET",
+        _response = await self._client_wrapper.httpx_client.request(
+            "v1/ingest/documents",
+            method="POST",
+            json={
+                "documents": convert_and_respect_annotation_metadata(
+                    object_=documents, annotation=typing.Sequence[IngestDocument], direction="write"
+                ),
+            },
+            headers={
+                "content-type": "application/json",
+            },
             request_options=request_options,
+            omit=OMIT,
         )
         try:
             if 200 <= _response.status_code < 300:
                 return typing.cast(
-                    DocumentResponse,
+                    IngestResponse,
                     parse_obj_as(
-                        type_=DocumentResponse,  # type: ignore
+                        type_=IngestResponse,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
@@ -695,18 +1042,21 @@ class DocumentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def delete_by_id(
-        self, document_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    async def delete(
+        self,
+        *,
+        document_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        request_options: typing.Optional[RequestOptions] = None,
     ) -> IngestResponse:
         """
-        Delete a single document hosted on GroundX
+        Delete multiple documents hosted on GroundX
 
         Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
 
         Parameters
         ----------
-        document_id : str
-            A documentId which correspond to a document ingested by GroundX
+        document_ids : typing.Optional[typing.Union[str, typing.Sequence[str]]]
+            A list of documentIds which correspond to documents ingested by GroundX
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -714,22 +1064,31 @@ class DocumentsClient:
         Returns
         -------
         IngestResponse
-            Document successfully deleted
+            Documents are queued to be deleted
 
         Examples
         --------
-        from groundx import GroundX
+        import asyncio
 
-        client = GroundX(
+        from groundx import AsyncGroundX
+
+        client = AsyncGroundX(
             api_key="YOUR_API_KEY",
         )
-        client.documents.delete_by_id(
-            document_id="documentId",
-        )
+
+
+        async def main() -> None:
+            await client.documents.delete()
+
+
+        asyncio.run(main())
         """
-        _response = self._client_wrapper.httpx_client.request(
-            f"v1/ingest/document/{jsonable_encoder(document_id)}",
+        _response = await self._client_wrapper.httpx_client.request(
+            "v1/ingest/documents",
             method="DELETE",
+            params={
+                "documentIds": document_ids,
+            },
             request_options=request_options,
         )
         try:
@@ -766,11 +1125,6 @@ class DocumentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-
-class AsyncDocumentsClient:
-    def __init__(self, *, client_wrapper: AsyncClientWrapper):
-        self._client_wrapper = client_wrapper
-
     async def ingest_remote(
         self,
         *,
@@ -1251,177 +1605,6 @@ class AsyncDocumentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def list(
-        self,
-        *,
-        n: typing.Optional[int] = None,
-        filter: typing.Optional[str] = None,
-        sort: typing.Optional[Sort] = None,
-        sort_order: typing.Optional[SortOrder] = None,
-        status: typing.Optional[ProcessingStatus] = None,
-        next_token: typing.Optional[str] = None,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> DocumentListResponse:
-        """
-        lookup all documents across all resources which are currently on GroundX
-
-        Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
-
-        Parameters
-        ----------
-        n : typing.Optional[int]
-            The maximum number of returned documents. Accepts 1-100 with a default of 20.
-
-        filter : typing.Optional[str]
-            Only documents with names that contain the filter string will be returned in the results.
-
-        sort : typing.Optional[Sort]
-            The document attribute that will be used to sort the results.
-
-        sort_order : typing.Optional[SortOrder]
-            The order in which to sort the results. A value for sort must also be set.
-
-        status : typing.Optional[ProcessingStatus]
-            A status filter on the get documents query. If this value is set, then only documents with this status will be returned in the results.
-
-        next_token : typing.Optional[str]
-            A token for pagination. If the number of documents for a given query is larger than n, the response will include a "nextToken" value. That token can be included in this field to retrieve the next batch of n documents.
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        DocumentListResponse
-            Look up success
-
-        Examples
-        --------
-        import asyncio
-
-        from groundx import AsyncGroundX
-
-        client = AsyncGroundX(
-            api_key="YOUR_API_KEY",
-        )
-
-
-        async def main() -> None:
-            await client.documents.list()
-
-
-        asyncio.run(main())
-        """
-        _response = await self._client_wrapper.httpx_client.request(
-            "v1/ingest/documents",
-            method="GET",
-            params={
-                "n": n,
-                "filter": filter,
-                "sort": sort,
-                "sortOrder": sort_order,
-                "status": status,
-                "nextToken": next_token,
-            },
-            request_options=request_options,
-        )
-        try:
-            if 200 <= _response.status_code < 300:
-                return typing.cast(
-                    DocumentListResponse,
-                    parse_obj_as(
-                        type_=DocumentListResponse,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
-
-    async def delete(
-        self,
-        *,
-        document_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> IngestResponse:
-        """
-        Delete multiple documents hosted on GroundX
-
-        Interact with the "Request Body" below to explore the arguments of this function. Enter your GroundX API key to send a request directly from this web page. Select your language of choice to structure a code snippet based on your specified arguments.
-
-        Parameters
-        ----------
-        document_ids : typing.Optional[typing.Union[str, typing.Sequence[str]]]
-            A list of documentIds which correspond to documents ingested by GroundX
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        IngestResponse
-            Documents are queued to be deleted
-
-        Examples
-        --------
-        import asyncio
-
-        from groundx import AsyncGroundX
-
-        client = AsyncGroundX(
-            api_key="YOUR_API_KEY",
-        )
-
-
-        async def main() -> None:
-            await client.documents.delete()
-
-
-        asyncio.run(main())
-        """
-        _response = await self._client_wrapper.httpx_client.request(
-            "v1/ingest/documents",
-            method="DELETE",
-            params={
-                "documentIds": document_ids,
-            },
-            request_options=request_options,
-        )
-        try:
-            if 200 <= _response.status_code < 300:
-                return typing.cast(
-                    IngestResponse,
-                    parse_obj_as(
-                        type_=IngestResponse,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-            if _response.status_code == 400:
-                raise BadRequestError(
-                    typing.cast(
-                        typing.Optional[typing.Any],
-                        parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
-                            object_=_response.json(),
-                        ),
-                    )
-                )
-            if _response.status_code == 401:
-                raise UnauthorizedError(
-                    typing.cast(
-                        typing.Optional[typing.Any],
-                        parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
-                            object_=_response.json(),
-                        ),
-                    )
-                )
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
-
     async def get(
         self, document_id: str, *, request_options: typing.Optional[RequestOptions] = None
     ) -> DocumentResponse:

groundx/types/__init__.py

@@ -21,6 +21,7 @@ from .health_response import HealthResponse
 from .health_response_health import HealthResponseHealth
 from .health_service import HealthService
 from .health_service_status import HealthServiceStatus
+from .ingest_document import IngestDocument
 from .ingest_local_document import IngestLocalDocument
 from .ingest_remote_document import IngestRemoteDocument
 from .ingest_response import IngestResponse
@@ -65,6 +66,7 @@ __all__ = [
     "HealthResponseHealth",
     "HealthService",
     "HealthServiceStatus",
+    "IngestDocument",
     "IngestLocalDocument",
     "IngestRemoteDocument",
     "IngestResponse",

groundx/types/ingest_document.py

@@ -0,0 +1,45 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
+from ..core.serialization import FieldMetadata
+import pydantic
+import typing
+from .document_type import DocumentType
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class IngestDocument(UniversalBaseModel):
+    bucket_id: typing_extensions.Annotated[int, FieldMetadata(alias="bucketId")] = pydantic.Field()
+    """
+    the bucketId of the bucket which this remote file will be ingested to.
+    """
+
+    file_name: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="fileName")] = pydantic.Field(
+        default=None
+    )
+    """
+    The name of the file being ingested
+    """
+
+    file_path: typing_extensions.Annotated[str, FieldMetadata(alias="filePath")] = pydantic.Field()
+    """
+    The local file path or remote URL of the document being ingested by GroundX.
+    """
+
+    file_type: typing_extensions.Annotated[typing.Optional[DocumentType], FieldMetadata(alias="fileType")] = None
+    search_data: typing_extensions.Annotated[
+        typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]], FieldMetadata(alias="searchData")
+    ] = pydantic.Field(default=None)
+    """
+    Custom metadata which can be used to influence GroundX's search functionality. This data can be used to further hone GroundX search.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

{groundx-2.0.17.dist-info → groundx-2.0.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: groundx
-Version: 2.0.17
+Version: 2.0.19
 Summary: 
 License: MIT
 Requires-Python: >=3.8,<4.0
@@ -52,19 +52,19 @@ A full reference for this library is available [here](./reference.md).
 Instantiate and use the client with the following:
 
 ```python
-from groundx import GroundX, IngestRemoteDocument
+from groundx import GroundX, IngestDocument
 
 client = GroundX(
     api_key="YOUR_API_KEY",
 )
-client.documents.ingest_remote(
+client.documents.ingest(
     documents=[
-        IngestRemoteDocument(
+        IngestDocument(
             bucket_id=1234,
             file_name="my_file.txt",
+            file_path="https://my.source.url.com/file.txt",
             file_type="txt",
             search_data={"key": "value"},
-            source_url="https://my.source.url.com/file.txt",
         )
     ],
 )
@@ -77,7 +77,7 @@ The SDK also exports an `async` client so that you can make non-blocking calls t
 ```python
 import asyncio
 
-from groundx import AsyncGroundX, IngestRemoteDocument
+from groundx import AsyncGroundX, IngestDocument
 
 client = AsyncGroundX(
     api_key="YOUR_API_KEY",
@@ -85,14 +85,14 @@ client = AsyncGroundX(
 
 
 async def main() -> None:
-    await client.documents.ingest_remote(
+    await client.documents.ingest(
         documents=[
-            IngestRemoteDocument(
+            IngestDocument(
                 bucket_id=1234,
                 file_name="my_file.txt",
+                file_path="https://my.source.url.com/file.txt",
                 file_type="txt",
                 search_data={"key": "value"},
-                source_url="https://my.source.url.com/file.txt",
             )
         ],
     )
@@ -110,7 +110,7 @@ will be thrown.
 from groundx.core.api_error import ApiError
 
 try:
-    client.documents.ingest_remote(...)
+    client.documents.ingest(...)
 except ApiError as e:
     print(e.status_code)
     print(e.body)
@@ -133,7 +133,7 @@ A request is deemed retriable when any of the following HTTP status codes is ret
 Use the `max_retries` request option to configure this behavior.
 
 ```python
-client.documents.ingest_remote(..., request_options={
+client.documents.ingest(..., request_options={
     "max_retries": 1
 })
 ```
@@ -153,7 +153,7 @@ client = GroundX(
 
 
 # Override timeout for a specific method
-client.documents.ingest_remote(..., request_options={
+client.documents.ingest(..., request_options={
     "timeout_in_seconds": 1
 })
 ```

{groundx-2.0.17.dist-info → groundx-2.0.19.dist-info}/RECORD

@@ -1,10 +1,10 @@
-groundx/__init__.py,sha256=22BLAf5omcgumWGCWHDb8o-ha8TnNbkO8LcEvpcYU6A,2851
+groundx/__init__.py,sha256=k9TpTModn8DZ6OiU_90cp_F5o40BSbwuo9z5Pd5xRlo,2893
 groundx/buckets/__init__.py,sha256=FTtvy8EDg9nNNg9WCatVgKTRYV8-_v1roeGPAKoa_pw,65
 groundx/buckets/client.py,sha256=TofNrkej1AC_-FU5rf_y8KG8ubFUpHtLa8PQ7rqax6E,26537
 groundx/client.py,sha256=Q1Kw0z6K-z-ShhNyuuPe5fYonM9M2I_55-ukUrUWk1U,6507
 groundx/core/__init__.py,sha256=SQ85PF84B9MuKnBwHNHWemSGuy-g_515gFYNFhvEE0I,1438
 groundx/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
-groundx/core/client_wrapper.py,sha256=zY1z1mzje1H39BKU9IR7OxYeBRV-PVvs004iAgfDqxI,1803
+groundx/core/client_wrapper.py,sha256=X38nIST_Dd7BXPecXq1I-3IODFee5YsbPXEULyPclZU,1803
 groundx/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 groundx/core/file.py,sha256=d4NNbX8XvXP32z8KpK2Xovv33nFfruIrpz0QWxlgpZk,2663
 groundx/core/http_client.py,sha256=siUQ6UV0ARZALlxubqWSSAAPC9B4VW8y6MGlHStfaeo,19552
@@ -17,7 +17,7 @@ groundx/core/serialization.py,sha256=D9h_t-RQON3-CHWs1C4ESY9B-Yd5d-l5lnTLb_X896g
 groundx/customer/__init__.py,sha256=FTtvy8EDg9nNNg9WCatVgKTRYV8-_v1roeGPAKoa_pw,65
 groundx/customer/client.py,sha256=C_JANeDewRD1Kg-q7LPxdiOSWbYSTOiYlBYZLRYPI44,3467
 groundx/documents/__init__.py,sha256=FTtvy8EDg9nNNg9WCatVgKTRYV8-_v1roeGPAKoa_pw,65
-groundx/documents/client.py,sha256=_l8K11r-p3qaMd0Qn43JjnSN68stMiaRoTzbbukQxl8,58882
+groundx/documents/client.py,sha256=GNT1B6uGS2JnHnC2MfNbwXhkf2JTLLEblK0ouKytA0k,65631
 groundx/environment.py,sha256=CInm1_DKtZ1mrxutmKb1qqv82P33r_S87hZD3Hc1VB0,159
 groundx/errors/__init__.py,sha256=-prNYsFd8xxM4va0vR1raZjcd10tllOJKyEWjX_pwdU,214
 groundx/errors/bad_request_error.py,sha256=_EbO8mWqN9kFZPvIap8qa1lL_EWkRcsZe1HKV9GDWJY,264
@@ -31,7 +31,7 @@ groundx/search/__init__.py,sha256=RagVzjShP33mDg9o4N3kGzV0egL1RYNjCpXPE8VzMYE,14
 groundx/search/client.py,sha256=10ifg9GyIwIZF13ULfCXF8iFIydq6H6QRDrGPDjpanw,19756
 groundx/search/types/__init__.py,sha256=fNFXQloPa1PHHO8VZim6KQNMA9N5EZtfSkissdxtY_c,165
 groundx/search/types/search_content_request_id.py,sha256=us7mYdzR0qPur_wR5I9BhHaLEzC5nLBRna6-xq4M1ec,128
-groundx/types/__init__.py,sha256=yCuwY3aySGDKKYYbxFX_v0kyG_ePu1_M0ZryOwMZJVk,3567
+groundx/types/__init__.py,sha256=ms9d1ANY2mUuAvKUOTd76dWc5Ujza4w31Dw6luDxQ-k,3633
 groundx/types/bounding_box_detail.py,sha256=51qcen326NTHY2ZqH1cFXut0_MCmk39EbLoDAwotdq4,1832
 groundx/types/bucket_detail.py,sha256=bQjCvfyWydjItmzNNTvH-iWxNDOggd7R7X1alFZzlEY,1511
 groundx/types/bucket_list_response.py,sha256=jC0NBsLCYDSwQrBzuW0g3PWFycjtKl8YRkKhic_-1DA,650
@@ -53,6 +53,7 @@ groundx/types/health_response.py,sha256=3UpYL2IZb56tTo-fOpSU-0OTRyWgpYiB3pMU3sfj
 groundx/types/health_response_health.py,sha256=I0QeEljFp6l5LCJbCTArW031Om84egePgnGdtE6WXlI,632
 groundx/types/health_service.py,sha256=M1-h1EJSpAXw-j3pY-09_g_WKkO0spdj8e7pgPzSGf0,1083
 groundx/types/health_service_status.py,sha256=ugKJXlx8QGi83n_J6s1frFrW1hYfOn3Dlb_pPNexwMA,185
+groundx/types/ingest_document.py,sha256=hIVo62aYNOpwmpUbyUya_u1WJy4qXfBNouuyPFMK7eU,1701
 groundx/types/ingest_local_document.py,sha256=2T1HXR2a-BDj5LEOTM98Sl4sgjVMWbVShQLn8MTR6QA,1602
 groundx/types/ingest_remote_document.py,sha256=xlPA4SYoUgoGXpxZhyORdezxIPGmr4wneav2ZEVmmOY,1683
 groundx/types/ingest_response.py,sha256=139rn8wpT44jlUzYXiy0r8XzN2U_OtdLltpSbRU0TyA,633
@@ -75,7 +76,7 @@ groundx/types/sort_order.py,sha256=hfJkStz6zHf3iWQFaVLkNCZPdyj5JS7TsQlN4Ij8Q5A,1
 groundx/types/subscription_detail.py,sha256=WNfUw2EMVECIvNYcV2s51zZ6T3Utc4zYXw63bPaeM6U,768
 groundx/types/subscription_detail_meters.py,sha256=lBa8-1QlMVHjr5RLGqhiTKnD1KMM0AAHTWvz9TVtG8w,830
 groundx/version.py,sha256=1yVogKaq260fQfckM2RYN2144SEw0QROsZW8ICtkG4U,74
-groundx-2.0.17.dist-info/LICENSE,sha256=8dMPYAFBTA7O4DUxhrEKEks8CL2waCMYM6dHohW4xrI,1065
-groundx-2.0.17.dist-info/METADATA,sha256=HZspuVrfswC62NtJa1cUVkS53KO8stJ8xnqTNfFx4lE,5206
-groundx-2.0.17.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-groundx-2.0.17.dist-info/RECORD,,
+groundx-2.0.19.dist-info/LICENSE,sha256=8dMPYAFBTA7O4DUxhrEKEks8CL2waCMYM6dHohW4xrI,1065
+groundx-2.0.19.dist-info/METADATA,sha256=dm1o9seVYMmGyZT9uAsw7frc_QjIS_aPPdCXVLy5KRQ,5145
+groundx-2.0.19.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+groundx-2.0.19.dist-info/RECORD,,