alloyai-client 0.1.1__py3-none-any.whl

alloyai_client/__init__.py

@@ -0,0 +1,11 @@
+from .alloy_client import AlloyClient, AlloyClientError
+from .types import ChatResponse, JsonSchemaValue, Message, Tool
+
+__all__ = [
+    "AlloyClient",
+    "AlloyClientError",
+    "ChatResponse",
+    "JsonSchemaValue",
+    "Message",
+    "Tool",
+]

alloyai_client/alloyai_client.py

@@ -0,0 +1,214 @@
+from __future__ import annotations
+
+import base64
+import json
+import urllib.error
+import urllib.request
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    Iterator,
+    Literal,
+    Mapping,
+    Optional,
+    Sequence,
+    Union,
+)
+
+from .types import ChatResponse, JsonSchemaValue, Message, Tool
+
+
+class AlloyClientError(RuntimeError):
+    def __init__(self, status_code: int, message: str, body: Optional[str] = None) -> None:
+        super().__init__(f"HTTP {status_code}: {message}")
+        self.status_code = status_code
+        self.body = body
+
+
+class AlloyClient:
+    def __init__(
+        self,
+        base_url: str = "http://127.0.0.1:8000",
+        *,
+        timeout_s: float = 300.0,
+    ) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._timeout_s = timeout_s
+
+    def image(
+        self,
+        model_id: str,
+        prompt: Any,
+        *,
+        stream: bool = False,
+        decode_images: bool = True,
+        timeout_s: Optional[float] = None,
+        **params: Any,
+    ) -> Union[Dict[str, Any], Iterator[Dict[str, Any]]]:
+        payload: Dict[str, Any] = {
+            "model_id": model_id,
+            "prompt": prompt,
+            "stream": stream,
+        }
+        payload.update(params)
+
+        if stream:
+            response = self._post("/image", payload, stream=True, timeout_s=timeout_s)
+            return self._stream_events(response, decode_images)
+
+        response = self._post("/image", payload, stream=False, timeout_s=timeout_s)
+        with response:
+            data = self._read_json(response)
+        return self._maybe_decode_images(data, decode_images)
+
+    def chat(
+        self,
+        model: str,
+        messages: Optional[Sequence[Union[Mapping[str, Any], Message]]],
+        *,
+        think: bool | Literal["low", "medium", "high"] | None = None,
+        tools: Optional[Sequence[Union[Mapping[str, Any], Tool, Callable]]] = None,
+        options: Optional[Dict[str, Any]] = None,
+        stream: bool = False,
+        format: Optional[Union[JsonSchemaValue, Literal["", "json"]]] = None,
+        keep_alive: float | str | None = None,
+    ) -> Union[Iterator[ChatResponse], ChatResponse]:
+        if stream:
+            raise ValueError("Streaming chat is not supported yet")
+
+        payload: Dict[str, Any] = {
+            "model": model,
+            "messages": messages,
+            "stream": stream,
+        }
+        if think is not None:
+            payload["think"] = think
+        if tools is not None:
+            payload["tools"] = tools
+        if options is not None:
+            payload["options"] = options
+        if format is not None:
+            payload["format"] = format
+        if keep_alive is not None:
+            payload["keep_alive"] = keep_alive
+
+        response = self._post("/chat", payload, stream=False, timeout_s=None)
+        with response:
+            return self._read_json(response)
+
+    def audio(
+        self,
+        model_id: str,
+        text: Any,
+        *,
+        language: Any = None,
+        speaker: Any = None,
+        instruct: Any = None,
+        ref_audio: Any = None,
+        ref_text: Any = None,
+        stream: bool = False,
+        keep_alive: float | str | None = None,
+        timeout_s: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        if stream:
+            raise ValueError("Streaming audio is not supported yet")
+
+        payload: Dict[str, Any] = {
+            "model_id": model_id,
+            "text": text,
+            "stream": stream,
+        }
+        if language is not None:
+            payload["language"] = language
+        if speaker is not None:
+            payload["speaker"] = speaker
+        if instruct is not None:
+            payload["instruct"] = instruct
+        if ref_audio is not None:
+            payload["ref_audio"] = ref_audio
+        if ref_text is not None:
+            payload["ref_text"] = ref_text
+        if keep_alive is not None:
+            payload["keep_alive"] = keep_alive
+
+        response = self._post("/audio", payload, stream=False, timeout_s=timeout_s)
+        with response:
+            return self._read_json(response)
+
+    def _post(
+        self,
+        path: str,
+        payload: Dict[str, Any],
+        *,
+        stream: bool,
+        timeout_s: Optional[float],
+    ):
+        url = f"{self._base_url}{path}"
+        data = json.dumps(payload).encode("utf-8")
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "text/event-stream" if stream else "application/json",
+        }
+        request = urllib.request.Request(url, data=data, method="POST", headers=headers)
+        timeout = self._timeout_s if timeout_s is None else timeout_s
+        try:
+            return urllib.request.urlopen(request, timeout=timeout)
+        except urllib.error.HTTPError as exc:
+            body = exc.read().decode("utf-8", "ignore")
+            message = body or exc.reason
+            raise AlloyClientError(exc.code, message, body=body) from None
+
+    def _read_json(self, response) -> Dict[str, Any]:
+        raw = response.read()
+        if not raw:
+            return {}
+        return json.loads(raw.decode("utf-8"))
+
+    def _maybe_decode_images(self, data: Dict[str, Any], decode_images: bool) -> Dict[str, Any]:
+        if not decode_images:
+            return data
+        images = data.get("images")
+        if isinstance(images, list):
+            data = dict(data)
+            data["images"] = [base64.b64decode(item) for item in images]
+        return data
+
+    def _stream_events(
+        self,
+        response,
+        decode_images: bool,
+    ) -> Iterator[Dict[str, Any]]:
+        try:
+            for event in self._iter_sse(response):
+                payload = event.get("payload")
+                if decode_images and isinstance(payload, dict):
+                    images = payload.get("images")
+                    if isinstance(images, list):
+                        payload = dict(payload)
+                        payload["images"] = [base64.b64decode(item) for item in images]
+                        event = dict(event)
+                        event["payload"] = payload
+                yield event
+        finally:
+            response.close()
+
+    def _iter_sse(self, response) -> Iterable[Dict[str, Any]]:
+        event: Dict[str, Any] = {}
+        for raw_line in response:
+            line = raw_line.decode("utf-8", "ignore").strip()
+            if not line:
+                if event:
+                    yield event
+                    event = {}
+                continue
+            if line.startswith("data:"):
+                data = line[len("data:") :].strip()
+                if not data:
+                    continue
+                event["payload"] = json.loads(data)
+            elif line.startswith("event:"):
+                event["event"] = line[len("event:") :].strip()
+        if event:
+            yield event

