chunkr-ai 0.0.14__py3-none-any.whl → 0.0.15__py3-none-any.whl

chunkr_ai/__init__.py

@@ -1,4 +1,4 @@
 from .api.chunkr import Chunkr
 from .api.chunkr_async import ChunkrAsync
 
-__all__ = ['Chunkr', 'ChunkrAsync']
+__all__ = ["Chunkr", "ChunkrAsync"]

chunkr_ai/api/auth.py

@@ -1,12 +1,12 @@
 class HeadersMixin:
     """Mixin class for handling authorization headers"""
-    
+
     def get_api_key(self) -> str:
         """Get the API key"""
-        if not hasattr(self, '_api_key') or not self._api_key:
+        if not hasattr(self, "_api_key") or not self._api_key:
             raise ValueError("API key not set")
         return self._api_key
-        
+
     def _headers(self) -> dict:
         """Generate authorization headers"""
-        return {"Authorization": self.get_api_key()} 
+        return {"Authorization": self.get_api_key()}

chunkr_ai/api/base.py

@@ -11,28 +11,23 @@ from PIL import Image
 import requests
 from typing import BinaryIO, Tuple, Union
 
+
 class ChunkrBase(HeadersMixin):
     """Base class with shared functionality for Chunkr API clients."""
 
     def __init__(self, url: str = None, api_key: str = None):
         load_dotenv()
-        self.url = (
-            url or 
-            os.getenv('CHUNKR_URL') or 
-            'https://api.chunkr.ai' 
-        )
-        self._api_key = (
-            api_key or 
-            os.getenv('CHUNKR_API_KEY')
-        )
+        self.url = url or os.getenv("CHUNKR_URL") or "https://api.chunkr.ai"
+        self._api_key = api_key or os.getenv("CHUNKR_API_KEY")
         if not self._api_key:
-            raise ValueError("API key must be provided either directly, in .env file, or as CHUNKR_API_KEY environment variable. You can get an api key at: https://www.chunkr.ai")
-            
+            raise ValueError(
+                "API key must be provided either directly, in .env file, or as CHUNKR_API_KEY environment variable. You can get an api key at: https://www.chunkr.ai"
+            )
+
         self.url = self.url.rstrip("/")
 
     def _prepare_file(
-        self,
-        file: Union[str, Path, BinaryIO, Image.Image]
+        self, file: Union[str, Path, BinaryIO, Image.Image]
     ) -> Tuple[str, BinaryIO]:
         """Convert various file types into a tuple of (filename, file-like object).
 
@@ -54,40 +49,43 @@ class ChunkrBase(HeadersMixin):
             ValueError: If the MIME type is unsupported
         """
         # Handle URLs
-        if isinstance(file, str) and (file.startswith('http://') or file.startswith('https://')):
+        if isinstance(file, str) and (
+            file.startswith("http://") or file.startswith("https://")
+        ):
             response = requests.get(file)
             response.raise_for_status()
             file_obj = io.BytesIO(response.content)
-            filename = Path(file.split('/')[-1]).name or 'downloaded_file'
+            filename = Path(file.split("/")[-1]).name or "downloaded_file"
             return filename, file_obj
 
         # Handle base64 strings
-        if isinstance(file, str) and ',' in file and ';base64,' in file:
+        if isinstance(file, str) and "," in file and ";base64," in file:
             try:
                 # Split header and data
-                header, base64_data = file.split(',', 1)
+                header, base64_data = file.split(",", 1)
                 import base64
+
                 file_bytes = base64.b64decode(base64_data)
                 file_obj = io.BytesIO(file_bytes)
-                
+
                 # Try to determine format from header
