groundx 2.2.7__py3-none-any.whl → 2.2.9__py3-none-any.whl

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.2.7",
+            "X-Fern-SDK-Version": "2.2.9",
         }
         headers["X-API-Key"] = self.api_key
         return headers

groundx/csv_splitter.py

@@ -0,0 +1,64 @@
+import csv, math, os, tempfile, typing
+from pathlib import Path
+
+
+class CSVSplitter:
+    def __init__(self, filepath, delimiter=','):
+        self.filepath = filepath
+        self.delimiter = delimiter
+        self.filename = os.path.basename(filepath)
+        self.file_size = os.path.getsize(filepath)
+        self.rows_count = self.get_row_count()
+
+    def get_row_count(self):
+        with open(self.filepath, "r", newline="", encoding="utf-8") as csvfile:
+            return sum(1 for _ in csvfile) - 1
+
+    def determine_splits(self):
+        row_mod = int(self.rows_count / 1000) + 1
+        file_mod = int(self.file_size / 1024 / 1024) + 1
+
+        return max(row_mod, file_mod)
+
+    def split(self):
+        splits = self.determine_splits()
+        if splits < 2:
+            return [Path(self.filepath)]
+
+        rows_per_file = math.ceil(self.rows_count / splits)
+
+        split_files: typing.List[Path] = []
+        with open(self.filepath, "r", newline="", encoding="utf-8") as csvfile:
+            reader = csv.reader(csvfile, delimiter=self.delimiter)
+            headers = next(reader)
+
+            temp_dir = tempfile.mkdtemp()
+
+            current_file_number = 1
+            current_row = 0
+            current_writer = None
+            current_output_file = None
+
+            for row in reader:
+                if current_row % rows_per_file == 0:
+                    if current_output_file:
+                        current_output_file.close()
+                    output_file_path = os.path.join(
+                        temp_dir,
+                        f"{os.path.splitext(self.filename)[0]}_{current_file_number}.csv",
+                    )
+                    split_files.append(Path(output_file_path))
+                    current_output_file = open(
+                        output_file_path, "w", newline="", encoding="utf-8"
+                    )
+                    current_writer = csv.writer(current_output_file, delimiter=self.delimiter)
+                    current_writer.writerow(headers)
+                    current_file_number += 1
+
+                current_writer.writerow(row)
+                current_row += 1
+
+            if current_output_file:
+                current_output_file.close()
+
+        return split_files

groundx/ingest.py

@@ -1,19 +1,12 @@
-import aiohttp, io, json, mimetypes, requests, time, typing, os
-from asyncio import TimeoutError
+import requests, time, typing, os
 from pathlib import Path
 from tqdm import tqdm
 from urllib.parse import urlparse, urlunparse
 
-from json.decoder import JSONDecodeError
-
 from .client import GroundXBase, AsyncGroundXBase
-from .core.api_error import ApiError
-from .core.pydantic_utilities import parse_obj_as
 from .core.request_options import RequestOptions
-from .errors.bad_request_error import BadRequestError
-from .errors.unauthorized_error import UnauthorizedError
+from .csv_splitter import CSVSplitter
 from .types.document import Document
-from .types.document_type import DocumentType
 from .types.ingest_remote_document import IngestRemoteDocument
 from .types.ingest_response import IngestResponse
 
@@ -45,23 +38,48 @@ MIME_TO_DOCUMENT_TYPE = {v: k for k, v in DOCUMENT_TYPE_TO_MIME.items()}
 
 ALLOWED_SUFFIXES = {f".{k}": v for k, v in DOCUMENT_TYPE_TO_MIME.items()}
 
+CSV_SPLITS = {
+    ".csv": True,
+}
+TSV_SPLITS = {
+    ".tsv": True,
+}
+
 SUFFIX_ALIASES = {
-    ".jpeg": ".jpg",
-    ".heic": ".heif",
-    ".tif": ".tiff",
+    ".jpeg": "jpg",
+    ".heic": "heif",
+    ".tif": "tiff",
+    ".md": "txt",
 }
 
 MAX_BATCH_SIZE = 50
 MIN_BATCH_SIZE = 1
 MAX_BATCH_SIZE_BYTES = 50 * 1024 * 1024
 
