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

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

@@ -1,12 +1,13 @@
 Metadata-Version: 2.2
 Name: chunkr-ai
-Version: 0.0.10
+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.10 → chunkr_ai-0.0.12}/pyproject.toml

@@ -4,13 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "chunkr-ai"
-version = "0.0.10"
+version = "0.0.12"
 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.10 → chunkr_ai-0.0.12}/src/chunkr_ai/api/config.py

@@ -1,6 +1,7 @@
 from pydantic import BaseModel, Field, model_validator, ConfigDict
 from enum import Enum
-from typing import Optional, List, Dict
+from typing import Optional, List, Dict, Union, Type
+from .schema import from_pydantic
 
 class GenerationStrategy(str, Enum):
     LLM = "LLM"
@@ -114,7 +115,7 @@ class Configuration(BaseModel):
     chunk_processing: Optional[ChunkProcessing] = Field(default=None)
     expires_in: Optional[int] = Field(default=None)
     high_resolution: Optional[bool] = Field(default=None)
-    json_schema: Optional[JsonSchema] = Field(default=None)
+    json_schema: Optional[Union[JsonSchema, Type[BaseModel], BaseModel]] = Field(default=None)
     model: Optional[Model] = Field(default=None)
     ocr_strategy: Optional[OcrStrategy] = Field(default=None)
     segment_processing: Optional[SegmentProcessing] = Field(default=None)
@@ -128,3 +129,17 @@ class Configuration(BaseModel):
                 values["chunk_processing"] = values.get("chunk_processing", {}) or {}
                 values["chunk_processing"]["target_length"] = target_length
         return values
+
+    @model_validator(mode='after')
+    def convert_json_schema(self) -> 'Configuration':
+        if self.json_schema is not None and not isinstance(self.json_schema, JsonSchema):
+            if isinstance(self.json_schema, (BaseModel, type)) and issubclass(getattr(self.json_schema, '__class__', type), BaseModel):
+                self.json_schema = JsonSchema(**from_pydantic(self.json_schema))
+        return self
+
+class Status(str, Enum):
+    STARTING = "Starting"
+    PROCESSING = "Processing"
+    SUCCEEDED = "Succeeded"
+    FAILED = "Failed"
+    CANCELLED = "Cancelled"

{chunkr_ai-0.0.10 → chunkr_ai-0.0.12}/src/chunkr_ai/api/misc.py

@@ -1,11 +1,10 @@
-from .config import Configuration, Property, JsonSchema
+from .config import Configuration
 import io
 import json
 from pathlib import Path
 from PIL import Image
 import requests
 from typing import Union, Tuple, BinaryIO, Optional
-from pydantic import BaseModel
 
 def prepare_file(
     file: Union[str, Path, BinaryIO, Image.Image]
@@ -127,33 +126,3 @@ def prepare_upload_data(
             files[key] = (None, json.dumps(value), 'application/json')
                 
     return files
-
-def from_pydantic(pydantic: BaseModel) -> dict:
-    """Convert a Pydantic model to a Chunk json schema.
-    
-    Args:
-        pydantic: A Pydantic BaseModel class or instance
-        
-    Returns:
-        dict: A JSON schema compatible with Chunk's format
-    """
-    model = pydantic if isinstance(pydantic, type) else pydantic.__class__
-    schema = model.model_json_schema()
-    print(schema)
-    properties = []
-    for name, details in schema.get('properties', {}).items():
-        prop = Property(
-            name=name,
-            title=details.get('title'),
-            prop_type=details.get('type', 'string'),
-            description=details.get('description'),
-            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
-    )
-    
-    return json_schema.model_dump(mode="json", exclude_none=True)

chunkr_ai-0.0.12/src/chunkr_ai/api/schema.py

@@ -0,0 +1,128 @@
+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:
+    """Convert a Pydantic model to a Chunk json schema."""
+    MAX_DEPTH = 5
+    model = pydantic if isinstance(pydantic, type) else pydantic.__class__
+    schema = model.model_json_schema()
+    properties = []
+
+    def get_enum_description(details: dict) -> str:
+        """Get description including enum values if they exist"""
+        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)
+            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)
+                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/'):
+            return {}
+        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', {}))
+        
+        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:
+                    ref_schema = details
+                    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
+                    }
+                else:
+                    nested_props[name] = {
+                        'type': details.get('type', 'string'),
+                        'description': get_enum_description(details)
+                    }
+        return nested_props
+
+    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', {}))
+            
+            # 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
+            )
+        # Handle objects and references
+        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', {}))
+            
+            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
+            )
+            
+        # Handle primitive types
+        else:
+            prop = Property(
+                name=name,
+                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
+            )
+            
+        properties.append(prop)
+    
+    json_schema = JsonSchema(
+        title=schema.get('title', model.__name__),
+        properties=properties
+    )
+    
+    return json_schema.model_dump(mode="json", exclude_none=True)