-                format = 'bin'
-                mime_type = header.split(':')[-1].split(';')[0].lower()
-                
+                format = "bin"
+                mime_type = header.split(":")[-1].split(";")[0].lower()
+
                 # Map MIME types to file extensions
                 mime_to_ext = {
-                    'application/pdf': 'pdf',
-                    'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'docx',
-                    'application/msword': 'doc',
-                    'application/vnd.openxmlformats-officedocument.presentationml.presentation': 'pptx',
-                    'application/vnd.ms-powerpoint': 'ppt',
-                    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'xlsx',
-                    'application/vnd.ms-excel': 'xls',
-                    'image/jpeg': 'jpg',
-                    'image/png': 'png',
-                    'image/jpg': 'jpg'
+                    "application/pdf": "pdf",
+                    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+                    "application/msword": "doc",
+                    "application/vnd.openxmlformats-officedocument.presentationml.presentation": "pptx",
+                    "application/vnd.ms-powerpoint": "ppt",
+                    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+                    "application/vnd.ms-excel": "xls",
+                    "image/jpeg": "jpg",
+                    "image/png": "png",
+                    "image/jpg": "jpg",
                 }
-                
+
                 if mime_type in mime_to_ext:
                     format = mime_to_ext[mime_type]
                 else:
@@ -102,20 +100,24 @@ class ChunkrBase(HeadersMixin):
             path = Path(file).resolve()
             if not path.exists():
                 raise FileNotFoundError(f"File not found: {file}")
-            return path.name, open(path, 'rb')
+            return path.name, open(path, "rb")
 
         # Handle PIL Images
         if isinstance(file, Image.Image):
             img_byte_arr = io.BytesIO()
-            format = file.format or 'PNG'
+            format = file.format or "PNG"
             file.save(img_byte_arr, format=format)
             img_byte_arr.seek(0)
             return f"image.{format.lower()}", img_byte_arr
 
         # Handle file-like objects
-        if hasattr(file, 'read') and hasattr(file, 'seek'):
+        if hasattr(file, "read") and hasattr(file, "seek"):
             # Try to get the filename from the file object if possible
-            name = getattr(file, 'name', 'document') if hasattr(file, 'name') else 'document'
+            name = (
+                getattr(file, "name", "document")
+                if hasattr(file, "name")
+                else "document"
+            )
             return Path(name).name, file
 
         raise TypeError(f"Unsupported file type: {type(file)}")
@@ -123,43 +125,51 @@ class ChunkrBase(HeadersMixin):
     def _prepare_upload_data(
         self,
         file: Union[str, Path, BinaryIO, Image.Image],
-        config: Configuration = None
+        config: Configuration = None,
     ) -> Tuple[dict, dict]:
         """Prepare files and data dictionaries for upload.
-        
+
         Args:
             file: The file to upload
             config: Optional configuration settings
-            
+
         Returns:
             Tuple[dict, dict]: (files dict, data dict) ready for upload
         """
         filename, file_obj = self._prepare_file(file)
         files = {"file": (filename, file_obj)}
         data = {}
-        
+
         if config:
             config_dict = config.model_dump(mode="json", exclude_none=True)
             for key, value in config_dict.items():
                 if isinstance(value, dict):
-                    files[key] = (None, json.dumps(value), 'application/json')
+                    files[key] = (None, json.dumps(value), "application/json")
                 else:
                     data[key] = value
-                    
+
         return files, data
-    
+
     @abstractmethod
-    def upload(self, file: Union[str, Path, BinaryIO, Image.Image], config: Configuration = None) -> TaskResponse:
+    def upload(
+        self,
+        file: Union[str, Path, BinaryIO, Image.Image],
+        config: Configuration = None,
+    ) -> TaskResponse:
         """Upload a file and wait for processing to complete.
-        
+
         Must be implemented by subclasses.
         """
         pass
 
     @abstractmethod
-    def start_upload(self, file: Union[str, Path, BinaryIO, Image.Image], config: Configuration = None) -> TaskResponse:
+    def start_upload(
+        self,
+        file: Union[str, Path, BinaryIO, Image.Image],
+        config: Configuration = None,
+    ) -> TaskResponse:
         """Upload a file for processing and immediately return the task response.
-        
+
         Must be implemented by subclasses.
         """
         pass
@@ -167,7 +177,7 @@ class ChunkrBase(HeadersMixin):
     @abstractmethod
     def get_task(self, task_id: str) -> TaskResponse:
         """Get a task response by its ID.
-        
+
         Must be implemented by subclasses.
         """
         pass

chunkr_ai/api/chunkr.py

@@ -7,6 +7,7 @@ import requests
 from typing import Union, BinaryIO
 from .misc import prepare_upload_data
 
+
 class Chunkr(ChunkrBase):
     """Chunkr API client"""
 
