chunkr-ai 0.0.11__py3-none-any.whl → 0.0.12__py3-none-any.whl

chunkr_ai/api/config.py

@@ -142,4 +142,4 @@ class Status(str, Enum):
     PROCESSING = "Processing"
     SUCCEEDED = "Succeeded"
     FAILED = "Failed"
-    CANCELLED = "Cancelled"
+    CANCELLED = "Cancelled"

chunkr_ai/api/task.py

@@ -1,38 +1,10 @@
-from .protocol import ChunkrClientProtocol
-from .config import Configuration, OutputResponse, Status
+from .config import Configuration
 from .misc import prepare_upload_data
-import asyncio
-from datetime import datetime
-from pydantic import BaseModel, PrivateAttr
+from .task_base import TaskBase
 import time
-from typing import Optional, Union
-
-class TaskResponse(BaseModel):
-    configuration: Configuration
-    created_at: datetime
-    expires_at: Optional[datetime] = None
-    file_name: Optional[str] = None
-    finished_at: Optional[datetime] = None
-    input_file_url: Optional[str] = None
-    message: str
-    output: Optional[OutputResponse] = None
-    page_count: Optional[int] = None
-    pdf_url: Optional[str] = None
-    started_at: Optional[datetime] = None
-    status: Status
-    task_id: str
-    task_url: Optional[str] = None
-    _client: Optional[Union[ChunkrClientProtocol]] = PrivateAttr(default=None)
-
-    def with_client(self, client: Union[ChunkrClientProtocol]) -> 'TaskResponse':
-        self._client = client
-        return self
-    
-    def _poll_request_sync(self) -> dict:
-        """Helper method to make polling request with retry logic (synchronous)"""
-        if not self.task_url:
-            raise ValueError("Task URL not found in response")
 
+class TaskResponse(TaskBase):
+    def _poll_request(self) -> dict:
         while True:
             try:
                 r = self._client._session.get(self.task_url, headers=self._client._headers())
@@ -44,68 +16,20 @@ class TaskResponse(BaseModel):
             except Exception as e:
                 raise
 
-    async def _poll_request_async(self) -> dict:
-        """Helper method to make polling request with retry logic (asynchronous)"""
+    def poll(self) -> 'TaskResponse':
         if not self.task_url:
             raise ValueError("Task URL not found in response")
-
-        while True:
-            try:
-                r = await self._client._client.get(self.task_url, headers=self._client._headers())
-                r.raise_for_status()
-                response = r.json()
-                return response
-            except (ConnectionError, TimeoutError) as _:
-                print("Connection error while polling the task, retrying...")
-                await asyncio.sleep(0.5)
-            except Exception as e:
-                raise
-
-    def _check_status(self) -> Optional['TaskResponse']:
-        """Helper method to check task status and handle completion/failure"""
-        if self.status == "Failed":
-            raise ValueError(self.message)
-        if self.status not in ("Starting", "Processing"):
-            return self
-        return None
-
-    def poll(self) -> 'TaskResponse':
-        """Poll the task for completion."""
         while True:
             response = self._poll_request_sync()
             updated_task = TaskResponse(**response).with_client(self._client)
             self.__dict__.update(updated_task.__dict__)
-            
             if result := self._check_status():
                 return result
-            
             time.sleep(0.5)
-
-    async def poll_async(self) -> 'TaskResponse':
-        """Poll the task for completion asynchronously."""
-        while True:
-            response = await self._poll_request_async()
-            updated_task = TaskResponse(**response).with_client(self._client)
-            self.__dict__.update(updated_task.__dict__)
-            
-            if result := self._check_status():
-                return result
-            
-            await asyncio.sleep(0.5)
-
-    def _get_content(self, content_type: str) -> str:
-        """Helper method to get either HTML, Markdown, or raw content."""
-        if not self.output:
-            return ""
-        parts = []
-        for c in self.output.chunks:
-            for s in c.segments:
-                content = getattr(s, content_type)
-                if content:
-                    parts.append(content)
-        return "\n".join(parts)
     
     def update(self, config: Configuration) -> 'TaskResponse':
+        if not self.task_url:
+            raise ValueError("Task URL not found")
         files = prepare_upload_data(None, config)
         r = self._client._session.patch(
             f"{self.task_url}",
@@ -113,56 +37,25 @@ class TaskResponse(BaseModel):
             headers=self._client._headers()
         )
         r.raise_for_status()
-        return TaskResponse(**r.json()).with_client(self._client)
-    
-    async def update_async(self, config: Configuration) -> 'TaskResponse':
-        files = prepare_upload_data(None, config)
-        r = await self._client._client.patch(
-            f"{self.task_url}",
-            files=files,
-            headers=self._client._headers()
-        )   
-        r.raise_for_status()
-        return TaskResponse(**r.json()).with_client(self._client)
+        updated = TaskResponse(**r.json()).with_client(self._client)
+        self.__dict__.update(updated.__dict__)
+        return self.poll()
     
     def cancel(self):
+        if not self.task_url:
+            raise ValueError("Task URL not found")
         r = self._client._session.get(
             f"{self.task_url}/cancel",
             headers=self._client._headers()
         )
         r.raise_for_status()
         self.poll()
-    
-    async def cancel_async(self):
-        r = await self._client._client.get(
-            f"{self.task_url}/cancel",
-            headers=self._client._headers()
-        )
-        r.raise_for_status()
-        await self.poll_async()
 
     def delete(self):
+        if not self.task_url:
+            raise ValueError("Task URL not found")
         r = self._client._session.delete(
-            f"{self.task_url}",
+            self.task_url,
             headers=self._client._headers()
         )
         r.raise_for_status()
-    
-    async def delete_async(self):
-        r = await self._client._client.delete(
-            f"{self.task_url}",
-            headers=self._client._headers()
-        )
-        r.raise_for_status()
-
-    def html(self) -> str:
-        """Get full HTML for the task"""
-        return self._get_content("html")
-
-    def markdown(self) -> str:
-        """Get full markdown for the task"""
-        return self._get_content("markdown")
-        
-    def content(self) -> str:
-        """Get full text for the task"""
-        return self._get_content("content")

chunkr_ai/api/task_async.py

@@ -1,34 +1,23 @@
-import asyncio
-from pydantic import BaseModel, PrivateAttr
-from datetime import datetime
-from typing import Optional, Union
-from .task_base import TaskBase
-from .protocol import ChunkrClientProtocol
-from .config import Configuration, OutputResponse, Status
+from .config import Configuration
 from .misc import prepare_upload_data
+from .task_base import TaskBase
+import asyncio
 
-class TaskResponseAsync(BaseModel, TaskBase):
-    configuration: Configuration
-    created_at: datetime
-    expires_at: Optional[datetime]
-    file_name: Optional[str]
-    finished_at: Optional[datetime]
-    input_file_url: Optional[str]
-    message: str
-    output: Optional[OutputResponse]
-    page_count: Optional[int]
-    pdf_url: Optional[str]
-    started_at: Optional[datetime]
-    status: Status
-    task_id: str
-    task_url: Optional[str]
-    _client: Optional[Union[ChunkrClientProtocol]] = PrivateAttr(default=None)
-
-    def with_client(self, client: Union[ChunkrClientProtocol]) -> 'TaskResponseAsync':
-        self._client = client
-        return self
+class TaskResponseAsync(TaskBase):
+    async def _poll_request(self) -> dict:
+        try:
+            r = await self._client._client.get(self.task_url, headers=self._client._headers())
+            r.raise_for_status()
+            return r.json()
+        except (ConnectionError, TimeoutError) as _:
+            print("Connection error while polling the task, retrying...")
+            await asyncio.sleep(0.5)
+        except Exception as e:
+            raise
 
     async def poll(self) -> 'TaskResponseAsync':
+        if not self.task_url:
+            raise ValueError("Task URL not found")
         while True:
             j = await self._poll_request()
             updated = TaskResponseAsync(**j).with_client(self._client)
@@ -37,28 +26,6 @@ class TaskResponseAsync(BaseModel, TaskBase):
                 return res
             await asyncio.sleep(0.5)
 