chunkr_ai-0.0.12/src/chunkr_ai/api/task.py

@@ -0,0 +1,61 @@
+from .config import Configuration
+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())
+                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:
+                raise
+
+    def poll(self) -> 'TaskResponse':
+        if not self.task_url:
+            raise ValueError("Task URL not found in response")
+        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)
+    
+    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}",
+            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")
+        r = self._client._session.get(
+            f"{self.task_url}/cancel",
+            headers=self._client._headers()
+        )
+        r.raise_for_status()
+        self.poll()
+
+    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()
+        )
+        r.raise_for_status()

chunkr_ai-0.0.12/src/chunkr_ai/api/task_async.py

@@ -0,0 +1,50 @@
+from .config import Configuration
+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())
+            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)
+            self.__dict__.update(updated.__dict__)
+            if res := self._check_status():
+                return res
+            await asyncio.sleep(0.5)
+
+    async def update(self, config: Configuration) -> 'TaskResponseAsync':
+        if not self.task_url:
+            raise ValueError("Task URL not found")
+        f = prepare_upload_data(None, config)
+        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__)
+        return await self.poll()
+
+    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())
+        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()

chunkr_ai-0.0.12/src/chunkr_ai/api/task_base.py

@@ -0,0 +1,83 @@
+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)
+
+    @abstractmethod
+    def _poll_request(self) -> dict:
+        """Helper method to make polling request with retry logic (synchronous)"""
+        pass
+
+    @abstractmethod
+    def poll(self) -> T:
+        """Poll the task for completion."""
+        pass
+
+    @abstractmethod
+    def update(self, config: Configuration) -> T:
+        """Update the task configuration."""
+        pass
+
+    @abstractmethod
+    def cancel(self) -> T:
+        """Cancel the task."""
+        pass
+
+    @abstractmethod
+    def delete(self) -> T:
+        """Delete the task."""
+        pass
+
+    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:
+        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)

{chunkr_ai-0.0.10 → chunkr_ai-0.0.12}/src/chunkr_ai/models.py

@@ -17,9 +17,11 @@ from .api.config import (
     SegmentProcessing,
     SegmentType,
     SegmentationStrategy,
+    Status,
 )
 
-from .api.task import TaskResponse, Status
+from .api.task import TaskResponse
+from .api.task_async import TaskResponseAsync
 
 __all__ = [
     'BoundingBox',
@@ -42,5 +44,6 @@ __all__ = [
     'SegmentType',
     'SegmentationStrategy',
     'Status',
-    'TaskResponse'
+    'TaskResponse',
+    'TaskResponseAsync',
 ]

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

@@ -1,12 +1,13 @@
 Metadata-Version: 2.2
 Name: chunkr-ai
-Version: 0.0.10
+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.10 → chunkr_ai-0.0.12}/src/chunkr_ai.egg-info/SOURCES.txt

@@ -2,7 +2,6 @@ LICENSE
 README.md
 pyproject.toml
 src/chunkr_ai/__init__.py
-src/chunkr_ai/main.py
 src/chunkr_ai/models.py
 src/chunkr_ai.egg-info/PKG-INFO
 src/chunkr_ai.egg-info/SOURCES.txt
@@ -17,6 +16,7 @@ src/chunkr_ai/api/chunkr_base.py
 src/chunkr_ai/api/config.py
 src/chunkr_ai/api/misc.py
 src/chunkr_ai/api/protocol.py
