chunkr-ai 0.0.12__tar.gz → 0.0.15__tar.gz

{chunkr_ai-0.0.12/src/chunkr_ai.egg-info → chunkr_ai-0.0.15}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.2
 Name: chunkr-ai
-Version: 0.0.12
+Version: 0.0.15
 Summary: Python client for Chunkr: open source document intelligence
 Author-email: Ishaan Kapoor <ishaan@lumina.sh>
 Project-URL: Homepage, https://chunkr.ai
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx>=0.25.0
-Requires-Dist: httpx>=0.25.0
 Requires-Dist: pillow>=10.0.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: pytest-asyncio>=0.21.0
@@ -81,7 +80,7 @@ async def process_document():
     # If you want to upload without waiting for processing
     task = await chunkr.start_upload("document.pdf")
     # ... do other things ...
-    await task.poll_async()  # Check status when needed
+    await task.poll()  # Check status when needed
 ```
 
 ### Additional Features

{chunkr_ai-0.0.12 → chunkr_ai-0.0.15}/README.md

@@ -62,7 +62,7 @@ async def process_document():
     # If you want to upload without waiting for processing
     task = await chunkr.start_upload("document.pdf")
     # ... do other things ...
-    await task.poll_async()  # Check status when needed
+    await task.poll()  # Check status when needed
 ```
 
 ### Additional Features

{chunkr_ai-0.0.12 → chunkr_ai-0.0.15}/pyproject.toml

@@ -4,14 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "chunkr-ai"
-version = "0.0.12"
+version = "0.0.15"
 authors = [{"name" = "Ishaan Kapoor", "email" = "ishaan@lumina.sh"}]
 description = "Python client for Chunkr: open source document intelligence"
 readme = "README.md"
 license = {"file" = "LICENSE"}
 urls = {Homepage = "https://chunkr.ai"} 
 dependencies = [
-    "httpx>=0.25.0",
     "httpx>=0.25.0",
     "pillow>=10.0.0",
     "pydantic>=2.0.0",

{chunkr_ai-0.0.12 → chunkr_ai-0.0.15}/src/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-0.0.12 → chunkr_ai-0.0.15}/src/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-0.0.15/src/chunkr_ai/api/base.py

@@ -0,0 +1,183 @@
+from .config import Configuration
+from .task import TaskResponse
+from .auth import HeadersMixin
+from abc import abstractmethod
+from dotenv import load_dotenv
+import io
+import json
+import os
+from pathlib import Path
+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")
+        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"
+            )
+
+        self.url = self.url.rstrip("/")
+
+    def _prepare_file(
+        self, file: Union[str, Path, BinaryIO, Image.Image]
+    ) -> Tuple[str, BinaryIO]:
+        """Convert various file types into a tuple of (filename, file-like object).
+
+        Args:
+            file: Input file, can be:
+                - String or Path to a file
+                - URL string starting with http:// or https://
+                - Base64 string
+                - Opened binary file (mode='rb')
+                - PIL/Pillow Image object
+
+        Returns:
+            Tuple[str, BinaryIO]: (filename, file-like object) ready for upload
+
+        Raises:
+            FileNotFoundError: If the file path doesn't exist
+            TypeError: If the file type is not supported
+            ValueError: If the URL is invalid or unreachable
+            ValueError: If the MIME type is unsupported
+        """
+        # Handle URLs
+        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"
+            return filename, file_obj
+
+        # Handle base64 strings
+        if isinstance(file, str) and "," in file and ";base64," in file:
+            try:
+                # Split header and data
+                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()
+
+                # 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",
+                }
+
+                if mime_type in mime_to_ext:
+                    format = mime_to_ext[mime_type]
+                else:
+                    raise ValueError(f"Unsupported MIME type: {mime_type}")
+
+                return f"file.{format}", file_obj
+            except Exception as e:
+                raise ValueError(f"Invalid base64 string: {str(e)}")
+
+        # Handle file paths
+        if isinstance(file, (str, Path)):
+            path = Path(file).resolve()
+            if not path.exists():
+                raise FileNotFoundError(f"File not found: {file}")
+            return path.name, open(path, "rb")
+
+        # Handle PIL Images
+        if isinstance(file, Image.Image):
+            img_byte_arr = io.BytesIO()
+            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"):
+            # Try to get the filename from the file object if possible
+            name = (
+                getattr(file, "name", "document")
+                if hasattr(file, "name")
+                else "document"
+            )
+            return Path(name).name, file
+
+        raise TypeError(f"Unsupported file type: {type(file)}")
+
+    def _prepare_upload_data(
+        self,
+        file: Union[str, Path, BinaryIO, Image.Image],
+        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")
+                else:
+                    data[key] = value
+
+        return files, data
+
+    @abstractmethod
+    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:
+        """Upload a file for processing and immediately return the task response.
+
+        Must be implemented by subclasses.
+        """
+        pass
+
+    @abstractmethod
+    def get_task(self, task_id: str) -> TaskResponse:
+        """Get a task response by its ID.
+
+        Must be implemented by subclasses.
+        """
+        pass

chunkr_ai-0.0.15/src/chunkr_ai/api/chunkr.py

@@ -0,0 +1,78 @@
+from .chunkr_base import ChunkrBase
+from .config import Configuration
+from .task import TaskResponse
+from pathlib import Path
+from PIL import Image
+import requests
+from typing import Union, BinaryIO
+from .misc import prepare_upload_data
+
+
+class Chunkr(ChunkrBase):
+    """Chunkr API client"""
+
+    def __init__(self, url: str = None, api_key: str = None):
+        super().__init__(url, api_key)
+        self._session = requests.Session()
+
+    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)
+        if not self._session:
+            raise ValueError("Session not found")
+        r = self._session.post(
+            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()
+        )
+
+        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()
+        )
+        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()
+        )
+        r.raise_for_status()
+
+    def cancel_task(self, task_id: str) -> None:
+        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()
+        )
+        r.raise_for_status()

