wexa-sdk 0.1.0__tar.gz

wexa_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: wexa-sdk
+Version: 0.1.0
+Summary: Official Wexa Python SDK
+Author: Wexa
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/wexa-ai/wexa-sdk
+Keywords: wexa,sdk,api
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.6
+
+# wexa-sdk (Python)
+
+Python SDK for Wexa API.
+
+```python
+from wexa_sdk import WexaClient
+```

wexa_sdk-0.1.0/README.md

@@ -0,0 +1,7 @@
+# wexa-sdk (Python)
+
+Python SDK for Wexa API.
+
+```python
+from wexa_sdk import WexaClient
+```

wexa_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wexa-sdk"
+version = "0.1.0"
+description = "Official Wexa Python SDK"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "Apache-2.0" }
+keywords = ["wexa", "sdk", "api"]
+authors = [{ name = "Wexa" }]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: Apache Software License",
+  "Programming Language :: Python :: 3 :: Only",
+]
+dependencies = [
+  "httpx>=0.27",
+  "pydantic>=2.6",
+]
+
+[project.urls]
+Homepage = "https://github.com/wexa-ai/wexa-sdk"
+
+[tool.setuptools]
+packages = ["wexa_sdk", "wexa_sdk.connectors", "wexa_sdk.models"]
+include-package-data = true

wexa_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

wexa_sdk-0.1.0/wexa_sdk/__init__.py

@@ -0,0 +1,37 @@
+from .core.http import HttpClient
+from .agentflows import AgentFlows
+from .executions import Executions
+from .tables import Tables
+from .connectors.core import Connectors
+from .projects import Projects
+from .skills import Skills
+from .tasks import Tasks
+from .inbox import Inbox
+from .settings import Settings
+from .marketplace import Marketplace
+from .analytics import Analytics
+from .project_members import ProjectMembers
+from .connectors_mgmt import ConnectorsMgmt
+from .files import Files
+
+class WexaClient:
+    def __init__(self, base_url: str, api_key: str, user_agent: str | None = None, timeout: dict | None = None, retries: dict | None = None, polling: dict | None = None):
+        self.http = HttpClient(base_url=base_url, api_key=api_key, user_agent=user_agent, timeout=timeout, retries=retries)
+        self.agentflows = AgentFlows(self.http)
+        self.executions = Executions(self.http, polling or {})
+        self.tables = Tables(self.http)
+        self.connectors = Connectors(self.http)
+        self.projects = Projects(self.http)
+        self.skills = Skills(self.http)
+        self.tasks = Tasks(self.http)
+        self.inbox = Inbox(self.http)
+        self.settings = Settings(self.http)
+        self.marketplace = Marketplace(self.http)
+        self.analytics = Analytics(self.http)
+        self.project_members = ProjectMembers(self.http)
+        self.connectors_mgmt = ConnectorsMgmt(self.http)
+        self.files = Files(self.http)
+
+    def _action(self, *args, **kwargs):
+        # Kept for backward compatibility; delegate to connectors.action
+        return self.connectors.action(*args, **kwargs)

wexa_sdk-0.1.0/wexa_sdk/agentflows.py

@@ -0,0 +1,37 @@
+from .core.http import HttpClient
+
+class AgentFlows:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(
+        self,
+        project_id: str | None = None,
+        projectID: str | None = None,
+        skip: int | None = None,
+        limit: int | None = None,
+    ):
+        # API expects 'projectID' (capital D); accept both and normalize
+        pid = projectID or project_id
+        params: dict | None = None
+        if pid is not None or skip is not None or limit is not None:
+            params = {}
+            if pid is not None:
+                params["projectID"] = pid
+            if skip is not None:
+                params["skip"] = skip
+            if limit is not None:
+                params["limit"] = limit
+        return self.http.request("GET", "/agentflows", params=params)
+
+    def get(self, id: str):
+        return self.http.request("GET", f"/agentflow/{id}")
+
+    def create(self, body: dict):
+        return self.http.request("POST", "/agentflow/", json=body)
+
+    def update(self, id: str, body: dict):
+        return self.http.request("PUT", f"/agentflow/{id}", json=body)
+
+    def delete(self, project_id: str, id: str):
+        return self.http.request("DELETE", f"/agentflow/{project_id}/{id}")