+def get_presigned_url(
+    endpoint: str,
+    file_name: str,
+    file_extension: str,
+) -> typing.Dict[str, typing.Any]:
+    params = {"name": file_name, "type": file_extension}
+    response = requests.get(endpoint, params=params)
+    response.raise_for_status()
+
+    return response.json()
+
+def strip_query_params(
+    url: str,
+) -> str:
+    parsed = urlparse(url)
+    clean_url = urlunparse((parsed.scheme, parsed.netloc, parsed.path, "", "", ""))
+
+    return clean_url
+
 def prep_documents(
     documents: typing.Sequence[Document],
 ) -> typing.Tuple[
     typing.List[IngestRemoteDocument],
-    typing.List[
-        typing.Tuple[str, typing.Tuple[typing.Union[str, None], typing.BinaryIO, str]]
-    ],
+    typing.List[Document],
 ]:
     """
     Process documents and separate them into remote and local documents.
@@ -80,9 +98,7 @@ def prep_documents(
         except ValueError:
             return False
 
-    local_documents: typing.List[
-        typing.Tuple[str, typing.Tuple[typing.Union[str, None], typing.BinaryIO, str]]
-    ] = []
+    local_documents: typing.List[Document] = []
     remote_documents: typing.List[IngestRemoteDocument] = []
 
     for document in documents:
@@ -100,64 +116,31 @@ def prep_documents(
             )
             remote_documents.append(remote_document)
         elif is_valid_local_path(document.file_path):
-            expanded_path = os.path.expanduser(document.file_path)
-            file_name = os.path.basename(expanded_path)
-            mime_type = mimetypes.guess_type(file_name)[0] or "application/octet-stream"
-            file_type = MIME_TO_DOCUMENT_TYPE.get(mime_type, None)
-            if document.file_type:
-                file_type = document.file_type
-                mime_type = DOCUMENT_TYPE_TO_MIME.get(
-                    document.file_type, "application/octet-stream"
-                )
-
-            if document.file_name:
-                file_name = document.file_name
-
-            try:
-                local_documents.append(
-                    (
-                        "blob",
-                        (
-                            file_name,
-                            open(expanded_path, "rb"),
-                            mime_type,
-                        ),
-                    )
-                )
-            except Exception as e:
-                raise ValueError(f"Error reading file {expanded_path}: {e}")
-
-            metadata = {
-                "bucketId": document.bucket_id,
-                "fileName": file_name,
-                "fileType": file_type,
-            }
-            if document.process_level:
-                metadata["processLevel"] = document.process_level
-            if document.search_data:
-                metadata["searchData"] = document.search_data
-
-            local_documents.append(
-                (
-                    "metadata",
-                    (
-                        f"data.json",
-                        io.BytesIO(json.dumps(metadata).encode("utf-8")),
-                        "application/json",
-                    ),
-                )
-            )
+            local_documents.append(document)
         else:
             raise ValueError(f"Invalid file path: {document.file_path}")
 
     return remote_documents, local_documents
 
 
+def split_doc(file):
+    if file.is_file() and (
+        file.suffix.lower() in ALLOWED_SUFFIXES
+        or file.suffix.lower() in SUFFIX_ALIASES
+    ):
+        if file.suffix.lower() in CSV_SPLITS:
+            return CSVSplitter(filepath=file).split()
+        elif file.suffix.lower() in TSV_SPLITS:
+            return CSVSplitter(filepath=file, delimiter='\t').split()
+        return [file]
+    return []
+
 class GroundX(GroundXBase):
     def ingest(
         self,
         *,
         documents: typing.Sequence[Document],
+        upload_api: typing.Optional[str] = "https://api.eyelevel.ai/upload/file",
         request_options: typing.Optional[RequestOptions] = None,
     ) -> IngestResponse:
         """
@@ -167,6 +150,10 @@ class GroundX(GroundXBase):
         ----------
         documents : typing.Sequence[Document]
 
