decart 0.0.1__tar.gz

decart-0.0.1/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: decart
+Version: 0.0.1
+Summary: 
+Author: Decart
+Author-email: support@decart.ai
+Requires-Python: >=3.8,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: httpx (>=0.25.2,<0.26.0)
+Requires-Dist: httpx-sse (>=0.3.1,<0.4.0)
+Requires-Dist: pydantic (>=2.5.2,<3.0.0)
+Description-Content-Type: text/markdown
+
+

decart-0.0.1/decart/__init__.py

@@ -0,0 +1,11 @@
+from .clients import client
+
+class _ClientMixin:
+    _base_url = "https://api.decart.ai/v1"
+    _key_variable = "DECART_API_KEY"
+
+class Decart(_ClientMixin, client.Client):
+    pass
+
+class AsyncDecart(_ClientMixin, client.AsyncClient):
+    pass

decart-0.0.1/decart/clients/base_client.py

@@ -0,0 +1,86 @@
+from typing import AsyncIterator, Iterable, Mapping, TypeVar
+import httpx
+import httpx_sse
+import pydantic
+
+
+_ResponseT = TypeVar("_ResponseT", bound=pydantic.BaseModel)
+
+
+class BaseClient:
+    def __init__(
+        self,
+        headers: Mapping[str, str],
+        base_url: httpx.URL,
+    ) -> None:
+        self._client = httpx.Client(
+            headers=headers,
+            base_url=base_url,
+        )
+
+    def post(
+        self, url: httpx.URL, request: pydantic.BaseModel, cls: type[_ResponseT]
+    ) -> _ResponseT:
+        response = self._client.post(
+            url,
+            json=request.model_dump(),
+        )
+
+        if response.status_code != httpx.codes.OK:
+            raise self._make_status_error(response)
+
+        return cls.model_validate(response.json())
+
+    def stream(
+        self, url: httpx.URL, request: pydantic.BaseModel, cls: type[_ResponseT]
+    ) -> Iterable[_ResponseT]:
+        with httpx_sse.connect_sse(
+            self._client,
+            method="POST",
+            url=str(url),
+            json=request.model_dump(),
+        ) as event_source:
+            for response in event_source.iter_sse():
+                yield cls.model_validate(response.json())
+
+    def _make_status_error(self, response: httpx.Response) -> Exception:
+        raise NotImplementedError()
+
+class AsyncBaseClient:
+    def __init__(
+        self,
+        headers: Mapping[str, str],
+        base_url: httpx.URL,
+    ) -> None:
+        self._client = httpx.AsyncClient(
+            headers=headers,
+            base_url=base_url,
+        )
+
+    async def post(
+        self, url: httpx.URL, request: pydantic.BaseModel, cls: type[_ResponseT]
+    ) -> _ResponseT:
+        response = await self._client.post(
+            url,
+            json=request.model_dump(),
+        )
+
+        if response.status_code != httpx.codes.OK:
+            raise self._make_status_error(response)
+
+        return cls.model_validate(response.json())
+
+    async def stream(
+        self, url: httpx.URL, request: pydantic.BaseModel, cls: type[_ResponseT]
+    ) -> AsyncIterator[_ResponseT]:
+        async with httpx_sse.aconnect_sse(
+            self._client,
+            method="POST",
+            url=str(url),
+            json=request.model_dump(),
+        ) as event_source:
+            async for response in event_source.aiter_sse():
+                yield cls.model_validate(response.json())
+
+    def _make_status_error(self, response: httpx.Response) -> Exception:
+        raise NotImplementedError()

decart-0.0.1/decart/clients/client.py

@@ -0,0 +1,46 @@
+import os
+import httpx
+from ..resources import chat
+from ..resources import completions
+from . import base_client
+from .. import exceptions
+
+
+class _ClientMixin:
+    _base_url: httpx.URL
+    _key_variable: str
+
+    def _make_status_error(self, response: httpx.Response) -> exceptions.APIError:
+        # TODO(vova): based on code
+        return exceptions.APIError()
+
+class Client(_ClientMixin, base_client.BaseClient):
+    def __init__(self, api_key: str | None = None) -> None:
+        if api_key is None:
+            api_key = os.getenv(self._key_variable)
+
+        self.chat = chat.Chat(self)
+        self.completion = completions.Completions(self)
+
+        super().__init__(
+            headers={
+                "Authorization": f"Bearer {api_key}",
+            },
+            base_url=httpx.URL(self._base_url),
+        )
+
+
+class AsyncClient(_ClientMixin, base_client.AsyncBaseClient):
+    def __init__(self, api_key: str | None = None) -> None:
+        if api_key is None:
+            api_key = os.getenv(self._key_variable)
+
+        self.chat = chat.AsyncChat(self)
+        self.completion = completions.AsyncCompletions(self)
+
+        super().__init__(
+            headers={
+                "Authorization": f"Bearer {api_key}",
+            },
+            base_url=httpx.URL(self._base_url),
+        )

