modulex-python 0.1.0__py3-none-any.whl

modulex/resources/credentials.py

@@ -0,0 +1,197 @@
+"""Credentials resource for the ModuleX Python SDK."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from modulex._base import _BaseResource
+from modulex._streaming import EventSourceStream
+
+
+class Credentials(_BaseResource):
+    """Resource for managing integration credentials."""
+
+    async def list(
+        self,
+        *,
+        integration_name: str | None = None,
+        auth_type: str | None = None,
+        limit: int = 100,
+        offset: int = 0,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return a paginated list of credentials, optionally filtered by integration or auth type."""
+        params: dict[str, Any] = {"limit": limit, "offset": offset}
+        if integration_name is not None:
+            params["integration_name"] = integration_name
+        if auth_type is not None:
+            params["auth_type"] = auth_type
+        return await self._get("/credentials", params=params, organization_id=organization_id)
+
+    async def get(
+        self,
+        credential_id: str,
+        *,
+        include_masked: bool = False,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return a single credential by its ID, optionally including masked auth data."""
+        return await self._get(
+            f"/credentials/{credential_id}",
+            params={"include_masked": include_masked},
+            organization_id=organization_id,
+        )
+
+    async def create(
+        self,
+        integration_name: str,
+        *,
+        auth_data: dict[str, Any] | None = None,
+        auth_type: str | None = None,
+        display_name: str | None = None,
+        metadata: dict[str, Any] | None = None,
+        make_default: bool = False,
+        expires_at: str | None = None,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Create a new credential for the specified integration."""
+        body: dict[str, Any] = {
+            "integration_name": integration_name,
+            "make_default": make_default,
+        }
+        if auth_data is not None:
+            body["auth_data"] = auth_data
+        if auth_type is not None:
+            body["auth_type"] = auth_type
+        if display_name is not None:
+            body["display_name"] = display_name
+        if metadata is not None:
+            body["metadata"] = metadata
+        if expires_at is not None:
+            body["expires_at"] = expires_at
+        return await self._post("/credentials", json=body, organization_id=organization_id)
+
+    async def update(
+        self,
+        credential_id: str,
+        *,
+        display_name: str | None = None,
+        metadata: dict[str, Any] | None = None,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Update the display name or metadata of an existing credential."""
+        body: dict[str, Any] = {}
+        if display_name is not None:
+            body["display_name"] = display_name
+        if metadata is not None:
+            body["metadata"] = metadata
+        return await self._put(
+            f"/credentials/{credential_id}",
+            json=body or None,
+            organization_id=organization_id,
+        )
+
+    async def delete(self, credential_id: str, *, organization_id: str | None = None) -> None:
+        """Permanently delete a credential by its ID."""
+        await self._delete(f"/credentials/{credential_id}", organization_id=organization_id)
+
+    async def set_default(self, credential_id: str, *, organization_id: str | None = None) -> Any:
+        """Mark a credential as the default for its integration."""
+        return await self._post(
+            f"/credentials/{credential_id}/set-default",
+            organization_id=organization_id,
+        )
+
+    async def test(self, credential_id: str, *, organization_id: str | None = None) -> Any:
+        """Test an existing credential to verify it is still valid."""
+        return await self._post(f"/credentials/{credential_id}/test", organization_id=organization_id)
+
+    async def test_temporary(
+        self,
+        integration_name: str,
+        auth_type: str,
+        auth_data: dict[str, Any],
+        *,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Test a set of credentials without persisting them."""
+        body: dict[str, Any] = {
+            "integration_name": integration_name,
+            "auth_type": auth_type,
+            "auth_data": auth_data,
+        }
+        return await self._post("/credentials/test-temporary", json=body, organization_id=organization_id)
+
+    async def usage(
+        self,
+        credential_id: str,
+        *,
+        start_date: str | None = None,
+        end_date: str | None = None,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return usage statistics for a credential within an optional date range."""
+        params: dict[str, Any] = {}
+        if start_date is not None:
+            params["start_date"] = start_date
+        if end_date is not None:
+            params["end_date"] = end_date
+        return await self._get(
+            f"/credentials/{credential_id}/usage",
+            params=params or None,
+            organization_id=organization_id,
+        )
+
+    async def audit(
+        self,
+        credential_id: str,
+        *,
+        limit: int = 100,
+        offset: int = 0,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return the audit log for a credential."""
+        return await self._get(
+            f"/credentials/{credential_id}/audit",
+            params={"limit": limit, "offset": offset},
+            organization_id=organization_id,
+        )
+
+    async def create_mcp_server(
+        self,
+        server_url: str,
+        *,
+        headers: dict[str, Any] | None = None,
+        display_name: str | None = None,
+        make_default: bool = False,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Register an MCP server as a credential."""
+        body: dict[str, Any] = {"server_url": server_url, "make_default": make_default}
+        if headers is not None:
+            body["headers"] = headers
+        if display_name is not None:
+            body["display_name"] = display_name
+        return await self._post("/credentials/mcp-server", json=body, organization_id=organization_id)
+
+    async def refresh_mcp_discovery(self, credential_id: str, *, organization_id: str | None = None) -> Any:
+        """Refresh the tool discovery for an MCP server credential."""
+        return await self._post(
+            f"/credentials/{credential_id}/refresh-discovery",
+            organization_id=organization_id,
+        )
+
+    async def mcp_tools(self, credential_id: str, *, organization_id: str | None = None) -> Any:
+        """Return the list of tools exposed by an MCP server credential."""
+        return await self._get(
+            f"/credentials/{credential_id}/mcp-tools",
+            organization_id=organization_id,
+        )
+
+    def bulk_modulex_keys_stream(self, *, organization_id: str | None = None) -> EventSourceStream:
+        """Open an SSE stream to receive bulk ModuleX key data."""
+        return self._stream_sse(
+            "/credentials/bulk-modulex-keys/stream",
+            method="POST",
+            organization_id=organization_id,
+        )

modulex/resources/dashboard.py

@@ -0,0 +1,110 @@
+"""Dashboard resource for the ModuleX Python SDK."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from modulex._base import _BaseResource
+
+
+class Dashboard(_BaseResource):
+    """Resource for accessing dashboard logs, analytics, and user management."""
+
+    async def logs(
+        self,
+        *,
+        limit: int = 50,
+        offset: int = 0,
+        category: str | None = None,
+        operation: str | None = None,
+        start_date: str | None = None,
+        end_date: str | None = None,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return activity logs for the organization with optional filters."""
+        params: dict[str, Any] = {
+            k: v
+            for k, v in {
+                "limit": limit,
+                "offset": offset,
+                "category": category,
+                "operation": operation,
+                "start_date": start_date,
+                "end_date": end_date,
+            }.items()
+            if v is not None
+        }
+        return await self._get("/dashboard/logs", params=params, organization_id=organization_id)
+
+    async def analytics_overview(
+        self,
+        *,
+        limit: int = 20,
+        offset: int = 0,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return a high-level analytics overview for the organization."""
+        params: dict[str, Any] = {"limit": limit, "offset": offset}
+        return await self._get(
+            "/dashboard/analytics/overview",
+            params=params,
+            organization_id=organization_id,
+        )
+
+    async def analytics_tools(
+        self,
+        *,
+        period: str = "7d",
+        limit: int = 20,
+        offset: int = 0,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return tool usage analytics for the organization over a given period."""
+        params: dict[str, Any] = {"period": period, "limit": limit, "offset": offset}
+        return await self._get(
+            "/dashboard/analytics/tools",
+            params=params,
+            organization_id=organization_id,
+        )
+
+    async def analytics_llm_usage(
+        self,
+        *,
+        period: str = "7d",
+        limit: int = 20,
+        offset: int = 0,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return LLM token consumption analytics for the organization over a given period."""
+        params: dict[str, Any] = {"period": period, "limit": limit, "offset": offset}
+        return await self._get(
+            "/dashboard/analytics/llm-usage",
+            params=params,
+            organization_id=organization_id,
+        )
+
+    async def users(
+        self,
+        *,
+        search: str | None = None,
+        status: str | None = None,
+        sort_by: str = "created_at",
+        order: str = "desc",
+        page: int = 1,
+        limit: int = 10,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return paginated users for the organization with optional search and sort."""
+        params: dict[str, Any] = {
+            k: v
+            for k, v in {
+                "search": search,
+                "status": status,
+                "sort_by": sort_by,
+                "order": order,
+                "page": page,
+                "limit": limit,
+            }.items()
+            if v is not None
+        }
+        return await self._get("/dashboard/users", params=params, organization_id=organization_id)

modulex/resources/deployments.py

@@ -0,0 +1,92 @@
+"""Deployments resource for the ModuleX Python SDK."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from modulex._base import _BaseResource
+
+
+class Deployments(_BaseResource):
+    """Resource for managing workflow deployments."""
+
+    async def create(
+        self,
+        workflow_id: str,
+        *,
+        deployment_note: str | None = None,
+        schema_image_url: str | None = None,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Deploy a workflow and create a new deployment record."""
+        body: dict[str, Any] = {}
+        if deployment_note is not None:
+            body["deployment_note"] = deployment_note
+        if schema_image_url is not None:
+            body["schema_image_url"] = schema_image_url
+        return await self._post(
+            f"/workflows/{workflow_id}/deploy",
+            json=body or None,
+            organization_id=organization_id,
+        )
+
+    async def list(
+        self,
+        workflow_id: str,
+        *,
+        limit: int = 20,
+        offset: int = 0,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return a paginated list of deployments for a workflow."""
+        return await self._get(
+            f"/workflows/{workflow_id}/deployments",
+            params={"limit": limit, "offset": offset},
+            organization_id=organization_id,
+        )
+
+    async def get(
+        self,
+        workflow_id: str,
+        deployment_id: str,
+        *,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return a single deployment by workflow ID and deployment ID."""
+        return await self._get(
+            f"/workflows/{workflow_id}/deployments/{deployment_id}",
+            organization_id=organization_id,
+        )
+
+    async def activate(
+        self,
+        workflow_id: str,
+        deployment_id: str,
+        *,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Activate a specific deployment, making it the live version."""
+        return await self._put(
+            f"/workflows/{workflow_id}/deployments/{deployment_id}/activate",
+            organization_id=organization_id,
+        )
+
+    async def deactivate(self, workflow_id: str, *, organization_id: str | None = None) -> Any:
+        """Deactivate the currently live deployment for a workflow."""
+        return await self._delete(
+            f"/workflows/{workflow_id}/deployments/live",
+            organization_id=organization_id,
+        )
+
+    async def delete(
+        self,
+        workflow_id: str,
+        deployment_id: str,
+        *,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Permanently delete a deployment by workflow ID and deployment ID."""
+        return await self._delete(
+            f"/workflows/{workflow_id}/deployments/{deployment_id}",
+            organization_id=organization_id,
+        )

modulex/resources/executions.py

@@ -0,0 +1,97 @@
+"""Executions resource for the ModuleX Python SDK."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from modulex._base import _BaseResource
+from modulex._streaming import EventSourceStream
+
+
+class Executions(_BaseResource):
+    """Resource for running and managing workflow executions."""
+
+    async def run(
+        self,
+        *,
+        workflow_id: str | None = None,
+        workflow: dict[str, Any] | None = None,
+        llm: dict[str, Any] | None = None,
+        system_workflow: str | None = None,
+        input: dict[str, Any] | None = None,
+        config: dict[str, Any] | None = None,
+        stream: bool = True,
+        ephemeral: bool = False,
+        is_private: bool = False,
+        knowledge_config: dict[str, Any] | None = None,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Trigger a workflow execution and return the run result or stream handle."""
+        body: dict[str, Any] = {
+            "stream": stream,
+            "ephemeral": ephemeral,
+            "is_private": is_private,
+        }
+        if workflow_id is not None:
+            body["workflow_id"] = workflow_id
+        if workflow is not None:
+            body["workflow"] = workflow
+        if llm is not None:
+            body["llm"] = llm
+        if system_workflow is not None:
+            body["system_workflow"] = system_workflow
+        if input is not None:
+            body["input"] = input
+        if config is not None:
+            body["config"] = config
+        if knowledge_config is not None:
+            body["knowledge_config"] = knowledge_config
+        return await self._post("/workflows/run", json=body, organization_id=organization_id)
+
+    async def get_state(self, thread_id: str, *, organization_id: str | None = None) -> Any:
+        """Return the current state of a workflow thread."""
+        return await self._get(f"/workflows/state/{thread_id}", organization_id=organization_id)
+
+    async def resume(
+        self,
+        thread_id: str,
+        run_id: str,
+        resume_value: Any,
+        *,
+        workflow_id: str | None = None,
+        workflow: dict[str, Any] | None = None,
+        stream: bool = True,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Resume a paused workflow thread with the provided resume value."""
+        body: dict[str, Any] = {
+            "run_id": run_id,
+            "resume_value": resume_value,
+            "stream": stream,
+        }
+        if workflow_id is not None:
+            body["workflow_id"] = workflow_id
+        if workflow is not None:
+            body["workflow"] = workflow
+        return await self._post(f"/workflows/resume/{thread_id}", json=body, organization_id=organization_id)
+
+    async def cancel(
+        self,
+        run_id: str,
+        *,
+        reason: str | None = None,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Cancel an in-progress workflow run by its run ID."""
+        body: dict[str, Any] = {}
+        if reason is not None:
+            body["reason"] = reason
+        return await self._post(
+            f"/workflows/cancel/{run_id}",
+            json=body or None,
+            organization_id=organization_id,
+        )
+
+    def listen(self, run_id: str, *, organization_id: str | None = None) -> EventSourceStream:
+        """Open an SSE stream to receive live events for a workflow run."""
+        return self._stream_sse(f"/workflows/listen/{run_id}", organization_id=organization_id)

modulex/resources/integrations.py

@@ -0,0 +1,110 @@
+"""Integrations resource for the ModuleX Python SDK."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from modulex._base import _BaseResource
+
+
+class Integrations(_BaseResource):
+    """Resource for browsing and inspecting available integrations."""
+
+    async def browse(
+        self,
+        *,
+        category: str | None = None,
+        type: str | None = None,
+        auth_type: str | None = None,
+        search: str | None = None,
+        include_details: bool = True,
+        paginate: bool = True,
+        page: int = 1,
+        page_size: int = 50,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Browse all available integrations with optional filters and pagination."""
+        params: dict[str, Any] = {
+            k: v
+            for k, v in {
+                "category": category,
+                "type": type,
+                "auth_type": auth_type,
+                "search": search,
+                "include_details": include_details,
+                "paginate": paginate,
+                "page": page,
+                "page_size": page_size,
+            }.items()
+            if v is not None
+        }
+        return await self._get("/integrations/browse", params=params, organization_id=organization_id)
+
+    async def tools(
+        self,
+        *,
+        category: str | None = None,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return available tool integrations, optionally filtered by category."""
+        params: dict[str, Any] = {k: v for k, v in {"category": category}.items() if v is not None}
+        return await self._get("/integrations/tools", params=params, organization_id=organization_id)
+
+    async def tool_detail(
+        self,
+        integration_name: str,
+        *,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return detailed information for a single tool integration by name."""
+        return await self._get(f"/integrations/tools/{integration_name}", organization_id=organization_id)
+
+    async def llm_providers(
+        self,
+        *,
+        category: str | None = None,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return available LLM provider integrations, optionally filtered by category."""
+        params: dict[str, Any] = {k: v for k, v in {"category": category}.items() if v is not None}
+        return await self._get("/integrations/llm-providers", params=params, organization_id=organization_id)
+
+    async def llm_provider_detail(
+        self,
+        provider_name: str,
+        *,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return detailed information for a single LLM provider by name."""
+        return await self._get(f"/integrations/llm-providers/{provider_name}", organization_id=organization_id)
+
+    async def knowledge_providers(
+        self,
+        *,
+        category: str | None = None,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return available knowledge provider integrations, optionally filtered by category."""
+        params: dict[str, Any] = {k: v for k, v in {"category": category}.items() if v is not None}
+        return await self._get("/integrations/knowledge-providers", params=params, organization_id=organization_id)
+
+    async def knowledge_provider_detail(
+        self,
+        provider_name: str,
+        *,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return detailed information for a single knowledge provider by name."""
+        return await self._get(
+            f"/integrations/knowledge-providers/{provider_name}",
+            organization_id=organization_id,
+        )
+
+    async def get(
+        self,
+        integration_name: str,
+        *,
+        organization_id: str | None = None,
+    ) -> Any:
+        """Return the integration record for a given integration name."""
+        return await self._get(f"/integrations/{integration_name}", organization_id=organization_id)