wexa_sdk-0.1.0/wexa_sdk/analytics.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+from typing import Any
+
+from .core.http import HttpClient
+
+class Analytics:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    # GET /analytics?projectID=...
+    def get(self, project_id: str) -> Any:
+        return self.http.request("GET", "/analytics", params={"projectID": project_id})

wexa_sdk-0.1.0/wexa_sdk/connectors/__init__.py

@@ -0,0 +1 @@
+from .google_drive import GoogleDrive  # re-export

wexa_sdk-0.1.0/wexa_sdk/connectors/core.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+from typing import Any, Optional
+
+from ..core.http import HttpClient
+from .google_drive import GoogleDrive
+
+class Connectors:
+    def __init__(self, http: HttpClient):
+        self.http = http
+        self.google_drive = GoogleDrive(http)
+
+    # POST /actions/{CATEGORY}/{ACTION}/{connector_id?}
+    def action(self, category: str, action: str, connector_id: Optional[str] = None, *, body: Optional[dict] = None, projectID: Optional[str] = None) -> Any:
+        path = f"/actions/{category}/{action}/{connector_id}" if connector_id else f"/actions/{category}/{action}"
+        params = {"projectID": projectID} if projectID else None
+        return self.http.request("POST", path, params=params, json=body)
+
+    # POST /actions/{CATEGORY}/config?projectID=...
+    def set_config(self, category: str, project_id: str, body: dict) -> Any:
+        return self.http.request("POST", f"/actions/{category}/config", params={"projectID": project_id}, json=body)
+
+    # GET /actions/{CATEGORY}/config/{projectID}
+    def get_config(self, category: str, project_id: str) -> Any:
+        return self.http.request("GET", f"/actions/{category}/config/{project_id}")

wexa_sdk-0.1.0/wexa_sdk/connectors/google_drive.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+from typing import Any, Dict, Optional
+
+from ..core.http import HttpClient
+
+class GoogleDrive:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list_files(self, connector_id: str, *, folder_id: str, page_size: Optional[int] = None, page_token: Optional[str] = None, fetch_all: Optional[bool] = None):
+        body: Dict[str, Any] = {"folder_id": folder_id}
+        if page_size is not None:
+            body["page_size"] = page_size
+        if page_token is not None:
+            body["page_token"] = page_token
+        if fetch_all is not None:
+            body["fetch_all"] = fetch_all
+        return self.http.request("POST", f"/actions/google_drive/list_files/{connector_id}", json=body)
+
+    def read(self, connector_id: str, *, file_id: str):
+        body = {"file_id": file_id}
+        return self.http.request("POST", f"/actions/google_drive/read/{connector_id}", json=body)

wexa_sdk-0.1.0/wexa_sdk/connectors_mgmt.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+from typing import Any, Optional
+
+from .core.http import HttpClient
+
+class ConnectorsMgmt:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    # GET /connectors/?projectID=...
+    def list(self, project_id: Optional[str] = None) -> Any:
+        params = {"projectID": project_id} if project_id else None
+        return self.http.request("GET", "/connectors/", params=params)
+
+    # GET /connectors/{projectID}
+    def list_by_project_id(self, project_id: str) -> Any:
+        return self.http.request("GET", f"/connectors/{project_id}")
+
+    # GET /v1/connector/{id}
+    def get_by_id(self, connector_id: str) -> Any:
+        return self.http.request("GET", f"/v1/connector/{connector_id}")
+
+    # GET /connector/{connector_id}
+    def get_by_id_path(self, connector_id: str) -> Any:
+        return self.http.request("GET", f"/connector/{connector_id}")
+
+    # DELETE /v1/connector/{id}?projectID=...
+    def delete(self, connector_id: str, *, project_id: Optional[str] = None) -> Any:
+        params = {"projectID": project_id} if project_id else None
+        return self.http.request("DELETE", f"/v1/connector/{connector_id}", params=params)
+
+    # DELETE /connector/{connector_id}?projectID=...
+    def delete_by_id_path(self, connector_id: str, *, project_id: str) -> Any:
+        return self.http.request("DELETE", f"/connector/{connector_id}", params={"projectID": project_id})
+
+    # POST /connectors/change_status
+    def update_status(self, *, new_status: str, connectorID: str, data_loader_config: dict) -> Any:
+        body = {"new_status": new_status, "connectorID": connectorID, "data_loader_config": data_loader_config}
+        return self.http.request("POST", "/connectors/change_status", json=body)
+
+    # GET /connectors/trigger_actions?projectID=...
+    def list_trigger_actions(self, project_id: str) -> Any:
+        return self.http.request("GET", "/connectors/trigger_actions", params={"projectID": project_id})
+
+    # GET /connectors/{projectID}/trigger_actions
+    def list_trigger_actions_by_project(self, project_id: str) -> Any:
+        return self.http.request("GET", f"/connectors/{project_id}/trigger_actions", params={"projectID": project_id})

