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

chunkr_ai/api/schema.py

@@ -2,17 +2,22 @@ from pydantic import BaseModel
 from typing import Optional, List, Union, Type
 import json
 
+
 class Property(BaseModel):
     name: str
     prop_type: str
     description: Optional[str] = None
     default: Optional[str] = None
 
+
 class JsonSchema(BaseModel):
     title: str
     properties: List[Property]
 
-def from_pydantic(pydantic: Union[BaseModel, Type[BaseModel]], current_depth: int = 0) -> dict:
+
+def from_pydantic(
+    pydantic: Union[BaseModel, Type[BaseModel]], current_depth: int = 0
+) -> dict:
     """Convert a Pydantic model to a Chunk json schema."""
     MAX_DEPTH = 5
     model = pydantic if isinstance(pydantic, type) else pydantic.__class__
@@ -21,108 +26,111 @@ def from_pydantic(pydantic: Union[BaseModel, Type[BaseModel]], current_depth: in
 
     def get_enum_description(details: dict) -> str:
         """Get description including enum values if they exist"""
-        description = details.get('description', '')
-        
+        description = details.get("description", "")
+
         # First check if this is a direct enum
-        if 'enum' in details:
-            enum_values = details['enum']
-            enum_str = '\nAllowed values:\n' + '\n'.join(f'- {val}' for val in enum_values)
+        if "enum" in details:
+            enum_values = details["enum"]
+            enum_str = "\nAllowed values:\n" + "\n".join(
+                f"- {val}" for val in enum_values
+            )
             return f"{description}{enum_str}"
-            
+
         # Then check if it's a reference to an enum
-        if '$ref' in details:
-            ref_schema = resolve_ref(details['$ref'], schema.get('$defs', {}))
-            if 'enum' in ref_schema:
-                enum_values = ref_schema['enum']
-                enum_str = '\nAllowed values:\n' + '\n'.join(f'- {val}' for val in enum_values)
+        if "$ref" in details:
+            ref_schema = resolve_ref(details["$ref"], schema.get("$defs", {}))
+            if "enum" in ref_schema:
+                enum_values = ref_schema["enum"]
+                enum_str = "\nAllowed values:\n" + "\n".join(
+                    f"- {val}" for val in enum_values
+                )
                 return f"{description}{enum_str}"
-                
+
         return description
 
     def resolve_ref(ref: str, definitions: dict) -> dict:
         """Resolve a $ref reference to its actual schema"""
-        if not ref.startswith('#/$defs/'):
+        if not ref.startswith("#/$defs/"):
             return {}
-        ref_name = ref[len('#/$defs/'):]
+        ref_name = ref[len("#/$defs/") :]
         return definitions.get(ref_name, {})
 
     def get_nested_schema(field_schema: dict, depth: int) -> dict:
         if depth >= MAX_DEPTH:
             return {}
-        
+
         # If there's a $ref, resolve it first
-        if '$ref' in field_schema:
-            field_schema = resolve_ref(field_schema['$ref'], schema.get('$defs', {}))
-        
+        if "$ref" in field_schema:
+            field_schema = resolve_ref(field_schema["$ref"], schema.get("$defs", {}))
+
         nested_props = {}
-        if field_schema.get('type') == 'object':
-            for name, details in field_schema.get('properties', {}).items():
-                if details.get('type') == 'object' or '$ref' in details:
+        if field_schema.get("type") == "object":
+            for name, details in field_schema.get("properties", {}).items():
+                if details.get("type") == "object" or "$ref" in details:
                     ref_schema = details
-                    if '$ref' in details:
-                        ref_schema = resolve_ref(details['$ref'], schema.get('$defs', {}))
+                    if "$ref" in details:
+                        ref_schema = resolve_ref(
+                            details["$ref"], schema.get("$defs", {})
+                        )
                     nested_schema = get_nested_schema(ref_schema, depth + 1)
                     nested_props[name] = {
-                        'type': 'object',
-                        'description': get_enum_description(details),
-                        'properties': nested_schema
+                        "type": "object",
+                        "description": get_enum_description(details),
+                        "properties": nested_schema,
                     }
                 else:
                     nested_props[name] = {
-                        'type': details.get('type', 'string'),
-                        'description': get_enum_description(details)
+                        "type": details.get("type", "string"),
+                        "description": get_enum_description(details),
                     }
         return nested_props
 
-    for name, details in schema.get('properties', {}).items():
+    for name, details in schema.get("properties", {}).items():
         # Handle arrays
-        if details.get('type') == 'array':
-            items = details.get('items', {})
-            if '$ref' in items:
-                items = resolve_ref(items['$ref'], schema.get('$defs', {}))
-            
+        if details.get("type") == "array":
+            items = details.get("items", {})
+            if "$ref" in items:
+                items = resolve_ref(items["$ref"], schema.get("$defs", {}))
+
             # Get nested schema for array items
             item_schema = get_nested_schema(items, current_depth)
             description = get_enum_description(details)
-            
+
             if item_schema:
                 description = f"{description}\nList items schema:\n{json.dumps(item_schema, indent=2)}"
-            
-            prop = Property(
-                name=name,
-                prop_type='list',
-                description=description
-            )
+
+            prop = Property(name=name, prop_type="list", description=description)
         # Handle objects and references
-        elif details.get('type') == 'object' or '$ref' in details:
-            prop_type = 'object'
+        elif details.get("type") == "object" or "$ref" in details:
+            prop_type = "object"
             ref_schema = details
-            if '$ref' in details:
-                ref_schema = resolve_ref(details['$ref'], schema.get('$defs', {}))
-            
+            if "$ref" in details:
+                ref_schema = resolve_ref(details["$ref"], schema.get("$defs", {}))
+
             nested_schema = get_nested_schema(ref_schema, current_depth)
-            
+
             prop = Property(
                 name=name,
                 prop_type=prop_type,
                 description=get_enum_description(details),
-                properties=nested_schema
+                properties=nested_schema,
             )
-            
+
         # Handle primitive types
         else:
             prop = Property(
                 name=name,
-                prop_type=details.get('type', 'string'),
+                prop_type=details.get("type", "string"),
                 description=get_enum_description(details),
-                default=str(details.get('default')) if details.get('default') is not None else None
+                default=str(details.get("default"))
+                if details.get("default") is not None
+                else None,
             )
-            
+
         properties.append(prop)
-    
+
     json_schema = JsonSchema(
-        title=schema.get('title', model.__name__),
-        properties=properties
+        title=schema.get("title", model.__name__), properties=properties
     )
-    
-    return json_schema.model_dump(mode="json", exclude_none=True)
+
+    return json_schema.model_dump(mode="json", exclude_none=True)

chunkr_ai/api/task.py

@@ -3,50 +3,56 @@ from .misc import prepare_upload_data
 from .task_base import TaskBase
 import time
 
+
 class TaskResponse(TaskBase):
     def _poll_request(self) -> dict:
         while True:
             try:
-                r = self._client._session.get(self.task_url, headers=self._client._headers())
+                if not self.task_url:
+                    raise ValueError("Task URL not found in response")
+                if not self._client._session:
+                    raise ValueError("Client session not found")
+                r = self._client._session.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...")
                 time.sleep(0.5)
-            except Exception as e:
+            except Exception:
                 raise
 
-    def poll(self) -> 'TaskResponse':
-        if not self.task_url:
-            raise ValueError("Task URL not found in response")
+    def poll(self) -> "TaskResponse":
         while True:
-            response = self._poll_request_sync()
+            response = self._poll_request()
             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)
