morphik 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

morphik/__init__.py

@@ -12,4 +12,4 @@ __all__ = [
     "Document",
 ]
 
-__version__ = "0.1.3"
+__version__ = "0.1.4"

morphik/_internal.py

@@ -211,7 +211,7 @@ class _MorphikClientLogic:
         data = {
             "metadata": json.dumps(metadata or {}),
             "rules": json.dumps(converted_rules),
-            "use_colpali": str(use_colpali).lower() if use_colpali is not None else None,
+            # use_colpali is a query parameter, not a form field
             "parallel": str(parallel).lower(),
         }
 

morphik/async_.py

@@ -172,9 +172,10 @@ class AsyncFolder:
 
             response = await self._client._request(
                 "POST",
-                f"ingest/file?use_colpali={str(use_colpali).lower()}",
+                "ingest/file",
                 data=form_data,
                 files=files,
+                params={"use_colpali": str(use_colpali).lower()},
             )
             doc = self._client._logic._parse_document_response(response)
             doc._client = self._client
@@ -215,7 +216,11 @@ class AsyncFolder:
             )
 
             response = await self._client._request(
-                "POST", "ingest/files", data=data, files=file_objects
+                "POST", 
+                "ingest/files", 
+                data=data, 
+                files=file_objects,
+                params={"use_colpali": str(use_colpali).lower()},
             )
 
             if response.get("errors"):
@@ -419,9 +424,10 @@ class AsyncFolder:
         Returns:
             List[Document]: List of document metadata for found documents
         """
-        request = self._client._logic._prepare_batch_get_documents_request(
-            document_ids, self._name, None
-        )
+        # API expects a dict with document_ids key
+        request = {"document_ids": document_ids}
+        if self._name:
+            request["folder_name"] = self._name
         response = await self._client._request("POST", "batch/documents", data=request)
         docs = self._client._logic._parse_document_list_response(response)
         for doc in docs:
@@ -701,7 +707,11 @@ class AsyncUserScope:
                 data["folder_name"] = self._folder_name
 
             response = await self._client._request(
-                "POST", "ingest/files", data=data, files=file_objects
+                "POST", 
+                "ingest/files", 
+                data=data, 
+                files=file_objects,
+                params={"use_colpali": str(use_colpali).lower()},
             )
 
             if response.get("errors"):
@@ -905,9 +915,12 @@ class AsyncUserScope:
         Returns:
             List[Document]: List of document metadata for found documents
         """
-        request = self._client._logic._prepare_batch_get_documents_request(
-            document_ids, self._folder_name, self._end_user_id
-        )
+        # API expects a dict with document_ids key
+        request = {"document_ids": document_ids}
+        if self._end_user_id:
+            request["end_user_id"] = self._end_user_id
+        if self._folder_name:
+            request["folder_name"] = self._folder_name
         response = await self._client._request("POST", "batch/documents", data=request)
         docs = self._client._logic._parse_document_list_response(response)
         for doc in docs:
@@ -1060,9 +1073,15 @@ class AsyncMorphik:
 
         # Configure request data based on type
         if files:
-            # Multipart form data for files
-            request_data = {"files": files, "data": data}
-            # Don't set Content-Type, let httpx handle it
+            # When uploading files, we need to make sure not to set Content-Type
+            # Remove Content-Type if it exists - httpx will set the correct multipart boundary
+            if "Content-Type" in headers:
+                del headers["Content-Type"]
+                
+            # For file uploads with form data, use form data (not json)
+            request_data = {"files": files}
+            if data:
+                request_data["data"] = data
         else:
             # JSON for everything else
             headers["Content-Type"] = "application/json"
@@ -1253,9 +1272,10 @@ class AsyncMorphik:
 
             response = await self._request(
                 "POST",
-                f"ingest/file?use_colpali={str(use_colpali).lower()}",
+                "ingest/file",
                 data=form_data,
                 files=files,
+                params={"use_colpali": str(use_colpali).lower()},
             )
             doc = self._logic._parse_document_response(response)
             doc._client = self
@@ -1298,7 +1318,13 @@ class AsyncMorphik:
                 metadata, rules, use_colpali, parallel, None, None
             )
 
-            response = await self._request("POST", "ingest/files", data=data, files=file_objects)
+            response = await self._request(
+                "POST", 
+                "ingest/files", 
+                data=data, 
+                files=file_objects,
+                params={"use_colpali": str(use_colpali).lower()},
+            )
 
             if response.get("errors"):
                 # Log errors but don't raise exception