@@ -14,56 +15,57 @@ class Chunkr(ChunkrBase):
         super().__init__(url, api_key)
         self._session = requests.Session()
 
-    def upload(self, file: Union[str, Path, BinaryIO, Image.Image], config: Configuration = None) -> TaskResponse:
+    def upload(
+        self,
+        file: Union[str, Path, BinaryIO, Image.Image],
+        config: Configuration = None,
+    ) -> TaskResponse:
         task = self.create_task(file, config)
         return task.poll()
-    
+
     def update(self, task_id: str, config: Configuration) -> TaskResponse:
         task = self.update_task(task_id, config)
         return task.poll()
 
-    def create_task(self, file: Union[str, Path, BinaryIO, Image.Image], config: Configuration = None) -> TaskResponse:
-        files= prepare_upload_data(file, config)
+    def create_task(
+        self,
+        file: Union[str, Path, BinaryIO, Image.Image],
+        config: Configuration = None,
+    ) -> TaskResponse:
+        files = prepare_upload_data(file, config)
         if not self._session:
             raise ValueError("Session not found")
         r = self._session.post(
-            f"{self.url}/api/v1/task",
-            files=files,
-            headers=self._headers()
+            f"{self.url}/api/v1/task", files=files, headers=self._headers()
         )
         r.raise_for_status()
         return TaskResponse(**r.json()).with_client(self)
-    
+
     def update_task(self, task_id: str, config: Configuration) -> TaskResponse:
         files = prepare_upload_data(None, config)
         if not self._session:
             raise ValueError("Session not found")
         r = self._session.patch(
-            f"{self.url}/api/v1/task/{task_id}",
-            files=files,
-            headers=self._headers()
+            f"{self.url}/api/v1/task/{task_id}", files=files, headers=self._headers()
         )
-  
+
         r.raise_for_status()
         return TaskResponse(**r.json()).with_client(self)
-    
+
     def get_task(self, task_id: str) -> TaskResponse:
         if not self._session:
             raise ValueError("Session not found")
         r = self._session.get(
-            f"{self.url}/api/v1/task/{task_id}",
-            headers=self._headers()
+            f"{self.url}/api/v1/task/{task_id}", headers=self._headers()
         )
         r.raise_for_status()
         return TaskResponse(**r.json()).with_client(self)
 
-
     def delete_task(self, task_id: str) -> None:
         if not self._session:
             raise ValueError("Session not found")
         r = self._session.delete(
-            f"{self.url}/api/v1/task/{task_id}",
-            headers=self._headers()
+            f"{self.url}/api/v1/task/{task_id}", headers=self._headers()
         )
         r.raise_for_status()
 
@@ -71,7 +73,6 @@ class Chunkr(ChunkrBase):
         if not self._session:
             raise ValueError("Session not found")
         r = self._session.get(
-            f"{self.url}/api/v1/task/{task_id}/cancel",
-            headers=self._headers()
+            f"{self.url}/api/v1/task/{task_id}/cancel", headers=self._headers()
         )
         r.raise_for_status()

chunkr_ai/api/chunkr_async.py

@@ -7,14 +7,19 @@ from pathlib import Path
 from PIL import Image
 from typing import Union, BinaryIO
 
+
 class ChunkrAsync(ChunkrBase):
     """Asynchronous Chunkr API client"""
-    
+
     def __init__(self, url: str = None, api_key: str = None):
         super().__init__(url, api_key)
         self._client = httpx.AsyncClient()
 
-    async def upload(self, file: Union[str, Path, BinaryIO, Image.Image], config: Configuration = None) -> TaskResponseAsync:
+    async def upload(
+        self,
+        file: Union[str, Path, BinaryIO, Image.Image],
+        config: Configuration = None,
+    ) -> TaskResponseAsync:
         if not self._client or self._client.is_closed:
             self._client = httpx.AsyncClient()
         try:
@@ -23,7 +28,7 @@ class ChunkrAsync(ChunkrBase):
         except Exception as e:
             await self._client.aclose()
             raise e
-    
+
     async def update(self, task_id: str, config: Configuration) -> TaskResponseAsync:
         if not self._client or self._client.is_closed:
             self._client = httpx.AsyncClient()