-    
-    def update(self, config: Configuration) -> 'TaskResponse':
+
+    def update(self, config: Configuration) -> "TaskResponse":
         if not self.task_url:
             raise ValueError("Task URL not found")
+        if not self._client._session:
+            raise ValueError("Client session not found")
         files = prepare_upload_data(None, config)
         r = self._client._session.patch(
-            f"{self.task_url}",
-            files=files,
-            headers=self._client._headers()
+            self.task_url, files=files, headers=self._client._headers()
         )
         r.raise_for_status()
         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")
+        if not self._client._session:
+            raise ValueError("Client session not found")
         r = self._client._session.get(
-            f"{self.task_url}/cancel",
-            headers=self._client._headers()
+            f"{self.task_url}/cancel", headers=self._client._headers()
         )
         r.raise_for_status()
         self.poll()
@@ -54,8 +60,7 @@ class TaskResponse(TaskBase):
     def delete(self):
         if not self.task_url:
             raise ValueError("Task URL not found")
-        r = self._client._session.delete(
-            self.task_url,
-            headers=self._client._headers()
-        )
+        if not self._client._session:
+            raise ValueError("Client session not found")
+        r = self._client._session.delete(self.task_url, headers=self._client._headers())
         r.raise_for_status()

chunkr_ai/api/task_async.py