@@ -1306,7 +1332,7 @@ class AsyncMorphik:
                     logger.error(f"Failed to ingest {error['filename']}: {error['error']}")
 
             # Parse the documents from the response
-            docs = [self._client._logic._parse_document_response(doc) for doc in response["documents"]]
+            docs = [self._logic._parse_document_response(doc) for doc in response["documents"]]
             for doc in docs:
                 doc._client = self
             return docs
@@ -2025,7 +2051,8 @@ class AsyncMorphik:
                 print(f"Document {doc.external_id}: {doc.metadata.get('title')}")
             ```
         """
-        request = self._logic._prepare_batch_get_documents_request(document_ids, None, None)
+        # API expects a dict with document_ids key, not a direct list
+        request = {"document_ids": document_ids}
         response = await self._request("POST", "batch/documents", data=request)
         docs = self._logic._parse_document_list_response(response)
         for doc in docs:

morphik/sync.py

@@ -172,11 +172,13 @@ class Folder:
                 metadata, rules, self._name, None
             )
 
+            # use_colpali should be a query parameter as defined in the API
             response = self._client._request(
                 "POST",
-                f"ingest/file?use_colpali={str(use_colpali).lower()}",
+                "ingest/file",
                 data=form_data,
                 files=files,
+                params={"use_colpali": str(use_colpali).lower()},
             )
             doc = self._client._logic._parse_document_response(response)
             doc._client = self._client
@@ -216,7 +218,13 @@ class Folder:
                 metadata, rules, use_colpali, parallel, self._name, None
             )
 
-            response = self._client._request("POST", "ingest/files", data=data, files=file_objects)
+            response = self._client._request(
+                "POST", 
+                "ingest/files", 
+                data=data, 
+                files=file_objects,
+                params={"use_colpali": str(use_colpali).lower()},
+            )
 
             if response.get("errors"):
                 # Log errors but don't raise exception
@@ -669,12 +677,14 @@ class UserScope:
             # Add folder name if scoped to a folder
             if self._folder_name:
                 form_data["folder_name"] = self._folder_name
-
+                
+            # use_colpali should be a query parameter as defined in the API
             response = self._client._request(
                 "POST",
-                f"ingest/file?use_colpali={str(use_colpali).lower()}",
+                "ingest/file",
                 data=form_data,
                 files=files,
+                params={"use_colpali": str(use_colpali).lower()},
             )
             doc = self._client._logic._parse_document_response(response)
             doc._client = self._client
@@ -734,7 +744,7 @@ class UserScope:
             data = {
                 "metadata": json.dumps(metadata or {}),
                 "rules": json.dumps(converted_rules),
-                "use_colpali": str(use_colpali).lower() if use_colpali is not None else None,
+                # Remove use_colpali from form data - it should be a query param
                 "parallel": str(parallel).lower(),
                 "end_user_id": self._end_user_id,  # Add end user ID here
             }
@@ -743,7 +753,13 @@ class UserScope:
             if self._folder_name:
                 data["folder_name"] = self._folder_name
 
-            response = self._client._request("POST", "ingest/files", data=data, files=file_objects)
+            response = self._client._request(
+                "POST", 
+                "ingest/files", 
+                data=data, 
+                files=file_objects,
+                params={"use_colpali": str(use_colpali).lower()},
+            )
 
             if response.get("errors"):
                 # Log errors but don't raise exception
@@ -1153,9 +1169,17 @@ class Morphik:
 
         # Configure request data based on type
         if files:
-            # Multipart form data for files
-            request_data = {"files": files, "data": data}
-            # Don't set Content-Type, let httpx handle it
+            # When uploading files, we need to make sure not to set Content-Type
+            # Remove Content-Type if it exists - httpx will set the correct multipart boundary
+            if "Content-Type" in headers:
+                del headers["Content-Type"]
+                
+            # For file uploads with form data, use form data (not json)
+            request_data = {"files": files}
+            if data:
+                request_data["data"] = data
+                
+            # Files are now properly handled
         else:
             # JSON for everything else
             headers["Content-Type"] = "application/json"
@@ -1380,11 +1404,13 @@ class Morphik:
             # Create form data
             form_data = self._logic._prepare_ingest_file_form_data(metadata, rules, None, None)
 
+            # use_colpali should be a query parameter as defined in the API
             response = self._request(
                 "POST",
-                f"ingest/file?use_colpali={str(use_colpali).lower()}",
+                "ingest/file",
                 data=form_data,
                 files=files,
+                params={"use_colpali": str(use_colpali).lower()},
             )
             doc = self._logic._parse_document_response(response)
             doc._client = self
@@ -1423,11 +1449,18 @@ class Morphik:
 
         try:
             # Prepare form data
+            # Prepare form data - use_colpali should be a query parameter, not form data
             data = self._logic._prepare_ingest_files_form_data(
                 metadata, rules, use_colpali, parallel, None, None
             )
 
-            response = self._request("POST", "ingest/files", data=data, files=file_objects)
+            response = self._request(
+                "POST", 
+                "ingest/files", 
+                data=data, 
+                files=file_objects,
+                params={"use_colpali": str(use_colpali).lower()},
+            )
 
             if response.get("errors"):
                 # Log errors but don't raise exception
@@ -2151,7 +2184,8 @@ class Morphik:
                 print(f"Document {doc.external_id}: {doc.metadata.get('title')}")
             ```
         """
-        response = self._request("POST", "batch/documents", data=document_ids)
+        # API expects a dict with document_ids key, not a direct list
+        response = self._request("POST", "batch/documents", data={"document_ids": document_ids})
         docs = self._logic._parse_document_list_response(response)
         for doc in docs:
             doc._client = self

morphik/tests/README.md

@@ -0,0 +1,41 @@
+# Morphik SDK Tests
+
+This directory contains tests and example code for the Morphik SDK.
+
+## Test Types
+
+- `test_sync.py` - Tests for the synchronous client
+- `test_async.py` - Tests for the asynchronous client
+
+### Test Data
+- `test_docs/` - Sample text files for testing document ingestion
+
+### Example Code
+- `example_usage.py` - Example script demonstrating basic usage of the SDK
+
+## Running Tests
+
+```bash
+# Using default localhost:8000 URL
+pytest test_sync.py test_async.py -v
+
+# Tests connect to localhost:8000 by default
+# No need to specify a URL unless you want to test against a different server
+
+# With a custom server URL (optional)
+MORPHIK_TEST_URL=http://custom-url:8000 pytest test_sync.py -v
+```
+
+### Example Usage Script
+```bash
+# Run synchronous example
+python example_usage.py
+
+# Run asynchronous example
+python example_usage.py --async
+```
+
+## Environment Variables
+
+- `MORPHIK_TEST_URL` - The URL of the Morphik server to use for tests (default: http://localhost:8000)
+- `SKIP_LIVE_TESTS` - Set to "1" to skip tests that require a running server

morphik/tests/example_usage.py

@@ -0,0 +1,280 @@
+#!/usr/bin/env python
+"""
+Example script demonstrating basic usage of the Morphik SDK.
+This can be run to verify that the SDK is working correctly.
+
+Usage:
+    python example_usage.py [--async]
+    
+Options:
+    --async    Run the example using the async client
+"""
+
+import os
+import sys
+import time
+from pathlib import Path
+import argparse
+
+
+def run_sync_example():
+    """Run synchronous SDK examples"""
+    from morphik import Morphik
+    
+    # Get the test files directory - this script is in the tests directory
+    test_docs_dir = Path(__file__).parent / "test_docs"
+    
+    print("Running Morphik SDK Sync Example")
+    print("===============================")
+    
+    # Initialize the client - using default localhost:8000
+    print("\n1. Initializing Morphik client...")
+    db = Morphik()  # Connects to localhost:8000 by default
+    print(f"   Connected to {db._logic._base_url}")
+    
+    try:
+        # Ingest a text document
+        print("\n2. Ingesting a text document...")
+        text_doc = db.ingest_text(
+            content="This is a sample document created using the Morphik SDK. "
+                  "It demonstrates the text ingestion capabilities.",
+            filename="sdk_example.txt",
+            metadata={"source": "sdk_example", "type": "text"}
+        )
+        print(f"   Document created with ID: {text_doc.external_id}")
+        print(f"   Filename: {text_doc.filename}")
+        print(f"   Metadata: {text_doc.metadata}")
+        
+        # Ingest a file
+        print("\n3. Ingesting a file from disk...")
+        file_path = test_docs_dir / "sample1.txt"
+        file_doc = db.ingest_file(
+            file=file_path,
+            metadata={"source": "sdk_example", "type": "file"}
+        )
+        print(f"   Document created with ID: {file_doc.external_id}")
+        print(f"   Filename: {file_doc.filename}")
+        
+        # Create a folder
+        print("\n4. Creating a folder...")
+        folder = db.create_folder(name="sdk_example_folder", description="Example folder created by SDK")
+        print(f"   Folder created with name: {folder.name}")
+        print(f"   Folder ID: {folder.id}")
+        
+        # Ingest document into folder
+        print("\n5. Ingesting a document into the folder...")
+        folder_doc = folder.ingest_text(
+            content="This document is stored in a specific folder.",
+            filename="folder_example.txt",
+            metadata={"source": "sdk_example", "type": "folder_doc"}
+        )
+        print(f"   Document created with ID: {folder_doc.external_id}")
+        
+        # Create a user scope
+        print("\n6. Creating a user scope...")
+        user = db.signin("sdk_example_user")
+        print(f"   User scope created for: {user.end_user_id}")
+        
+        # Ingest document as user
+        print("\n7. Ingesting a document as this user...")
+        user_doc = user.ingest_text(
+            content="This document is associated with a specific user.",
+            filename="user_example.txt",
+            metadata={"source": "sdk_example", "type": "user_doc"}
+        )
+        print(f"   Document created with ID: {user_doc.external_id}")
+        
+        # Wait for processing to complete
+        print("\n8. Waiting for documents to be processed...")
+        for _ in range(10):
+            status = db.get_document_status(text_doc.external_id)
+            if status.get("status") == "completed":
+                print(f"   Document {text_doc.external_id} is now processed")
+                break
+            print(f"   Document status: {status.get('status')}. Waiting...")
+            time.sleep(3)
+        
+        # Search using retrieve_chunks
+        print("\n9. Retrieving relevant chunks...")
+        chunks = db.retrieve_chunks(
+            query="What is this document about?",
+            filters={"source": "sdk_example"},
+            k=2
+        )
+        print(f"   Found {len(chunks)} chunks")
+        for i, chunk in enumerate(chunks):
+            print(f"   Chunk {i+1}: Score {chunk.score}")
+            print(f"      Content: {chunk.content[:50]}...")
+        
+        # Query using RAG
+        print("\n10. Generating a completion using RAG...")
+        completion = db.query(
+            query="Summarize what these documents contain",
+            filters={"source": "sdk_example"},
+            k=3,
+            temperature=0.7
+        )
+        print(f"   Completion: {completion.completion}")
+        print(f"   Using {len(completion.sources)} sources")
+        for i, source in enumerate(completion.sources):
+            print(f"      Source {i+1}: Document {source.document_id}, Chunk {source.chunk_number}")
+        
+        # List documents
+        print("\n11. Listing documents...")
+        docs = db.list_documents(filters={"source": "sdk_example"})
+        print(f"   Found {len(docs)} documents")
+        for i, doc in enumerate(docs):
+            print(f"   Document {i+1}: {doc.filename} (ID: {doc.external_id})")
+        
+        # Cleanup
+        print("\n12. Cleaning up test documents...")
+        # Delete the documents in reverse order (won't delete folder)
+        doc_ids = [user_doc.external_id, folder_doc.external_id, file_doc.external_id, text_doc.external_id]
+        for doc_id in doc_ids:
+            result = db.delete_document(doc_id)
+            print(f"   Deleted document {doc_id}: {result.get('message', 'No message')}")
+        
+        print("\nExample completed successfully!")
+    
+    finally:
+        db.close()
+
+
+async def run_async_example():
+    """Run asynchronous SDK examples"""
+    import asyncio
+    from morphik.async_ import AsyncMorphik
+    
+    # Get the test files directory - this script is in the tests directory
+    test_docs_dir = Path(__file__).parent / "test_docs"
+    
+    print("Running Morphik SDK Async Example")
+    print("================================")
+    
+    # Initialize the client - using default localhost:8000
+    print("\n1. Initializing AsyncMorphik client...")
+    async with AsyncMorphik() as db:  # Connects to localhost:8000 by default
+        print(f"   Connected to {db._logic._base_url}")
+        
+        try:
+            # Ingest a text document
+            print("\n2. Ingesting a text document...")
+            text_doc = await db.ingest_text(
+                content="This is a sample document created using the Morphik SDK async client. "
+                      "It demonstrates the text ingestion capabilities.",
+                filename="async_sdk_example.txt",
+                metadata={"source": "async_sdk_example", "type": "text"}
+            )
+            print(f"   Document created with ID: {text_doc.external_id}")
+            print(f"   Filename: {text_doc.filename}")
+            print(f"   Metadata: {text_doc.metadata}")
+            
+            # Ingest a file
+            print("\n3. Ingesting a file from disk...")
+            file_path = test_docs_dir / "sample2.txt"
+            file_doc = await db.ingest_file(
+                file=file_path,
+                metadata={"source": "async_sdk_example", "type": "file"}
+            )
+            print(f"   Document created with ID: {file_doc.external_id}")
+            print(f"   Filename: {file_doc.filename}")
+            
+            # Create a folder
+            print("\n4. Creating a folder...")
+            folder = await db.create_folder(name="async_sdk_example_folder", description="Example folder created by SDK")
+            print(f"   Folder created with name: {folder.name}")
+            print(f"   Folder ID: {folder.id}")
+            
+            # Ingest document into folder
+            print("\n5. Ingesting a document into the folder...")
+            folder_doc = await folder.ingest_text(
+                content="This document is stored in a specific folder using the async client.",
+                filename="async_folder_example.txt",
+                metadata={"source": "async_sdk_example", "type": "folder_doc"}
+            )
+            print(f"   Document created with ID: {folder_doc.external_id}")
+            
+            # Create a user scope
+            print("\n6. Creating a user scope...")
+            user = db.signin("async_sdk_example_user")
+            print(f"   User scope created for: {user.end_user_id}")
+            
+            # Ingest document as user
+            print("\n7. Ingesting a document as this user...")
+            user_doc = await user.ingest_text(
+                content="This document is associated with a specific user using the async client.",
+                filename="async_user_example.txt",
+                metadata={"source": "async_sdk_example", "type": "user_doc"}
+            )
+            print(f"   Document created with ID: {user_doc.external_id}")
+            
+            # Wait for processing to complete
+            print("\n8. Waiting for documents to be processed...")
+            for _ in range(10):
+                status = await db.get_document_status(text_doc.external_id)
+                if status.get("status") == "completed":
+                    print(f"   Document {text_doc.external_id} is now processed")
+                    break
+                print(f"   Document status: {status.get('status')}. Waiting...")
+                await asyncio.sleep(3)
+            
+            # Search using retrieve_chunks
+            print("\n9. Retrieving relevant chunks...")
+            chunks = await db.retrieve_chunks(
+                query="What is this document about?",
+                filters={"source": "async_sdk_example"},
+                k=2
+            )
+            print(f"   Found {len(chunks)} chunks")
+            for i, chunk in enumerate(chunks):
+                print(f"   Chunk {i+1}: Score {chunk.score}")
+                print(f"      Content: {chunk.content[:50]}...")
+            
+            # Query using RAG
+            print("\n10. Generating a completion using RAG...")
+            completion = await db.query(
+                query="Summarize what these documents contain",
+                filters={"source": "async_sdk_example"},
+                k=3,
+                temperature=0.7
+            )
+            print(f"   Completion: {completion.completion}")
+            print(f"   Using {len(completion.sources)} sources")
+            for i, source in enumerate(completion.sources):
+                print(f"      Source {i+1}: Document {source.document_id}, Chunk {source.chunk_number}")
+            
+            # List documents
+            print("\n11. Listing documents...")
+            docs = await db.list_documents(filters={"source": "async_sdk_example"})
+            print(f"   Found {len(docs)} documents")
+            for i, doc in enumerate(docs):
+                print(f"   Document {i+1}: {doc.filename} (ID: {doc.external_id})")
+            
+            # Cleanup
+            print("\n12. Cleaning up test documents...")
+            # Delete the documents in reverse order (won't delete folder)
+            doc_ids = [user_doc.external_id, folder_doc.external_id, file_doc.external_id, text_doc.external_id]
+            for doc_id in doc_ids:
+                result = await db.delete_document(doc_id)
+                print(f"   Deleted document {doc_id}: {result.get('message', 'No message')}")
+            
+            print("\nAsync example completed successfully!")
+        
+        except Exception as e:
+            print(f"Error in async example: {e}")
+            raise
+
+
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Morphik SDK example script")
+    parser.add_argument("--async", action="store_true", help="Run the async example")
+    args = parser.parse_args()
+    
+    if args.async:
+        # Run the async example
+        import asyncio
+        asyncio.run(run_async_example())
+    else:
+        # Run the sync example
+        run_sync_example()