@@ -34,15 +39,17 @@ class ChunkrAsync(ChunkrBase):
             await self._client.aclose()
             raise e
 
-    async def create_task(self, file: Union[str, Path, BinaryIO, Image.Image], config: Configuration = None) -> TaskResponseAsync:
+    async def create_task(
+        self,
+        file: Union[str, Path, BinaryIO, Image.Image],
+        config: Configuration = None,
+    ) -> TaskResponseAsync:
         if not self._client or self._client.is_closed:
             self._client = httpx.AsyncClient()
         try:
             files = prepare_upload_data(file, config)
             r = await self._client.post(
-                f"{self.url}/api/v1/task",
-                files=files,
-                headers=self._headers()
+                f"{self.url}/api/v1/task", files=files, headers=self._headers()
             )
             r.raise_for_status()
             return TaskResponseAsync(**r.json()).with_client(self)
@@ -50,7 +57,9 @@ class ChunkrAsync(ChunkrBase):
             await self._client.aclose()
             raise e
 
-    async def update_task(self, task_id: str, config: Configuration) -> TaskResponseAsync:
+    async def update_task(
+        self, task_id: str, config: Configuration
+    ) -> TaskResponseAsync:
         if not self._client or self._client.is_closed:
             self._client = httpx.AsyncClient()
         try:
@@ -58,49 +67,46 @@ class ChunkrAsync(ChunkrBase):
             r = await self._client.patch(
                 f"{self.url}/api/v1/task/{task_id}",
                 files=files,
-                headers=self._headers()
+                headers=self._headers(),
             )
-     
+
             r.raise_for_status()
             return TaskResponseAsync(**r.json()).with_client(self)
         except Exception as e:
             await self._client.aclose()
             raise e
-    
+
     async def get_task(self, task_id: str) -> TaskResponseAsync:
         if not self._client or self._client.is_closed:
             self._client = httpx.AsyncClient()
         try:
             r = await self._client.get(
-                f"{self.url}/api/v1/task/{task_id}",
-                headers=self._headers()
+                f"{self.url}/api/v1/task/{task_id}", headers=self._headers()
             )
             r.raise_for_status()
             return TaskResponseAsync(**r.json()).with_client(self)
         except Exception as e:
             await self._client.aclose()
             raise e
-    
+
     async def delete_task(self, task_id: str) -> None:
         if not self._client or self._client.is_closed:
             self._client = httpx.AsyncClient()
         try:
             r = await self._client.delete(
-                f"{self.url}/api/v1/task/{task_id}",
-                headers=self._headers()
+                f"{self.url}/api/v1/task/{task_id}", headers=self._headers()
             )
             r.raise_for_status()
         except Exception as e:
             await self._client.aclose()
             raise e
-    
+
     async def cancel_task(self, task_id: str) -> None:
         if not self._client or self._client.is_closed:
             self._client = httpx.AsyncClient()
         try:
             r = await self._client.get(
-                f"{self.url}/api/v1/task/{task_id}/cancel",
-                headers=self._headers()
+                f"{self.url}/api/v1/task/{task_id}/cancel", headers=self._headers()
             )
             r.raise_for_status()
         except Exception as e:
@@ -111,4 +117,4 @@ class ChunkrAsync(ChunkrBase):
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self._client.aclose()
+        await self._client.aclose()

chunkr_ai/api/chunkr_base.py

@@ -9,31 +9,31 @@ from pathlib import Path
 from PIL import Image
 from typing import BinaryIO, Union
 
+
 class ChunkrBase(HeadersMixin):
     """Base class with shared functionality for Chunkr API clients."""
 
     def __init__(self, url: str = None, api_key: str = None):
         load_dotenv()
-        self.url = (
-            url or 
-            os.getenv('CHUNKR_URL') or 
-            'https://api.chunkr.ai' 
-        )
-        self._api_key = (
-            api_key or 
-            os.getenv('CHUNKR_API_KEY')
-        )
+        self.url = url or os.getenv("CHUNKR_URL") or "https://api.chunkr.ai"
+        self._api_key = api_key or os.getenv("CHUNKR_API_KEY")
         if not self._api_key:
-            raise ValueError("API key must be provided either directly, in .env file, or as CHUNKR_API_KEY environment variable. You can get an api key at: https://www.chunkr.ai")
-            
+            raise ValueError(
+                "API key must be provided either directly, in .env file, or as CHUNKR_API_KEY environment variable. You can get an api key at: https://www.chunkr.ai"
+            )
+
         self.url = self.url.rstrip("/")
 
     @abstractmethod
-    def upload(self, file: Union[str, Path, BinaryIO, Image.Image], config: Configuration = None) -> Union[TaskResponse, TaskResponseAsync]:
+    def upload(
+        self,
+        file: Union[str, Path, BinaryIO, Image.Image],
+        config: Configuration = None,
+    ) -> Union[TaskResponse, TaskResponseAsync]:
         """Upload a file and wait for processing to complete.
 
         Args:
-            file: The file to upload. 
+            file: The file to upload.
             config: Configuration options for processing. Optional.
 
         Examples:
@@ -44,7 +44,7 @@ class ChunkrBase(HeadersMixin):
         # Upload from opened file
         with open("document.pdf", "rb") as f:
             await chunkr.upload(f)
-        
+
         # Upload from URL
         await chunkr.upload("https://example.com/document.pdf")
 
@@ -60,11 +60,13 @@ class ChunkrBase(HeadersMixin):
             TaskResponse: The completed task response
         """
         pass
-    
+
     @abstractmethod
-    def update(self, task_id: str, config: Configuration) -> Union[TaskResponse, TaskResponseAsync]:
+    def update(
+        self, task_id: str, config: Configuration
+    ) -> Union[TaskResponse, TaskResponseAsync]:
         """Update a task by its ID and wait for processing to complete.
-        
+
         Args:
             task_id: The ID of the task to update
             config: Configuration options for processing. Optional.
@@ -75,7 +77,11 @@ class ChunkrBase(HeadersMixin):
         pass
 
     @abstractmethod
-    def create_task(self, file: Union[str, Path, BinaryIO, Image.Image], config: Configuration = None) -> Union[TaskResponse, TaskResponseAsync]:
+    def create_task(
+        self,
+        file: Union[str, Path, BinaryIO, Image.Image],
+        config: Configuration = None,
+    ) -> Union[TaskResponse, TaskResponseAsync]:
         """Upload a file for processing and immediately return the task response. It will not wait for processing to complete. To wait for the full processing to complete, use `task.poll()`.
 
         Args:
@@ -90,7 +96,7 @@ class ChunkrBase(HeadersMixin):
         # Upload from opened file
         with open("document.pdf", "rb") as f:
             task = await chunkr.create_task(f)
-    
+
         # Upload from URL
         task = await chunkr.create_task("https://example.com/document.pdf")
 
@@ -109,9 +115,11 @@ class ChunkrBase(HeadersMixin):
         pass
 
     @abstractmethod
-    def update_task(self, task_id: str, config: Configuration) -> Union[TaskResponse, TaskResponseAsync]:
+    def update_task(
+        self, task_id: str, config: Configuration
+    ) -> Union[TaskResponse, TaskResponseAsync]:
         """Update a task by its ID and immediately return the task response. It will not wait for processing to complete. To wait for the full processing to complete, use `task.poll()`.
-        
+
         Args:
             task_id: The ID of the task to update
             config: Configuration options for processing. Optional.
@@ -120,11 +128,11 @@ class ChunkrBase(HeadersMixin):
             TaskResponse: The updated task response
         """
         pass
-    
+
     @abstractmethod
     def get_task(self, task_id: str) -> Union[TaskResponse, TaskResponseAsync]:
         """Get a task response by its ID.
-        
+
         Args:
             task_id: The ID of the task to get
 
@@ -136,18 +144,17 @@ class ChunkrBase(HeadersMixin):
     @abstractmethod
     def delete_task(self, task_id: str) -> None:
         """Delete a task by its ID.
-        
+
         Args:
             task_id: The ID of the task to delete
         """
         pass
-    
+
     @abstractmethod
     def cancel_task(self, task_id: str) -> None:
         """Cancel a task by its ID.
-        
+
         Args:
             task_id: The ID of the task to cancel
         """
         pass
-