@@ -3,21 +3,28 @@ from .misc import prepare_upload_data
 from .task_base import TaskBase
 import asyncio
 
+
 class TaskResponseAsync(TaskBase):
     async def _poll_request(self) -> dict:
         try:
-            r = await self._client._client.get(self.task_url, headers=self._client._headers())
+            if not self._client._client:
+                raise ValueError("Client not found")
+            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:
+        except Exception:
             raise
 
-    async def poll(self) -> 'TaskResponseAsync':
+    async def poll(self) -> "TaskResponseAsync":
         if not self.task_url:
             raise ValueError("Task URL not found")
+        if not self._client._client:
+            raise ValueError("Client not found")
         while True:
             j = await self._poll_request()
             updated = TaskResponseAsync(**j).with_client(self._client)
@@ -26,11 +33,15 @@ class TaskResponseAsync(TaskBase):
                 return res
             await asyncio.sleep(0.5)
 
-    async def update(self, config: Configuration) -> 'TaskResponseAsync':
+    async def update(self, config: Configuration) -> "TaskResponseAsync":
         if not self.task_url:
             raise ValueError("Task URL not found")
+        if not self._client._client:
+            raise ValueError("Client not found")
         f = prepare_upload_data(None, config)
-        r = await self._client._client.patch(self.task_url, files=f, headers=self._client._headers())
+        r = await self._client._client.patch(
+            self.task_url, files=f, headers=self._client._headers()
+        )
         r.raise_for_status()
         updated = TaskResponseAsync(**r.json()).with_client(self._client)
         self.__dict__.update(updated.__dict__)
@@ -39,12 +50,20 @@ class TaskResponseAsync(TaskBase):
     async def cancel(self):
         if not self.task_url:
             raise ValueError("Task URL not found")
-        r = await self._client._client.get(f"{self.task_url}/cancel", headers=self._client._headers())
+        if not self._client._client:
+            raise ValueError("Client not found")
+        r = await self._client._client.get(
+            f"{self.task_url}/cancel", headers=self._client._headers()
+        )
         r.raise_for_status()
         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()
+        if not self._client._client:
+            raise ValueError("Client not found")
+        r = await self._client._client.delete(
+            self.task_url, headers=self._client._headers()
+        )
+        r.raise_for_status()

chunkr_ai/api/task_base.py

@@ -1,12 +1,12 @@
-from .config import Configuration
+from .config import Configuration, Status, OutputResponse
 from .protocol import ChunkrClientProtocol
-from ..models import Status, OutputResponse
 from abc import ABC, abstractmethod
-from typing import TypeVar, Optional, Generic, Union
+from typing import TypeVar, Optional, Generic
 from pydantic import BaseModel, PrivateAttr
 from datetime import datetime
 
-T = TypeVar('T', bound='TaskBase')
+T = TypeVar("T", bound="TaskBase")
+
 
 class TaskBase(BaseModel, ABC, Generic[T]):
     configuration: Configuration
@@ -23,7 +23,7 @@ class TaskBase(BaseModel, ABC, Generic[T]):
     status: Status
     task_id: str
     task_url: Optional[str]
-    _client: Optional[Union[ChunkrClientProtocol]] = PrivateAttr(default=None)
+    _client: Optional[ChunkrClientProtocol] = PrivateAttr(default=None)
 
     @abstractmethod
     def _poll_request(self) -> dict:
@@ -50,7 +50,7 @@ class TaskBase(BaseModel, ABC, Generic[T]):
         """Delete the task."""
         pass
 
-    def with_client(self, client: Union[ChunkrClientProtocol]) -> T:
+    def with_client(self, client: ChunkrClientProtocol) -> T:
         self._client = client
         return self
 

chunkr_ai/models.py