decart-0.0.1/decart/exceptions.py

@@ -0,0 +1,2 @@
+class APIError(Exception):
+    pass

decart-0.0.1/decart/resources/base_resource.py

@@ -0,0 +1,75 @@
+from typing import AsyncIterator, Iterable, Literal, TypeVar, overload
+import httpx
+import pydantic
+from ..clients import base_client
+
+_ResponseT = TypeVar("_ResponseT", bound=pydantic.BaseModel)
+
+
+class BaseResource:
+    def __init__(self, client: base_client.BaseClient):
+        self._client = client
+
+    @overload
+    def _post(
+        self,
+        url: str,
+        model: pydantic.BaseModel,
+        stream: Literal[False],
+        cls: type[_ResponseT],
+    ) -> _ResponseT:
+        ...
+
+    @overload
+    def _post(
+        self,
+        url: str,
+        model: pydantic.BaseModel,
+        stream: Literal[True],
+        cls: type[_ResponseT],
+    ) -> Iterable[_ResponseT]:
+        ...
+
+    def _post(
+        self, url: str, model: pydantic.BaseModel, stream: bool, cls: type[_ResponseT]
+    ) -> _ResponseT | Iterable[_ResponseT]:
+        url_httpx = httpx.URL(url)
+
+        if stream:
+            return self._client.stream(url_httpx, model, cls)
+        else:
+            return self._client.post(url_httpx, model, cls)
+
+class AsyncBaseResource:
+    def __init__(self, client: base_client.AsyncBaseClient):
+        self._client = client
+
+    @overload
+    async def _post(
+        self,
+        url: str,
+        model: pydantic.BaseModel,
+        stream: Literal[False],
+        cls: type[_ResponseT],
+    ) -> _ResponseT:
+        ...
+
+    @overload
+    async def _post(
+        self,
+        url: str,
+        model: pydantic.BaseModel,
+        stream: Literal[True],
+        cls: type[_ResponseT],
+    ) -> AsyncIterator[_ResponseT]:
+        ...
+
+    async def _post(
+        self, url: str, model: pydantic.BaseModel, stream: bool, cls: type[_ResponseT]
+    ) -> _ResponseT | AsyncIterator[_ResponseT]:
+        url_httpx = httpx.URL(url)
+
+        if stream:
+            return self._client.stream(url_httpx, model, cls)
+        else:
+            return await self._client.post(url_httpx, model, cls)

decart-0.0.1/decart/resources/chat.py

@@ -0,0 +1,13 @@
+from . import chat_completions
+from ..clients import base_client
+
+
+class Chat:
+    def __init__(self, client: base_client.BaseClient):
+        self._client = client
+        self.completions = chat_completions.Completions(client)
+
+class AsyncChat:
+    def __init__(self, client: base_client.AsyncBaseClient):
+        self._client = client
+        self.completions = chat_completions.AsyncCompletions(client)

decart-0.0.1/decart/resources/chat_completions.py

