uip-sdk 0.1.0__tar.gz

uip_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: uip-sdk
+Version: 0.1.0
+Summary: UIP — Universal Inference Platform Python SDK
+Author-email: Zhu Wenbo <zwb.2002@tsinghua.org.cn>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+
+# UIP Python SDK
+
+Universal Inference Platform 的 Python 客户端库。
+
+## 安装
+
+```bash
+pip install uip-sdk
+```
+
+## 快速开始
+
+```python
+from uip_sdk import UIPClient
+
+# 方式 1: API Key
+client = UIPClient(api_key="ggw-xxx...")
+
+# 方式 2: JWT Token
+client = UIPClient(token="eyJhbGciOiJIUzI1NiIs...")
+
+# 方式 3: 环境变量 (UIP_API_KEY)
+client = UIPClient()
+```
+
+## 使用示例
+
+### 对话 (Chat Completions)
+
+```python
+resp = client.chat(
+    messages=[{"role": "user", "content": "你好"}],
+    model="qwen2.5:7b",
+)
+print(resp.text)
+```
+
+### 流式生成
+
+```python
+for chunk in client.generate("写一首关于春天的诗", stream=True):
+    print(chunk.text, end="", flush=True)
+```
+
+### Rerank (文档重排序)
+
+```python
+results = client.rerank(
+    query="CBA季后赛战术分析",
+    documents=[
+        "CBA联赛采用胜率决定排名",
+        "篮球三分线距离为6.75米",
+        "广东队采用全场紧逼战术",
+    ],
+    model="Qwen3-Reranker-0.6B",
+    top_n=2,
+)
+for r in results.results:
+    print(f"#{r.index}: {r.document[:30]}... score={r.relevance_score:.2f}")
+```
+
+### 批量推理
+
+```python
+batch = client.batch(
+    prompts=["你好", "介绍你自己"],
+    model="qwen2.5:7b",
+)
+for item in batch.results:
+    print(f"[{item.index}] {item.response[:50]}")
+```
+
+### 指定调度策略
+
+```python
+client.with_strategy("least_queue").generate("hi")
+```
+
+### 嵌入向量
+
+```python
+resp = client.embed(input="需要向量化的文本", model="bge-m3:567m")
+print(len(resp.embedding))  # 768
+```
+
+## License
+
+MIT License. Copyright (c) 2026 Zhu Wenbo (zwb.2002@tsinghua.org.cn).

uip_sdk-0.1.0/README.md

@@ -0,0 +1,88 @@
+# UIP Python SDK
+
+Universal Inference Platform 的 Python 客户端库。
+
+## 安装
+
+```bash
+pip install uip-sdk
+```
+
+## 快速开始
+
+```python
+from uip_sdk import UIPClient
+
+# 方式 1: API Key
+client = UIPClient(api_key="ggw-xxx...")
+
+# 方式 2: JWT Token
+client = UIPClient(token="eyJhbGciOiJIUzI1NiIs...")
+
+# 方式 3: 环境变量 (UIP_API_KEY)
+client = UIPClient()
+```
+
+## 使用示例
+
+### 对话 (Chat Completions)
+
+```python
+resp = client.chat(
+    messages=[{"role": "user", "content": "你好"}],
+    model="qwen2.5:7b",
+)
+print(resp.text)
+```
+
+### 流式生成
+
+```python
+for chunk in client.generate("写一首关于春天的诗", stream=True):
+    print(chunk.text, end="", flush=True)
+```
+
+### Rerank (文档重排序)
+
+```python
+results = client.rerank(
+    query="CBA季后赛战术分析",
+    documents=[
+        "CBA联赛采用胜率决定排名",
+        "篮球三分线距离为6.75米",
+        "广东队采用全场紧逼战术",
+    ],
+    model="Qwen3-Reranker-0.6B",
+    top_n=2,
+)
+for r in results.results:
+    print(f"#{r.index}: {r.document[:30]}... score={r.relevance_score:.2f}")
+```
+
+### 批量推理
+
+```python
+batch = client.batch(
+    prompts=["你好", "介绍你自己"],
+    model="qwen2.5:7b",
+)
+for item in batch.results:
+    print(f"[{item.index}] {item.response[:50]}")
+```
+
+### 指定调度策略
+
+```python
+client.with_strategy("least_queue").generate("hi")
+```
+
+### 嵌入向量
+
+```python
+resp = client.embed(input="需要向量化的文本", model="bge-m3:567m")
+print(len(resp.embedding))  # 768
+```
+
+## License
+
+MIT License. Copyright (c) 2026 Zhu Wenbo (zwb.2002@tsinghua.org.cn).