+src/chunkr_ai/api/schema.py
 src/chunkr_ai/api/task.py
 src/chunkr_ai/api/task_async.py
 src/chunkr_ai/api/task_base.py

{chunkr_ai-0.0.10 → chunkr_ai-0.0.12}/src/chunkr_ai.egg-info/requires.txt

@@ -1,4 +1,5 @@
 httpx>=0.25.0
+httpx>=0.25.0
 pillow>=10.0.0
 pydantic>=2.0.0
 pytest-asyncio>=0.21.0

chunkr_ai-0.0.10/src/chunkr_ai/api/task.py

@@ -1,176 +0,0 @@
-from .protocol import ChunkrClientProtocol
-from .config import Configuration, OutputResponse
-from .misc import prepare_upload_data
-import asyncio
-from datetime import datetime
-from enum import Enum
-from pydantic import BaseModel, PrivateAttr
-import time
-from typing import Optional, Union
-
-class Status(str, Enum):
-    STARTING = "Starting"
-    PROCESSING = "Processing"
-    SUCCEEDED = "Succeeded"
-    FAILED = "Failed"
-    CANCELLED = "Cancelled"
-    
-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")
-
-        while True:
-            try:
-                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:
-                raise
-
-    async def _poll_request_async(self) -> dict:
-        """Helper method to make polling request with retry logic (asynchronous)"""
-        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':
-        files = prepare_upload_data(None, config)
-        r = self._client._session.patch(
-            f"{self.task_url}",
-            files=files,
-            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)
-    
-    def cancel(self):
-        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):
-        r = self._client._session.delete(
-            f"{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-0.0.10/src/chunkr_ai/api/task_async.py

@@ -1,111 +0,0 @@
-import asyncio
-from pydantic import BaseModel, PrivateAttr
-from datetime import datetime
-from enum import Enum
-from typing import Optional, Union
-from .task_base import TaskBase
-from .protocol import ChunkrClientProtocol
-from .config import Configuration, OutputResponse
-from .misc import prepare_upload_data
-
-class Status(str, Enum):
-    STARTING = "Starting"
-    PROCESSING = "Processing"
-    SUCCEEDED = "Succeeded"
-    FAILED = "Failed"
-    CANCELLED = "Cancelled"
-
-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
-
-    async def poll(self) -> 'TaskResponseAsync':
-        while True:
-            j = await self._poll_request()
-            updated = TaskResponseAsync(**j).with_client(self._client)
-            self.__dict__.update(updated.__dict__)
-            if res := self._check_status():
-                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")
-        f = prepare_upload_data(None, config)
-        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__)
-        return await self.poll()
-
-    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())
-        r.raise_for_status()
-        return await self.poll()
-
-    async def delete(self):
-        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

chunkr_ai-0.0.10/src/chunkr_ai/api/task_base.py

@@ -1,31 +0,0 @@
-from abc import ABC, abstractmethod
-from .config import Configuration
-
-class TaskBase(ABC):
-    @abstractmethod
-    def poll(self):
-        pass
-
-    @abstractmethod
-    def update(self, config: Configuration):
-        pass
-
-    @abstractmethod
-    def cancel(self):
-        pass
-
-    @abstractmethod
-    def delete(self):
-        pass
-
-    @abstractmethod
-    def html(self) -> str:
-        pass
-
-    @abstractmethod
-    def markdown(self) -> str:
-        pass
-
-    @abstractmethod
-    def content(self) -> str:
-        pass

chunkr_ai-0.0.10/src/chunkr_ai/main.py

@@ -1,12 +0,0 @@
-from chunkr_ai.api.chunkr import Chunkr
-from chunkr_ai.models import Configuration
-from chunkr_ai.api.config import SegmentationStrategy, ChunkProcessing
-
-if __name__ == "__main__":
-    chunkr = Chunkr()
-    task = chunkr.update_task("556b4fe5-e3f7-48dc-9f56-0fb7fbacdb87", Configuration(
-        chunk_processing=ChunkProcessing(
-            target_length=1000
-        )
-    ))
-    print(task)