-    async def _poll_request(self) -> dict:
-        if not self.task_url:
-            raise ValueError("Task URL not found")
-        while True:
-            try:
-                r = await self._client._client.get(self.task_url, headers=self._client._headers())
-                r.raise_for_status()
-                return r.json()
-            except Exception as e:
-                if self.status == Status.FAILED:
-                    raise ValueError(self.message) from e
-                await asyncio.sleep(0.5)
-
-    def _check_status(self) -> Optional['TaskResponseAsync']:
-        if self.status == Status.FAILED:
-            raise ValueError(f"Task failed: {self.message}")
-        if self.status == Status.CANCELLED:
-            return self
-        if self.status not in [Status.STARTING, Status.PROCESSING]:
-            return self
-        return None
-
     async def update(self, config: Configuration) -> 'TaskResponseAsync':
         if not self.task_url:
             raise ValueError("Task URL not found")
@@ -77,27 +44,7 @@ class TaskResponseAsync(BaseModel, TaskBase):
         return await self.poll()
 
     async def delete(self):
+        if not self.task_url:
+            raise ValueError("Task URL not found")
         r = await self._client._client.delete(self.task_url, headers=self._client._headers())
-        r.raise_for_status()
-
-    def html(self) -> str:
-        return self._get_content("html")
-
-    def markdown(self) -> str:
-        return self._get_content("markdown")
-
-    def content(self) -> str:
-        return self._get_content("content")
-
-    def _get_content(self, t: str) -> str:
-        if not self.output:
-            return ""
-        parts = []
-        for c in self.output.chunks:
-            for s in c.segments:
-                v = getattr(s, t)
-                if v:
-                    parts.append(v)
-        return "\n".join(parts)
-
-    # Satisfying TaskBase abstract methods with stubs
+        r.raise_for_status()

chunkr_ai/api/task_base.py

@@ -1,31 +1,83 @@
-from abc import ABC, abstractmethod
 from .config import Configuration
+from .protocol import ChunkrClientProtocol
+from ..models import Status, OutputResponse
+from abc import ABC, abstractmethod
+from typing import TypeVar, Optional, Generic, Union
+from pydantic import BaseModel, PrivateAttr
+from datetime import datetime
+
+T = TypeVar('T', bound='TaskBase')
+
+class TaskBase(BaseModel, ABC, Generic[T]):
+    configuration: Configuration
+    created_at: datetime
+    expires_at: Optional[datetime]
+    file_name: Optional[str]
+    finished_at: Optional[datetime]
+    input_file_url: Optional[str]
+    message: str
+    output: Optional[OutputResponse]
+    page_count: Optional[int]
+    pdf_url: Optional[str]
+    started_at: Optional[datetime]
+    status: Status
+    task_id: str
+    task_url: Optional[str]
+    _client: Optional[Union[ChunkrClientProtocol]] = PrivateAttr(default=None)
 
-class TaskBase(ABC):
     @abstractmethod
-    def poll(self):
+    def _poll_request(self) -> dict:
+        """Helper method to make polling request with retry logic (synchronous)"""
         pass
 
     @abstractmethod
-    def update(self, config: Configuration):
+    def poll(self) -> T:
+        """Poll the task for completion."""
         pass
 
     @abstractmethod
-    def cancel(self):
+    def update(self, config: Configuration) -> T:
+        """Update the task configuration."""
         pass
 
     @abstractmethod
-    def delete(self):
+    def cancel(self) -> T:
+        """Cancel the task."""
         pass
 
     @abstractmethod
-    def html(self) -> str:
+    def delete(self) -> T:
+        """Delete the task."""
         pass
 
-    @abstractmethod
+    def with_client(self, client: Union[ChunkrClientProtocol]) -> T:
+        self._client = client
+        return self
+
+    def _check_status(self) -> Optional[T]:
+        """Helper method to check task status and handle completion/failure"""
+        if self.status == "Failed":
+            raise ValueError(self.message)
+        if self.status not in ("Starting", "Processing"):
+            return self
+        return None
+
+    def html(self) -> str:
+        return self._get_content("html")
+
     def markdown(self) -> str:
-        pass
+        return self._get_content("markdown")
 
-    @abstractmethod
     def content(self) -> str:
-        pass
+        return self._get_content("content")
+
+    def _get_content(self, t: str) -> str:
+        if not self.output:
+            return ""
+        parts = []
+        for c in self.output.chunks:
+            for s in c.segments:
+                v = getattr(s, t)
+                if v:
+                    parts.append(v)
+        return "\n".join(parts)

{chunkr_ai-0.0.11.dist-info → chunkr_ai-0.0.12.dist-info}/METADATA

@@ -1,12 +1,13 @@
 Metadata-Version: 2.2
 Name: chunkr-ai
-Version: 0.0.11
+Version: 0.0.12
 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

{chunkr_ai-0.0.11.dist-info → chunkr_ai-0.0.12.dist-info}/RECORD

@@ -5,15 +5,15 @@ chunkr_ai/api/auth.py,sha256=iSd5Jek2BFaHGw9HY-RrqgwP56BHFU0xbSuJS4fU6AA,425
 chunkr_ai/api/chunkr.py,sha256=0qpV9b1hOpDhA9EuKkXW9X_laUmw5NY3ZYq0cUOTbww,5190
 chunkr_ai/api/chunkr_async.py,sha256=ZkLBrn4cqzu3sqMfS8cfZZgSvpdyQuWZP95lfGxuHx0,4900
 chunkr_ai/api/chunkr_base.py,sha256=IYO0pmoL02GchIggj6_Q5nvtAUoOvYAAvT7VLFU6scY,2506
-chunkr_ai/api/config.py,sha256=y6wZz01ihRJ_5_cK_JklFWn397yll7jfXntd8bBBa5s,4861
+chunkr_ai/api/config.py,sha256=joTn7jiOlJXTwwza-jHauLV-39CMzaxZVGB9JBm8Cok,4862
 chunkr_ai/api/misc.py,sha256=9vnfrbJ7sFlZqwEIQ4NTMb5rhPOmETT7e1jR-b42PXM,4977
 chunkr_ai/api/protocol.py,sha256=XKS9RmtvBpJItYhPg18qlOCKpaSHdOuQTRSUxAdUz2g,479
 chunkr_ai/api/schema.py,sha256=OeLOhBRXeRBgEImg0Q6O9Z10ojT6aSEVvwnDR8UeENo,4971
-chunkr_ai/api/task.py,sha256=Z5Da_Ijvih5rBz5ry98oAYNcJEDbQhhDWBQ35nHCRK4,5881
-chunkr_ai/api/task_async.py,sha256=o7tXvViIrdcrdclxaGzxrgIv-n-W8-twQ7XsDLXfXhM,3659
-chunkr_ai/api/task_base.py,sha256=Tkk7dhIeB3ic5M9g_b-MVRdNv4XQTvajpaUy8JylQ8A,526
-chunkr_ai-0.0.11.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chunkr_ai-0.0.11.dist-info/METADATA,sha256=s8UeXDnBDVG_1RN5colcJCGhwrICRy9VMQWmTUKVRJc,4845
-chunkr_ai-0.0.11.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-chunkr_ai-0.0.11.dist-info/top_level.txt,sha256=0IZY7PZIiS8bw5r4NUQRUQ-ATi-L_3vLQVq3ZLouOW8,10
-chunkr_ai-0.0.11.dist-info/RECORD,,
+chunkr_ai/api/task.py,sha256=4insrdGEVzBHs1ejZvde8bbEetVzgJELa47UjhfBqCA,2116
+chunkr_ai/api/task_async.py,sha256=LqS-LL-mCOgfGsgvuSXhKkSEUM6MMro-EZHl_ZedQQk,1998
+chunkr_ai/api/task_base.py,sha256=iS5UVIDEPIiDoWrn21Oh_dQurkd_hvKQ8ng32j6sGoA,2369
+chunkr_ai-0.0.12.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chunkr_ai-0.0.12.dist-info/METADATA,sha256=dfo9myRizW2A5W0H6FpIoBzHa4QxmEe3lsedPYhwjXM,4874
+chunkr_ai-0.0.12.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+chunkr_ai-0.0.12.dist-info/top_level.txt,sha256=0IZY7PZIiS8bw5r4NUQRUQ-ATi-L_3vLQVq3ZLouOW8,10
+chunkr_ai-0.0.12.dist-info/RECORD,,