morphik 0.1.3__tar.gz → 0.1.4__tar.gz

morphik-0.1.4/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: morphik
+Version: 0.1.4
+Summary: Morphik Python Client
+Author-email: Morphik <founders@morphik.ai>
+Requires-Python: >=3.8
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: pillow==10.4.0
+Requires-Dist: pydantic==2.10.3
+Requires-Dist: pyjwt>=2.0.0
+Requires-Dist: requests>=2.32.3
+Description-Content-Type: text/markdown
+
+# Morphik
+
+A Python client for Morphik API that enables document ingestion, semantic search, and retrieval augmented generation capabilities.
+
+## Installation
+
+```bash
+pip install morphik
+```
+
+## Usage
+
+The SDK provides both synchronous and asynchronous clients:
+
+### Synchronous Usage
+
+```python
+from morphik import Morphik
+
+# Initialize client - connects to localhost:8000 by default
+db = Morphik()
+
+# Or with authentication URI (for production)
+# db = Morphik("morphik://owner_id:token@api.morphik.ai")
+
+# Ingest a text document
+doc = db.ingest_text(
+    content="Your document content",
+    metadata={"title": "Example Document"}
+)
+
+# Ingest a file
+doc = db.ingest_file(
+    file="path/to/document.pdf",
+    metadata={"category": "reports"}
+)
+
+# Retrieve relevant chunks
+chunks = db.retrieve_chunks(
+    query="Your search query",
+    filters={"category": "reports"}
+)
+
+# Query with RAG
+response = db.query(
+    query="Summarize the key points in the document",
+    filters={"category": "reports"}
+)
+
+print(response.completion)
+```
+
+### Asynchronous Usage
+
+```python
+import asyncio
+from morphik.async_ import AsyncMorphik
+
+async def main():
+    # Initialize async client - connects to localhost:8000 by default
+    async with AsyncMorphik() as db:
+    
+    # Or with authentication URI (for production)
+    # async with AsyncMorphik("morphik://owner_id:token@api.morphik.ai") as db:
+        # Ingest a text document
+        doc = await db.ingest_text(
+            content="Your document content",
+            metadata={"title": "Example Document"}
+        )
+        
+        # Query with RAG
+        response = await db.query(
+            query="Summarize the key points in the document",
+        )
+        
+        print(response.completion)
+
+# Run the async function
+asyncio.run(main())
+```
+
+## Features
+
+- Document ingestion (text, files, directories)
+- Semantic search and retrieval
+- Retrieval-augmented generation (RAG)
+- Knowledge graph creation and querying
+- Multi-user and multi-folder scoping
+- Metadata filtering
+- Document management
+
+## Development
+
+### Running Tests
+
+To run the tests, first install the development dependencies:
+
+```bash
+pip install -r test_requirements.txt
+```
+
+Then run the tests:
+
+```bash
+# Run all tests (requires a running Morphik server)
+pytest morphik/tests/ -v
+
+# Run specific test modules
+pytest morphik/tests/test_sync.py -v
+pytest morphik/tests/test_async.py -v
+
+# Skip tests if you don't have a running server
+SKIP_LIVE_TESTS=1 pytest morphik/tests/ -v
+
+# Specify a custom server URL for tests
+MORPHIK_TEST_URL=http://custom-server:8000 pytest morphik/tests/ -v
+```
+
+### Example Usage Script
+
+The SDK comes with an example script that demonstrates basic usage:
+
+```bash
+# Run synchronous example
+python -m morphik.tests.example_usage
+
+# Run asynchronous example
+python -m morphik.tests.example_usage --async
+```
+
+The example script demonstrates:
+- Text and file ingestion
+- Creating folders and user scopes
+- Retrieving chunks and documents
+- Generating completions using RAG
+- Batch operations and cleanup
+
+## License
+
+[License information]

morphik-0.1.4/README.md

@@ -0,0 +1,140 @@
+# Morphik
+
+A Python client for Morphik API that enables document ingestion, semantic search, and retrieval augmented generation capabilities.
+
+## Installation
+
+```bash
+pip install morphik
+```
+
+## Usage
+
+The SDK provides both synchronous and asynchronous clients:
+
+### Synchronous Usage
+
+```python
+from morphik import Morphik
+
+# Initialize client - connects to localhost:8000 by default
+db = Morphik()
+
+# Or with authentication URI (for production)
+# db = Morphik("morphik://owner_id:token@api.morphik.ai")
+
+# Ingest a text document
+doc = db.ingest_text(
+    content="Your document content",
+    metadata={"title": "Example Document"}
+)
+
+# Ingest a file
+doc = db.ingest_file(
+    file="path/to/document.pdf",
+    metadata={"category": "reports"}
+)
+
+# Retrieve relevant chunks
+chunks = db.retrieve_chunks(
+    query="Your search query",
+    filters={"category": "reports"}
+)
+
+# Query with RAG
+response = db.query(
+    query="Summarize the key points in the document",
+    filters={"category": "reports"}
+)
+
+print(response.completion)
+```
+
+### Asynchronous Usage
+
+```python
+import asyncio
+from morphik.async_ import AsyncMorphik
+
+async def main():
+    # Initialize async client - connects to localhost:8000 by default
+    async with AsyncMorphik() as db:
+    
+    # Or with authentication URI (for production)
+    # async with AsyncMorphik("morphik://owner_id:token@api.morphik.ai") as db:
+        # Ingest a text document
+        doc = await db.ingest_text(
+            content="Your document content",
+            metadata={"title": "Example Document"}
+        )
+        
+        # Query with RAG
+        response = await db.query(
+            query="Summarize the key points in the document",
+        )
+        
+        print(response.completion)
+
+# Run the async function
+asyncio.run(main())
+```
+
+## Features
+
+- Document ingestion (text, files, directories)
+- Semantic search and retrieval
+- Retrieval-augmented generation (RAG)
+- Knowledge graph creation and querying
+- Multi-user and multi-folder scoping
+- Metadata filtering
+- Document management
+
+## Development
+
+### Running Tests
+
+To run the tests, first install the development dependencies:
+
+```bash
+pip install -r test_requirements.txt
+```
+
+Then run the tests:
+
+```bash
+# Run all tests (requires a running Morphik server)
+pytest morphik/tests/ -v
+
+# Run specific test modules
+pytest morphik/tests/test_sync.py -v
+pytest morphik/tests/test_async.py -v
+
+# Skip tests if you don't have a running server
+SKIP_LIVE_TESTS=1 pytest morphik/tests/ -v
+
+# Specify a custom server URL for tests
+MORPHIK_TEST_URL=http://custom-server:8000 pytest morphik/tests/ -v
+```
+
+### Example Usage Script
+
+The SDK comes with an example script that demonstrates basic usage:
+
+```bash
+# Run synchronous example
+python -m morphik.tests.example_usage
+
+# Run asynchronous example
+python -m morphik.tests.example_usage --async
+```
+
+The example script demonstrates:
+- Text and file ingestion
+- Creating folders and user scopes
+- Retrieving chunks and documents
+- Generating completions using RAG
+- Batch operations and cleanup
+
+## License
+
+[License information]

{morphik-0.1.3 → morphik-0.1.4}/morphik/__init__.py

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

{morphik-0.1.3 → morphik-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-0.1.3 → morphik-0.1.4}/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-0.1.3 → morphik-0.1.4}/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-0.1.4/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