morphik 0.1.2__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.2 → morphik-0.1.4}/morphik/__init__.py

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

{morphik-0.1.2 → 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.2 → morphik-0.1.4}/morphik/async_.py

@@ -14,6 +14,7 @@ from .models import (
     IngestTextRequest,
     ChunkSource,
     Graph,
+    FolderInfo,
     # Prompt override models
     GraphPromptOverrides,
     QueryPromptOverrides,
@@ -56,16 +57,43 @@ class AsyncFolder:
     Args:
         client: The AsyncMorphik client instance
         name: The name of the folder
+        folder_id: Optional folder ID (if already known)
     """
 
-    def __init__(self, client: "AsyncMorphik", name: str):
+    def __init__(self, client: "AsyncMorphik", name: str, folder_id: Optional[str] = None):
         self._client = client
         self._name = name
+        self._id = folder_id
 
     @property
     def name(self) -> str:
         """Returns the folder name."""
         return self._name
+        
+    @property
+    def id(self) -> Optional[str]:
+        """Returns the folder ID if available."""
+        return self._id
+        
+    async def get_info(self) -> Dict[str, Any]:
+        """
+        Get detailed information about this folder.
+        
+        Returns:
+            Dict[str, Any]: Detailed folder information
+        """
+        if not self._id:
+            # If we don't have the ID, find the folder by name first
+            folders = await self._client.list_folders()
+            for folder in folders:
+                if folder.name == self._name:
+                    self._id = folder.id
+                    break
+            if not self._id:
+                raise ValueError(f"Folder '{self._name}' not found")
+        
+        return await self._client._request("GET", f"folders/{self._id}")
+        
 
     def signin(self, end_user_id: str) -> "AsyncUserScope":
         """
@@ -144,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
@@ -187,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"):
@@ -391,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:
@@ -673,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"):
@@ -877,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:
@@ -1032,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"
@@ -1054,19 +1101,30 @@ class AsyncMorphik:
         """Convert a rule to a dictionary format"""
         return self._logic._convert_rule(rule)
 
-    def create_folder(self, name: str) -> AsyncFolder:
+    async def create_folder(self, name: str, description: Optional[str] = None) -> AsyncFolder:
         """
         Create a folder to scope operations.
 
         Args:
             name: The name of the folder
+            description: Optional description for the folder
 
         Returns:
-            AsyncFolder: A folder object for scoped operations
-        """
-        return AsyncFolder(self, name)
-
-    def get_folder(self, name: str) -> AsyncFolder:
+            AsyncFolder: A folder object ready for scoped operations
+        """
+        payload = {
+            "name": name
+        }
+        if description:
+            payload["description"] = description
+            
+        response = await self._request("POST", "folders", data=payload)
+        folder_info = FolderInfo(**response)
+        
+        # Return a usable AsyncFolder object with the ID from the response
+        return AsyncFolder(self, name, folder_id=folder_info.id)
+    
+    def get_folder_by_name(self, name: str) -> AsyncFolder:
         """
         Get a folder by name to scope operations.
 
@@ -1077,6 +1135,57 @@ class AsyncMorphik:
             AsyncFolder: A folder object for scoped operations
         """
         return AsyncFolder(self, name)
+        
+    async def get_folder(self, folder_id: str) -> AsyncFolder:
+        """
+        Get a folder by ID.
+
+        Args:
+            folder_id: ID of the folder
+
+        Returns:
+            AsyncFolder: A folder object for scoped operations
+        """
+        response = await self._request("GET", f"folders/{folder_id}")
+        return AsyncFolder(self, response["name"], folder_id)
+        
+    async def list_folders(self) -> List[AsyncFolder]:
+        """
+        List all folders the user has access to as AsyncFolder objects.
+
+        Returns:
+            List[AsyncFolder]: List of AsyncFolder objects ready for operations
+        """
+        response = await self._request("GET", "folders")
+        return [AsyncFolder(self, folder["name"], folder["id"]) for folder in response]
+        
+    async def add_document_to_folder(self, folder_id: str, document_id: str) -> Dict[str, str]:
+        """
+        Add a document to a folder.
+
+        Args:
+            folder_id: ID of the folder
+            document_id: ID of the document
+
+        Returns:
+            Dict[str, str]: Success status
+        """
+        response = await self._request("POST", f"folders/{folder_id}/documents/{document_id}")
+        return response
+        
+    async def remove_document_from_folder(self, folder_id: str, document_id: str) -> Dict[str, str]:
+        """
+        Remove a document from a folder.
+
+        Args:
+            folder_id: ID of the folder
+            document_id: ID of the document
+
+        Returns:
+            Dict[str, str]: Success status
+        """
+        response = await self._request("DELETE", f"folders/{folder_id}/documents/{document_id}")
+        return response
 
     def signin(self, end_user_id: str) -> AsyncUserScope:
         """
@@ -1163,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
@@ -1208,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
@@ -1216,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
@@ -1490,6 +1606,76 @@ class AsyncMorphik:
         doc = self._logic._parse_document_response(response)
         doc._client = self
         return doc
+        
+    async def get_document_status(self, document_id: str) -> Dict[str, Any]:
+        """
+        Get the current processing status of a document.
+        
+        Args:
+            document_id: ID of the document to check
+            
+        Returns:
+            Dict[str, Any]: Status information including current status, potential errors, and other metadata
+            
+        Example:
+            ```python
+            status = await db.get_document_status("doc_123")
+            if status["status"] == "completed":
+                print("Document processing complete")
+            elif status["status"] == "failed":
+                print(f"Processing failed: {status['error']}")
+            else:
+                print("Document still processing...")
+            ```
+        """
+        response = await self._request("GET", f"documents/{document_id}/status")
+        return response
+    
+    async def wait_for_document_completion(self, document_id: str, timeout_seconds=300, check_interval_seconds=2) -> Document:
+        """
+        Wait for a document's processing to complete.
+        
+        Args:
+            document_id: ID of the document to wait for
+            timeout_seconds: Maximum time to wait for completion (default: 300 seconds)
+            check_interval_seconds: Time between status checks (default: 2 seconds)
+            
+        Returns:
+            Document: Updated document with the latest status
+            
+        Raises:
+            TimeoutError: If processing doesn't complete within the timeout period
+            ValueError: If processing fails with an error
+            
+        Example:
+            ```python
+            # Upload a file and wait for processing to complete
+            doc = await db.ingest_file("large_document.pdf")
+            try:
+                completed_doc = await db.wait_for_document_completion(doc.external_id)
+                print(f"Processing complete! Document has {len(completed_doc.chunk_ids)} chunks")
+            except TimeoutError:
+                print("Processing is taking too long")
+            except ValueError as e:
+                print(f"Processing failed: {e}")
+            ```
+        """
+        import asyncio
+        start_time = asyncio.get_event_loop().time()
+        
+        while (asyncio.get_event_loop().time() - start_time) < timeout_seconds:
+            status = await self.get_document_status(document_id)
+            
+            if status["status"] == "completed":
+                # Get the full document now that it's complete
+                return await self.get_document(document_id)
+            elif status["status"] == "failed":
+                raise ValueError(f"Document processing failed: {status.get('error', 'Unknown error')}")
+            
+            # Wait before checking again
+            await asyncio.sleep(check_interval_seconds)
+        
+        raise TimeoutError(f"Document processing did not complete within {timeout_seconds} seconds")
 
     async def get_document_by_filename(self, filename: str) -> Document:
         """
@@ -1865,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: