prismind 0.2.0__py3-none-any.whl

prismind/__init__.py

@@ -0,0 +1,11 @@
+from .entrypoints.sdk import chat, chat_stream, chat_async, set_mode, set_config, clear_cache, clear_history, list_tools
+from .core.multimodal import detect_vision_type, ImageLoader
+from .core.config import load_config, save_config
+
+__version__ = "0.2.0"
+__all__ = [
+    "chat", "chat_stream", "chat_async", "set_mode", "set_config",
+    "clear_cache", "clear_history", "list_tools",
+    "detect_vision_type", "ImageLoader",
+    "load_config", "save_config",
+]

prismind/core/__init__.py

@@ -0,0 +1,10 @@
+from .engine import Engine
+from .prompts import PromptLoader, BUILTIN_PROMPTS, QTYPES, pick_prisms, get_prism_prompt, PRISM_TEMPLATES
+from .reasoning_control import ReasonMode, ReasoningController, DEEP_WARNING
+from .model_profile import ModelProfile, detect_model_profile
+from .cache import Cache
+from .session import SessionManager
+from .tools import ToolRegistry
+from .api_adapter import APIAdapter
+from .multimodal import detect_vision_type, ImageLoader, prune_images, VISION_PROMPTS
+from .config import load_config, save_config

prismind/core/api_adapter.py