alloyai_client/types.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+from typing import (
+    Any,
+    Dict,
+    Literal,
+    Mapping,
+    Optional,
+    Sequence,
+    Union,
+)
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+)
+from PIL.Image import Image
+
+JsonSchemaValue = Dict[str, Any]
+
+class SubscriptableBaseModel(BaseModel):
+    def __getitem__(self, key: str) -> Any:
+        """
+        >>> msg = Message(role='user')
+        >>> msg['role']
+        'user'
+        >>> msg = Message(role='user')
+        >>> msg['nonexistent']
+        Traceback (most recent call last):
+        KeyError: 'nonexistent'
+        """
+        if key in self:
+            return getattr(self, key)
+
+        raise KeyError(key)
+    
+    def __setitem__(self, key: str, value: Any) -> None:
+        """
+        >>> msg = Message(role='user')
+        >>> msg['role'] = 'assistant'
+        >>> msg['role']
+        'assistant'
+        >>> tool_call = Message.ToolCall(function=Message.ToolCall.Function(name='foo', arguments={}))
+        >>> msg = Message(role='user', content='hello')
+        >>> msg['tool_calls'] = [tool_call]
+        >>> msg['tool_calls'][0]['function']['name']
+        'foo'
+        """
+        setattr(self, key, value)
+
+    def __contains__(self, key: str) -> bool:
+        """
+        >>> msg = Message(role='user')
+        >>> 'nonexistent' in msg
+        False
+        >>> 'role' in msg
+        True
+        >>> 'content' in msg
+        False
+        >>> msg.content = 'hello!'
+        >>> 'content' in msg
+        True
+        >>> msg = Message(role='user', content='hello!')
+        >>> 'content' in msg
+        True
+        >>> 'tool_calls' in msg
+        False
+        >>> msg['tool_calls'] = []
+        >>> 'tool_calls' in msg
+        True
+        >>> msg['tool_calls'] = [Message.ToolCall(function=Message.ToolCall.Function(name='foo', arguments={}))]
+        >>> 'tool_calls' in msg
+        True
+        >>> msg['tool_calls'] = None
+        >>> 'tool_calls' in msg
+        True
+        >>> tool = Tool()
+        >>> 'type' in tool
+        True
+        """
+        if key in self.model_fields_set:
+            return True
+
+        if value := self.__class__.model_fields.get(key):
+            return value.default is not None
+
+        return False
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        >>> msg = Message(role='user')
+        >>> msg.get('role')
+        'user'
+        >>> msg = Message(role='user')
+        >>> msg.get('nonexistent')
+        >>> msg = Message(role='user')
+        >>> msg.get('nonexistent', 'default')
+        'default'
+        >>> msg = Message(role='user', tool_calls=[ Message.ToolCall(function=Message.ToolCall.Function(name='foo', arguments={}))])
+        >>> msg.get('tool_calls')[0]['function']['name']
+        'foo'
+        """
+        return getattr(self, key) if hasattr(self, key) else default
+
+class Message(SubscriptableBaseModel):
+    """
+    Chat message.
+    """
+
+    role: str
+    "Assumed role of the message. Response messages has role 'assistant' or 'tool'."
+
+    content: Optional[str] = None
+    'Content of the message. Response messages contains message fragments when streaming.'
+
+    thinking: Optional[str] = None
+    'Thinking content. Only present when thinking is enabled.'
+
+    images: Optional[Sequence[Image]] = None
+    """
+    Optional list of image data for multimodal models.
+
+    Valid input types are:
+
+    - `str` or path-like object: path to image file
+    - `bytes` or bytes-like object: raw image data
+
+    Valid image formats depend on the model. See the model card for more information.
+    """
+
+    tool_name: Optional[str] = None
+    'Name of the executed tool.'
+
+    class ToolCall(SubscriptableBaseModel):
+        """
+        Model tool calls.
+        """
+
+        class Function(SubscriptableBaseModel):
+            """
+            Tool call function.
+            """
+
+            name: str
+            'Name of the function.'
+
+            arguments: Mapping[str, Any]
+            'Arguments of the function.'
+
+        function: Function
+        'Function to be called.'
+
+    tool_calls: Optional[Sequence[ToolCall]] = None
+    """
+    Tools calls to be made by the model.
+    """
+
+
+class Tool(SubscriptableBaseModel):
+  type: Optional[str] = 'function'
+
+  class Function(SubscriptableBaseModel):
+    name: Optional[str] = None
+    description: Optional[str] = None
+
+    class Parameters(SubscriptableBaseModel):
+      model_config = ConfigDict(populate_by_name=True)
+      type: Optional[Literal['object']] = 'object'
+      defs: Optional[Any] = Field(None, alias='$defs')
+      items: Optional[Any] = None
+      required: Optional[Sequence[str]] = None
+
+      class Property(SubscriptableBaseModel):
+        model_config = ConfigDict(arbitrary_types_allowed=True)
+
+        type: Optional[Union[str, Sequence[str]]] = None
+        items: Optional[Any] = None
+        description: Optional[str] = None
+        enum: Optional[Sequence[Any]] = None
+
+      properties: Optional[Mapping[str, Property]] = None
+
+    parameters: Optional[Parameters] = None
+
+  function: Optional[Function] = None
+
+
+class BaseGenerateResponse(SubscriptableBaseModel):
+    model: Optional[str] = None
+    'Model used to generate response.'
+
+    created_at: Optional[str] = None
+    'Time when the request was created.'
+
+    done: Optional[bool] = None
+    'True if response is complete, otherwise False. Useful for streaming to detect the final response.'
+
+    done_reason: Optional[str] = None
+    'Reason for completion. Only present when done is True.'
+
+    total_duration: Optional[int] = None
+    'Total duration in nanoseconds.'
+
+    load_duration: Optional[int] = None
+    'Load duration in nanoseconds.'
+
+    prompt_eval_count: Optional[int] = None
+    'Number of tokens evaluated in the prompt.'
+
+    prompt_eval_duration: Optional[int] = None
+    'Duration of evaluating the prompt in nanoseconds.'
+
+    eval_count: Optional[int] = None
+    'Number of tokens evaluated in inference.'
+
+    eval_duration: Optional[int] = None
+    'Duration of evaluating inference in nanoseconds.'
+
+class EmbedResponse(BaseGenerateResponse):
+    """
+    Response returned by embed requests.
+    """
+
+    embeddings: Sequence[Sequence[float]]
+    'Embeddings of the inputs.'
+
+class ChatResponse(BaseGenerateResponse):
+    """
+    Response returned by chat requests.
+    """
+
+    message: Message
+    'Response message.'

alloyai_client-0.1.1.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: alloyai-client
+Version: 0.1.1
+Summary: Python client for the Alloy server
+License: MIT License
+        
+        Copyright (c) 2026 Alloy Contributors
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic<3,>=2.12.5
+Requires-Dist: pillow<13,>=12.1.0
+Dynamic: license-file
+
+# alloy-client
+
+A lightweight Python client for the Alloy server.
+
+## Install
+
+```bash
+pip install alloyai-client
+```
+
+For local development:
+
+```bash
+pip install -e .
+```
+
+## Quick start
+
+```python
+from alloy_client import AlloyClient
+
+client = AlloyClient("http://127.0.0.1:8000")
+
+# Images
+result = client.image(model_id="qwen-image", prompt="a cinematic portrait")
+with open("output.png", "wb") as f:
+    f.write(result["images"][0])
+
+# Chat (non-streaming)
+response = client.chat(
+    model="qwen3-medium",
+    messages=[{"role": "user", "content": "Hello!"}],
+)
+print(response["message"]["content"])
+
+# Audio (non-streaming)
+audio = client.audio(
+    model_id="qwen3-tts-base",
+    text="Hello from Alloy",
+)
+print(audio["sample_rate"], len(audio["outputs"]))
+```
+
+## Types
+
+The client re-exports minimal Ollama-style types so you can annotate inputs without
+pulling in the `ollama` dependency:
+
+```python
+from alloy_client import Message, JsonSchemaValue
+```
+
+## Notes
+
+- Streaming is supported for `/image` only.
+- `/chat` and `/audio` are non-streaming for now.

alloyai_client-0.1.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+alloyai_client/__init__.py,sha256=Ni3bePA04S27k8rMeLnFvpCXds3gGhZbeiwuBZL3LsI,248
+alloyai_client/alloyai_client.py,sha256=5efrnQL2-vp1Vhain7W-Sylj4nYk-jNj9gp5fwC0uqU,6916
+alloyai_client/types.py,sha256=W4hj2tUwwMWlkEV9D7p60DAJMyAdnEOKVf4LCxwS4wU,6390
+alloyai_client-0.1.1.dist-info/licenses/LICENSE,sha256=SAwc119ZCsRjxVu0qvjeRQEENDLW4sl0suNPdyOIbns,1075
+alloyai_client-0.1.1.dist-info/METADATA,sha256=FE1c6VIH-9E4dEOZDtbj00LD-qqU8yrRxU_7hqKNBP4,2604
+alloyai_client-0.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+alloyai_client-0.1.1.dist-info/top_level.txt,sha256=oM1nqpgWdx1ZT5ydfq5Stea7wfXSGeuFgFUb92IoP1M,15
+alloyai_client-0.1.1.dist-info/RECORD,,

alloyai_client-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

alloyai_client-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alloy Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

alloyai_client-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+alloyai_client