wexa_sdk-0.1.0/wexa_sdk/executions.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+import time
+from typing import Any, Callable, Optional
+
+from .core.http import HttpClient
+
+DEFAULT_TERMINAL = {"completed", "failed", "canceled"}
+
+class Executions:
+    def __init__(self, http: HttpClient, polling: Optional[dict] = None):
+        self.http = http
+        self.polling = polling or {}
+
+    def start(self, payload: dict, *, projectID: Optional[str] = None):
+        params = {"projectID": projectID} if projectID else None
+        return self.http.request("POST", "/execute_flow", json=payload, params=params)
+
+    def get(self, execution_id: str):
+        return self.http.request("GET", f"/execute_flow/{execution_id}")
+
+    def monitor(self, agentflow_id: str):
+        return self.http.request("GET", f"/execute_flow/{agentflow_id}/monitor")
+
+    def pause(self, execution_id: str):
+        return self.http.request("POST", f"/execute_flow/{execution_id}/pause")
+
+    def resume(self, execution_id: str):
+        return self.http.request("POST", f"/execute_flow/{execution_id}/resume")
+
+    def cancel(self, execution_id: str):
+        return self.http.request("POST", f"/execute_flow/{execution_id}/cancel")
+
+    def approve_preview(self, execution_id: str):
+        return self.http.request("PUT", f"/execute_flow/{execution_id}/approve_preview")
+
+    def approve_anomaly(self, execution_id: str):
+        return self.http.request("PUT", f"/execute_flow/{execution_id}/approve_anomaly")
+
+    def update_runtime_input(self, execution_id: str, body: dict):
+        return self.http.request("PUT", f"/execute_flow/{execution_id}/runtime_input", json=body)
+
+    def wait(self, execution_id: str, *, interval_ms: Optional[int] = None, timeout_ms: Optional[int] = None, is_terminal: Optional[Callable[[str], bool]] = None):
+        interval = interval_ms or self.polling.get("intervalMs", 2000)
+        timeout = timeout_ms or self.polling.get("timeoutMs", 30 * 60 * 1000)
+        jitter = self.polling.get("jitter", 0.2)
+        term = is_terminal or (lambda s: (s or "").lower() in DEFAULT_TERMINAL)
+
+        start = time.time()
+        while True:
+            info = self.get(execution_id)
+            status = (info.get("status") or info.get("state") or "").lower()
+            if term(status):
+                return info
+            if (time.time() - start) * 1000 > timeout:
+                raise TimeoutError("Execution wait timeout")
+            j = 1 + ((2 * (time.time() % 1) - 1) * jitter)
+            time.sleep(max(0.2, (interval * j) / 1000))

wexa_sdk-0.1.0/wexa_sdk/files.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+from typing import Any, Dict, Optional
+
+from .core.http import HttpClient
+
+class Files:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    # POST /files/upload?projectID=...&container_name=...
+    # body example: { "filenames": ["file.pdf"], "tags": ["resume"], "source_type": "STORAGE", "org_id": "..." }
+    def upload_request(self, project_id: str, container_name: str, body: Dict[str, Any]):
+        params: Dict[str, Any] = {"projectID": project_id, "container_name": container_name}
+        return self.http.request("POST", "/files/upload", params=params, json=body)
+
+    # GET /file/{fileId}/?projectID=...
+    def get_by_file_id(self, file_id: str, project_id: Optional[str] = None):
+        params = {"projectID": project_id} if project_id else None
+        return self.http.request("GET", f"/file/{file_id}/", params=params)
+
+    # GET /files/{connectorId}/connector/
+    def list_by_connector(self, connector_id: str):
+        return self.http.request("GET", f"/files/{connector_id}/connector/")

