liveblocks 3.15.3__py3-none-any.whl

liveblocks/__init__.py

@@ -0,0 +1,12 @@
+"""A client library for accessing Liveblocks API"""
+
+from .client import AsyncLiveblocks, Liveblocks
+from .errors import LiveblocksError
+from .webhooks import WebhookHandler
+
+__all__ = (
+    "AsyncLiveblocks",
+    "Liveblocks",
+    "LiveblocksError",
+    "WebhookHandler",
+)

liveblocks/api/__init__.py

@@ -0,0 +1 @@
+"""Contains methods for accessing the API"""

liveblocks/api/ai/__init__.py

@@ -0,0 +1 @@
+"""Contains endpoint functions for accessing the API"""

liveblocks/api/ai/create_ai_copilot.py

@@ -0,0 +1,124 @@
+from typing import Any
+
+import httpx
+
+from ... import errors
+from ...models.ai_copilot_anthropic import AiCopilotAnthropic
+from ...models.ai_copilot_google import AiCopilotGoogle
+from ...models.ai_copilot_open_ai import AiCopilotOpenAi
+from ...models.ai_copilot_open_ai_compatible import AiCopilotOpenAiCompatible
+from ...models.create_ai_copilot_options_anthropic import CreateAiCopilotOptionsAnthropic
+from ...models.create_ai_copilot_options_google import CreateAiCopilotOptionsGoogle
+from ...models.create_ai_copilot_options_open_ai import CreateAiCopilotOptionsOpenAi
+from ...models.create_ai_copilot_options_open_ai_compatible import CreateAiCopilotOptionsOpenAiCompatible
+
+
+def _get_kwargs(
+    *,
+    body: CreateAiCopilotOptionsAnthropic
+    | CreateAiCopilotOptionsGoogle
+    | CreateAiCopilotOptionsOpenAi
+    | CreateAiCopilotOptionsOpenAiCompatible,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/v2/ai/copilots",
+    }
+
+    if isinstance(body, CreateAiCopilotOptionsOpenAi):
+        _kwargs["json"] = body.to_dict()
+    elif isinstance(body, CreateAiCopilotOptionsAnthropic):
+        _kwargs["json"] = body.to_dict()
+    elif isinstance(body, CreateAiCopilotOptionsGoogle):
+        _kwargs["json"] = body.to_dict()
+    else:
+        _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, response: httpx.Response
+) -> AiCopilotAnthropic | AiCopilotGoogle | AiCopilotOpenAi | AiCopilotOpenAiCompatible:
+    if response.status_code == 201:
+
+        def _parse_response_201(
+            data: object,
+        ) -> AiCopilotAnthropic | AiCopilotGoogle | AiCopilotOpenAi | AiCopilotOpenAiCompatible:
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_ai_copilot_type_0 = AiCopilotOpenAi.from_dict(data)
+
+                return componentsschemas_ai_copilot_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_ai_copilot_type_1 = AiCopilotAnthropic.from_dict(data)
+
+                return componentsschemas_ai_copilot_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_ai_copilot_type_2 = AiCopilotGoogle.from_dict(data)
+
+                return componentsschemas_ai_copilot_type_2
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            if not isinstance(data, dict):
+                raise TypeError()
+            componentsschemas_ai_copilot_type_3 = AiCopilotOpenAiCompatible.from_dict(data)
+
+            return componentsschemas_ai_copilot_type_3
+
+        response_201 = _parse_response_201(response.json())
+
+        return response_201
+
+    raise errors.LiveblocksError.from_response(response)
+
+
+def _sync(
+    *,
+    client: httpx.Client,
+    body: CreateAiCopilotOptionsAnthropic
+    | CreateAiCopilotOptionsGoogle
+    | CreateAiCopilotOptionsOpenAi
+    | CreateAiCopilotOptionsOpenAiCompatible,
+) -> AiCopilotAnthropic | AiCopilotGoogle | AiCopilotOpenAi | AiCopilotOpenAiCompatible:
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.request(
+        **kwargs,
+    )
+    return _parse_response(response=response)
+
+
+async def _asyncio(
+    *,
+    client: httpx.AsyncClient,
+    body: CreateAiCopilotOptionsAnthropic
+    | CreateAiCopilotOptionsGoogle
+    | CreateAiCopilotOptionsOpenAi
+    | CreateAiCopilotOptionsOpenAiCompatible,
+) -> AiCopilotAnthropic | AiCopilotGoogle | AiCopilotOpenAi | AiCopilotOpenAiCompatible:
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.request(
+        **kwargs,
+    )
+
+    return _parse_response(response=response)

liveblocks/api/ai/create_file_knowledge_source.py

@@ -0,0 +1,80 @@
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...models.create_file_knowledge_source_response import CreateFileKnowledgeSourceResponse
+from ...types import File
+
+
+def _get_kwargs(
+    copilot_id: str,
+    name: str,
+    *,
+    body: File,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "put",
+        "url": "/v2/ai/copilots/{copilot_id}/knowledge/file/{name}".format(
+            copilot_id=quote(str(copilot_id), safe=""),
+            name=quote(str(name), safe=""),
+        ),
+    }
+
+    _kwargs["content"] = body.payload
+
+    headers["Content-Type"] = "application/octet-stream"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(*, response: httpx.Response) -> CreateFileKnowledgeSourceResponse:
+    if response.status_code == 200:
+        response_200 = CreateFileKnowledgeSourceResponse.from_dict(response.json())
+
+        return response_200
+
+    raise errors.LiveblocksError.from_response(response)
+
+
+def _sync(
+    copilot_id: str,
+    name: str,
+    *,
+    client: httpx.Client,
+    body: File,
+) -> CreateFileKnowledgeSourceResponse:
+    kwargs = _get_kwargs(
+        copilot_id=copilot_id,
+        name=name,
+        body=body,
+    )
+
+    response = client.request(
+        **kwargs,
+    )
+    return _parse_response(response=response)
+
+
+async def _asyncio(
+    copilot_id: str,
+    name: str,
+    *,
+    client: httpx.AsyncClient,
+    body: File,
+) -> CreateFileKnowledgeSourceResponse:
+    kwargs = _get_kwargs(
+        copilot_id=copilot_id,
+        name=name,
+        body=body,
+    )
+
+    response = await client.request(
+        **kwargs,
+    )
+
+    return _parse_response(response=response)

liveblocks/api/ai/create_web_knowledge_source.py

@@ -0,0 +1,74 @@
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...models.create_web_knowledge_source_request_body import CreateWebKnowledgeSourceRequestBody
+from ...models.create_web_knowledge_source_response import CreateWebKnowledgeSourceResponse
+
+
+def _get_kwargs(
+    copilot_id: str,
+    *,
+    body: CreateWebKnowledgeSourceRequestBody,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/v2/ai/copilots/{copilot_id}/knowledge/web".format(
+            copilot_id=quote(str(copilot_id), safe=""),
+        ),
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(*, response: httpx.Response) -> CreateWebKnowledgeSourceResponse:
+    if response.status_code == 200:
+        response_200 = CreateWebKnowledgeSourceResponse.from_dict(response.json())
+
+        return response_200
+
+    raise errors.LiveblocksError.from_response(response)
+
+
+def _sync(
+    copilot_id: str,
+    *,
+    client: httpx.Client,
+    body: CreateWebKnowledgeSourceRequestBody,
+) -> CreateWebKnowledgeSourceResponse:
+    kwargs = _get_kwargs(
+        copilot_id=copilot_id,
+        body=body,
+    )
+
+    response = client.request(
+        **kwargs,
+    )
+    return _parse_response(response=response)
+
+
+async def _asyncio(
+    copilot_id: str,
+    *,
+    client: httpx.AsyncClient,
+    body: CreateWebKnowledgeSourceRequestBody,
+) -> CreateWebKnowledgeSourceResponse:
+    kwargs = _get_kwargs(
+        copilot_id=copilot_id,
+        body=body,
+    )
+
+    response = await client.request(
+        **kwargs,
+    )
+
+    return _parse_response(response=response)

liveblocks/api/ai/delete_ai_copilot.py

@@ -0,0 +1,58 @@
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+
+
+def _get_kwargs(
+    copilot_id: str,
+) -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": "/v2/ai/copilots/{copilot_id}".format(
+            copilot_id=quote(str(copilot_id), safe=""),
+        ),
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, response: httpx.Response) -> None:
+    if response.status_code == 204:
+        return None
+
+    raise errors.LiveblocksError.from_response(response)
+
+
+def _sync(
+    copilot_id: str,
+    *,
+    client: httpx.Client,
+) -> None:
+    kwargs = _get_kwargs(
+        copilot_id=copilot_id,
+    )
+
+    response = client.request(
+        **kwargs,
+    )
+    return _parse_response(response=response)
+
+
+async def _asyncio(
+    copilot_id: str,
+    *,
+    client: httpx.AsyncClient,
+) -> None:
+    kwargs = _get_kwargs(
+        copilot_id=copilot_id,
+    )
+
+    response = await client.request(
+        **kwargs,
+    )
+
+    return _parse_response(response=response)

liveblocks/api/ai/delete_file_knowledge_source.py

@@ -0,0 +1,64 @@
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+
+
+def _get_kwargs(
+    copilot_id: str,
+    knowledge_source_id: str,
+) -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": "/v2/ai/copilots/{copilot_id}/knowledge/file/{knowledge_source_id}".format(
+            copilot_id=quote(str(copilot_id), safe=""),
+            knowledge_source_id=quote(str(knowledge_source_id), safe=""),
+        ),
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, response: httpx.Response) -> None:
+    if response.status_code == 204:
+        return None
+
+    raise errors.LiveblocksError.from_response(response)
+
+
+def _sync(
+    copilot_id: str,
+    knowledge_source_id: str,
+    *,
+    client: httpx.Client,
+) -> None:
+    kwargs = _get_kwargs(
+        copilot_id=copilot_id,
+        knowledge_source_id=knowledge_source_id,
+    )
+
+    response = client.request(
+        **kwargs,
+    )
+    return _parse_response(response=response)
+
+
+async def _asyncio(
+    copilot_id: str,
+    knowledge_source_id: str,
+    *,
+    client: httpx.AsyncClient,
+) -> None:
+    kwargs = _get_kwargs(
+        copilot_id=copilot_id,
+        knowledge_source_id=knowledge_source_id,
+    )
+
+    response = await client.request(
+        **kwargs,
+    )
+
+    return _parse_response(response=response)

liveblocks/api/ai/delete_web_knowledge_source.py

@@ -0,0 +1,64 @@
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+
+
+def _get_kwargs(
+    copilot_id: str,
+    knowledge_source_id: str,
+) -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": "/v2/ai/copilots/{copilot_id}/knowledge/web/{knowledge_source_id}".format(
+            copilot_id=quote(str(copilot_id), safe=""),
+            knowledge_source_id=quote(str(knowledge_source_id), safe=""),
+        ),
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, response: httpx.Response) -> None:
+    if response.status_code == 204:
+        return None
+
+    raise errors.LiveblocksError.from_response(response)
+
+
+def _sync(
+    copilot_id: str,
+    knowledge_source_id: str,
+    *,
+    client: httpx.Client,
+) -> None:
+    kwargs = _get_kwargs(
+        copilot_id=copilot_id,
+        knowledge_source_id=knowledge_source_id,
+    )
+
+    response = client.request(
+        **kwargs,
+    )
+    return _parse_response(response=response)
+
+
+async def _asyncio(
+    copilot_id: str,
+    knowledge_source_id: str,
+    *,
+    client: httpx.AsyncClient,
+) -> None:
+    kwargs = _get_kwargs(
+        copilot_id=copilot_id,
+        knowledge_source_id=knowledge_source_id,
+    )
+
+    response = await client.request(
+        **kwargs,
+    )
+
+    return _parse_response(response=response)

liveblocks/api/ai/get_ai_copilot.py