chunkr_ai-0.0.15/src/chunkr_ai/api/chunkr_async.py

@@ -0,0 +1,120 @@
+from .chunkr_base import ChunkrBase
+from .config import Configuration
+from .misc import prepare_upload_data
+from .task_async import TaskResponseAsync
+import httpx
+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:
+        if not self._client or self._client.is_closed:
+            self._client = httpx.AsyncClient()
+        try:
+            task = await self.create_task(file, config)
+            return await task.poll()
+        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()
+        try:
+            task = await self.update_task(task_id, config)
+            return await task.poll()
+        except Exception as e:
+            await self._client.aclose()
+            raise e
+
+    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()
+            )
+            r.raise_for_status()
+            return TaskResponseAsync(**r.json()).with_client(self)
+        except Exception as e:
+            await self._client.aclose()
+            raise e
+
+    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:
+            files = prepare_upload_data(None, config)
+            r = await self._client.patch(
+                f"{self.url}/api/v1/task/{task_id}",
+                files=files,
+                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()
+            )
+            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()
+            )
+            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()
+            )
+            r.raise_for_status()
+        except Exception as e:
+            await self._client.aclose()
+            raise e
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self._client.aclose()

chunkr_ai-0.0.15/src/chunkr_ai/api/chunkr_base.py

@@ -0,0 +1,160 @@
+from .config import Configuration
+from .task import TaskResponse
+from .task_async import TaskResponseAsync
+from .auth import HeadersMixin
+from abc import abstractmethod
+from dotenv import load_dotenv
+import os
+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")
+        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"
+            )
+
+        self.url = self.url.rstrip("/")
+
+    @abstractmethod
+    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.
+            config: Configuration options for processing. Optional.
+
+        Examples:
+        ```python
+        # Upload from file path
+        await chunkr.upload("document.pdf")
+
+        # 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")
+
+        # Upload from base64 string (must include MIME type header)
+        await chunkr.upload("data:application/pdf;base64,JVBERi0...")
+
+        # Upload an image
+        from PIL import Image
+        img = Image.open("photo.jpg")
+        await chunkr.upload(img)
+        ```
+        Returns:
+            TaskResponse: The completed task response
+        """
+        pass
+
+    @abstractmethod
+    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.
+
+        Returns:
+            TaskResponse: The updated task response
+        """
+        pass
+
+    @abstractmethod
+    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:
+            file: The file to upload.
+            config: Configuration options for processing. Optional.
+
+        Examples:
+        ```
+        # Upload from file path
+        task = await chunkr.create_task("document.pdf")
+
+        # 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")
+
+        # Upload from base64 string (must include MIME type header)
+        task = await chunkr.create_task("data:application/pdf;base64,JVBERi0xLjcKCjEgMCBvYmo...")
+
+        # Upload an image
+        from PIL import Image
+        img = Image.open("photo.jpg")
+        task = await chunkr.create_task(img)
+
+        # Wait for the task to complete - this can be done when needed
+        await task.poll()
+        ```
+        """
+        pass
+
+    @abstractmethod
+    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.
+
+        Returns:
+            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
+
+        Returns:
+            TaskResponse: The task response
+        """
+        pass
+
+    @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