wexa_sdk-0.1.0/wexa_sdk/inbox.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+from typing import Any, Dict, Optional
+
+from .core.http import HttpClient
+
+class Inbox:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    # POST /inbox/create
+    def create(self, body: Dict[str, Any]):
+        return self.http.request("POST", "/inbox/create", json=body)
+
+    # GET /inbox?projectID=...&limit=...
+    def list(self, project_id: str, *, limit: Optional[int] = None):
+        params: Dict[str, Any] = {"projectID": project_id}
+        if limit is not None:
+            params["limit"] = limit
+        return self.http.request("GET", "/inbox", params=params)
+
+    # POST /inbox/update/runtime_input/?projectID=...
+    def update_runtime(self, project_id: str, body: Dict[str, Any]):
+        return self.http.request("POST", "/inbox/update/runtime_input/", params={"projectID": project_id}, json=body)
+
+    # POST /inbox/update/anomaly_detection/?projectID=...
+    def update_anomaly(self, project_id: str, body: Dict[str, Any]):
+        return self.http.request("POST", "/inbox/update/anomaly_detection/", params={"projectID": project_id}, json=body)
+
+    # POST /inbox/update/preview/?projectID=...
+    def update_preview(self, project_id: str, body: Dict[str, Any]):
+        return self.http.request("POST", "/inbox/update/preview/", params={"projectID": project_id}, json=body)
+
+    # POST /inbox/update/preview/{execution_id}?projectID=...
+    def update_preview_by_execution(self, execution_id: str, body: Dict[str, Any], project_id: Optional[str] = None):
+        params = {"projectID": project_id} if project_id else None
+        return self.http.request("POST", f"/inbox/update/preview/{execution_id}", params=params, json=body)
+
+    # GET /inbox/{id}?projectID=...
+    def get(self, inbox_id: str, project_id: Optional[str] = None):
+        params = {"projectID": project_id} if project_id else None
+        return self.http.request("GET", f"/inbox/{inbox_id}", params=params)

wexa_sdk-0.1.0/wexa_sdk/marketplace.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+from typing import Any, Dict
+
+from .core.http import HttpClient
+
+class Marketplace:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    # GET /public/connectors/all?search_key=...&projectID=...&filter_type=...
+    def list_connectors(self, *, search_key: str, projectID: str, filter_type: str):
+        params: Dict[str, Any] = {"search_key": search_key, "projectID": projectID, "filter_type": filter_type}
+        return self.http.request("GET", "/public/connectors/all", params=params)
+
+    # GET /public/marketplace/coworkers?search_key=...&limit=...
+    def list_coworkers(self, *, search_key: str, limit: int | str):
+        params: Dict[str, Any] = {"search_key": search_key, "limit": limit}
+        return self.http.request("GET", "/public/marketplace/coworkers", params=params)
+
+    # GET /public/marketplace/coworker/{coworker_id}
+    def get_coworker_by_id(self, coworker_id: str):
+        return self.http.request("GET", f"/public/marketplace/coworker/{coworker_id}")
+
+    # POST /marketplace/coworker/{coworker_id}/purchase?organization_id=...
+    def purchase_coworker(self, coworker_id: str, *, organization_id: str, body: Dict[str, Any] | None = None):
+        params = {"organization_id": organization_id}
+        return self.http.request("POST", f"/marketplace/coworker/{coworker_id}/purchase", params=params, json=(body or {}))
+
+    # GET /marketplace/coworker/update/{coworker_id}/check
+    def check_coworker_update(self, coworker_id: str):
+        return self.http.request("GET", f"/marketplace/coworker/update/{coworker_id}/check")

wexa_sdk-0.1.0/wexa_sdk/models/__init__.py

@@ -0,0 +1 @@
+# Placeholder for pydantic models (to be added as API payloads stabilize).

wexa_sdk-0.1.0/wexa_sdk/project_members.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from typing import Any
+
+from .core.http import HttpClient
+
+class ProjectMembers:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    # GET /project-member/{projectID}/summary
+    def summary(self, project_id: str) -> Any:
+        return self.http.request("GET", f"/project-member/{project_id}/summary")
+
+    # GET /project-member/{projectID}
+    def list(self, project_id: str) -> Any:
+        return self.http.request("GET", f"/project-member/{project_id}")