@@ -0,0 +1,100 @@
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...models.ai_copilot_anthropic import AiCopilotAnthropic
+from ...models.ai_copilot_google import AiCopilotGoogle
+from ...models.ai_copilot_open_ai import AiCopilotOpenAi
+from ...models.ai_copilot_open_ai_compatible import AiCopilotOpenAiCompatible
+
+
+def _get_kwargs(
+    copilot_id: str,
+) -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/v2/ai/copilots/{copilot_id}".format(
+            copilot_id=quote(str(copilot_id), safe=""),
+        ),
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, response: httpx.Response
+) -> AiCopilotAnthropic | AiCopilotGoogle | AiCopilotOpenAi | AiCopilotOpenAiCompatible:
+    if response.status_code == 200:
+
+        def _parse_response_200(
+            data: object,
+        ) -> AiCopilotAnthropic | AiCopilotGoogle | AiCopilotOpenAi | AiCopilotOpenAiCompatible:
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_ai_copilot_type_0 = AiCopilotOpenAi.from_dict(data)
+
+                return componentsschemas_ai_copilot_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_ai_copilot_type_1 = AiCopilotAnthropic.from_dict(data)
+
+                return componentsschemas_ai_copilot_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_ai_copilot_type_2 = AiCopilotGoogle.from_dict(data)
+
+                return componentsschemas_ai_copilot_type_2
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            if not isinstance(data, dict):
+                raise TypeError()
+            componentsschemas_ai_copilot_type_3 = AiCopilotOpenAiCompatible.from_dict(data)
+
+            return componentsschemas_ai_copilot_type_3
+
+        response_200 = _parse_response_200(response.json())
+
+        return response_200
+
+    raise errors.LiveblocksError.from_response(response)
+
+
+def _sync(
+    copilot_id: str,
+    *,
+    client: httpx.Client,
+) -> AiCopilotAnthropic | AiCopilotGoogle | AiCopilotOpenAi | AiCopilotOpenAiCompatible:
+    kwargs = _get_kwargs(
+        copilot_id=copilot_id,
+    )
+
+    response = client.request(
+        **kwargs,
+    )
+    return _parse_response(response=response)
+
+
+async def _asyncio(
+    copilot_id: str,
+    *,
+    client: httpx.AsyncClient,
+) -> AiCopilotAnthropic | AiCopilotGoogle | AiCopilotOpenAi | AiCopilotOpenAiCompatible:
+    kwargs = _get_kwargs(
+        copilot_id=copilot_id,
+    )
+
+    response = await client.request(
+        **kwargs,
+    )
+
+    return _parse_response(response=response)

liveblocks/api/ai/get_ai_copilots.py

@@ -0,0 +1,74 @@
+from typing import Any
+
+import httpx
+
+from ... import errors
+from ...models.get_ai_copilots_response import GetAiCopilotsResponse
+from ...types import UNSET, Unset
+
+
+def _get_kwargs(
+    *,
+    limit: int | Unset = 20,
+    starting_after: str | Unset = UNSET,
+) -> dict[str, Any]:
+
+    params: dict[str, Any] = {}
+
+    params["limit"] = limit
+
+    params["startingAfter"] = starting_after
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/v2/ai/copilots",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, response: httpx.Response) -> GetAiCopilotsResponse:
+    if response.status_code == 200:
+        response_200 = GetAiCopilotsResponse.from_dict(response.json())
+
+        return response_200
+
+    raise errors.LiveblocksError.from_response(response)
+
+
+def _sync(
+    *,
+    client: httpx.Client,
+    limit: int | Unset = 20,
+    starting_after: str | Unset = UNSET,
+) -> GetAiCopilotsResponse:
+    kwargs = _get_kwargs(
+        limit=limit,
+        starting_after=starting_after,
+    )
+
+    response = client.request(
+        **kwargs,
+    )
+    return _parse_response(response=response)
+
+
+async def _asyncio(
+    *,
+    client: httpx.AsyncClient,
+    limit: int | Unset = 20,
+    starting_after: str | Unset = UNSET,
+) -> GetAiCopilotsResponse:
+    kwargs = _get_kwargs(
+        limit=limit,
+        starting_after=starting_after,
+    )
+
+    response = await client.request(
+        **kwargs,
+    )
+
+    return _parse_response(response=response)