+        # an endpoint that accepts 'name' and 'type' query params
+        # and returns a presigned URL in a JSON dictionary with key 'URL'
+        upload_api : typing.Optional[str]
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -196,65 +183,41 @@ class GroundX(GroundXBase):
         """
         remote_documents, local_documents = prep_documents(documents)
 
-        if local_documents and remote_documents:
-            raise ValueError("Documents must all be either local or remote, not a mix.")
+        if len(remote_documents) + len(local_documents) > MAX_BATCH_SIZE:
+            raise ValueError("You have sent too many documents in this request")
 
-        if len(remote_documents) > 0:
-            return self.documents.ingest_remote(
-                documents=remote_documents,
-                request_options=request_options,
-            )
+        if len(remote_documents) + len(local_documents) == 0:
+            raise ValueError("No valid documents were provided")
 
-        timeout = self._client_wrapper.get_timeout()
-        headers = self._client_wrapper.get_headers()
-        base_url = self._client_wrapper.get_base_url().rstrip("/")
-        follow_redirects = getattr(
-            self._client_wrapper.httpx_client, "follow_redirects", True
-        )
+        for d in local_documents:
+            splits = split_doc(Path(os.path.expanduser(d.file_path)))
 
-        url = f"{base_url}/v1/ingest/documents/local"
-        _response = requests.post(
-            url,
-            files=local_documents,
-            headers=headers,
-            timeout=timeout,
-            allow_redirects=follow_redirects,
-        )
+            for sd in splits:
+                url = self._upload_file(upload_api, sd)
 
-        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(),
-                        ),
+                ft = d.file_type
+                if sd.suffix.lower() in SUFFIX_ALIASES:
+                    ft = SUFFIX_ALIASES[sd.suffix.lower()]
+
+                fn = sd.name
+                if len(splits) == 1 and d.file_name:
+                    fn = d.file_name
+
+                remote_documents.append(
+                    IngestRemoteDocument(
+                        bucket_id=d.bucket_id,
+                        file_name=fn,
+                        file_type=ft,
+                        process_level=d.process_level,
+                        search_data=d.search_data,
+                        source_url=url,
                     )
                 )
-            _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)
+        return self.documents.ingest_remote(
+            documents=remote_documents,
+            request_options=request_options,
+        )
 
     def ingest_directory(
         self,
@@ -275,7 +238,7 @@ class GroundX(GroundXBase):
         batch_size : type.Optional[int]
 
         # an endpoint that accepts 'name' and 'type' query params
-        # and returns a presigned URL
+        # and returns a presigned URL in a JSON dictionary with key 'URL'
         upload_api : typing.Optional[str]
 
         request_options : typing.Optional[RequestOptions]
@@ -300,13 +263,6 @@ class GroundX(GroundXBase):
         )
         """
 
-        def get_presigned_url(endpoint, file_name, file_extension) -> typing.Dict[str, typing.Any]:
-            params = {"name": file_name, "type": file_extension}
-            response = requests.get(endpoint, params=params)
-            response.raise_for_status()
-
-            return response.json()
-
         def is_valid_local_directory(path: str) -> bool:
             expanded_path = os.path.expanduser(path)
             return os.path.isdir(expanded_path)
@@ -314,89 +270,12 @@ class GroundX(GroundXBase):
         def load_directory_files(directory: str) -> typing.List[Path]:
             dir_path = Path(directory)
 
-            matched_files = [
-                file
-                for file in dir_path.rglob("*")
-                if file.is_file() and (
-                    file.suffix.lower() in ALLOWED_SUFFIXES
-                    or file.suffix.lower() in SUFFIX_ALIASES
-                )
-            ]
+            matched_files: typing.List[Path] = []
+            for file in dir_path.rglob("*"):
+                for sd in split_doc(file):
+                    matched_files.append(sd)    
 