@@ -0,0 +1,158 @@
+from typing import AsyncIterator, Iterable, Iterator, Literal, Optional, Sequence, overload
+
+from ..types.chat_completion_chunk import ChatCompletionChunk
+from . import base_resource
+from ..clients import base_client
+from ..types.model import Model
+from ..types.chat_completion import (
+    ChatCompletion,
+    CreateChatCompletion,
+    ChatCompletionMessage,
+)
+
+
+class Completions(base_resource.BaseResource):
+    def __init__(self, client: base_client.BaseClient) -> None:
+        super().__init__(client)
+
+    @overload
+    def create(
+        self,
+        *,
+        messages: Sequence[ChatCompletionMessage],
+        model: Model,
+        frequency_penalty: float = 0.0,
+        presence_penalty: float = 0.0,
+        stop: Sequence[str] = (),
+        max_tokens: Optional[int] = None,
+        stream: Literal[False],
+        temperature: float = 0.0,
+        top_p: float = 1.0,
+        top_k: int | None = None,
+    ) -> ChatCompletion:
+        ...
+
+    @overload
+    def create(
+        self,
+        *,
+        messages: Sequence[ChatCompletionMessage],
+        model: Model,
+        frequency_penalty: float = 0.0,
+        presence_penalty: float = 0.0,
+        stop: Sequence[str] = (),
+        max_tokens: Optional[int] = None,
+        stream: Literal[True],
+        temperature: float = 0.0,
+        top_p: float = 1.0,
+        top_k: int | None = None,
+    ) -> Iterator[ChatCompletionChunk]:
+        ...
+
+    def create(
+        self,
+        *,
+        messages: Sequence[ChatCompletionMessage],
+        model: Model,
+        frequency_penalty: float = 0.0,
+        presence_penalty: float = 0.0,
+        stop: Sequence[str] = (),
+        max_tokens: Optional[int] = None,
+        stream: bool = False,
+        temperature: float = 0.0,
+        top_p: float = 1.0,
+        top_k: int | None = None,
+    ) -> ChatCompletion | Iterable[ChatCompletionChunk]:
+        create_chat_completion = CreateChatCompletion(
+            messages=messages,
+            model=model,
+            frequency_penalty=frequency_penalty,
+            presence_penalty=presence_penalty,
+            max_tokens=max_tokens,
+            stop=stop,
+            stream=stream,
+            temperature=temperature,
+            top_p=top_p,
+            top_k=top_k,
+        )
+        if stream:
+            return self._post(
+                "/chat/completions", create_chat_completion, True, ChatCompletionChunk
+            )
+        else:
+            return self._post(
+                "/chat/completions", create_chat_completion, False, ChatCompletion
+            )
+
+class AsyncCompletions(base_resource.AsyncBaseResource):
+    def __init__(self, client: base_client.AsyncBaseClient) -> None:
+        super().__init__(client)
+
+    @overload
+    async def create(
+        self,
+        *,
+        messages: Sequence[ChatCompletionMessage],
+        model: Model,
+        frequency_penalty: float = 0.0,
+        presence_penalty: float = 0.0,
+        stop: Sequence[str] = (),
+        max_tokens: Optional[int] = None,
+        stream: Literal[False],
+        temperature: float = 0.0,
+        top_p: float = 1.0,
+        top_k: int | None = None,
+    ) -> ChatCompletion:
+        ...
+
+    @overload
+    async def create(
+        self,
+        *,
+        messages: Sequence[ChatCompletionMessage],
+        model: Model,
+        frequency_penalty: float = 0.0,
+        presence_penalty: float = 0.0,
+        stop: Sequence[str] = (),
+        max_tokens: Optional[int] = None,
+        stream: Literal[True],
+        temperature: float = 0.0,
+        top_p: float = 1.0,
+        top_k: int | None = None,
+    ) -> AsyncIterator[ChatCompletionChunk]:
+        ...
+
+    async def create(
+        self,
+        *,
+        messages: Sequence[ChatCompletionMessage],
+        model: Model,
+        frequency_penalty: float = 0.0,
+        presence_penalty: float = 0.0,
+        stop: Sequence[str] = (),
+        max_tokens: Optional[int] = None,
+        stream: bool = False,
+        temperature: float = 0.0,
+        top_p: float = 1.0,
+        top_k: int | None = None,
+    ) -> ChatCompletion | AsyncIterator[ChatCompletionChunk]:
+        create_chat_completion = CreateChatCompletion(
+            messages=messages,
+            model=model,
+            frequency_penalty=frequency_penalty,
+            presence_penalty=presence_penalty,
+            max_tokens=max_tokens,
+            stop=stop,
+            stream=stream,
+            temperature=temperature,
+            top_p=top_p,
+            top_k=top_k,
+        )
+        if stream:
+            return await self._post(
+                "/chat/completions", create_chat_completion, True, ChatCompletionChunk
+            )
+        else:
+            return await self._post(
+                "/chat/completions", create_chat_completion, False, ChatCompletion
+            )

decart-0.0.1/decart/resources/completions.py

@@ -0,0 +1,11 @@
+from . import base_resource
+from ..clients import base_client
+
+
+class Completions(base_resource.BaseResource):
+    def __init__(self, client: base_client.BaseClient) -> None:
+        super().__init__(client)
+
+class AsyncCompletions(base_resource.AsyncBaseResource):
+    def __init__(self, client: base_client.AsyncBaseClient) -> None:
+        super().__init__(client)

decart-0.0.1/decart/types/chat_completion.py