@@ -0,0 +1,213 @@
+"""API适配器：统一OpenAI格式 + 多模态差异化构建"""
+import os, time, json, base64, hashlib, sys, requests
+
+
+class APIAdapter:
+    def __init__(self):
+        self._session = requests.Session()
+        self._session.headers.update({"Connection": "keep-alive"})
+
+    def call(self, msgs: list, model: str, ak: str, ab: str,
+             mt: int, temp: float, to: int, stream: bool = False,
+             images: list = None):
+        """统一调用入口，自动识别供应商"""
+        provider = self._detect_provider(ab)
+        has_img = bool(images)
+
+        try:
+            if provider == "ollama":
+                return self._call_ollama(msgs, model, ak, ab, mt, temp, to, stream, images)
+            if provider == "claude":
+                return self._call_claude(msgs, model, ak, ab, mt, temp, to, stream, images)
+            if provider == "gemini":
+                return self._call_gemini(msgs, model, ak, ab, mt, temp, to, stream, images)
+            return self._call_openai(msgs, model, ak, ab, mt, temp, to, stream, images, provider)
+        except Exception as e:
+            print(f"[API 错误] {model}@{ab}: {e}", file=sys.stderr)
+            return None
+
+    # ---- Ollama ----
+    def _call_ollama(self, msgs, model, ak, ab, mt, temp, to, stream, images):
+        text = msgs[-1]["content"]
+        img_data = []
+        if images:
+            for img in images:
+                if img.get("data"): img_data.append(img["data"])
+                elif img.get("url"):
+                    d, _ = self._download_img(img["url"])
+                    if d: img_data.append(d["data"])
+            msgs[-1] = {"role": "user", "content": text}
+        py = {"model": model, "messages": msgs, "stream": stream,
+              "options": {"num_predict": mt, "temperature": temp}}
+        if img_data: py["images"] = img_data
+        r = self._session.post(ab.rstrip("/") + "/api/chat", json=py,
+                                headers={"Content-Type": "application/json"}, timeout=to, stream=stream)
+        if stream:
+            return self._stream_ollama(r)
+        if r.status_code != 200: return None
+        # Ollama 有时返回 NDJSON（每行一个 JSON），兼容两种格式
+        body = r.text.strip()
+        try:
+            return json.loads(body).get("message", {}).get("content", "").strip()
+        except json.JSONDecodeError:
+            # NDJSON 格式：逐行解析取最后一行的 content
+            lines = [l.strip() for l in body.split("\n") if l.strip()]
+            for line in reversed(lines):
+                try:
+                    d = json.loads(line)
+                    if d.get("done"):
+                        return d.get("message", {}).get("content", "") or ""
+                except: continue
+            return ""
+
+    def _stream_ollama(self, r):
+        def gen():
+            try:
+                for l in r.iter_lines():
+                    if not l: continue
+                    try:
+                        d = json.loads(l.decode())
+                        if d.get("done"): break
+                        yield d.get("message", {}).get("content", "")
+                    except: continue
+            finally: pass
+        return gen()
+
+    # ---- Claude ----
+    def _call_claude(self, msgs, model, ak, ab, mt, temp, to, stream, images):
+        sy, ot = "", []
+        for m in msgs:
+            if m["role"] == "system": sy = m["content"]
+            else:
+                if images and m["role"] == "user" and m == msgs[-1]:
+                    content = self._build_claude_content(m["content"], images)
+                    ot.append({"role": "user", "content": content})
+                else:
+                    ot.append({"role": m["role"], "content": m["content"]})
+        py = {"model": model, "max_tokens": mt, "messages": ot, "stream": stream}
+        if sy: py["system"] = sy
+        r = self._session.post(ab.rstrip("/") + "/v1/messages", json=py,
+                                headers={"x-api-key": ak, "anthropic-version": "2023-06-01",
+                                         "Content-Type": "application/json"}, timeout=to, stream=stream)
+        if stream:
+            def gen():
+                try:
+                    for l in r.iter_lines():
+                        if not l: continue
+                        d = json.loads(l.decode().lstrip("data: "))
+                        if d.get("type") == "content_block_delta": yield d["delta"]["text"]
+                finally: pass
+            return gen()
+        return r.json()["content"][0]["text"].strip()
+
+    def _build_claude_content(self, text, images):
+        parts = [{"type": "text", "text": text}]
+        for img in images:
+            if img.get("data"):
+                parts.append({"type": "image",
+                              "source": {"type": "base64", "media_type": img.get("mime", "image/jpeg"),
+                                        "data": img["data"]}})
+            elif img.get("url"):
+                d, _ = self._download_img(img["url"])
+                if d:
+                    parts.append({"type": "image",
+                                  "source": {"type": "base64", "media_type": d["mime"], "data": d["data"]}})
+        return parts
+
+    # ---- Gemini ----
+    def _call_gemini(self, msgs, model, ak, ab, mt, temp, to, stream, images):
+        contents = []
+        for m in msgs:
+            role = "model" if m["role"] == "assistant" else "user"
+            if images and m["role"] == "user" and m == msgs[-1]:
+                parts = self._build_openai_content(m["content"], images)
+                gp = []
+                for p in parts:
+                    if p["type"] == "text": gp.append({"text": p["text"]})
+                    elif p["type"] == "image_url":
+                        u = p["image_url"]["url"]
+                        if u.startswith("data:"):
+                            _, b64 = u.split(",", 1)
+                            gp.append({"inline_data": {"mime_type": u.split(";")[0].split(":")[1], "data": b64}})
+                        else:
+                            gp.append({"text": f"[图片: {u[:80]}]"})
+                contents.append({"role": role, "parts": gp})
+            else:
+                contents.append({"role": role, "parts": [{"text": m.get("content", "")}]})
+        py = {"contents": contents, "generationConfig": {"maxOutputTokens": mt, "temperature": temp}}
+        r = self._session.post(ab.rstrip("/") + "/v1beta/models/" + model + ":generateContent",
+                                json=py, headers={"Content-Type": "application/json"}, timeout=to)
+        if r.status_code == 200:
+            try: return r.json()["candidates"][0]["content"]["parts"][0]["text"].strip()
+            except: return None
+        return None
+
+    # ---- OpenAI 兼容 ----
+    def _call_openai(self, msgs, model, ak, ab, mt, temp, to, stream, images, provider):
+        if images:
+            oa = []
+            for m in msgs:
+                if m["role"] == "user" and m == msgs[-1]:
+                    oa.append({"role": "user", "content": self._build_openai_content(m["content"], images)})
+                else:
+                    oa.append(m)
+        else:
+            oa = msgs
+        py = {"model": model, "messages": oa, "max_tokens": mt, "temperature": temp, "stream": stream}
+        if provider == "ernie":
+            py = {"model": model, "messages": oa, "max_output_tokens": mt, "temperature": temp, "stream": stream}
+        r = self._session.post(ab.rstrip("/") + "/chat/completions", json=py,
+                                headers={"Authorization": f"Bearer {ak}", "Content-Type": "application/json"},
+                                timeout=to, stream=stream)
+        if stream:
+            def gen():
+                try:
+                    for l in r.iter_lines():
+                        if not l: continue
+                        d = l.decode().strip()
+                        if not d.startswith("data:"): continue
+                        d = d[5:].strip()
+                        if d == "[DONE]": break
+                        try: yield json.loads(d)["choices"][0]["delta"].get("content", "")
+                        except: pass
+                finally: pass
+            return gen()
+        if r.status_code == 200:
+            return r.json()["choices"][0]["message"]["content"].strip()
+        return None
+
+    def _build_openai_content(self, text, images):
+        parts = [{"type": "text", "text": text}]
+        for img in images:
+            if img.get("url"):
+                parts.append({"type": "image_url", "image_url": {"url": img["url"]}})
+            elif img.get("data"):
+                mime = img.get("mime", "image/jpeg")
+                parts.append({"type": "image_url",
+                              "image_url": {"url": f"data:{mime};base64,{img['data']}"}})
+        return parts
+
+    def _download_img(self, url, timeout=10):
+        try:
+            r = requests.get(url, timeout=timeout)
+            if r.status_code != 200: return None, "下载失败"
+            ct = r.headers.get("content-type", "").lower()
+            valid = {"image/jpeg", "image/png", "image/gif", "image/webp"}
+            if ct not in valid:
+                ext = os.path.splitext(url.split("?")[0])[1].lower()
+                m = {".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png",
+                     ".gif": "image/gif", ".webp": "image/webp"}
+                ct = m.get(ext, "image/jpeg")
+            return {"data": base64.b64encode(r.content).decode(), "mime": ct}, ""
+        except Exception as e:
+            return None, str(e)
+
+    def _detect_provider(self, ab: str) -> str:
+        b = ab.lower()
+        if "11434" in b: return "ollama"
+        if "anthropic" in b: return "claude"
+        if "googleapis" in b or "generativelanguage" in b: return "gemini"
+        if "baidu" in b or "ernie" in b: return "ernie"
+        if "dashscope" in b or "qwen" in b: return "dashscope"
+        if "bigmodel" in b or "zhipu" in b: return "glm"
+        return "openai"

