limely-sdk 0.0.0__tar.gz

limely_sdk-0.0.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.py[cod]
+dist/
+build/
+*.egg-info/
+.venv/

limely_sdk-0.0.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: limely-sdk
+Version: 0.0.0
+Summary: Official Python client for the Limely API (chatbots, knowledge bases, forms, conversations, analytics).
+Project-URL: Homepage, https://limely.co
+License: MIT
+Keywords: api-client,chatbot,limely,sdk
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# limely-sdk (Python)
+
+Official Python client for the [Limely](https://limely.co) API. Manage chatbots,
+knowledge bases, forms, conversations, and analytics.
+
+## Install
+
+```bash
+pip install limely-sdk
+```
+
+Imports as `limely`.
+
+## Auth
+
+The Limely API authenticates with a Clerk bearer token and scopes every call to
+the token owner's workspace.
+
+```python
+from limely import LimelyClient
+
+with LimelyClient(token="...") as limely:
+    types = limely.chatbot_types.list()
+
+    kb = limely.knowledge_bases.create_from_text(
+        name="Support docs",
+        content="Our return window is 30 days...",
+    )
+
+    bot = limely.chatbots.create(
+        name="Support bot",
+        chatbot_type_id=types[0]["_id"],
+        knowledge_base_ids=[kb["_id"]],
+    )
+
+    stats = limely.analytics.chatbot(bot["_id"], start="2026-06-01", end="2026-06-30")
+```
+
+## API
+
+- `workspace.get()`
+- `chatbot_types.list()`
+- `chatbots.list() | get(id) | create(...) | toggle_status(id) | delete(id)`
+- `knowledge_bases.list() | create_from_text(...) | delete(id)`
+- `forms.list() | get(id) | create(...) | submissions(id) | templates()`
+- `analytics.dashboard() | billing() | chatbot(id, start=, end=)`
+- `chats.list(start_date=, end_date=) | get(session_id)`
+
+Errors are raised as `LimelyApiError` with `.status_code` and `.body`.
+
+## Requirements
+
+Python >= 3.9. Depends on `httpx`.

limely_sdk-0.0.0/README.md

@@ -0,0 +1,53 @@
+# limely-sdk (Python)
+
+Official Python client for the [Limely](https://limely.co) API. Manage chatbots,
+knowledge bases, forms, conversations, and analytics.
+
+## Install
+
+```bash
+pip install limely-sdk
+```
+
+Imports as `limely`.
+
+## Auth
+
+The Limely API authenticates with a Clerk bearer token and scopes every call to
+the token owner's workspace.
+
+```python
+from limely import LimelyClient
+
+with LimelyClient(token="...") as limely:
+    types = limely.chatbot_types.list()
+
+    kb = limely.knowledge_bases.create_from_text(
+        name="Support docs",
+        content="Our return window is 30 days...",
+    )
+
+    bot = limely.chatbots.create(
+        name="Support bot",
+        chatbot_type_id=types[0]["_id"],
+        knowledge_base_ids=[kb["_id"]],
+    )
+
+    stats = limely.analytics.chatbot(bot["_id"], start="2026-06-01", end="2026-06-30")
+```
+
+## API
+
+- `workspace.get()`
+- `chatbot_types.list()`
+- `chatbots.list() | get(id) | create(...) | toggle_status(id) | delete(id)`
+- `knowledge_bases.list() | create_from_text(...) | delete(id)`
+- `forms.list() | get(id) | create(...) | submissions(id) | templates()`
+- `analytics.dashboard() | billing() | chatbot(id, start=, end=)`
+- `chats.list(start_date=, end_date=) | get(session_id)`
+
+Errors are raised as `LimelyApiError` with `.status_code` and `.body`.
+
+## Requirements
+
+Python >= 3.9. Depends on `httpx`.

limely_sdk-0.0.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "limely-sdk"
+dynamic = ["version"]
+description = "Official Python client for the Limely API (chatbots, knowledge bases, forms, conversations, analytics)."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+keywords = ["limely", "sdk", "chatbot", "api-client"]
+dependencies = ["httpx>=0.27"]
+
+[project.urls]
+Homepage = "https://limely.co"
+
+[tool.hatch.version]
+source = "vcs"
+# The release tag is `vX.Y.Z`; strip the local segment so PyPI accepts it.
+# fallback_version is used when building outside a tagged commit (local dev).
+raw-options = { local_scheme = "no-local-version", fallback_version = "0.0.0" }
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/limely"]

limely_sdk-0.0.0/src/limely/__init__.py

@@ -0,0 +1,5 @@
+"""Official Python client for the Limely API."""
+
+from .client import LimelyClient, LimelyApiError
+
+__all__ = ["LimelyClient", "LimelyApiError"]

limely_sdk-0.0.0/src/limely/client.py

@@ -0,0 +1,264 @@
+"""Synchronous client for the Limely API.
+
+The Limely API authenticates with a Clerk bearer token and scopes every call to
+the token owner's workspace. Construct the client with that token::
+
+    from limely import LimelyClient
+
+    limely = LimelyClient(token="...")
+    bots = limely.chatbots.list()
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Mapping, Optional, Sequence
+
+import httpx
+
+DEFAULT_BASE_URL = "https://api.limely.co"
+DEFAULT_TIMEOUT = 30.0
+
+
+class LimelyApiError(Exception):
+    """Raised when the Limely API returns a non-2xx response."""
+
+    def __init__(self, status_code: int, body: Any) -> None:
+        self.status_code = status_code
+        self.body = body
+        detail = body if isinstance(body, str) else json.dumps(body)
+        super().__init__(f"Limely API responded {status_code}: {detail}")
+
+
+def _clean_params(params: Optional[Mapping[str, Any]]) -> dict[str, Any]:
+    if not params:
+        return {}
+    return {k: v for k, v in params.items() if v is not None and v != ""}
+
+
+class LimelyClient:
+    """Client for the Limely API."""
+
+    def __init__(
+        self,
+        token: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = DEFAULT_TIMEOUT,
+        http_client: Optional[httpx.Client] = None,
+    ) -> None:
+        if not token:
+            raise ValueError("LimelyClient requires a `token`.")
+        self._client = http_client or httpx.Client(
+            base_url=base_url.rstrip("/"),
+            timeout=timeout,
+            headers={
+                "Authorization": f"Bearer {token}",
+                "Accept": "application/json",
+            },
+        )
+        self.workspace = _WorkspaceResource(self)
+        self.chatbot_types = _ChatbotTypesResource(self)
+        self.chatbots = _ChatbotsResource(self)
+        self.knowledge_bases = _KnowledgeBasesResource(self)
+        self.forms = _FormsResource(self)
+        self.analytics = _AnalyticsResource(self)
+        self.chats = _ChatsResource(self)
+
+    # -- low-level ----------------------------------------------------------
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Optional[Mapping[str, Any]] = None,
+        json_body: Any = None,
+        data: Optional[Mapping[str, Any]] = None,
+        files: Optional[Mapping[str, Any]] = None,
+    ) -> Any:
+        response = self._client.request(
+            method,
+            path,
+            params=_clean_params(params),
+            json=json_body,
+            data=data,
+            files=files,
+        )
+        text = response.text
+        try:
+            parsed: Any = response.json() if text else None
+        except ValueError:
+            parsed = text
+        if response.is_error:
+            raise LimelyApiError(response.status_code, parsed)
+        return parsed
+
+    # -- lifecycle ----------------------------------------------------------
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> "LimelyClient":
+        return self
+
+    def __exit__(self, *_exc: object) -> None:
+        self.close()
+
+
+class _Resource:
+    def __init__(self, client: LimelyClient) -> None:
+        self._c = client
+
+
+class _WorkspaceResource(_Resource):
+    def get(self) -> Any:
+        return self._c.request("GET", "/workspace")
+
+
+class _ChatbotTypesResource(_Resource):
+    def list(self) -> Any:
+        return self._c.request("GET", "/chatbot-type")
+
+
+class _ChatbotsResource(_Resource):
+    def list(self) -> Any:
+        return self._c.request("GET", "/chatbot")
+
+    def get(self, chatbot_id: str) -> Any:
+        return self._c.request("GET", f"/chatbot/{chatbot_id}")
+
+    def create(
+        self,
+        *,
+        name: str,
+        chatbot_type_id: str,
+        knowledge_base_ids: Sequence[str],
+        description: Optional[str] = None,
+        voice_chat: Optional[bool] = None,
+        rate_limiting: Optional[int] = None,
+        behavior: Optional[Mapping[str, Any]] = None,
+        appearance: Optional[Mapping[str, Any]] = None,
+    ) -> Any:
+        body: dict[str, Any] = {
+            "name": name,
+            "chatbotTypeId": chatbot_type_id,
+            "knowledgeBaseIds": list(knowledge_base_ids),
+        }
+        if description is not None:
+            body["description"] = description
+        if voice_chat is not None:
+            body["voice_chat"] = voice_chat
+        if rate_limiting is not None:
+            body["rateLimiting"] = rate_limiting
+        if behavior is not None:
+            body["behavior"] = dict(behavior)
+        if appearance is not None:
+            body["appearance"] = dict(appearance)
+        return self._c.request("POST", "/chatbot", json_body=body)
+
+    def toggle_status(self, chatbot_id: str) -> Any:
+        return self._c.request("PATCH", f"/chatbot/{chatbot_id}/toggle-status")
+
+    def delete(self, chatbot_id: str) -> Any:
+        return self._c.request("DELETE", f"/chatbot/{chatbot_id}")
+
+
+class _KnowledgeBasesResource(_Resource):
+    def list(self) -> Any:
+        return self._c.request("GET", "/knowledgeBase")
+
+    def create_from_text(
+        self,
+        *,
+        name: str,
+        content: str,
+        description: Optional[str] = None,
+        tags: Optional[Sequence[str]] = None,
+        filename: Optional[str] = None,
+    ) -> Any:
+        data: dict[str, Any] = {
+            "name": name,
+            "fileCharacter": json.dumps([{"characters": len(content)}]),
+        }
+        if description is not None:
+            data["description"] = description
+        if tags:
+            data["tags"] = json.dumps(list(tags))
+        base = (filename or f"{name}.txt").strip()
+        if not base.endswith(".txt"):
+            base = f"{base}.txt"
+        files = {"files": (base, content.encode("utf-8"), "text/plain")}
+        return self._c.request("POST", "/knowledgeBase", data=data, files=files)
+
+    def delete(self, knowledge_base_id: str) -> Any:
+        return self._c.request("DELETE", f"/knowledgeBase/{knowledge_base_id}")
+
+
+class _FormsResource(_Resource):
+    def list(self) -> Any:
+        return self._c.request("GET", "/forms")
+
+    def get(self, form_id: str) -> Any:
+        return self._c.request("GET", f"/forms/{form_id}")
+
+    def create(
+        self,
+        *,
+        name: str,
+        form_type: Optional[str] = None,
+        status: Optional[str] = None,
+        questions: Optional[Sequence[Mapping[str, Any]]] = None,
+        theme_settings: Optional[Mapping[str, Any]] = None,
+    ) -> Any:
+        body: dict[str, Any] = {"name": name}
+        if form_type is not None:
+            body["form_type"] = form_type
+        if status is not None:
+            body["status"] = status
+        if questions is not None:
+            body["questions"] = [dict(q) for q in questions]
+        if theme_settings is not None:
+            body["theme_settings"] = dict(theme_settings)
+        return self._c.request("POST", "/forms", json_body=body)
+
+    def submissions(self, form_id: str) -> Any:
+        return self._c.request("GET", f"/forms/{form_id}/submissions")
+
+    def templates(self) -> Any:
+        return self._c.request("GET", "/form-templates")
+
+
+class _AnalyticsResource(_Resource):
+    def dashboard(self) -> Any:
+        return self._c.request("GET", "/analytics/dashboard")
+
+    def billing(self) -> Any:
+        return self._c.request("GET", "/analytics/billing")
+
+    def chatbot(
+        self,
+        chatbot_id: str,
+        *,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+    ) -> Any:
+        return self._c.request(
+            "GET",
+            f"/analytics/chatbot/{chatbot_id}",
+            params={"start": start, "end": end},
+        )
+
+
+class _ChatsResource(_Resource):
+    def list(
+        self,
+        *,
+        start_date: Optional[str] = None,
+        end_date: Optional[str] = None,
+    ) -> Any:
+        return self._c.request(
+            "GET",
+            "/chats/user",
+            params={"startDate": start_date, "endDate": end_date},
+        )
+
+    def get(self, session_id: str) -> Any:
+        return self._c.request("GET", f"/chats/session/{session_id}")