@@ -24,26 +24,25 @@ from .api.task import TaskResponse
 from .api.task_async import TaskResponseAsync
 
 __all__ = [
-    'BoundingBox',
-    'Chunk',
-    'ChunkProcessing',
-    'Configuration',
-    'CroppingStrategy',
-    'ExtractedJson',
-    'GenerationConfig',
-    'GenerationStrategy',
-    'JsonSchema',
-    'LlmConfig',
-    'Model',
-    'OCRResult',
-    'OcrStrategy',
-    'OutputResponse',
-    'Property',
-    'Segment',
-    'SegmentProcessing',
-    'SegmentType',
-    'SegmentationStrategy',
-    'Status',
-    'TaskResponse',
-    'TaskResponseAsync',
+    "BoundingBox",
+    "Chunk",
+    "ChunkProcessing",
+    "Configuration",
+    "CroppingStrategy",
+    "ExtractedJson",
+    "GenerationConfig",
+    "GenerationStrategy",
+    "JsonSchema",
+    "Model",
+    "OCRResult",
+    "OcrStrategy",
+    "OutputResponse",
+    "Property",
+    "Segment",
+    "SegmentProcessing",
+    "SegmentType",
+    "SegmentationStrategy",
+    "Status",
+    "TaskResponse",
+    "TaskResponseAsync",
 ]

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

@@ -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.15.dist-info/RECORD

@@ -0,0 +1,21 @@
+chunkr_ai/__init__.py,sha256=q5YosvCNXPNGjV10pZY1gcvdosqUh38nVQTQA9g8EuM,110
+chunkr_ai/models.py,sha256=KPcZDkRAziyke33ciEZymvCA28_QuSozoR11fXtjats,886
+chunkr_ai/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chunkr_ai/api/api.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chunkr_ai/api/auth.py,sha256=hlv0GiUmlsbFO1wLL9sslqOnsBSoBqkL_6Mk2SDvxgE,413
+chunkr_ai/api/base.py,sha256=QvHl8FInKHYKPLWDeEPpCchB1uktzOwTW7iPnyXccUc,6449
+chunkr_ai/api/chunkr.py,sha256=0extAWVeZtI7B-g14smTfFZD_csdJNCcVNXx2_L69OQ,2617
+chunkr_ai/api/chunkr_async.py,sha256=aa0s_tnYoujHBsfe8uLiPpVEnb2l9A3CXwPP34w9Mk8,4127
+chunkr_ai/api/chunkr_base.py,sha256=k34Dyt1f21NBWZvZJ3w6Svvpg4SKnzr2ldGQ4ib96Wc,4951
+chunkr_ai/api/config.py,sha256=0vbPMAYvs-tb7zIDIoSFQekz8bK0-iw3iz7BqMnHbDI,4930
+chunkr_ai/api/misc.py,sha256=Dk8lWrgX-pZYcvcP2SzRhCdyBwMSSTrE8y7MzVQnScw,4878
+chunkr_ai/api/protocol.py,sha256=lxIR_qoCA2a1OXjpq3LrWMdS0jRHct1bEmBlUzV8gvE,526
+chunkr_ai/api/schema.py,sha256=yYesvueGgtmRa7Fi_Tpdv8A2bzHlx-B-5DxRAPlaDHo,4926
+chunkr_ai/api/task.py,sha256=28J4dR8BDjvtkh3CQjW_YUEkgPXhCHBGu0wH6AQKKuE,2474
+chunkr_ai/api/task_async.py,sha256=K5hTEOnmD42snPZg_JtJsVWg6QBUFZ1aBz1Abwv58-A,2529
+chunkr_ai/api/task_base.py,sha256=esEawvntjzfaPnV78KW2IbIFqI74-eJV_g70BVIubbY,2329
+chunkr_ai-0.0.15.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chunkr_ai-0.0.15.dist-info/METADATA,sha256=097bhYg2V6cuxLkiVmiSTNuGzlBvGFV1Hw2bFWxBYKc,4839
+chunkr_ai-0.0.15.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+chunkr_ai-0.0.15.dist-info/top_level.txt,sha256=0IZY7PZIiS8bw5r4NUQRUQ-ATi-L_3vLQVq3ZLouOW8,10
+chunkr_ai-0.0.15.dist-info/RECORD,,

chunkr_ai-0.0.12.dist-info/RECORD

@@ -1,19 +0,0 @@
-chunkr_ai/__init__.py,sha256=eXygrEhGxxIHXNYIlHF2eied8rGsx2RphgR8Wo4lRyo,110
-chunkr_ai/models.py,sha256=-dbwtTHTcGhH3LXUdVUPkobbPoeFNXRizeAW8BCGSkE,903
-chunkr_ai/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-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=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=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,,