prismind/core/cache.py

@@ -0,0 +1,55 @@
+"""本地缓存（内存LRU + 可选json持久化）"""
+import os, json, time, threading
+from collections import OrderedDict
+
+
+class Cache:
+    def __init__(self, max_size: int = 200, ttl: int = 3600, persist_path: str = None):
+        self._d = OrderedDict()
+        self._lock = threading.Lock()
+        self.max_size = max_size
+        self.ttl = ttl
+        self.persist_path = persist_path
+        if persist_path and os.path.exists(persist_path):
+            self._load()
+
+    def get(self, key: str):
+        with self._lock:
+            if key not in self._d: return None
+            v, t = self._d[key]
+            if time.time() - t > self.ttl:
+                del self._d[key]
+                return None
+            self._d.move_to_end(key)
+            return v
+
+    def set(self, key: str, value: str):
+        with self._lock:
+            self._d[key] = (value[:10000], time.time())
+            self._d.move_to_end(key)
+            while len(self._d) > self.max_size:
+                self._d.popitem(last=False)
+        self._save()
+
+    def clear(self):
+        with self._lock:
+            self._d.clear()
+        self._save()
+
+    def _save(self):
+        """持久化到磁盘"""
+        if not self.persist_path: return
+        try:
+            os.makedirs(os.path.dirname(self.persist_path), exist_ok=True)
+            with self._lock:
+                with open(self.persist_path, "w", encoding="utf-8") as f:
+                    json.dump({k: v for k, v in self._d.items()}, f, ensure_ascii=False)
+        except: pass
+
+    def _load(self):
+        try:
+            with open(self.persist_path) as f:
+                for k, v in json.load(f).items():
+                    if time.time() - v[1] < self.ttl:
+                        self._d[k] = v
+        except: pass