@@ -0,0 +1,36 @@
+from typing import Literal, Optional, Sequence
+import pydantic
+
+from ..types.chat_completion_message import ChatCompletionMessage
+from ..types.finish_reason import FinishReason
+from ..types.model import Model
+from ..types.completion_usage import CompletionUsage
+
+
+class CreateChatCompletion(pydantic.BaseModel):
+    messages: Sequence[ChatCompletionMessage]
+    model: Model
+    frequency_penalty: float
+    presence_penalty: float
+    stop: Sequence[str]
+    max_tokens: Optional[int]
+    stream: bool
+    temperature: float
+    top_p: float
+    top_k: int | None
+
+
+class Choice(pydantic.BaseModel):
+    finish_reason: FinishReason
+    index: int
+    message: ChatCompletionMessage
+
+
+class ChatCompletion(pydantic.BaseModel):
+    id: str
+    choices: Sequence[Choice]
+    created: int
+    model: str
+    object: Literal["chat.completion"]
+    system_fingerprint: Optional[str] = None
+    usage: Optional[CompletionUsage] = None

decart-0.0.1/decart/types/chat_completion_chunk.py

@@ -0,0 +1,21 @@
+from typing import Literal, Optional, Sequence
+
+import pydantic
+
+from ..types.chat_completion_message import ChatCompletionMessage
+from ..types.finish_reason import FinishReason
+
+
+class Choice(pydantic.BaseModel):
+    delta: ChatCompletionMessage
+    finish_reason: Optional[FinishReason]
+    index: int
+
+
+class ChatCompletionChunk(pydantic.BaseModel):
+    id: str
+    choices: Sequence[Choice]
+    created: int
+    model: str
+    object: Literal["chat.completion.chunk"]
+    system_fingerprint: Optional[str] = None

decart-0.0.1/decart/types/chat_completion_message.py

@@ -0,0 +1,14 @@
+import enum
+from typing import Optional
+import pydantic
+
+
+class Role(str, enum.Enum):
+    SYSTEM = "system"
+    USER = "user"
+    ASSISTANT = "assistant"
+
+
+class ChatCompletionMessage(pydantic.BaseModel):
+    content: Optional[str] = None
+    role: Optional[Role] = None

decart-0.0.1/decart/types/completion_usage.py

@@ -0,0 +1,7 @@
+import pydantic
+
+
+class CompletionUsage(pydantic.BaseModel):
+    completion_tokens: int
+    prompt_tokens: int
+    total_tokens: int

decart-0.0.1/decart/types/finish_reason.py

@@ -0,0 +1,6 @@
+import enum
+
+
+class FinishReason(str, enum.Enum):
+    STOP = "stop"
+    LENGTH = "length"

decart-0.0.1/decart/types/model.py

@@ -0,0 +1,9 @@
+import enum
+
+
+class Model(str, enum.Enum):
+    LLAMA_70B_CHAT = "meta-llama/llama-2-70b-chat-hf"
+    MISTRAL_7B_INSTRUCT = "mistralai/mistral-7b-instruct-v0.1"
+    ZEPHYR_7B_BETA = "huggingfaceh4/zephyr-7b-beta"
+    LZLV_70B = "lizpreciatior/lzlv_70b_fp16_hf"
+    FALCON_180B = "tiiuae/falcon-180b-chat"

decart-0.0.1/decart/types/models.py

@@ -0,0 +1,14 @@
+import enum
+
+
+class Model(str, enum.Enum):
+
+    LLAMA_70B_CHAT = "meta-llama/llama-2-70b-chat-hf"
+
+    MISTRAL_7B_INSTRUCT = "mistralai/mistral-7b-instruct-v0.1"
+
+    ZEPHYR_7B_BETA = "huggingfaceh4/zephyr-7b-beta"
+
+    LZLV_70B = "lizpreciatior/lzlv_70b_fp16_hf"
+
+    FALCON_180B = "tiiuae/falcon-180b-chat"

decart-0.0.1/pyproject.toml

@@ -0,0 +1,22 @@
+[tool.poetry]
+name = "decart"
+version = "0.0.1"
+description = ""
+authors = ["Decart <support@decart.ai>"]
+readme = "decart/README.md"
+
+[tool.poetry.dependencies]
+python = "^3.8"
+httpx = "^0.25.2"
+pydantic = "^2.5.2"
+httpx-sse = "^0.3.1"
+
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.1.8"
+jinja2 = "^3.1.2"
+pyyaml = "^6.0.1"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"