wexa_sdk-0.1.0/wexa_sdk/projects.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+from typing import Optional, Dict, Any
+
+from .core.http import HttpClient
+
+class Projects:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    # Per developers.wexa.ai: POST https://api.wexa.ai/v1/project
+    def create(self, body: Dict[str, Any]):
+        """
+        Expected body (example):
+        {
+          "orgId": "67fdea40aac77be632954f0f",
+          "projectName": "New",
+          "description": "yoooo",
+          "coworker_role": "testrole"
+        }
+        """
+        return self.http.request("POST", "/v1/project", json=body)
+
+    def list(self):
+        return self.http.request("GET", "/v1/project")
+
+    def get(self, project_id: str):
+        return self.http.request("GET", f"/v1/project/{project_id}")
+
+    def update(self, project_id: str, body: Dict[str, Any]):
+        return self.http.request("PUT", f"/v1/project/{project_id}", json=body)
+
+    def delete(self, project_id: str):
+        return self.http.request("DELETE", f"/v1/project/{project_id}")

wexa_sdk-0.1.0/wexa_sdk/settings.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from .core.http import HttpClient
+
+class Settings:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    # GET /settings/{projectID}
+    def get(self, project_id: str):
+        return self.http.request("GET", f"/settings/{project_id}")

wexa_sdk-0.1.0/wexa_sdk/skills.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+from typing import Any, Dict, Optional
+
+from .core.http import HttpClient
+
+class Skills:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    # POST /skills/
+    def create(self, body: Dict[str, Any]):
+        return self.http.request("POST", "/skills/", json=body)
+
+    # GET /skills/?projectID=...&limit=...
+    def list(self, project_id: str, *, limit: Optional[int] = None):
+        params: Dict[str, Any] = {"projectID": project_id}
+        if limit is not None:
+            params["limit"] = limit
+        return self.http.request("GET", "/skills/", params=params)
+
+    # GET /skills/category?projectId=...&category=...&limit=...
+    def list_by_category(self, project_id: str, category: str, *, limit: Optional[int] = None):
+        params: Dict[str, Any] = {"projectId": project_id, "category": category}
+        if limit is not None:
+            params["limit"] = limit
+        return self.http.request("GET", "/skills/category", params=params)
+
+    # GET /skills/{id}
+    def get_by_id(self, skill_id: str):
+        return self.http.request("GET", f"/skills/{skill_id}")
+
+    # GET /skills/?name=...&projectID=...
+    def get_by_name(self, name: str, project_id: str):
+        params = {"name": name, "projectID": project_id}
+        return self.http.request("GET", "/skills/", params=params)

wexa_sdk-0.1.0/wexa_sdk/tables.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+from typing import Any, Optional
+
+from .core.http import HttpClient
+
+class Tables:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    # Tables
+    def create_table(self, project_id: str, spec: dict):
+        # API expects projectID as query param and in body with 'projectID' casing
+        params = {"projectID": project_id}
+        body = {"projectID": project_id, **spec}
+        return self.http.request("POST", "/create/table", params=params, json=body)
+
+    def list_tables(self, project_id: str):
+        return self.http.request("GET", f"/storage/{project_id}")
+
+    def get_table(self, project_id: str, table_id: str):
+        return self.http.request("GET", f"/storage/{project_id}/{table_id}")
+
+    def get_table_view(self, table_id: str):
+        return self.http.request("GET", f"/table/view/{table_id}")
+
+    def rename_table(self, project_id: str, table_id: str, new_name: str):
+        return self.http.request("POST", f"/table/rename/{project_id}", json={"tableId": table_id, "newName": new_name})
+
+    # Columns
+    def get_columns(self, project_id: str, table_id: str):
+        return self.http.request("GET", f"/column/storage/{project_id}/{table_id}")
+
+    def edit_columns(self, table_id: str, spec: dict):
+        return self.http.request("POST", f"/edit/columns/{table_id}", json=spec)
+
+    def delete_column(self, project_id: str, column_id: str):
+        return self.http.request("DELETE", f"/delete/column/{project_id}", json={"columnId": column_id})
+
+    # Records
+    def create_record(self, project_id: str, table_id: str, record: dict):
+        return self.http.request("POST", f"/storage/{project_id}/{table_id}", json=record)
+
+    def get_record(self, project_id: str, table_id: str, record_id: str):
+        return self.http.request("GET", f"/storage/{project_id}/{table_id}/{record_id}")
+
+    def update_record(self, project_id: str, table_id: str, record_id: str, record: dict):
+        return self.http.request("PUT", f"/storage/{project_id}/{table_id}/{record_id}", json=record)
+
+    def delete_record(self, project_id: str, table_id: str, record_id: str):
+        return self.http.request("DELETE", f"/storage/{project_id}/{table_id}/{record_id}")
+
+    def list_records(self, project_id: str, table_id: str, query: Optional[dict] = None):
+        return self.http.request("GET", f"/storage/{project_id}/{table_id}", params=query)
+
+    def bulk_upsert(self, project_id: str, table_id: str, records: list[dict]):
+        return self.http.request("POST", f"/bulk/storage/{project_id}/{table_id}", json={"records": records})
+
+    def export(self, project_id: str, table_id: str):
+        return self.http.request("GET", f"/table_data/storage/{table_id}/export")