-            return matched_files
-
-        def strip_query_params(url: str) -> str:
-            parsed = urlparse(url)
-            clean_url = urlunparse((parsed.scheme, parsed.netloc, parsed.path, "", "", ""))
-            return clean_url
-
-        def _upload_file_batch(bucket_id, batch, upload_api, request_options, pbar):
-            docs = []
-
-            progress = len(batch)
-            for file in batch:
-                url = upload_file(upload_api, file)
-                docs.append(
-                    Document(
-                        bucket_id=bucket_id,
-                        file_path=url,
-                    ),
-                )
-                pbar.update(0.25)
-                progress -= 0.25
-
-            if docs:
-                ingest = self.ingest(documents=docs, request_options=request_options)
-
-                completed_files = set()
-
-                while (
-                    ingest is not None
-                    and ingest.ingest.status not in ["complete", "error", "cancelled"]
-                ):
-                    time.sleep(3)
-                    ingest = self.documents.get_processing_status_by_id(ingest.ingest.process_id)
-
-                    if ingest.ingest.progress and ingest.ingest.progress.processing:
-                        for doc in ingest.ingest.progress.processing.documents:
-                            if doc.status == "complete" and doc.document_id not in completed_files:
-                                pbar.update(0.75)
-                                progress -= 0.75
-
-                if ingest.ingest.status in ["error", "cancelled"]:
-                    raise ValueError(f"Ingest failed with status: {ingest.ingest.status}")
-
-                if progress > 0:
-                    pbar.update(progress)
-
-        def upload_file(endpoint, file_path) -> str:
-            file_name = os.path.basename(file_path)
-            file_extension = os.path.splitext(file_name)[1][1:].lower()
-
-            presigned_info = get_presigned_url(endpoint, file_name, file_extension)
-
-            upload_url = presigned_info["URL"]
-            headers = presigned_info.get("Header", {})
-            method = presigned_info.get("Method", "PUT").upper()
-
-            for key, value in headers.items():
-                if isinstance(value, list):
-                    headers[key] = value[0]
-
-            with open(file_path, "rb") as f:
-                file_data = f.read()
-
-            if method == "PUT":
-                upload_response = requests.put(upload_url, data=file_data, headers=headers)
-            else:
-                raise ValueError(f"Unsupported HTTP method: {method}")
-
-            if upload_response.status_code not in (200, 201):
-                raise Exception(
-                    f"Upload failed: {upload_response.status_code} - {upload_response.text}"
-                )
-
-            return strip_query_params(upload_url)
+            return matched_files      
 
         if bucket_id < 1:
             raise ValueError(f"Invalid bucket_id: {bucket_id}")
@@ -419,7 +298,7 @@ class GroundX(GroundXBase):
                 file_size = file.stat().st_size
 
                 if (current_batch_size + file_size > MAX_BATCH_SIZE_BYTES) or (len(current_batch) >= n):
-                    _upload_file_batch(bucket_id, current_batch, upload_api, request_options, pbar)
+                    self._upload_file_batch(bucket_id, current_batch, upload_api, request_options, pbar)
                     current_batch = []
                     current_batch_size = 0
 
@@ -427,7 +306,119 @@ class GroundX(GroundXBase):
                 current_batch_size += file_size
 
             if current_batch:
-                _upload_file_batch(bucket_id, current_batch, upload_api, request_options, pbar)
+                self._upload_file_batch(bucket_id, current_batch, upload_api, request_options, pbar)
+
+    def _upload_file(
+        self,
+        endpoint,
+        file_path,
+    ):
+        file_name = os.path.basename(file_path)
+        file_extension = os.path.splitext(file_name)[1][1:].lower()
+        if f".{file_extension}" in SUFFIX_ALIASES:
+            file_extension = SUFFIX_ALIASES[f".{file_extension}"]
+
+        presigned_info = get_presigned_url(endpoint, file_name, file_extension)
+
+        upload_url = presigned_info["URL"]
+        headers = presigned_info.get("Header", {})
+        method = presigned_info.get("Method", "PUT").upper()
+
+        for key, value in headers.items():
+            if isinstance(value, list):
+                headers[key] = value[0]
+
+        try:
+            with open(file_path, "rb") as f:
+                file_data = f.read()
+        except Exception as e:
+            raise ValueError(f"Error reading file {file_path}: {e}")
+
+        if method == "PUT":
+            upload_response = requests.put(upload_url, data=file_data, headers=headers)
+        else:
+            raise ValueError(f"Unsupported HTTP method: {method}")
+
+        if upload_response.status_code not in (200, 201):
+            raise Exception(
+                f"Upload failed: {upload_response.status_code} - {upload_response.text}"
+            )
+
+        return strip_query_params(upload_url)
+
+    def _upload_file_batch(
+        self,
+        bucket_id,
+        batch,
+        upload_api,
+        request_options,
+        pbar,
+    ):
+        docs = []
+
+        progress = len(batch)
+        for file in batch:
+            url = self._upload_file(upload_api, file)
+            if file.suffix.lower() in SUFFIX_ALIASES:
+                docs.append(
+                    Document(
+                        bucket_id=bucket_id,
+                        file_name=file.name,
+                        file_path=url,
+                        file_type=SUFFIX_ALIASES[file.suffix.lower()],
+                    ),
+                )
+            else:
+                docs.append(
+                    Document(
+                        bucket_id=bucket_id,
+                        file_name=file.name,
+                        file_path=url,
+                    ),
+                )
+            pbar.update(0.25)
+            progress -= 0.25
+
+        if docs:
+            ingest = self.ingest(documents=docs, request_options=request_options)
+
+            completed_files = set()
+
+            while (
+                ingest is not None
+                and ingest.ingest.status not in ["complete", "error", "cancelled"]
+            ):
+                time.sleep(3)
+                ingest = self.documents.get_processing_status_by_id(ingest.ingest.process_id)
+
+                if ingest.ingest.progress:
+                    if ingest.ingest.progress.processing and ingest.ingest.progress.processing.documents:
+                        for doc in ingest.ingest.progress.processing.documents:
+                            if doc.status in ["complete", "error", "cancelled"] and doc.document_id not in completed_files:
+                                pbar.update(0.75)
+                                progress -= 0.75
+                    if ingest.ingest.progress.complete and ingest.ingest.progress.complete.documents:
+                        for doc in ingest.ingest.progress.complete.documents:
+                            if doc.status in ["complete", "error", "cancelled"] and doc.document_id not in completed_files:
+                                pbar.update(0.75)
+                                progress -= 0.75
+                    if ingest.ingest.progress.cancelled and ingest.ingest.progress.cancelled.documents:
+                        for doc in ingest.ingest.progress.cancelled.documents:
+                            if doc.status in ["complete", "error", "cancelled"] and doc.document_id not in completed_files:
+                                pbar.update(0.75)
+                                progress -= 0.75
+                    if ingest.ingest.progress.errors and ingest.ingest.progress.errors.documents:
+                        for doc in ingest.ingest.progress.errors.documents:
+                            if doc.status in ["complete", "error", "cancelled"] and doc.document_id not in completed_files:
+                                pbar.update(0.75)
+                                progress -= 0.75
+
+
+            if ingest.ingest.status in ["error", "cancelled"]:
+                raise ValueError(f"Ingest failed with status: {ingest.ingest.status}")
+
+            if progress > 0:
+                pbar.update(progress)
 
 
 
@@ -436,6 +427,7 @@ class AsyncGroundX(AsyncGroundXBase):
         self,
         *,
         documents: typing.Sequence[Document],
+        upload_api: str = "https://api.eyelevel.ai/upload/file",
         request_options: typing.Optional[RequestOptions] = None,
     ) -> IngestResponse:
         """
@@ -445,6 +437,10 @@ class AsyncGroundX(AsyncGroundXBase):
         ----------
         documents : typing.Sequence[Document]
 
+        # an endpoint that accepts 'name' and 'type' query params
+        # and returns a presigned URL in a JSON dictionary with key 'URL'
+        upload_api : typing.Optional[str]
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -479,53 +475,76 @@ class AsyncGroundX(AsyncGroundXBase):
         """
         remote_documents, local_documents = prep_documents(documents)
 
-        if local_documents and remote_documents:
-            raise ValueError("Documents must all be either local or remote, not a mix.")
+        if len(remote_documents) + len(local_documents) > MAX_BATCH_SIZE:
+            raise ValueError("You have sent too many documents in this request")
 
-        if len(remote_documents) > 0:
-            return await self.documents.ingest_remote(
-                documents=remote_documents,
-                request_options=request_options,
-            )
+        if len(remote_documents) + len(local_documents) == 0:
+            raise ValueError("No valid documents were provided")
 
-        timeout = self._client_wrapper.get_timeout()
-        headers = self._client_wrapper.get_headers()
-        base_url = self._client_wrapper.get_base_url().rstrip("/")
+        for d in local_documents:
+            splits = split_doc(Path(os.path.expanduser(d.file_path)))
 