uip_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "uip-sdk"
+version = "0.1.0"
+description = "UIP — Universal Inference Platform Python SDK"
+readme = "README.md"
+authors = [{name = "Zhu Wenbo", email = "zwb.2002@tsinghua.org.cn"}]
+license = {text = "MIT"}
+requires-python = ">=3.10"
+dependencies = ["httpx>=0.27"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[tool.setuptools.packages.find]
+include = ["uip_sdk*"]

uip_sdk-0.1.0/setup.cfg

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

uip_sdk-0.1.0/uip_sdk/__init__.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2026 Zhu Wenbo (zwb.2002@tsinghua.org.cn). Licensed under the MIT License.
+"""
+UIP Python SDK — Universal Inference Platform Client Library
+
+Usage:
+    from uip_sdk import UIPClient
+
+    client = UIPClient(base_url="http://10.0.1.115:11438", api_key="ggw-xxx")
+    for chunk in client.generate("你好", stream=True):
+        print(chunk.text, end="")
+"""
+
+from .client import UIPClient
+from .models import (
+    ChatResponse,
+    GenResponse,
+    EmbedResponse,
+    RerankResponse,
+    BatchResponse,
+    UploadResponse,
+    ModelItem,
+    StreamChunk,
+    TokenUsage,
+)
+from .errors import (
+    UIPError,
+    AuthenticationError,
+    InsufficientBalanceError,
+    UIGOfflineError,
+    TimeoutError,
+    RateLimitError,
+)
+
+__all__ = [
+    "UIPClient",
+    "ChatResponse",
+    "GenResponse",
+    "EmbedResponse",
+    "RerankResponse",
+    "BatchResponse",
+    "UploadResponse",
+    "ModelItem",
+    "StreamChunk",
+    "TokenUsage",
+    "UIPError",
+    "AuthenticationError",
+    "InsufficientBalanceError",
+    "UIGOfflineError",
+    "TimeoutError",
+    "RateLimitError",
+]

uip_sdk-0.1.0/uip_sdk/client.py

@@ -0,0 +1,437 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2026 Zhu Wenbo (zwb.2002@tsinghua.org.cn). Licensed under the MIT License.
+"""UIP SDK — 核心客户端"""
+
+import json
+import os
+import time
+from typing import Any, AsyncIterator, Iterator, Optional, Union
+
+import httpx
+
+from .errors import (
+    AuthenticationError,
+    InsufficientBalanceError,
+    NotFoundError,
+    RateLimitError,
+    ServerError,
+    TimeoutError,
+    UIGOfflineError,
+    UIPError,
+)
+from .models import (
+    BatchResponse,
+    BatchResult,
+    ChatResponse,
+    EmbedResponse,
+    GenResponse,
+    ModelItem,
+    RerankItem,
+    RerankResponse,
+    StreamChunk,
+    TokenUsage,
+    UploadResponse,
+)
+from .stream import iter_sse_lines
+
+
+class UIPClient:
+    """UIP API 客户端
+
+    Args:
+        base_url: UIP API 地址 (默认 http://10.0.1.115:11438)
+        api_key: API Key (与 token 二选一)
+        token: JWT Token (与 api_key 二选一)
+        timeout: HTTP 超时秒数 (默认 300)
+        strategy: 调度策略 (可选，如 "least_queue")
+    """
+
+    def __init__(
+        self,
+        base_url: str = "http://10.0.1.115:11438",
+        api_key: Optional[str] = None,
+        token: Optional[str] = None,
+        timeout: int = 300,
+        strategy: Optional[str] = None,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self._api_key = api_key or os.environ.get("UIP_API_KEY", "")
+        self._token = token or os.environ.get("UIP_TOKEN", "")
+        self.timeout = timeout
+        self._strategy = strategy
+
+        if not self._api_key and not self._token:
+            # 尝试从 UIP_API_KEY 环境变量读取
+            self._api_key = os.environ.get("UIP_API_KEY", "")
+        if not self._api_key and not self._token:
+            raise AuthenticationError(
+                "需要提供 api_key 或 token。"
+                "可通过参数传入或设置 UIP_API_KEY 环境变量。"
+            )
+
+        self._client = httpx.Client(timeout=httpx.Timeout(self.timeout), base_url=self.base_url)
+
+    # ─── 认证头 ─────────────────────────────────────────────────────
+
+    def _headers(self) -> dict:
+        h = {}
+        if self._token:
+            h["Authorization"] = f"Bearer {self._token}"
+        elif self._api_key:
+            h["x-api-key"] = self._api_key
+        if self._strategy:
+            h["X-UIP-Strategy"] = self._strategy
+        return h
+
+    def _raise_on_error(self, resp: httpx.Response) -> None:
+        if resp.status_code < 400:
+            return
+        detail = ""
+        try:
+            body = resp.json()
+            detail = body.get("detail", resp.text[:200])
+        except Exception:
+            detail = resp.text[:200]
+
+        if resp.status_code == 401:
+            raise AuthenticationError("认证失败，请检查 api_key 或 token", 401, detail)
+        elif resp.status_code == 402:
+            raise InsufficientBalanceError("余额不足", 402, detail)
+        elif resp.status_code == 404:
+            raise NotFoundError("资源不存在", 404, detail)
+        elif resp.status_code == 429:
+            raise RateLimitError("请求频率限制", 429, detail)
+        elif resp.status_code == 503:
+            raise UIGOfflineError("UIG 全部离线", 503, detail)
+        elif resp.status_code == 504:
+            raise TimeoutError("请求超时", 504, detail)
+        elif resp.status_code >= 500:
+            raise ServerError(f"服务端错误", resp.status_code, detail)
+        else:
+            raise UIPError(f"请求失败", resp.status_code, detail)
+
+    def _post(self, endpoint: str, json_body: dict) -> httpx.Response:
+        url = f"{self.base_url}/{endpoint.lstrip('/')}"
+        resp = self._client.post(url, json=json_body, headers=self._headers())
+        self._raise_on_error(resp)
+        return resp
+
+    def _post_stream(self, endpoint: str, json_body: dict) -> httpx.Response:
+        url = f"{self.base_url}/{endpoint.lstrip('/')}"
+        resp = self._client.post(
+            url, json=json_body,
+            headers={**self._headers(), "Accept": "text/event-stream"},
+        )
+        self._raise_on_error(resp)
+        return resp
+
+    # ─── 上下文管理器 ─────────────────────────────────────────────
+
+    def close(self):
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    # ─── Chat Completions ──────────────────────────────────────────
+
+    def chat(
+        self,
+        messages: list[dict],
+        model: str = "qwen2.5:7b",
+        stream: bool = False,
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        top_p: float = 1.0,
+        **kwargs,
+    ) -> Union[ChatResponse, Iterator[StreamChunk]]:
+        """OpenAI 兼容 Chat API
+
+        Args:
+            messages: 消息列表 [{"role":"user","content":"hi"}]
+            model: 模型名
+            stream: 是否流式
+            temperature: 温度 (0-2)
+            max_tokens: 最大输出 Token
+
+        Returns:
+            非流式 → ChatResponse
+            流式 → Iterator[StreamChunk]
+        """
+        body = {
+            "model": model,
+            "messages": messages,
+            "stream": stream,
+            "temperature": temperature,
+            **kwargs,
+        }
+        if max_tokens is not None:
+            body["max_tokens"] = max_tokens
+        if top_p != 1.0:
+            body["top_p"] = top_p
+
+        if stream:
+            return self._stream_chat(body)
+
+        resp = self._post("api/v1/chat/completions", body)
+        data = resp.json()
+        choice = data.get("choices", [{}])[0]
+        usage = data.get("usage", {})
+        return ChatResponse(
+            text=choice.get("message", {}).get("content", ""),
+            model=data.get("model", model),
+            tokens=TokenUsage(
+                input=usage.get("prompt_tokens", 0),
+                output=usage.get("completion_tokens", 0),
+                total=usage.get("total_tokens", 0),
+            ),
+            finish_reason=choice.get("finish_reason", ""),
+            raw=data,
+        )
+
+    def _stream_chat(self, body: dict) -> Iterator[StreamChunk]:
+        resp = self._post_stream("api/v1/chat/completions", body)
+        from .stream import parse_chat_stream_chunk, parse_sse_line
+        buf = b""
+        for chunk in resp.iter_bytes():
+            buf += chunk
+            while b"\n" in buf:
+                line, buf = buf.split(b"\n", 1)
+                raw = line.decode("utf-8", errors="replace").strip()
+                if not raw:
+                    continue
+                parsed = parse_sse_line(raw)
+                if not parsed:
+                    continue
+                if parsed.get("done"):
+                    return
+                yield parse_chat_stream_chunk(parsed)
+
+    # ─── Generate ─────────────────────────────────────────────────
+
+    def generate(
+        self,
+        prompt: str,
+        model: str = "qwen2.5:7b",
+        system: str = "",
+        stream: bool = False,
+        options: Optional[dict] = None,
+    ) -> Union[GenResponse, Iterator[StreamChunk]]:
+        """Ollama 兼容生成 API
+
+        Args:
+            prompt: 输入提示
+            model: 模型名
+            system: 系统提示词
+            stream: 是否流式
+            options: Ollama 选项 (如 {"num_predict": 100})
+
+        Returns:
+            非流式 → GenResponse
+            流式 → Iterator[StreamChunk]
+        """
+        body = {"model": model, "prompt": prompt, "stream": stream}
+        if system:
+            body["system"] = system
+        if options:
+            body["options"] = options
+
+        if stream:
+            return self._stream_generate(body)
+
+        t0 = time.monotonic()
+        resp = self._post("api/v1/generate", body)
+        elapsed_ms = int((time.monotonic() - t0) * 1000)
+        data = resp.json()
+        return GenResponse(
+            text=data.get("response", ""),
+            thinking=data.get("thinking", ""),
+            model=data.get("model", model),
+            done=data.get("done", True),
+            done_reason=data.get("done_reason", ""),
+            tokens=TokenUsage(
+                input=data.get("prompt_eval_count", 0),
+                output=data.get("eval_count", 0),
+            ),
+            total_duration=data.get("total_duration"),
+            load_duration=data.get("load_duration"),
+            prompt_eval_count=data.get("prompt_eval_count"),
+            eval_count=data.get("eval_count"),
+            eval_duration=data.get("eval_duration"),
+            elapsed_ms=elapsed_ms,
+            raw=data,
+        )
+
+    def _stream_generate(self, body: dict) -> Iterator[StreamChunk]:
+        resp = self._post_stream("api/v1/generate", body)
+        yield from iter_sse_lines(resp.iter_bytes())
+
+    # ─── Embeddings ───────────────────────────────────────────────
+
+    def embed(
+        self,
+        input: Union[str, list[str]],
+        model: str = "bge-m3:567m",
+    ) -> EmbedResponse:
+        """文本向量化"""
+        body = {"model": model, "input": input}
+        resp = self._post("api/v1/embeddings", body)
+        data = resp.json()
+
+        usage = data.get("usage", {})
+        embedding = data.get("data", [{}])[0].get("embedding", data.get("embedding", []))
+        if not embedding:
+            embedding = data.get("embeddings", [[]])[0]
+
+        return EmbedResponse(
+            embedding=embedding,
+            model=data.get("model", model),
+            tokens=TokenUsage(
+                input=usage.get("prompt_tokens", usage.get("total_tokens", 0)),
+                output=0,
+                total=usage.get("total_tokens", 0),
+            ),
+            raw=data,
+        )
+
+    # ─── Rerank ───────────────────────────────────────────────────
+
+    def rerank(
+        self,
+        query: str,
+        documents: list[str],
+        model: str = "Qwen3-Reranker-0.6B",
+        top_n: Optional[int] = None,
+    ) -> RerankResponse:
+        """自定义 RerankZ 接口 — 文档重排序
+
+        Args:
+            query: 查询语句
+            documents: 待排序文档列表
+            model: Rerank 模型名
+            top_n: 返回前 N 条 (默认全部)
+        """
+        body = {"model": model, "query": query, "documents": documents}
+        if top_n is not None:
+            body["top_n"] = top_n
+
+        t0 = time.monotonic()
+        resp = self._post("rerank", body)
+        elapsed_ms = int((time.monotonic() - t0) * 1000)
+        data = resp.json()
+
+        results = []
+        for item in data.get("results", []):
+            results.append(RerankItem(
+                index=item.get("index", 0),
+                document=item.get("document", ""),
+                relevance_score=item.get("relevance_score", 0.0),
+            ))
+
+        return RerankResponse(
+            results=results,
+            total=data.get("total", len(documents)),
+            model=data.get("model", model),
+            elapsed_ms=data.get("elapsed_ms", elapsed_ms),
+            raw=data,
+        )
+
+    # ─── Batch ────────────────────────────────────────────────────
+
+    def batch(
+        self,
+        prompts: list[str],
+        model: str = "qwen2.5:7b",
+        system: str = "",
+    ) -> BatchResponse:
+        """批量推理 — 并发转发多个 prompt"""
+        body = {"model": model, "prompts": prompts, "stream": False}
+        if system:
+            body["system"] = system
+
+        resp = self._post("api/v1/batch/completions", body)
+        data = resp.json()
+
+        results = []
+        for item in data.get("results", []):
+            results.append(BatchResult(
+                index=item.get("index", 0),
+                prompt=item.get("prompt", ""),
+                response=item.get("response", ""),
+                error=item.get("error"),
+            ))
+
+        return BatchResponse(
+            total=data.get("total", 0),
+            completed=data.get("completed", 0),
+            errors=data.get("errors", 0),
+            elapsed_ms=data.get("elapsed_ms", 0),
+            results=results,
+            model=data.get("model", model),
+            raw=data,
+        )
+
+    # ─── Upload ───────────────────────────────────────────────────
+
+    def upload(self, file_path: str) -> UploadResponse:
+        """上传文件
+
+        Args:
+            file_path: 本地文件路径
+        """
+        import os as _os
+        filename = _os.path.basename(file_path)
+        with open(file_path, "rb") as f:
+            files = {"file": (filename, f)}
+            url = f"{self.base_url}/api/v1/upload"
+            resp = httpx.post(url, files=files, headers=self._headers(), timeout=self.timeout)
+            self._raise_on_error(resp)
+
+        data = resp.json()
+        return UploadResponse(
+            filename=data.get("filename", ""),
+            original_name=data.get("original_name", filename),
+            size=data.get("size", 0),
+            url=data.get("url", ""),
+            content_type=data.get("content_type", ""),
+            raw=data,
+        )
+
+    # ─── Models ───────────────────────────────────────────────────
+
+    def list_models(self) -> list[ModelItem]:
+        """获取可用模型列表"""
+        resp = self._post("api/v1/models", {})
+        data = resp.json()
+        items = []
+        for m in data.get("data", []):
+            items.append(ModelItem(
+                id=m.get("id", ""),
+                created=m.get("created", 0),
+                owned_by=m.get("owned_by", "uip"),
+            ))
+        return items
+
+    # ─── Strategy ─────────────────────────────────────────────────
+
+    def with_strategy(self, strategy: str) -> "UIPClient":
+        """指定调度策略 (链式调用)
+
+        Args:
+            strategy: model_first / least_queue / weighted_rr / affinity
+
+        Returns:
+            self (支持链式调用)
+        """
+        self._strategy = strategy
+        return self
+
+    # ─── Health ───────────────────────────────────────────────────
+
+    def ping(self) -> dict:
+        """健康检查"""
+        resp = self._post("api/v1/ping", {})
+        return resp.json()

uip_sdk-0.1.0/uip_sdk/errors.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2026 Zhu Wenbo (zwb.2002@tsinghua.org.cn). Licensed under the MIT License.
+"""UIP SDK — 异常层级"""
+
+
+class UIPError(Exception):
+    """UIP SDK 基础异常"""
+    def __init__(self, message: str, status_code: int = 0, detail: str = ""):
+        self.status_code = status_code
+        self.detail = detail
+        super().__init__(f"[{status_code}] {message}" if status_code else message)
+
+
+class AuthenticationError(UIPError):
+    """认证失败 (401)"""
+    pass
+
+
+class InsufficientBalanceError(UIPError):
+    """余额不足 (402)"""
+    pass
+
+
+class UIGOfflineError(UIPError):
+    """UIG 全部离线 (503)"""
+    pass
+
+
+class TimeoutError(UIPError):
+    """请求超时 (504)"""
+    pass
+
+
+class RateLimitError(UIPError):
+    """频率限制 (429)"""
+    pass
+
+
+class NotFoundError(UIPError):
+    """资源不存在 (404)"""
+    pass
+
+
+class ServerError(UIPError):
+    """服务端错误 (5xx)"""
+    pass

uip_sdk-0.1.0/uip_sdk/models.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2026 Zhu Wenbo (zwb.2002@tsinghua.org.cn). Licensed under the MIT License.
+"""UIP SDK — 数据结构模型"""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class TokenUsage:
+    """Token 用量"""
+    input: int = 0
+    output: int = 0
+    total: int = 0
+
+
+@dataclass
+class StreamChunk:
+    """流式响应片段"""
+    text: str = ""
+    done: bool = False
+    total_duration: Optional[int] = None
+    eval_count: Optional[int] = None
+    eval_duration: Optional[int] = None
+    tokens: Optional[TokenUsage] = None
+    index: Optional[int] = None  # chat completions 流式索引
+
+
+@dataclass
+class ChatResponse:
+    """Chat completions 响应"""
+    text: str = ""
+    model: str = ""
+    tokens: TokenUsage = field(default_factory=TokenUsage)
+    elapsed_ms: int = 0
+    finish_reason: str = ""
+    raw: dict = field(default_factory=dict)
+
+
+@dataclass
+class GenResponse:
+    """Generate 响应"""
+    text: str = ""
+    thinking: str = ""
+    model: str = ""
+    done: bool = True
+    done_reason: str = ""
+    tokens: TokenUsage = field(default_factory=TokenUsage)
+    total_duration: Optional[int] = None
+    load_duration: Optional[int] = None
+    prompt_eval_count: Optional[int] = None
+    eval_count: Optional[int] = None
+    eval_duration: Optional[int] = None
+    elapsed_ms: int = 0
+    raw: dict = field(default_factory=dict)
+
+
+@dataclass
+class RerankItem:
+    """Rerank 单条结果"""
+    index: int = 0
+    document: str = ""
+    relevance_score: float = 0.0
+
+
+@dataclass
+class RerankResponse:
+    """Rerank 响应"""
+    results: list[RerankItem] = field(default_factory=list)
+    total: int = 0
+    model: str = ""
+    elapsed_ms: float = 0.0
+    raw: dict = field(default_factory=dict)
+
+
+@dataclass
+class EmbedResponse:
+    """Embedding 响应"""
+    embedding: list[float] = field(default_factory=list)
+    model: str = ""
+    tokens: TokenUsage = field(default_factory=TokenUsage)
+    raw: dict = field(default_factory=dict)
+
+
+@dataclass
+class BatchResult:
+    """批量推理单条结果"""
+    index: int = 0
+    prompt: str = ""
+    response: str = ""
+    error: Optional[str] = None
+
+
+@dataclass
+class BatchResponse:
+    """批量推理响应"""
+    total: int = 0
+    completed: int = 0
+    errors: int = 0
+    elapsed_ms: int = 0
+    results: list[BatchResult] = field(default_factory=list)
+    model: str = ""
+    raw: dict = field(default_factory=dict)
+
+
+@dataclass
+class UploadResponse:
+    """文件上传响应"""
+    filename: str = ""
+    original_name: str = ""
+    size: int = 0
+    url: str = ""
+    content_type: str = ""
+    raw: dict = field(default_factory=dict)
+
+
+@dataclass
+class ModelItem:
+    """模型列表项"""
+    id: str = ""
+    created: int = 0
+    owned_by: str = "uip"

uip_sdk-0.1.0/uip_sdk/stream.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2026 Zhu Wenbo (zwb.2002@tsinghua.org.cn). Licensed under the MIT License.
+"""UIP SDK — SSE 流解析器"""
+
+import json
+from typing import AsyncIterator, Iterator, Optional
+
+from .models import StreamChunk, TokenUsage
+
+
+def parse_sse_line(line: str) -> Optional[dict]:
+    """解析单行 SSE 数据"""
+    line = line.strip()
+    if not line or not line.startswith("data: "):
+        return None
+    data = line[6:]  # 去掉 "data: " 前缀
+    if data.strip() == "[DONE]":
+        return {"done": True}
+    try:
+        return json.loads(data)
+    except json.JSONDecodeError:
+        return None
+
+
+def parse_chat_stream_chunk(data: dict) -> StreamChunk:
+    """解析 /v1/chat/completions 的流式 chunk"""
+    text = ""
+    usage = None
+    finish = ""
+
+    choices = data.get("choices", [])
+    if choices:
+        ch = choices[0]
+        delta = ch.get("delta", {})
+        text = delta.get("content", "")
+        finish = ch.get("finish_reason", "")
+        if ch.get("index") is not None:
+            finish = str(ch["index"])
+
+    if data.get("usage"):
+        u = data["usage"]
+        usage = TokenUsage(
+            input=u.get("prompt_tokens", 0),
+            output=u.get("completion_tokens", 0),
+            total=u.get("total_tokens", 0),
+        )
+
+    done = finish not in ("", None) or data.get("done", False) or bool(data.get("usage"))
+
+    return StreamChunk(
+        text=text,
+        done=done,
+        tokens=usage,
+    )
+
+
+def parse_gen_stream_chunk(data: dict) -> StreamChunk:
+    """解析 /api/generate 的流式 chunk"""
+    text = data.get("response", "")
+    done = data.get("done", False)
+
+    result = StreamChunk(
+        text=text,
+        done=done,
+        total_duration=data.get("total_duration"),
+        eval_count=data.get("eval_count"),
+        eval_duration=data.get("eval_duration"),
+    )
+
+    if done and data.get("eval_count") is not None:
+        result.tokens = TokenUsage(
+            input=data.get("prompt_eval_count", 0),
+            output=data.get("eval_count", 0),
+        )
+
+    return result
+
+
+def iter_sse_lines(body: Iterator[bytes]) -> Iterator[StreamChunk]:
+    """同步 SSE 解析迭代器"""
+    buf = b""
+    for chunk in body:
+        buf += chunk
+        while b"\n" in buf:
+            line, buf = buf.split(b"\n", 1)
+            raw = line.decode("utf-8", errors="replace")
+            parsed = parse_sse_line(raw)
+            if parsed:
+                yield parse_gen_stream_chunk(parsed)
+                if parsed.get("done"):
+                    return
+
+
+async def iter_sse_lines_async(body: AsyncIterator[bytes]) -> AsyncIterator[StreamChunk]:
+    """异步 SSE 解析迭代器"""
+    buf = b""
+    async for chunk in body:
+        buf += chunk
+        while b"\n" in buf:
+            line, buf = buf.split(b"\n", 1)
+            raw = line.decode("utf-8", errors="replace")
+            parsed = parse_sse_line(raw)
+            if parsed:
+                yield parse_gen_stream_chunk(parsed)
+                if parsed.get("done"):
+                    return

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

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: uip-sdk
+Version: 0.1.0
+Summary: UIP — Universal Inference Platform Python SDK
+Author-email: Zhu Wenbo <zwb.2002@tsinghua.org.cn>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+
+# UIP Python SDK
+
+Universal Inference Platform 的 Python 客户端库。
+
+## 安装
+
+```bash
+pip install uip-sdk
+```
+
+## 快速开始
+
+```python
+from uip_sdk import UIPClient
+
+# 方式 1: API Key
+client = UIPClient(api_key="ggw-xxx...")
+
+# 方式 2: JWT Token
+client = UIPClient(token="eyJhbGciOiJIUzI1NiIs...")
+
+# 方式 3: 环境变量 (UIP_API_KEY)
+client = UIPClient()
+```
+
+## 使用示例
+
+### 对话 (Chat Completions)
+
+```python
+resp = client.chat(
+    messages=[{"role": "user", "content": "你好"}],
+    model="qwen2.5:7b",
+)
+print(resp.text)
+```
+
+### 流式生成
+
+```python
+for chunk in client.generate("写一首关于春天的诗", stream=True):
+    print(chunk.text, end="", flush=True)
+```
+
+### Rerank (文档重排序)
+
+```python
+results = client.rerank(
+    query="CBA季后赛战术分析",
+    documents=[
+        "CBA联赛采用胜率决定排名",
+        "篮球三分线距离为6.75米",
+        "广东队采用全场紧逼战术",
+    ],
+    model="Qwen3-Reranker-0.6B",
+    top_n=2,
+)
+for r in results.results:
+    print(f"#{r.index}: {r.document[:30]}... score={r.relevance_score:.2f}")
+```
+
+### 批量推理
+
+```python
+batch = client.batch(
+    prompts=["你好", "介绍你自己"],
+    model="qwen2.5:7b",
+)
+for item in batch.results:
+    print(f"[{item.index}] {item.response[:50]}")
+```
+
+### 指定调度策略
+
+```python
+client.with_strategy("least_queue").generate("hi")
+```
+
+### 嵌入向量
+
+```python
+resp = client.embed(input="需要向量化的文本", model="bge-m3:567m")
+print(len(resp.embedding))  # 768
+```
+
+## License
+
+MIT License. Copyright (c) 2026 Zhu Wenbo (zwb.2002@tsinghua.org.cn).

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

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+uip_sdk/__init__.py
+uip_sdk/client.py
+uip_sdk/errors.py
+uip_sdk/models.py
+uip_sdk/stream.py
+uip_sdk.egg-info/PKG-INFO
+uip_sdk.egg-info/SOURCES.txt
+uip_sdk.egg-info/dependency_links.txt
+uip_sdk.egg-info/requires.txt
+uip_sdk.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+httpx>=0.27

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

@@ -0,0 +1 @@
+uip_sdk