prismind/core/config.py

@@ -0,0 +1,113 @@
+"""
+配置文件加载：支持 persfuse.json / .env / 环境变量
+优先级：环境变量 > .env > persfuse.json > 默认值
+"""
+import os, json, platform
+
+
+DEFAULT_CONFIG = {
+    "model": "deepseek-chat",
+    "ak": "",
+    "ab": "https://api.deepseek.com/v1",
+    "mode": "standard",
+}
+
+
+def _load_dotenv(path: str = None) -> dict:
+    """简易 .env 解析器（不依赖 python-dotenv）"""
+    if path is None:
+        path = os.path.join(os.getcwd(), ".env")
+    if not os.path.exists(path):
+        return {}
+    result = {}
+    try:
+        with open(path, encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith("#"):
+                    continue
+                if "=" not in line:
+                    continue
+                key, _, val = line.partition("=")
+                key, val = key.strip(), val.strip().strip("\"'").strip()
+                if key.startswith("PRISMIND_"):
+                    env_key = key[len("PRISMIND_"):].lower()
+                    result[env_key] = val
+    except Exception:
+        pass
+    return result
+
+
+def _find_config_file() -> str:
+    """搜索配置文件：当前目录 -> 用户主目录"""
+    candidates = [
+        os.path.join(os.getcwd(), "persfuse.json"),
+        os.path.join(os.getcwd(), ".persfuse.json"),
+    ]
+    home = os.path.expanduser("~")
+    if platform.system() == "Windows":
+        candidates.append(os.path.join(home, "persfuse.json"))
+        candidates.append(os.path.join(os.getenv("APPDATA", ""), "persfuse", "config.json"))
+    else:
+        candidates.append(os.path.join(home, ".config", "persfuse", "config.json"))
+        candidates.append(os.path.join(home, ".persfuse.json"))
+    for path in candidates:
+        if os.path.exists(path):
+            return path
+    return ""
+
+
+def _load_json(path: str) -> dict:
+    try:
+        with open(path, encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def load_config(overrides: dict = None) -> dict:
+    """加载配置，返回值合并了环境变量和文件的设置"""
+    cfg = dict(DEFAULT_CONFIG)
+
+    # 1. .env 文件（在配置文件之前，低于环境变量）
+    dotenv_cfg = _load_dotenv()
+    cfg.update({k: v for k, v in dotenv_cfg.items() if v})
+
+    # 2. 配置文件 (persfuse.json)
+    path = _find_config_file()
+    if path:
+        file_cfg = _load_json(path)
+        cfg.update(file_cfg)
+
+    # 3. 环境变量覆盖（最高）
+    env_map = {
+        "PRISMIND_MODEL": "model",
+        "PRISMIND_AK": "ak",
+        "PRISMIND_AB": "ab",
+        "PRISMIND_MODE": "mode",
+    }
+    for env_key, cfg_key in env_map.items():
+        val = os.environ.get(env_key)
+        if val:
+            cfg[cfg_key] = val
+
+    # 4. 运行时覆盖（最高优先级）
+    if overrides:
+        for k in ("model", "ak", "ab", "mode"):
+            if k in overrides and overrides[k]:
+                cfg[k] = overrides[k]
+
+    return cfg
+
+
+def save_config(cfg: dict, path: str = None) -> str:
+    """保存配置到文件"""
+    if not path:
+        if platform.system() == "Windows":
+            path = os.path.join(os.getenv("APPDATA", os.path.expanduser("~")), "persfuse", "config.json")
+        else:
+            path = os.path.join(os.path.expanduser("~"), ".config", "persfuse", "config.json")
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(cfg, f, ensure_ascii=False, indent=2)
+    return path