-        url = f"{base_url}/v1/ingest/documents/local"
+            for sd in splits:
+                url = self._upload_file(upload_api, sd)
 
-        try:
-            async with aiohttp.ClientSession() as session:
-                data = aiohttp.FormData()
-                for field_name, (file_name, file_obj, content_type) in local_documents:
-                    data.add_field(
-                        name=field_name,
-                        value=file_obj,
-                        filename=file_name,
-                        content_type=content_type,
-                    )
+                ft = d.file_type
+                if sd.suffix.lower() in SUFFIX_ALIASES:
+                    ft = SUFFIX_ALIASES[sd.suffix.lower()]
 
-                async with session.post(
-                    url, data=data, headers=headers, timeout=timeout
-                ) as response:
-                    if 200 <= response.status < 300:
-                        response_data = await response.json()
-                        return typing.cast(
-                            IngestResponse,
-                            parse_obj_as(
-                                type_=IngestResponse,  # type: ignore
-                                object_=response_data,
-                            ),
-                        )
-                    if response.status == 400:
-                        raise BadRequestError(await response.json())
-                    if response.status == 401:
-                        raise UnauthorizedError(await response.json())
-
-                    raise ApiError(
-                        status_code=response.status, body=await response.text()
+                fn = sd.name
+                if len(splits) == 1 and d.file_name:
+                    fn = d.file_name
+
+                remote_documents.append(
+                    IngestRemoteDocument(
+                        bucket_id=d.bucket_id,
+                        file_name=fn,
+                        file_type=ft,
+                        process_level=d.process_level,
+                        search_data=d.search_data,
+                        source_url=url,
                     )
-        except TimeoutError:
-            raise ApiError(status_code=408, body="Request timed out")
-        except aiohttp.ClientError as e:
-            raise ApiError(status_code=500, body=str(e))
+                )
+
+        return await self.documents.ingest_remote(
+            documents=remote_documents,
+            request_options=request_options,
+        )
+
+    def _upload_file(
+        self,
+        endpoint,
+        file_path,
+    ):
+        file_name = os.path.basename(file_path)
+        file_extension = os.path.splitext(file_name)[1][1:].lower()
+        if f".{file_extension}" in SUFFIX_ALIASES:
+            file_extension = SUFFIX_ALIASES[f".{file_extension}"]
+
+        presigned_info = get_presigned_url(endpoint, file_name, file_extension)
+
+        upload_url = presigned_info["URL"]
+        headers = presigned_info.get("Header", {})
+        method = presigned_info.get("Method", "PUT").upper()
+
+        for key, value in headers.items():
+            if isinstance(value, list):
+                headers[key] = value[0]
+
+        try:
+            with open(file_path, "rb") as f:
+                file_data = f.read()
+        except Exception as e:
+            raise ValueError(f"Error reading file {file_path}: {e}")
+
+        if method == "PUT":
+            upload_response = requests.put(upload_url, data=file_data, headers=headers)
+        else:
+            raise ValueError(f"Unsupported HTTP method: {method}")
+
+        if upload_response.status_code not in (200, 201):
+            raise Exception(
+                f"Upload failed: {upload_response.status_code} - {upload_response.text}"
+            )
+
+        return strip_query_params(upload_url)

{groundx-2.2.7.dist-info → groundx-2.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: groundx
-Version: 2.2.7
+Version: 2.2.9
 Summary: 
 License: MIT
 Requires-Python: >=3.8,<4.0

{groundx-2.2.7.dist-info → groundx-2.2.9.dist-info}/RECORD

@@ -4,7 +4,7 @@ groundx/buckets/client.py,sha256=4jlc9vfIult1mMJ4FZW4_KFJybZPStZt1FUplIgrxbU,239
 groundx/client.py,sha256=dIW9OyrMyfC1N7HSxRrHh0w_8rJ8osNUOPdYD6ueQ6g,6515
 groundx/core/__init__.py,sha256=SQ85PF84B9MuKnBwHNHWemSGuy-g_515gFYNFhvEE0I,1438
 groundx/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
-groundx/core/client_wrapper.py,sha256=Bhc6L2UfeJoET17u-IIW6OWHD5GwdYaita2HNWDJjr4,1802
+groundx/core/client_wrapper.py,sha256=D6uZpUYxYzmgxNNCTN7quiFvNlBQmPOyLstnrXfcJcs,1802
 groundx/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 groundx/core/file.py,sha256=d4NNbX8XvXP32z8KpK2Xovv33nFfruIrpz0QWxlgpZk,2663
 groundx/core/http_client.py,sha256=Z77OIxIbL4OAB2IDqjRq_sYa5yNYAWfmdhdCSSvh6Y4,19552
@@ -14,6 +14,7 @@ groundx/core/query_encoder.py,sha256=ekulqNd0j8TgD7ox-Qbz7liqX8-KP9blvT9DsRCenYM
 groundx/core/remove_none_from_dict.py,sha256=EU9SGgYidWq7SexuJbNs4-PZ-5Bl3Vppd864mS6vQZw,342
 groundx/core/request_options.py,sha256=h0QUNCFVdCW_7GclVySCAY2w4NhtXVBUCmHgmzaxpcg,1681
 groundx/core/serialization.py,sha256=D9h_t-RQON3-CHWs1C4ESY9B-Yd5d-l5lnTLb_X896g,9601
+groundx/csv_splitter.py,sha256=6HGXdDpwBX_IJaCbla1WuirJERBTvjLzBf9OBtwGFWU,2254
 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
@@ -26,7 +27,7 @@ groundx/groups/__init__.py,sha256=FTtvy8EDg9nNNg9WCatVgKTRYV8-_v1roeGPAKoa_pw,65
 groundx/groups/client.py,sha256=bytQRh9m7e4vIuYHb7dD1kCTQZvyBxedCqGnmmLqrsI,35237
 groundx/health/__init__.py,sha256=FTtvy8EDg9nNNg9WCatVgKTRYV8-_v1roeGPAKoa_pw,65
 groundx/health/client.py,sha256=fcTa21RWPyBuT77PQ0EncC6rBaW_DrYlRvudy9-0H58,7545
-groundx/ingest.py,sha256=RTgmeg_4cEaZynSEyf-3ArKGBcnhbcZhJl7BAeUeAMU,18187
+groundx/ingest.py,sha256=LtnUGcgtE1MNYL3PGFrzPqRMnLeOxr-fVsZ3fmTAUKI,18294
 groundx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 groundx/search/__init__.py,sha256=RagVzjShP33mDg9o4N3kGzV0egL1RYNjCpXPE8VzMYE,145
 groundx/search/client.py,sha256=zrrqFy0HowDUYPsMU4nfvDV2RgmkEQ4E8WYNktu3xcs,18684
@@ -81,7 +82,7 @@ groundx/types/subscription_detail.py,sha256=WNfUw2EMVECIvNYcV2s51zZ6T3Utc4zYXw63
 groundx/types/subscription_detail_meters.py,sha256=lBa8-1QlMVHjr5RLGqhiTKnD1KMM0AAHTWvz9TVtG8w,830
 groundx/types/website_source.py,sha256=3WeRCiilNKKBTfhwgjo3jbcVI3vLTeM-KxI6dVzpg9o,1578
 groundx/version.py,sha256=1yVogKaq260fQfckM2RYN2144SEw0QROsZW8ICtkG4U,74
-groundx-2.2.7.dist-info/LICENSE,sha256=dFE6nY1bHnSn6NqmdlghlU1gQqLqYNphrceGVehSa7o,1065
-groundx-2.2.7.dist-info/METADATA,sha256=Gx6smhve9G7ECJbxQBrw3pJ_LosNgtehM3VETuW0c9I,5173
-groundx-2.2.7.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-groundx-2.2.7.dist-info/RECORD,,
+groundx-2.2.9.dist-info/LICENSE,sha256=dFE6nY1bHnSn6NqmdlghlU1gQqLqYNphrceGVehSa7o,1065
+groundx-2.2.9.dist-info/METADATA,sha256=1BWmC2-Lx8AT1vEY0juSK4ugjxyn9W5ndJy0bomFEwQ,5173
+groundx-2.2.9.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+groundx-2.2.9.dist-info/RECORD,,