morphik 0.1.9__tar.gz → 0.2.1__tar.gz

{morphik-0.1.9 → morphik-0.2.1}/.gitignore

@@ -44,3 +44,8 @@ ui-component/notebook-storage/notebooks.json
 ee/ui-component/package-lock.json
 ee/ee_tokens/gdrive_token_dev_user.pickle
 core/tests/integration/test_data/version_test_1.txt
+ee/ee_tokens/*
+
+migrations
+ugly-onetime-code/*
+trees

{morphik-0.1.9 → morphik-0.2.1}/PKG-INFO

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

{morphik-0.1.9 → morphik-0.2.1}/morphik/__init__.py

@@ -12,4 +12,4 @@ __all__ = [
     "Document",
 ]
 
-__version__ = "0.1.8"
+__version__ = "0.2.1"

{morphik-0.1.9 → morphik-0.2.1}/morphik/_internal.py

@@ -172,8 +172,14 @@ class _MorphikClientLogic:
         rules: Optional[List[RuleOrDict]],
         folder_name: Optional[str],
         end_user_id: Optional[str],
+        use_colpali: Optional[bool] = None,
     ) -> Dict[str, Any]:
-        """Prepare form data for ingest_file endpoint"""
+        """Prepare form data for ingest_file endpoint.
+
+        All parameters are included in the multipart body so that the server
+        never relies on query-string values.  *use_colpali* is therefore always
+        embedded here when provided.
+        """
         form_data = {
             "metadata": json.dumps(metadata or {}),
             "rules": json.dumps([self._convert_rule(r) for r in (rules or [])]),
@@ -182,6 +188,12 @@ class _MorphikClientLogic:
             form_data["folder_name"] = folder_name
         if end_user_id:
             form_data["end_user_id"] = end_user_id
+
+        # Only include the flag when caller supplied a specific value to avoid
+        # overriding server defaults unintentionally.
+        if use_colpali is not None:
+            form_data["use_colpali"] = str(use_colpali).lower()
+
         return form_data
 
     def _prepare_ingest_files_form_data(
@@ -208,10 +220,15 @@ class _MorphikClientLogic:
         data = {
             "metadata": json.dumps(metadata or {}),
             "rules": json.dumps(converted_rules),
-            # use_colpali is a query parameter, not a form field
             "parallel": str(parallel).lower(),
         }
 
+        # Always carry use_colpali in the body for consistency with single-file
+        # ingestion.  The API treats missing values as "true" for backward
+        # compatibility, hence we only add it when explicitly provided.
+        if use_colpali is not None:
+            data["use_colpali"] = str(use_colpali).lower()
+
         if folder_name:
             data["folder_name"] = folder_name
         if end_user_id:
@@ -234,6 +251,7 @@ class _MorphikClientLogic:
         prompt_overrides: Optional[Dict],
         folder_name: Optional[Union[str, List[str]]],
         end_user_id: Optional[str],
+        chat_id: Optional[str] = None,
         schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
     ) -> Dict[str, Any]:
         """Prepare request for query endpoint"""
@@ -254,6 +272,8 @@ class _MorphikClientLogic:
             payload["folder_name"] = folder_name
         if end_user_id:
             payload["end_user_id"] = end_user_id
+        if chat_id:
+            payload["chat_id"] = chat_id
 
         # Add schema to payload if provided
         if schema:

{morphik-0.1.9 → morphik-0.2.1}/morphik/async_.py

@@ -3,6 +3,7 @@ import logging
 from io import BytesIO, IOBase
 from pathlib import Path
 from typing import Any, BinaryIO, Dict, List, Optional, Type, Union
+from datetime import datetime
 
 import httpx
 from pydantic import BaseModel
@@ -163,14 +164,15 @@ class AsyncFolder:
             files = {"file": (filename, file_obj)}
 
             # Create form data
-            form_data = self._client._logic._prepare_ingest_file_form_data(metadata, rules, self._name, None)
+            form_data = self._client._logic._prepare_ingest_file_form_data(
+                metadata, rules, self._name, None, use_colpali
+            )
 
             response = await self._client._request(
                 "POST",
                 "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 +217,6 @@ class AsyncFolder:
                 "ingest/files",
                 data=data,
                 files=file_objects,
-                params={"use_colpali": str(use_colpali).lower()},
             )
 
             if response.get("errors"):
@@ -354,6 +355,7 @@ class AsyncFolder:
         prompt_overrides: Optional[Union[QueryPromptOverrides, Dict[str, Any]]] = None,
         additional_folders: Optional[List[str]] = None,
         schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
+        chat_id: Optional[str] = None,
     ) -> CompletionResponse:
         """
         Generate completion using relevant chunks as context within this folder.
@@ -391,6 +393,7 @@ class AsyncFolder:
             prompt_overrides,
             effective_folder,
             None,
+            chat_id,
             schema,
         )
 
@@ -474,9 +477,7 @@ class AsyncFolder:
             List[FinalChunkResult]: List of chunk results
         """
         merged = self._merge_folders(additional_folders)
-        request = self._client._logic._prepare_batch_get_chunks_request(
-            sources, merged, None, use_colpali
-        )
+        request = self._client._logic._prepare_batch_get_chunks_request(sources, merged, None, use_colpali)
         response = await self._client._request("POST", "batch/chunks", data=request)
         return self._client._logic._parse_chunk_result_list_response(response)
 
@@ -670,14 +671,14 @@ class AsyncUserScope:
             # Prepare multipart form data
             files = {"file": (filename, file_obj)}
 
-            # Add metadata and rules
+            # Add metadata, rules and scoping information
             data = {
                 "metadata": json.dumps(metadata or {}),
                 "rules": json.dumps([self._client._convert_rule(r) for r in (rules or [])]),
-                "end_user_id": self._end_user_id,  # Add end user ID here
+                "end_user_id": self._end_user_id,
+                "use_colpali": str(use_colpali).lower(),
             }
 
-            # Add folder name if scoped to a folder
             if self._folder_name:
                 data["folder_name"] = self._folder_name
 
@@ -738,9 +739,9 @@ class AsyncUserScope:
             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,
                 "parallel": str(parallel).lower(),
-                "end_user_id": self._end_user_id,  # Add end user ID here
+                "end_user_id": self._end_user_id,
+                "use_colpali": str(use_colpali).lower(),
             }
 
             # Add folder name if scoped to a folder
@@ -752,7 +753,6 @@ class AsyncUserScope:
                 "ingest/files",
                 data=data,
                 files=file_objects,
-                params={"use_colpali": str(use_colpali).lower()},
             )
 
             if response.get("errors"):
@@ -891,6 +891,7 @@ class AsyncUserScope:
         prompt_overrides: Optional[Union[QueryPromptOverrides, Dict[str, Any]]] = None,
         additional_folders: Optional[List[str]] = None,
         schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
+        chat_id: Optional[str] = None,
     ) -> CompletionResponse:
         """
         Generate completion using relevant chunks as context, scoped to the end user.
@@ -928,6 +929,7 @@ class AsyncUserScope:
             prompt_overrides,
             effective_folder,
             self._end_user_id,
+            chat_id,
             schema,
         )
 
@@ -1345,14 +1347,13 @@ class AsyncMorphik:
             files = {"file": (filename, file_obj)}
 
             # Create form data
-            form_data = self._logic._prepare_ingest_file_form_data(metadata, rules, None, None)
+            form_data = self._logic._prepare_ingest_file_form_data(metadata, rules, None, None, use_colpali)
 
             response = await self._request(
                 "POST",
                 "ingest/file",
                 data=form_data,
                 files=files,
-                params={"use_colpali": str(use_colpali).lower()},
             )
             doc = self._logic._parse_document_response(response)
             doc._client = self
@@ -1398,7 +1399,6 @@ class AsyncMorphik:
                 "ingest/files",
                 data=data,
                 files=file_objects,
-                params={"use_colpali": str(use_colpali).lower()},
             )
 
             if response.get("errors"):
@@ -1554,6 +1554,7 @@ class AsyncMorphik:
         include_paths: bool = False,
         prompt_overrides: Optional[Union[QueryPromptOverrides, Dict[str, Any]]] = None,
         folder_name: Optional[Union[str, List[str]]] = None,
+        chat_id: Optional[str] = None,
         schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
     ) -> CompletionResponse:
         """
@@ -1659,6 +1660,7 @@ class AsyncMorphik:
             prompt_overrides,
             effective_folder,
             None,
+            chat_id,
             schema,
         )
 
@@ -1676,6 +1678,45 @@ class AsyncMorphik:
         response = await self._request("POST", "query", data=payload)
         return self._logic._parse_completion_response(response)
 
+    async def agent_query(self, query: str) -> Dict[str, Any]:
+        """
+        Execute an agentic query with tool access and conversation handling.
+
+        The agent can autonomously use various tools to answer complex queries including:
+        - Searching and retrieving relevant documents
+        - Analyzing document content 
+        - Performing calculations and data processing
+        - Creating summaries and reports
+        - Managing knowledge graphs
+
+        Args:
+            query: Natural language query for the Morphik agent
+
+        Returns:
+            Dict[str, Any]: Agent response with potential tool execution results and sources
+
+        Example:
+            ```python
+            # Simple query
+            result = await db.agent_query("What are the main trends in our Q3 sales data?")
+            print(result["response"])
+
+            # Complex analysis request
+            result = await db.agent_query(
+                "Analyze all documents from the marketing department, "
+                "identify key performance metrics, and create a summary "
+                "with actionable insights"
+            )
+            print(result["response"])
+
+            # Tool usage is automatic - the agent will decide which tools to use
+            # based on the query requirements
+            ```
+        """
+        request = {"query": query}
+        response = await self._request("POST", "agent", data=request)
+        return response
+
     async def list_documents(
         self,
         skip: int = 0,
@@ -2225,9 +2266,7 @@ class AsyncMorphik:
                 print(f"Chunk from {chunk.document_id}, number {chunk.chunk_number}: {chunk.content[:50]}...")
             ```
         """
-        request = self._logic._prepare_batch_get_chunks_request(
-            sources, folder_name, None, use_colpali
-        )
+        request = self._logic._prepare_batch_get_chunks_request(sources, folder_name, None, use_colpali)
         response = await self._request("POST", "batch/chunks", data=request)
         return self._logic._parse_chunk_result_list_response(response)
 
@@ -2552,3 +2591,77 @@ class AsyncMorphik:
                 raise RuntimeError(graph.error or "Graph processing failed")
             await asyncio.sleep(check_interval_seconds)
         raise TimeoutError("Timed out waiting for graph completion")
+
+    async def ping(self) -> Dict[str, Any]:
+        """Simple health-check call to ``/ping`` endpoint."""
+        return await self._request("GET", "ping")
+
+    # ------------------------------------------------------------------
+    # Chat API ----------------------------------------------------------
+    # ------------------------------------------------------------------
+    async def get_chat_history(self, chat_id: str) -> List[Dict[str, Any]]:
+        """Return the full message history for *chat_id*."""
+        return await self._request("GET", f"chat/{chat_id}")
+
+    async def list_chat_conversations(self, limit: int = 100) -> List[Dict[str, Any]]:
+        """List recent chat conversations for the current user (async)."""
+        limit_capped = max(1, min(limit, 500))
+        return await self._request("GET", "chats", params={"limit": limit_capped})
+
+    # ------------------------------------------------------------------
+    # Usage API ---------------------------------------------------------
+    # ------------------------------------------------------------------
+    async def get_usage_stats(self) -> Dict[str, int]:
+        """Return cumulative token usage statistics (async)."""
+        return await self._request("GET", "usage/stats")
+
+    async def get_recent_usage(
+        self,
+        operation_type: Optional[str] = None,
+        since: Optional["datetime"] = None,
+        status: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """Return recent usage entries with optional filtering (async)."""
+        from datetime import datetime
+
+        params: Dict[str, Any] = {}
+        if operation_type:
+            params["operation_type"] = operation_type
+        if since:
+            params["since"] = since.isoformat() if isinstance(since, datetime) else str(since)
+        if status:
+            params["status"] = status
+        return await self._request("GET", "usage/recent", params=params)
+
+    # ------------------------------------------------------------------
+    # Graph helpers -----------------------------------------------------
+    # ------------------------------------------------------------------
+    async def get_graph_visualization(
+        self,
+        name: str,
+        folder_name: Optional[Union[str, List[str]]] = None,
+        end_user_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Fetch nodes & links for visualising *name* graph (async)."""
+        params: Dict[str, Any] = {}
+        if folder_name is not None:
+            params["folder_name"] = folder_name
+        if end_user_id is not None:
+            params["end_user_id"] = end_user_id
+        return await self._request("GET", f"graph/{name}/visualization", params=params)
+
+    async def check_workflow_status(
+        self, workflow_id: str, run_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Poll the status of an async graph build/update workflow."""
+        params = {"run_id": run_id} if run_id else None
+        return await self._request("GET", f"graph/workflow/{workflow_id}/status", params=params)
+
+    # ------------------------------------------------------------------
+    # Document download helpers ----------------------------------------
+    # ------------------------------------------------------------------
+    async def get_document_download_url(self, document_id: str, expires_in: int = 3600) -> Dict[str, Any]:
+        """Generate a presigned download URL for a document (async)."""
+        return await self._request(
+            "GET", f"documents/{document_id}/download_url", params={"expires_in": expires_in}
+        )

{morphik-0.1.9 → morphik-0.2.1}/morphik/sync.py

@@ -3,6 +3,7 @@ import logging
 from io import BytesIO, IOBase
 from pathlib import Path
 from typing import Any, BinaryIO, Dict, List, Optional, Type, Union
+from datetime import datetime
 
 import httpx
 from pydantic import BaseModel
@@ -163,15 +164,16 @@ class Folder:
             files = {"file": (filename, file_obj)}
 
             # Create form data
-            form_data = self._client._logic._prepare_ingest_file_form_data(metadata, rules, self._name, None)
+            form_data = self._client._logic._prepare_ingest_file_form_data(
+                metadata, rules, self._name, None, use_colpali
+            )
 
-            # use_colpali should be a query parameter as defined in the API
+            # use_colpali flag is included in multipart form data for consistency
             response = self._client._request(
                 "POST",
                 "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,6 @@ class Folder:
                 "ingest/files",
                 data=data,
                 files=file_objects,
-                params={"use_colpali": str(use_colpali).lower()},
             )
 
             if response.get("errors"):
@@ -367,6 +368,7 @@ class Folder:
         prompt_overrides: Optional[Union[QueryPromptOverrides, Dict[str, Any]]] = None,
         additional_folders: Optional[List[str]] = None,
         schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
+        chat_id: Optional[str] = None,
     ) -> CompletionResponse:
         """
         Generate completion using relevant chunks as context within this folder.
@@ -404,6 +406,7 @@ class Folder:
             prompt_overrides,
             effective_folder,
             None,  # end_user_id not supported at this level
+            chat_id,
             schema,
         )
 
@@ -488,9 +491,7 @@ class Folder:
             List[FinalChunkResult]: List of chunk results
         """
         merged = self._merge_folders(additional_folders)
-        request = self._client._logic._prepare_batch_get_chunks_request(
-            sources, merged, None, use_colpali
-        )
+        request = self._client._logic._prepare_batch_get_chunks_request(sources, merged, None, use_colpali)
 
         response = self._client._request("POST", "batch/chunks", data=request)
         return self._client._logic._parse_chunk_result_list_response(response)
@@ -703,24 +704,22 @@ class UserScope:
             # Prepare multipart form data
             files = {"file": (filename, file_obj)}
 
-            # Add metadata and rules
+            # Add metadata, rules and scoping information
             form_data = {
                 "metadata": json.dumps(metadata or {}),
                 "rules": json.dumps([self._client._convert_rule(r) for r in (rules or [])]),
-                "end_user_id": self._end_user_id,  # Add end user ID here
+                "end_user_id": self._end_user_id,
+                "use_colpali": str(use_colpali).lower(),
             }
 
-            # 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",
                 "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
@@ -778,9 +777,9 @@ class UserScope:
             data = {
                 "metadata": json.dumps(metadata or {}),
                 "rules": json.dumps(converted_rules),
-                # 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
+                "use_colpali": str(use_colpali).lower(),
             }
 
             # Add folder name if scoped to a folder
@@ -792,7 +791,6 @@ class UserScope:
                 "ingest/files",
                 data=data,
                 files=file_objects,
-                params={"use_colpali": str(use_colpali).lower()},
             )
 
             if response.get("errors"):
@@ -953,6 +951,7 @@ class UserScope:
         prompt_overrides: Optional[Union[QueryPromptOverrides, Dict[str, Any]]] = None,
         additional_folders: Optional[List[str]] = None,
         schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
+        chat_id: Optional[str] = None,
     ) -> CompletionResponse:
         """
         Generate completion using relevant chunks as context as this end user.
@@ -990,6 +989,7 @@ class UserScope:
             prompt_overrides,
             effective_folder,
             self._end_user_id,
+            chat_id,
             schema,
         )
 
@@ -1088,9 +1088,7 @@ class UserScope:
             List[FinalChunkResult]: List of chunk results
         """
         merged = self._merge_folders(additional_folders)
-        request = self._client._logic._prepare_batch_get_chunks_request(
-            sources, merged, None, use_colpali
-        )
+        request = self._client._logic._prepare_batch_get_chunks_request(sources, merged, None, use_colpali)
 
         response = self._client._request("POST", "batch/chunks", data=request)
         return self._client._logic._parse_chunk_result_list_response(response)
@@ -1493,7 +1491,7 @@ class Morphik:
             files = {"file": (filename, file_obj)}
 
             # Create form data
-            form_data = self._logic._prepare_ingest_file_form_data(metadata, rules, None, None)
+            form_data = self._logic._prepare_ingest_file_form_data(metadata, rules, None, None, use_colpali)
 
             # use_colpali should be a query parameter as defined in the API
             response = self._request(
@@ -1501,7 +1499,6 @@ class Morphik:
                 "ingest/file",
                 data=form_data,
                 files=files,
-                params={"use_colpali": str(use_colpali).lower()},
             )
             doc = self._logic._parse_document_response(response)
             doc._client = self
@@ -1548,7 +1545,6 @@ class Morphik:
                 "ingest/files",
                 data=data,
                 files=file_objects,
-                params={"use_colpali": str(use_colpali).lower()},
             )
 
             if response.get("errors"):
@@ -1701,6 +1697,7 @@ class Morphik:
         include_paths: bool = False,
         prompt_overrides: Optional[Union[QueryPromptOverrides, Dict[str, Any]]] = None,
         folder_name: Optional[Union[str, List[str]]] = None,
+        chat_id: Optional[str] = None,
         schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
     ) -> CompletionResponse:
         """
@@ -1807,6 +1804,7 @@ class Morphik:
             prompt_overrides,
             folder_name,
             None,  # end_user_id not supported at this level
+            chat_id,
             schema,
         )
 
@@ -1824,6 +1822,45 @@ class Morphik:
         response = self._request("POST", "query", data=payload)
         return self._logic._parse_completion_response(response)
 
+    def agent_query(self, query: str) -> Dict[str, Any]:
+        """
+        Execute an agentic query with tool access and conversation handling.
+
+        The agent can autonomously use various tools to answer complex queries including:
+        - Searching and retrieving relevant documents
+        - Analyzing document content 
+        - Performing calculations and data processing
+        - Creating summaries and reports
+        - Managing knowledge graphs
+
+        Args:
+            query: Natural language query for the Morphik agent
+
+        Returns:
+            Dict[str, Any]: Agent response with potential tool execution results and sources
+
+        Example:
+            ```python
+            # Simple query
+            result = db.agent_query("What are the main trends in our Q3 sales data?")
+            print(result["response"])
+
+            # Complex analysis request
+            result = db.agent_query(
+                "Analyze all documents from the marketing department, "
+                "identify key performance metrics, and create a summary "
+                "with actionable insights"
+            )
+            print(result["response"])
+
+            # Tool usage is automatic - the agent will decide which tools to use
+            # based on the query requirements
+            ```
+        """
+        request = {"query": query}
+        response = self._request("POST", "agent", data=request)
+        return response
+
     def list_documents(
         self,
         skip: int = 0,
@@ -2368,9 +2405,7 @@ class Morphik:
                 print(f"Chunk from {chunk.document_id}, number {chunk.chunk_number}: {chunk.content[:50]}...")
             ```
         """
-        request = self._logic._prepare_batch_get_chunks_request(
-            sources, folder_name, None, use_colpali
-        )
+        request = self._logic._prepare_batch_get_chunks_request(sources, folder_name, None, use_colpali)
         response = self._request("POST", "batch/chunks", data=request)
         return self._logic._parse_chunk_result_list_response(response)
 
@@ -2729,3 +2764,96 @@ class Morphik:
                 raise RuntimeError(graph.error or "Graph processing failed")
             time.sleep(check_interval_seconds)
         raise TimeoutError("Timed out waiting for graph completion")
+
+    def ping(self) -> Dict[str, Any]:
+        """Simple health-check call to the server (``/ping``).
+
+        Returns
+        -------
+        Dict[str, Any]
+            The JSON payload returned by the server, typically
+            ``{"status": "ok", "message": "Server is running"}``.
+        """
+        return self._request("GET", "ping")
+
+    # ------------------------------------------------------------------
+    # Chat API ----------------------------------------------------------
+    # ------------------------------------------------------------------
+    def get_chat_history(self, chat_id: str) -> List[Dict[str, Any]]:
+        """Return the full message history for the given *chat_id*.
+
+        Parameters
+        ----------
+        chat_id:
+            Identifier of the chat conversation returned by previous
+            calls that used ``chat_id``.
+        """
+        return self._request("GET", f"chat/{chat_id}")
+
+    def list_chat_conversations(self, limit: int = 100) -> List[Dict[str, Any]]:
+        """List recent chat conversations available to the current user.
+
+        Parameters
+        ----------
+        limit:
+            Maximum number of conversations to return (1-500).
+        """
+        limit_capped = max(1, min(limit, 500))
+        return self._request("GET", "chats", params={"limit": limit_capped})
+
+    # ------------------------------------------------------------------
+    # Usage API ---------------------------------------------------------
+    # ------------------------------------------------------------------
+    def get_usage_stats(self) -> Dict[str, int]:
+        """Return cumulative usage statistics for the authenticated user."""
+        return self._request("GET", "usage/stats")
+
+    def get_recent_usage(
+        self,
+        operation_type: Optional[str] = None,
+        since: Optional["datetime"] = None,
+        status: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """Return recent usage records with optional filtering."""
+        from datetime import datetime  # Local import ensures small dependency surface
+
+        params: Dict[str, Any] = {}
+        if operation_type:
+            params["operation_type"] = operation_type
+        if since:
+            # Accept either ``str`` or ``datetime`` for *since*
+            params["since"] = since.isoformat() if isinstance(since, datetime) else str(since)
+        if status:
+            params["status"] = status
+        return self._request("GET", "usage/recent", params=params)
+
+    # ------------------------------------------------------------------
+    # Graph helpers -----------------------------------------------------
+    # ------------------------------------------------------------------
+    def get_graph_visualization(
+        self,
+        name: str,
+        folder_name: Optional[Union[str, List[str]]] = None,
+        end_user_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Fetch nodes & links for visualising *name* graph."""
+        params: Dict[str, Any] = {}
+        if folder_name is not None:
+            params["folder_name"] = folder_name
+        if end_user_id is not None:
+            params["end_user_id"] = end_user_id
+        return self._request("GET", f"graph/{name}/visualization", params=params)
+
+    def check_workflow_status(self, workflow_id: str, run_id: Optional[str] = None) -> Dict[str, Any]:
+        """Poll the status of an asynchronous graph build/update workflow."""
+        params = {"run_id": run_id} if run_id else None
+        return self._request("GET", f"graph/workflow/{workflow_id}/status", params=params)
+
+    # ------------------------------------------------------------------
+    # Document download helpers ----------------------------------------
+    # ------------------------------------------------------------------
+    def get_document_download_url(self, document_id: str, expires_in: int = 3600) -> Dict[str, Any]:
+        """Generate a presigned download URL for a document stored remotely."""
+        return self._request(
+            "GET", f"documents/{document_id}/download_url", params={"expires_in": expires_in}
+        )

{morphik-0.1.9 → morphik-0.2.1}/pyproject.toml

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