wexa_sdk-0.1.0/wexa_sdk/tasks.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+from typing import Any, Dict, Optional
+
+from .core.http import HttpClient
+
+class Tasks:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    # GET /tasks/?projectID=...&limit=...&skip=...&created_by=...
+    def list(self, project_id: str, *, limit: Optional[int] = None, skip: Optional[int] = None, created_by: Optional[str] = None):
+        params: Dict[str, Any] = {"projectID": project_id}
+        if limit is not None:
+            params["limit"] = limit
+        if skip is not None:
+            params["skip"] = skip
+        if created_by:
+            params["created_by"] = created_by
+        return self.http.request("GET", "/tasks/", params=params)
+
+    # GET /task/{id}?projectID=...
+    def get(self, task_id: str, project_id: Optional[str] = None):
+        params = {"projectID": project_id} if project_id else None
+        return self.http.request("GET", f"/task/{task_id}", params=params)
+
+    # POST /task/{id}/pause
+    def pause(self, task_id: str):
+        return self.http.request("POST", f"/task/{task_id}/pause")
+
+    # POST /task/{id}/resume
+    def resume(self, task_id: str):
+        return self.http.request("POST", f"/task/{task_id}/resume")
+
+    # POST /task/{id}/stop
+    def stop(self, task_id: str):
+        return self.http.request("POST", f"/task/{task_id}/stop")

wexa_sdk-0.1.0/wexa_sdk.egg-info/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: wexa-sdk
+Version: 0.1.0
+Summary: Official Wexa Python SDK
+Author: Wexa
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/wexa-ai/wexa-sdk
+Keywords: wexa,sdk,api
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.6
+
+# wexa-sdk (Python)
+
+Python SDK for Wexa API.
+
+```python
+from wexa_sdk import WexaClient
+```

wexa_sdk-0.1.0/wexa_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+README.md
+pyproject.toml
+wexa_sdk/__init__.py
+wexa_sdk/agentflows.py
+wexa_sdk/analytics.py
+wexa_sdk/connectors_mgmt.py
+wexa_sdk/executions.py
+wexa_sdk/files.py
+wexa_sdk/inbox.py
+wexa_sdk/marketplace.py
+wexa_sdk/project_members.py
+wexa_sdk/projects.py
+wexa_sdk/settings.py
+wexa_sdk/skills.py
+wexa_sdk/tables.py
+wexa_sdk/tasks.py
+wexa_sdk.egg-info/PKG-INFO
+wexa_sdk.egg-info/SOURCES.txt
+wexa_sdk.egg-info/dependency_links.txt
+wexa_sdk.egg-info/requires.txt
+wexa_sdk.egg-info/top_level.txt
+wexa_sdk/connectors/__init__.py
+wexa_sdk/connectors/core.py
+wexa_sdk/connectors/google_drive.py
+wexa_sdk/models/__init__.py

wexa_sdk-0.1.0/wexa_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

wexa_sdk-0.1.0/wexa_sdk.egg-info/requires.txt

@@ -0,0 +1,2 @@
+httpx>=0.27
+pydantic>=2.6

wexa_sdk-0.1.0/wexa_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+wexa_sdk