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

morphik/__init__.py

@@ -12,4 +12,4 @@ __all__ = [
     "Document",
 ]
 
-__version__ = "0.1.2"
+__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

@@ -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:

morphik/models.py

@@ -24,6 +24,60 @@ class Document(BaseModel):
 
     # Client reference for update methods
     _client = None
+    
+    @property
+    def status(self) -> Dict[str, Any]:
+        """Get the latest processing status of the document from the API.
+
+        Returns:
+            Dict[str, Any]: Status information including current status, potential errors, and other metadata
+        """
+        if self._client is None:
+            raise ValueError(
+                "Document instance not connected to a client. Use a document returned from a Morphik client method."
+            )
+        return self._client.get_document_status(self.external_id)
+    
+    @property
+    def is_processing(self) -> bool:
+        """Check if the document is still being processed."""
+        return self.status.get("status") == "processing"
+    
+    @property
+    def is_ingested(self) -> bool:
+        """Check if the document has completed processing."""
+        return self.status.get("status") == "completed"
+    
+    @property
+    def is_failed(self) -> bool:
+        """Check if document processing has failed."""
+        return self.status.get("status") == "failed"
+    
+    @property
+    def error(self) -> Optional[str]:
+        """Get the error message if processing failed."""
+        status_info = self.status
+        return status_info.get("error") if status_info.get("status") == "failed" else None
+    
+    def wait_for_completion(self, timeout_seconds=300, check_interval_seconds=2):
+        """Wait for document processing to complete.
+        
+        Args:
+            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
+        """
+        if self._client is None:
+            raise ValueError(
+                "Document instance not connected to a client. Use a document returned from a Morphik client method."
+            )
+        return self._client.wait_for_document_completion(self.external_id, timeout_seconds, check_interval_seconds)
 
     def update_with_text(
         self,
@@ -411,3 +465,19 @@ class QueryPromptOverrides(BaseModel):
         None,
         description="Overrides for query prompts - controls response generation style, format, and tone",
     )
+
+
+class FolderInfo(BaseModel):
+    """Folder metadata model"""
+
+    id: str = Field(..., description="Unique folder identifier")
+    name: str = Field(..., description="Folder name")
+    description: Optional[str] = Field(None, description="Folder description")
+    owner: Dict[str, str] = Field(..., description="Owner information")
+    document_ids: List[str] = Field(default_factory=list, description="IDs of documents in the folder")
+    system_metadata: Dict[str, Any] = Field(
+        default_factory=dict, description="System-managed metadata"
+    )
+    access_control: Dict[str, List[str]] = Field(
+        default_factory=dict, description="Access control information"
+    )