morphik 0.1.2__tar.gz → 0.1.3__tar.gz

{morphik-0.1.2 → morphik-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphik
-Version: 0.1.2
+Version: 0.1.3
 Summary: Morphik Python Client
 Author-email: Morphik <founders@morphik.ai>
 Requires-Python: >=3.8

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

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

{morphik-0.1.2 → morphik-0.1.3}/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":
         """
@@ -1054,19 +1082,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 +1116,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:
         """
@@ -1490,6 +1580,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:
         """

{morphik-0.1.2 → morphik-0.1.3}/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"
+    )

{morphik-0.1.2 → morphik-0.1.3}/morphik/sync.py

@@ -16,6 +16,7 @@ from .models import (
     IngestTextRequest,
     ChunkSource,
     Graph,
+    FolderInfo,
     # Prompt override models
     GraphPromptOverrides,
     QueryPromptOverrides,
@@ -58,16 +59,43 @@ class Folder:
     Args:
         client: The Morphik client instance
         name: The name of the folder
+        folder_id: Optional folder ID (if already known)
     """
 
-    def __init__(self, client: "Morphik", name: str):
+    def __init__(self, client: "Morphik", 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
+        
+    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 = 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 self._client._request("GET", f"folders/{self._id}")
+        
 
     def signin(self, end_user_id: str) -> "UserScope":
         """
@@ -1147,19 +1175,30 @@ class Morphik:
         """Convert a rule to a dictionary format"""
         return self._logic._convert_rule(rule)
 
-    def create_folder(self, name: str) -> Folder:
+    def create_folder(self, name: str, description: Optional[str] = None) -> Folder:
         """
         Create a folder to scope operations.
 
         Args:
             name: The name of the folder
+            description: Optional description for the folder
 
         Returns:
-            Folder: A folder object for scoped operations
+            Folder: A folder object ready for scoped operations
         """
-        return Folder(self, name)
-
-    def get_folder(self, name: str) -> Folder:
+        payload = {
+            "name": name
+        }
+        if description:
+            payload["description"] = description
+            
+        response = self._request("POST", "folders", data=payload)
+        folder_info = FolderInfo(**response)
+        
+        # Return a usable Folder object with the ID from the response
+        return Folder(self, name, folder_id=folder_info.id)
+    
+    def get_folder_by_name(self, name: str) -> Folder:
         """
         Get a folder by name to scope operations.
 
@@ -1170,6 +1209,57 @@ class Morphik:
             Folder: A folder object for scoped operations
         """
         return Folder(self, name)
+        
+    def get_folder(self, folder_id: str) -> Folder:
+        """
+        Get a folder by ID.
+
+        Args:
+            folder_id: ID of the folder
+
+        Returns:
+            Folder: A folder object for scoped operations
+        """
+        response = self._request("GET", f"folders/{folder_id}")
+        return Folder(self, response["name"], folder_id)
+
+    def list_folders(self) -> List[Folder]:
+        """
+        List all folders the user has access to as Folder objects.
+        
+        Returns:
+            List[Folder]: List of Folder objects ready for operations
+        """
+        folder_infos = self._request("GET", "folders")
+        return [Folder(self, info["name"], info["id"]) for info in folder_infos]
+        
+    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 = self._request("POST", f"folders/{folder_id}/documents/{document_id}")
+        return response
+        
+    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 = self._request("DELETE", f"folders/{folder_id}/documents/{document_id}")
+        return response
 
     def signin(self, end_user_id: str) -> UserScope:
         """
@@ -1618,6 +1708,76 @@ class Morphik:
         doc = self._logic._parse_document_response(response)
         doc._client = self
         return doc
+        
+    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 = 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 = self._request("GET", f"documents/{document_id}/status")
+        return response
+    
+    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 = db.ingest_file("large_document.pdf")
+            try:
+                completed_doc = 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 time
+        start_time = time.time()
+        
+        while (time.time() - start_time) < timeout_seconds:
+            status = self.get_document_status(document_id)
+            
+            if status["status"] == "completed":
+                # Get the full document now that it's complete
+                return self.get_document(document_id)
+            elif status["status"] == "failed":
+                raise ValueError(f"Document processing failed: {status.get('error', 'Unknown error')}")
+            
+            # Wait before checking again
+            time.sleep(check_interval_seconds)
+        
+        raise TimeoutError(f"Document processing did not complete within {timeout_seconds} seconds")
 
     def get_document_by_filename(self, filename: str) -> Document:
         """

{morphik-0.1.2 → morphik-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "morphik"
-version = "0.1.2"
+version = "0.1.3"
 authors = [
     { name = "Morphik", email = "founders@morphik.ai" },
 ]