chunkr-ai 0.0.47__tar.gz → 0.0.49__tar.gz

{chunkr_ai-0.0.47/src/chunkr_ai.egg-info → chunkr_ai-0.0.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chunkr-ai
-Version: 0.0.47
+Version: 0.0.49
 Summary: Python client for Chunkr: open source document intelligence
 Author-email: Ishaan Kapoor <ishaan@lumina.sh>
 License: MIT License

{chunkr_ai-0.0.47 → chunkr_ai-0.0.49}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "chunkr-ai"
-version = "0.0.47"
+version = "0.0.49"
 authors = [{"name" = "Ishaan Kapoor", "email" = "ishaan@lumina.sh"}]
 description = "Python client for Chunkr: open source document intelligence"
 readme = "README.md"

{chunkr_ai-0.0.47 → chunkr_ai-0.0.49}/src/chunkr_ai/api/chunkr.py

@@ -16,7 +16,7 @@ class Chunkr(ChunkrBase):
     @ensure_client()
     async def upload(
         self,
-        file: Union[str, Path, BinaryIO, Image.Image],
+        file: Union[str, Path, BinaryIO, Image.Image, bytes, bytearray, memoryview],
         config: Optional[Configuration] = None,
         filename: Optional[str] = None,
     ) -> TaskResponse:
@@ -34,7 +34,7 @@ class Chunkr(ChunkrBase):
     @retry_on_429()
     async def create_task(
         self,
-        file: Union[str, Path, BinaryIO, Image.Image],
+        file: Union[str, Path, BinaryIO, Image.Image, bytes, bytearray, memoryview],
         config: Optional[Configuration] = None,
         filename: Optional[str] = None,
     ) -> TaskResponse:

{chunkr_ai-0.0.47 → chunkr_ai-0.0.49}/src/chunkr_ai/api/configuration.py

@@ -23,6 +23,7 @@ class GenerationConfig(BaseModel):
     markdown: Optional[GenerationStrategy] = None
     crop_image: Optional[CroppingStrategy] = None
     embed_sources: Optional[List[EmbedSource]] = Field(default_factory=lambda: [EmbedSource.MARKDOWN])
+    extended_context: Optional[bool] = None
 
 class SegmentProcessing(BaseModel):
     model_config = ConfigDict(populate_by_name=True, alias_generator=str.title)

{chunkr_ai-0.0.47 → chunkr_ai-0.0.49}/src/chunkr_ai/api/misc.py

@@ -3,9 +3,9 @@ import base64
 import io
 from pathlib import Path
 from PIL import Image
-from typing import Union, Tuple, BinaryIO, Optional
+from typing import Union, Tuple, BinaryIO, Optional, Any
 
-async def prepare_file(file: Union[str, Path, BinaryIO, Image.Image]) -> Tuple[Optional[str], str]:
+async def prepare_file(file: Union[str, Path, BinaryIO, Image.Image, bytes, bytearray, memoryview]) -> Tuple[Optional[str], str]:
     """Convert various file types into a tuple of (filename, file content).
 
     Args:
@@ -15,6 +15,7 @@ async def prepare_file(file: Union[str, Path, BinaryIO, Image.Image]) -> Tuple[O
             - Local file path (will be converted to base64)
             - Opened binary file (will be converted to base64)
             - PIL/Pillow Image object (will be converted to base64)
+            - Bytes object (will be converted to base64)
 
     Returns:
         Tuple[Optional[str], str]: (filename, content) where content is either a URL or base64 string
@@ -26,22 +27,54 @@ async def prepare_file(file: Union[str, Path, BinaryIO, Image.Image]) -> Tuple[O
         ValueError: If the URL is invalid or unreachable
         ValueError: If the MIME type is unsupported
     """
-    # Handle strings
+    # Handle bytes-like objects
+    if isinstance(file, (bytes, bytearray, memoryview)):
+        # Convert to bytes first if it's not already
+        file_bytes = bytes(file)
+        
+        # Check if this might be an already-encoded base64 string in bytes form
+        try:
+            # Try to decode the bytes to a string and see if it's valid base64
+            potential_base64 = file_bytes.decode('utf-8', errors='strict')
+            base64.b64decode(potential_base64)
+            # If we get here, it was a valid base64 string in bytes form
+            return None, potential_base64
+        except:
+            # Not a base64 string in bytes form, encode it as base64
+            base64_str = base64.b64encode(file_bytes).decode()
+            return None, base64_str
+        
+    # Handle strings - urls or paths or base64
     if isinstance(file, str):
+        # Handle URLs
         if file.startswith(('http://', 'https://')):
             return None, file
-        # Try to handle as a file path first
-        path = Path(file)
-        if path.exists():
-            # It's a valid file path, convert to Path object and continue processing
-            file = path
-        else:
-            # If not a valid file path, try treating as base64
+            
+        # Handle data URLs
+        if file.startswith('data:'):
+            return None, file
+            
+        # Try to handle as a file path
+        try:
+            path = Path(file)
+            if path.exists():
+                # It's a valid file path, convert to Path object and continue processing
+                file = path
+            else:
+                # If not a valid file path, try treating as base64
+                try:
+                    # Just test if it's valid base64, don't store the result
+                    base64.b64decode(file)
+                    return None, file
+                except:
+                    raise ValueError(f"File not found: {file} and it's not a valid base64 string")
+        except Exception as e:
+            # If string can't be converted to Path or decoded as base64, it might still be a base64 string
             try:
                 base64.b64decode(file)
                 return None, file
             except:
-                raise ValueError(f"File not found: {file} and it's not a valid base64 string")
+                raise ValueError(f"Unable to process file: {e}")
 
     # Handle file paths - convert to base64
     if isinstance(file, Path):
@@ -71,17 +104,16 @@ async def prepare_file(file: Union[str, Path, BinaryIO, Image.Image]) -> Tuple[O
         file.seek(0)
         file_content = file.read()
         name = getattr(file, "name", "document")
-        file_ext = Path(name).suffix.lower().lstrip('.')
-        if not file_ext:
-            raise ValueError("File must have an extension")
+        if not name or not isinstance(name, str):
+            name = None
         base64_str = base64.b64encode(file_content).decode()
-        return Path(name).name, base64_str
+        return name, base64_str
 
     raise TypeError(f"Unsupported file type: {type(file)}")
 
 
 async def prepare_upload_data(
-    file: Optional[Union[str, Path, BinaryIO, Image.Image]] = None,
+    file: Optional[Union[str, Path, BinaryIO, Image.Image, bytes, bytearray, memoryview]] = None,
     filename: Optional[str] = None,
     config: Optional[Configuration] = None,
 ) -> dict:
@@ -89,8 +121,8 @@ async def prepare_upload_data(
 
     Args:
         file: The file to upload
+        filename: Optional filename to use (overrides any filename from the file)
         config: Optional configuration settings
-        client: HTTP client for downloading remote files
 
     Returns:
         dict: JSON-serializable data dictionary ready for upload

{chunkr_ai-0.0.47 → chunkr_ai-0.0.49/src/chunkr_ai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chunkr-ai
-Version: 0.0.47
+Version: 0.0.49
 Summary: Python client for Chunkr: open source document intelligence
 Author-email: Ishaan Kapoor <ishaan@lumina.sh>
 License: MIT License

{chunkr_ai-0.0.47 → chunkr_ai-0.0.49}/src/chunkr_ai.egg-info/SOURCES.txt

@@ -17,4 +17,5 @@ src/chunkr_ai/api/decorators.py
 src/chunkr_ai/api/misc.py
 src/chunkr_ai/api/protocol.py
 src/chunkr_ai/api/task_response.py
-tests/test_chunkr.py
+tests/test_chunkr.py
+tests/test_file_handling.py

{chunkr_ai-0.0.47 → chunkr_ai-0.0.49}/tests/test_chunkr.py

@@ -2,24 +2,25 @@ import pytest
 from pathlib import Path
 from PIL import Image
 import asyncio
-import base64
+from typing import Awaitable
 
 from chunkr_ai import Chunkr
 from chunkr_ai.models import (
+    ChunkProcessing,
     Configuration,
-    GenerationStrategy,
+    EmbedSource,
+    ErrorHandlingStrategy,
+    FallbackStrategy,
     GenerationConfig,
+    GenerationStrategy,
+    LlmProcessing,
     OcrStrategy,
     Pipeline,
     SegmentationStrategy,
     SegmentProcessing,
-    ChunkProcessing,
+    Status,
     TaskResponse,
-    EmbedSource,
-    ErrorHandlingStrategy,
     Tokenizer,
-    LlmProcessing,
-    FallbackStrategy,
 )
 
 @pytest.fixture
@@ -164,56 +165,20 @@ def model_fallback_config():
         ),
     )
 
-@pytest.mark.asyncio
-async def test_send_file_path(client, sample_path):
-    response = await client.upload(sample_path)
-    assert response.task_id is not None
-    assert response.status == "Succeeded"
-    assert response.output is not None
-
-@pytest.mark.asyncio
-async def test_send_file_path_str(client, sample_absolute_path_str):
-    response = await client.upload(sample_absolute_path_str)
-    assert response.task_id is not None
-    assert response.status == "Succeeded"
-    assert response.output is not None
-
-@pytest.mark.asyncio
-async def test_send_file_relative_path_str(client, sample_relative_path_str):
-    response = await client.upload(sample_relative_path_str)
-    assert response.task_id is not None
-    assert response.status == "Succeeded"
-    assert response.output is not None
-
-@pytest.mark.asyncio
-async def test_send_file_url(client, sample_url):
-    response = await client.upload(sample_url)
-    assert response.task_id is not None
-    assert response.status == "Succeeded"
-    assert response.output is not None
-
-@pytest.mark.asyncio
-async def test_send_file_path_as_str(client, sample_path):
-    response = await client.upload(str(sample_path))
-    assert response.task_id is not None
-    assert response.status == "Succeeded"
-    assert response.output is not None
-
-@pytest.mark.asyncio
-async def test_send_opened_file(client, sample_path):
-    with open(sample_path, "rb") as f:
-        response = await client.upload(f)
-    assert response.task_id is not None
-    assert response.status == "Succeeded"
-    assert response.output is not None
-
-@pytest.mark.asyncio
-async def test_send_pil_image(client, sample_image):
-    response = await client.upload(sample_image)
-    assert response.task_id is not None
-    assert response.status == "Succeeded"
-    assert response.output is not None
-    assert response.output is not None
+@pytest.fixture
+def extended_context_config():
+    return Configuration(
+        segment_processing=SegmentProcessing(
+            picture=GenerationConfig(
+                extended_context=True,
+                html=GenerationStrategy.LLM,
+            ),
+            table=GenerationConfig(
+                extended_context=True,
+                html=GenerationStrategy.LLM,
+            )
+        ),
+    )
 
 @pytest.mark.asyncio
 async def test_ocr_auto(client, sample_path):
@@ -313,9 +278,18 @@ async def test_cancel_task(client, sample_path):
 @pytest.mark.asyncio
 async def test_cancel_task_direct(client, sample_path):
     task = await client.create_task(sample_path)
-    assert isinstance(task, TaskResponse)
     assert task.status == "Starting"
-    await task.cancel()
+    try:
+        await task.cancel()
+    except Exception as e:
+        task = await client.get_task(task.task_id)
+        print(task.status)
+        if task.status == Status.PROCESSING:
+            print("Task is processing, so it can't be cancelled")
+            assert True
+        else:
+            print("Task status:", task.status)
+            raise e
     assert task.status == "Cancelled"
 
 @pytest.mark.asyncio
@@ -352,6 +326,7 @@ async def test_pipeline_type_azure(client, sample_path):
     assert response.task_id is not None
     assert response.status == "Succeeded"
     assert response.output is not None
+    assert response.configuration.pipeline == Pipeline.AZURE
     
 @pytest.mark.asyncio
 async def test_pipeline_type_chunkr(client, sample_path):
@@ -359,7 +334,8 @@ async def test_pipeline_type_chunkr(client, sample_path):
     assert response.task_id is not None
     assert response.status == "Succeeded"
     assert response.output is not None
-
+    assert response.configuration.pipeline == Pipeline.CHUNKR
+    
 @pytest.mark.asyncio
 async def test_client_lifecycle(client, sample_path):
     response1 = await client.upload(sample_path)
@@ -375,36 +351,6 @@ async def test_task_operations_after_client_close(client, sample_path):
     result = await task.poll()
     assert result.status == "Succeeded"
 
-@pytest.mark.asyncio
-async def test_send_base64_file(client, sample_path):
-    # Read file and convert to base64
-    with open(sample_path, "rb") as f:
-        base64_content = base64.b64encode(f.read()).decode('utf-8')
-    response = await client.upload(base64_content)
-    assert response.task_id is not None
-    assert response.status == "Succeeded"
-    assert response.output is not None
-
-@pytest.mark.asyncio
-async def test_send_base64_file_with_data_url(client, sample_path):
-    with open(sample_path, "rb") as f:
-        base64_content = base64.b64encode(f.read()).decode('utf-8')
-    response = await client.upload(f"data:application/pdf;base64,{base64_content}")
-    assert response.task_id is not None
-    assert response.status == "Succeeded"
-    assert response.output is not None
-
-@pytest.mark.asyncio
-async def test_send_base64_file_with_filename(client, sample_path):
-    # Read file and convert to base64
-    with open(sample_path, "rb") as f:
-        base64_content = base64.b64encode(f.read()).decode('utf-8')
-    
-    response = await client.upload(base64_content, filename="test.pdf")
-    assert response.task_id is not None
-    assert response.status == "Succeeded"
-    assert response.output is not None
-    
 @pytest.mark.asyncio
 async def test_output_files_no_dir(client, sample_path, tmp_path):
     task = await client.upload(sample_path)
@@ -444,6 +390,35 @@ async def test_output_files_with_dirs(client, sample_path, tmp_path):
     assert content_file.exists()
     assert json_file.exists()
 
+
+@pytest.mark.asyncio
+async def test_combined_config_with_llm_and_other_settings(client, sample_path):
+    # Test combining LLM settings with other configuration options
+    config = Configuration(
+        llm_processing=LlmProcessing(
+            model_id="qwen-2.5-vl-7b-instruct",
+            fallback_strategy=FallbackStrategy.model("gemini-flash-2.0"),
+            temperature=0.4
+        ),
+        segmentation_strategy=SegmentationStrategy.PAGE,
+        segment_processing=SegmentProcessing(
+            Page=GenerationConfig(
+                html=GenerationStrategy.LLM,
+                markdown=GenerationStrategy.LLM
+            )
+        ),
+        chunk_processing=ChunkProcessing(target_length=1024)
+    )
+    
+    response = await client.upload(sample_path, config)
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+    assert response.configuration.llm_processing is not None
+    assert response.configuration.llm_processing.model_id == "qwen-2.5-vl-7b-instruct"
+    assert response.configuration.segmentation_strategy == SegmentationStrategy.PAGE
+    assert response.configuration.chunk_processing.target_length == 1024
+
 @pytest.mark.asyncio
 async def test_embed_sources_markdown_only(client, sample_path, markdown_embed_config):
     response = await client.upload(sample_path, markdown_embed_config)
@@ -580,29 +555,30 @@ async def test_fallback_strategy_serialization():
     assert str(model_strategy) == "Model(gpt-4.1)"
 
 @pytest.mark.asyncio
-async def test_combined_config_with_llm_and_other_settings(client, sample_path):
-    # Test combining LLM settings with other configuration options
-    config = Configuration(
-        llm_processing=LlmProcessing(
-            model_id="qwen-2.5-vl-7b-instruct",
-            fallback_strategy=FallbackStrategy.model("gemini-flash-2.0"),
-            temperature=0.4
-        ),
-        segmentation_strategy=SegmentationStrategy.PAGE,
-        segment_processing=SegmentProcessing(
-            Page=GenerationConfig(
-                html=GenerationStrategy.LLM,
-                markdown=GenerationStrategy.LLM
-            )
-        ),
-        chunk_processing=ChunkProcessing(target_length=1024)
-    )
-    
-    response = await client.upload(sample_path, config)
-    assert response.task_id is not None
-    assert response.status == "Succeeded"
-    assert response.output is not None
-    assert response.configuration.llm_processing is not None
-    assert response.configuration.llm_processing.model_id == "qwen-2.5-vl-7b-instruct"
-    assert response.configuration.segmentation_strategy == SegmentationStrategy.PAGE
-    assert response.configuration.chunk_processing.target_length == 1024
+async def test_extended_context(client, sample_path, extended_context_config):
+    """Tests uploading with extended context enabled for pictures and tables."""
+    print("\nTesting extended context for Pictures and Tables...")
+    try:
+        task = await client.upload(sample_path, config=extended_context_config)
+        print(f"Task created with extended context config: {task.task_id}")
+        print(f"Initial Status: {task.status}")
+
+        # Poll the task until it finishes or fails
+        print(f"Final Status: {task.status}")
+        print(f"Message: {task.message}")
+
+        # Basic assertion: Check if the task completed (either succeeded or failed)
+        assert task.status in [Status.SUCCEEDED, Status.FAILED], f"Task ended in unexpected state: {task.status}"
+
+        # More specific assertions based on expected outcomes with your local server
+        # if task.status == Status.FAILED:
+        #     assert "context_length_exceeded" in task.message, "Expected context length error"
+        # elif task.status == Status.SUCCEEDED:
+        #     # Check if output reflects extended context usage if possible
+        #     pass
+
+        print("Extended context test completed.")
+
+    except Exception as e:
+        print(f"Error during extended context test: {e}")
+        raise # Re-raise the exception to fail the test explicitly

chunkr_ai-0.0.49/tests/test_file_handling.py

@@ -0,0 +1,362 @@
+import pytest
+from pathlib import Path
+from PIL import Image
+import base64
+import io
+import tempfile
+
+from chunkr_ai import Chunkr
+
+@pytest.fixture
+def sample_path():
+    return Path("tests/files/test.pdf")
+
+@pytest.fixture
+def sample_url():
+    return "https://chunkr-web.s3.us-east-1.amazonaws.com/landing_page/input/science.pdf"
+
+@pytest.fixture
+def sample_image():
+    return Image.open("tests/files/test.jpg")
+
+@pytest.fixture
+def client():
+    client = Chunkr()
+    yield client
+
+@pytest.mark.asyncio
+async def test_send_file_path(client, sample_path):
+    response = await client.upload(sample_path)
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_send_file_path_str(client, sample_path):
+    response = await client.upload(str(sample_path))
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_send_file_relative_path_str(client):
+    response = await client.upload("./tests/files/test.pdf")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_send_file_url(client, sample_url):
+    response = await client.upload(sample_url)
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_send_opened_file(client, sample_path):
+    with open(sample_path, "rb") as f:
+        response = await client.upload(f)
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_send_pil_image(client, sample_image):
+    response = await client.upload(sample_image)
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_send_base64_file(client, sample_path):
+    # Read file and convert to base64
+    with open(sample_path, "rb") as f:
+        base64_content = base64.b64encode(f.read())
+    response = await client.upload(base64_content)
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_send_base64_file_w_decode(client, sample_path):
+    # Read file and convert to base64
+    with open(sample_path, "rb") as f:
+        base64_content = base64.b64encode(f.read()).decode()
+    response = await client.upload(base64_content)
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_send_base64_file_with_data_url(client, sample_path):
+    with open(sample_path, "rb") as f:
+        base64_content = base64.b64encode(f.read()).decode('utf-8')
+    response = await client.upload(f"data:application/pdf;base64,{base64_content}")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_send_base64_file_with_filename(client, sample_path):
+    # Read file and convert to base64
+    with open(sample_path, "rb") as f:
+        base64_content = base64.b64encode(f.read()).decode('utf-8')
+    
+    response = await client.upload(base64_content, filename="test.pdf")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_file_like_no_name_attribute(client, sample_path):
+    # Create a file-like object without a name attribute
+    class NamelessBuffer:
+        def __init__(self, content):
+            self.buffer = io.BytesIO(content)
+        
+        def read(self):
+            return self.buffer.read()
+        
+        def seek(self, pos):
+            return self.buffer.seek(pos)
+    
+    with open(sample_path, "rb") as f:
+        content = f.read()
+    
+    nameless_buffer = NamelessBuffer(content)
+    response = await client.upload(nameless_buffer, filename="test.pdf")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_file_like_none_name(client, sample_path):
+    # Create a file-like object with None as name
+    class NoneNameBuffer:
+        def __init__(self, content):
+            self.buffer = io.BytesIO(content)
+            self.name = None
+        
+        def read(self):
+            return self.buffer.read()
+        
+        def seek(self, pos):
+            return self.buffer.seek(pos)
+    
+    with open(sample_path, "rb") as f:
+        content = f.read()
+    
+    none_name_buffer = NoneNameBuffer(content)
+    response = await client.upload(none_name_buffer, filename="test.pdf")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_file_like_no_extension(client, sample_path):
+    # Create a file-like object with a name but no extension
+    class NoExtensionBuffer:
+        def __init__(self, content):
+            self.buffer = io.BytesIO(content)
+            self.name = "test_document"
+        
+        def read(self):
+            return self.buffer.read()
+        
+        def seek(self, pos):
+            return self.buffer.seek(pos)
+    
+    with open(sample_path, "rb") as f:
+        content = f.read()
+    
+    no_ext_buffer = NoExtensionBuffer(content)
+    response = await client.upload(no_ext_buffer, filename="test.pdf")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_spooled_temporary_file(client, sample_path):
+    # Test with SpooledTemporaryFile which is what the user is using
+    with open(sample_path, "rb") as f:
+        content = f.read()
+    
+    temp_file = tempfile.SpooledTemporaryFile()
+    temp_file.write(content)
+    temp_file.seek(0)
+    
+    response = await client.upload(temp_file, filename="test.pdf")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_send_bytearray(client, sample_path):
+    # Read file and convert to bytearray
+    with open(sample_path, "rb") as f:
+        content = bytearray(f.read())
+    
+    response = await client.upload(content, filename="test.pdf")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_send_memoryview(client, sample_path):
+    # Read file and convert to memoryview
+    with open(sample_path, "rb") as f:
+        content_bytes = f.read()
+        content = memoryview(content_bytes)
+    
+    response = await client.upload(content, filename="test.pdf")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_with_explicit_filename_pdf(client, sample_path):
+    response = await client.upload(sample_path, filename="custom_name.pdf")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_with_explicit_filename_image(client, sample_image):
+    response = await client.upload(sample_image, filename="custom_image.jpg")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_with_special_character_filename(client, sample_path):
+    response = await client.upload(sample_path, filename="test file (1)&%$#@!.pdf")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_filename_with_non_matching_extension(client, sample_path):
+    # Test providing a filename with a different extension than the actual file
+    response = await client.upload(sample_path, filename="document.docx")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_bytes_with_explicit_filename(client, sample_path):
+    with open(sample_path, "rb") as f:
+        content = f.read()
+    
+    # For bytes objects, filename is required to know the file type
+    response = await client.upload(content, filename="document.pdf")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_bytearray_with_explicit_filename(client, sample_path):
+    with open(sample_path, "rb") as f:
+        content = bytearray(f.read())
+    
+    response = await client.upload(content, filename="document.pdf")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_memoryview_with_explicit_filename(client, sample_path):
+    with open(sample_path, "rb") as f:
+        content_bytes = f.read()
+        content = memoryview(content_bytes)
+    
+    response = await client.upload(content, filename="document.pdf")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_unicode_filename(client, sample_path):
+    # Test with a filename containing Unicode characters
+    response = await client.upload(sample_path, filename="测试文件.pdf")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_very_long_filename(client, sample_path):
+    # Test with an extremely long filename
+    long_name = "a" * 200 + ".pdf"  # 200 character filename
+    response = await client.upload(sample_path, filename=long_name)
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_filename_without_extension(client, sample_path):
+    # Test with a filename that has no extension
+    with open(sample_path, "rb") as f:
+        content = f.read()
+    
+    # This test verifies that the system uses the provided filename even without extension
+    response = await client.upload(content, filename="document_without_extension")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_custom_file_like_with_filename(client, sample_path):
+    # A more complex file-like object implementation
+    class CustomFileWrapper:
+        def __init__(self, content):
+            self.buffer = io.BytesIO(content)
+            self.position = 0
+            self.name = "original_name.txt"  # Should be overridden by explicit filename
+        
+        def read(self, size=-1):
+            return self.buffer.read(size)
+        
+        def seek(self, position, whence=0):
+            return self.buffer.seek(position, whence)
+        
+        def tell(self):
+            return self.buffer.tell()
+        
+        def close(self):
+            self.buffer.close()
+    
+    with open(sample_path, "rb") as f:
+        content = f.read()
+    
+    custom_file = CustomFileWrapper(content)
+    response = await client.upload(custom_file, filename="custom_wrapper.pdf")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_seek_at_nonzero_position(client, sample_path):
+    # Test with a file-like object that's not at position 0
+    with open(sample_path, "rb") as f:
+        content = f.read()
+    
+    buffer = io.BytesIO(content)
+    buffer.seek(100)  # Move position to 100
+    
+    response = await client.upload(buffer, filename="seek_test.pdf")
+    assert response.task_id is not None
+    assert response.status == "Succeeded"
+    assert response.output is not None
+
+@pytest.mark.asyncio
+async def test_reused_file_object(client, sample_path):
+    # Test that a file object can be reused after being processed
+    with open(sample_path, "rb") as f:
+        response1 = await client.upload(f, filename="first_use.pdf")
+        f.seek(0)  # Reset position
+        response2 = await client.upload(f, filename="second_use.pdf")
+    
+    assert response1.task_id is not None
+    assert response1.status == "Succeeded"
+    assert response2.task_id is not None
+    assert response2.status == "Succeeded"