llms-py 3.0.0b10__py3-none-any.whl → 3.0.2__py3-none-any.whl

llms/extensions/gallery/db.py

@@ -1,8 +1,19 @@
-import json
+import datetime
 import os
-import sqlite3
 from typing import Any, Dict
 
+from llms.db import DbManager, order_by, to_dto
+
+
+def with_user(data, user):
+    if user is None:
+        if "user" in data:
+            del data["user"]
+        return data
+    else:
+        data["user"] = user
+        return data
+
 
 def ratio_format(ratio):
     w, h = ratio.split(":")
@@ -20,7 +31,13 @@ class GalleryDB:
 
         self.ctx = ctx
         self.db_path = str(db_path)
+        dirname = os.path.dirname(self.db_path)
+        if dirname:
+            os.makedirs(dirname, exist_ok=True)
+
+        self.db = DbManager(ctx, self.db_path)
         self.columns = {
+            "id": "INTEGER",
             "name": "TEXT",  # chutes-hunyuan-image-3.png (filename)
             "type": "TEXT",  # image|audio|video
             "prompt": "TEXT",
@@ -59,7 +76,8 @@ class GalleryDB:
             "landscape": [ratio for ratio in ratios if ratio_format(ratio) == 1],
             "portrait": [ratio for ratio in ratios if ratio_format(ratio) == -1],
         }
-        self.init_db()
+        with self.db.create_writer_connection() as conn:
+            self.init_db(conn)
 
     def closest_aspect_ratio(self, width, height):
         target_ratio = width / height
@@ -76,172 +94,108 @@ class GalleryDB:
         return closest_ratio
 
     def get_connection(self):
-        return sqlite3.connect(self.db_path)
+        return self.db.create_reader_connection()
 
-    def exec(self, conn, sql, parameters=None):
-        self.ctx.dbg("SQL>" + ("\n" if "\n" in sql else " ") + sql)
-        return conn.execute(sql, parameters or ())
-
-    def all(self, conn, sql, parameters=None):
-        conn.row_factory = sqlite3.Row
-        cursor = self.exec(conn, sql, parameters)
-        return [dict(row) for row in cursor.fetchall()]
-
-    def init_db(self):
-        dirname = os.path.dirname(self.db_path)
-        if dirname:
-            os.makedirs(dirname, exist_ok=True)
-        with self.get_connection() as conn:
-            # Create table with all columns
-            self.exec(
-                conn,
-                """
-                CREATE TABLE IF NOT EXISTS media (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    name TEXT,
-                    type TEXT NOT NULL,
-                    prompt TEXT,
-                    model TEXT,
-                    created TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                    cost REAL,
-                    seed INTEGER,
-                    url TEXT NOT NULL UNIQUE,
-                    hash TEXT NOT NULL UNIQUE,
-                    aspect_ratio TEXT,
-                    width INTEGER,
-                    height INTEGER,
-                    size INTEGER,
-                    duration INTEGER,
-                    user TEXT,
-                    reactions JSON,
-                    caption TEXT,
-                    description TEXT,
-                    phash TEXT,
-                    color TEXT,
-                    category JSON,
-                    tags JSON,
-                    rating TEXT,
-                    ratings JSON,
-                    objects JSON,
-                    variantId TEXT,
-                    variantName TEXT,
-                    published TIMESTAMP,
-                    metadata JSON
-                )
-                """,
+    def init_db(self, conn):
+        # Create table with all columns
+        overrides = {
+            "id": "INTEGER PRIMARY KEY AUTOINCREMENT",
+            "created": "TIMESTAMP DEFAULT CURRENT_TIMESTAMP",
+        }
+        sql_columns = ",".join([f"{col} {overrides.get(col, dtype)}" for col, dtype in self.columns.items()])
+        self.db.exec(
+            conn,
+            f"""
+            CREATE TABLE IF NOT EXISTS media (
+                {sql_columns}
             )
+            """,
+        )
 
-            self.exec(conn, "CREATE INDEX IF NOT EXISTS idx_media_user ON media(user)")
-            self.exec(conn, "CREATE INDEX IF NOT EXISTS idx_media_type ON media(type)")
+        self.db.exec(conn, "CREATE INDEX IF NOT EXISTS idx_media_user ON media(user)")
+        self.db.exec(conn, "CREATE INDEX IF NOT EXISTS idx_media_type ON media(type)")
 
-            # Check for missing columns and migrate if necessary
-            cur = self.exec(conn, "PRAGMA table_info(media)")
-            columns = {row[1] for row in cur.fetchall()}
+        # Check for missing columns and migrate if necessary
+        cur = self.db.exec(conn, "PRAGMA table_info(media)")
+        columns = {row[1] for row in cur.fetchall()}
 
-            for col, dtype in self.columns.items():
-                if col not in columns:
-                    try:
-                        self.exec(conn, f"ALTER TABLE media ADD COLUMN {col} {dtype}")
-                    except Exception as e:
-                        self.ctx.err(f"adding column {col}", e)
+        for col, dtype in self.columns.items():
+            if col not in columns:
+                try:
+                    self.db.exec(conn, f"ALTER TABLE media ADD COLUMN {col} {dtype}")
+                except Exception as e:
+                    self.ctx.err(f"adding column {col}", e)
 
-    def insert_media(self, info):
-        try:
-            if not info:
-                raise Exception("info is required")
-
-            # Helper to safely dump JSON if value exists
-            def db_value(val):
-                if val is None or val == "":
-                    return None
-                if isinstance(val, (dict, list)):
-                    return json.dumps(val)
-                return val
-
-            meta = {}
-            metadata = {}
-            known_columns = self.columns.keys()
-            for k in known_columns:
-                val = info.get(k, None)
-                if k == "metadata":
-                    continue
-                if k == "created" and not val:
-                    continue
-                if k == "type":
-                    parts = val.split("/")
-                    if parts[0] == "image" or parts[0] == "video" or parts[0] == "audio":
-                        meta[k] = parts[0]
-                else:
-                    meta[k] = db_value(val)
-            # for items not in known_columns, add to metadata
-            for k in info:
-                if k not in known_columns:
-                    metadata[k] = info[k]
-
-            if not meta.get("hash"):
-                meta["hash"] = meta["url"].split("/")[-1].split(".")[0]
-
-            if "width" in meta and "height" in meta and meta["width"] and meta["height"]:
-                meta["aspect_ratio"] = self.closest_aspect_ratio(int(meta["width"]), int(meta["height"]))
-
-            meta["metadata"] = db_value(metadata)
-
-            with self.get_connection() as conn:
-                insert_keys = list(meta.keys())
-                insert_body = ", ".join(insert_keys)
-                insert_values = ", ".join(["?" for _ in insert_keys])
-
-                self.exec(
-                    conn,
-                    f"""
-                    INSERT INTO media (
-                        {insert_body}
-                    )
-                    VALUES ({insert_values})
-                    """,
-                    tuple(meta[k] for k in insert_keys),
-                )
-        except sqlite3.IntegrityError as e:
-            # unique constraint failed, file already exists.
-            self.ctx.dbg(f"media already exists {e}")
-        except Exception as e:
-            self.ctx.err("insert media", e)
+    def to_dto(self, row, json_columns):
+        return to_dto(self.ctx, row, json_columns)
 
-    def get_user_filter(self, user=None):
+    def get_user_filter(self, user=None, params=None):
         if user is None:
-            return "WHERE user IS NULL ", {}
+            return "WHERE user IS NULL", params or {}
+        else:
+            args = params.copy() if params else {}
+            args.update({"user": user})
+            return "WHERE user = :user", args
+
+    def prepare_media(self, media, id=None, user=None):
+        now = datetime.now()
+        if id:
+            media["id"] = id
         else:
-            return "WHERE user = :user ", {"user": user}
+            media["created"] = now
+        return with_user(media, user=user)
+
+    def insert_media(self, info, user=None, callback=None):
+        if not info:
+            raise Exception("info is required")
+
+        media = {}
+        metadata = {}
+        known_columns = self.columns.keys()
+        for k in known_columns:
+            val = info.get(k, None)
+            if k == "metadata":
+                continue
+            if k == "created" and not val:
+                continue
+            if k == "type":
+                parts = val.split("/")
+                if parts[0] == "image" or parts[0] == "video" or parts[0] == "audio":
+                    media[k] = parts[0]
+            else:
+                media[k] = self.db.value(val)
+        # for items not in known_columns, add to metadata
+        for k in info:
+            if k not in known_columns:
+                metadata[k] = info[k]
+
+        if not media.get("hash"):
+            media["hash"] = media["url"].split("/")[-1].split(".")[0]
+
+        if "width" in media and "height" in media and media["width"] and media["height"]:
+            media["aspect_ratio"] = self.closest_aspect_ratio(int(media["width"]), int(media["height"]))
+
+        media["metadata"] = self.db.value(metadata)
+        media = with_user(media, user=user)
+
+        insert_keys = list(media.keys())
+        insert_body = ", ".join(insert_keys)
+        insert_values = ", ".join(["?" for _ in insert_keys])
+
+        sql = f"INSERT INTO media ({insert_body}) VALUES ({insert_values})"
+
+        self.db.write(sql, tuple(media[k] for k in insert_keys), callback)
 
     def media_totals(self, user=None):
-        try:
-            with self.get_connection() as conn:
-                sql_where, params = self.get_user_filter(user)
-                return self.all(
-                    conn,
-                    f"SELECT type, COUNT(*) as count FROM media {sql_where} GROUP BY type ORDER BY count DESC",
-                    params,
-                )
-        except Exception as e:
-            self.ctx.err("media_totals", e)
-            return []
-
-    def all_media(self, limit=100, offset=0, user=None):
-        try:
-            with self.get_connection() as conn:
-                sql_where, params = self.get_user_filter(user)
-                params.update({"limit": limit, "offset": offset})
-                return self.all(
-                    conn,
-                    f"SELECT * FROM media {sql_where} ORDER BY id DESC LIMIT :limit OFFSET :offset",
-                    params,
-                )
-        except Exception as e:
-            self.ctx.err(f"all_media ({limit}, {offset})", e)
-            return []
+        sql_where, params = self.get_user_filter(user)
+        return self.db.all(
+            f"SELECT type, COUNT(*) as count FROM media {sql_where} GROUP BY type ORDER BY count DESC",
+            params,
+        )
 
     def query_media(self, query: Dict[str, Any], user=None):
         try:
+            all_columns = self.columns.keys()
             take = query.get("take", 50)
             skip = query.get("skip", 0)
             sort = query.get("sort", "-id")
@@ -275,24 +229,15 @@ class GalleryDB:
                 ratios = ", ".join([f"'{ratio}'" for ratio in format_ratios])
                 sql_where += f"aspect_ratio IN ({ratios})"
 
-            sql_orderby = "ORDER BY " + sort
-            sql_orderby = sql_orderby[1:] + " DESC" if sql_orderby.startswith("-") else sql_orderby + " ASC"
-
-            with self.get_connection() as conn:
-                return self.all(
-                    conn,
-                    f"SELECT * FROM media {sql_where} {sql_orderby} LIMIT :take OFFSET :skip",
-                    params,
-                )
+            return self.db.all(
+                f"SELECT * FROM media {sql_where} {order_by(all_columns, sort)} LIMIT :take OFFSET :skip",
+                params,
+            )
         except Exception as e:
             self.ctx.err(f"query_media ({take}, {skip})", e)
             return []
 
-    def delete_media(self, hash, user=None):
-        try:
-            with self.get_connection() as conn:
-                sql_where, params = self.get_user_filter(user)
-                params.update({"hash": hash})
-                self.exec(conn, f"DELETE FROM media {sql_where} AND hash = :hash", params)
-        except Exception as e:
-            self.ctx.err(f"delete_media ({hash})", e)
+    def delete_media(self, hash, user=None, callback=None):
+        sql_where, params = self.get_user_filter(user)
+        params.update({"hash": hash})
+        self.db.write(f"DELETE FROM media {sql_where} AND hash = :hash", params, callback)

llms/extensions/gallery/ui/index.mjs

@@ -471,7 +471,7 @@ export default {
         ctx.setLeftIcons({
             gallery: {
                 component: {
-                    template: `<svg @click="$ctx.togglePath('/gallery')" viewBox="0 0 15 15" class="w-6 h-6"><path fill="currentColor" d="M10.71 3L7.85.15a.5.5 0 0 0-.707-.003L7.14.15L4.29 3H1.5a.5.5 0 0 0-.5.5v9a.5.5 0 0 0 .5.5h12a.5.5 0 0 0 .5-.5v-9a.5.5 0 0 0-.5-.5zM7.5 1.21L9.29 3H5.71zM13 12H2V4h11zM5 7a1 1 0 1 1 0-2a1 1 0 0 1 0 2m7 4H4.5L6 8l1.25 2.5L9.5 6z"/></svg>`,
+                    template: `<svg @click="$ctx.togglePath('/gallery')" viewBox="0 0 15 15"><path fill="currentColor" d="M10.71 3L7.85.15a.5.5 0 0 0-.707-.003L7.14.15L4.29 3H1.5a.5.5 0 0 0-.5.5v9a.5.5 0 0 0 .5.5h12a.5.5 0 0 0 .5-.5v-9a.5.5 0 0 0-.5-.5zM7.5 1.21L9.29 3H5.71zM13 12H2V4h11zM5 7a1 1 0 1 1 0-2a1 1 0 0 1 0 2m7 4H4.5L6 8l1.25 2.5L9.5 6z"/></svg>`,
                 },
                 isActive({ path }) { return path === '/gallery' }
             }

llms/extensions/providers/__init__.py

@@ -1,4 +1,5 @@
 from .anthropic import install_anthropic
+from .cerebras import install_cerebras
 from .chutes import install_chutes
 from .google import install_google
 from .nvidia import install_nvidia
@@ -8,11 +9,12 @@ from .openrouter import install_openrouter
 
 def install(ctx):
     install_anthropic(ctx)
+    install_cerebras(ctx)
     install_chutes(ctx)
     install_google(ctx)
+    install_nvidia(ctx)
     install_openai(ctx)
     install_openrouter(ctx)
-    install_nvidia(ctx)
 
 
 __install__ = install

llms/extensions/providers/anthropic.py

@@ -27,7 +27,7 @@ def install_anthropic(ctx):
                 self.headers["anthropic-version"] = "2023-06-01"
             self.chat_url = f"{self.api}/messages"
 
-        async def chat(self, chat):
+        async def chat(self, chat, context=None):
             chat["model"] = self.provider_model(chat["model"]) or chat["model"]
 
             chat = await self.process_chat(chat, provider_id=self.id)
@@ -149,10 +149,14 @@ def install_anthropic(ctx):
                     data=json.dumps(anthropic_request),
                     timeout=aiohttp.ClientTimeout(total=120),
                 ) as response:
-                    return ctx.log_json(self.to_response(await self.response_json(response), chat, started_at))
+                    return ctx.log_json(
+                        self.to_response(await self.response_json(response), chat, started_at, context=context)
+                    )
 
-        def to_response(self, response, chat, started_at):
+        def to_response(self, response, chat, started_at, context=None):
             """Convert Anthropic response format to OpenAI-compatible format."""
+            if context is not None:
+                context["providerResponse"] = response
             # Transform Anthropic response to OpenAI format
             ret = {
                 "id": response.get("id", ""),

llms/extensions/providers/cerebras.py

@@ -0,0 +1,37 @@
+def install_cerebras(ctx):
+    from llms.main import OpenAiCompatible
+
+    class CerebrasProvider(OpenAiCompatible):
+        sdk = "@ai-sdk/cerebras"
+
+        def __init__(self, **kwargs):
+            if "api" not in kwargs:
+                kwargs["api"] = "https://api.cerebras.ai/v1"
+            super().__init__(**kwargs)
+
+        async def chat(self, chat, context=None):
+            # Cerebras only supports string content for text-only models
+            clean_chat = chat.copy()
+            clean_chat["messages"] = []
+            for msg in chat.get("messages", []):
+                new_msg = msg.copy()
+                content = msg.get("content")
+                if isinstance(content, list):
+                    # Check if text only
+                    is_text_only = True
+                    text_parts = []
+                    for part in content:
+                        if part.get("type") != "text":
+                            is_text_only = False
+                            break
+                        text_parts.append(part.get("text", ""))
+
+                    if is_text_only:
+                        new_msg["content"] = "".join(text_parts)
+                clean_chat["messages"].append(new_msg)
+
+            clean_chat.pop("modalities", None)
+            clean_chat.pop("systemPrompt", None)
+            return await super().chat(clean_chat, context)
+
+    ctx.add_provider(CerebrasProvider)

llms/extensions/providers/chutes.py

@@ -40,7 +40,7 @@ def install_chutes(ctx):
                 "iLustMix",
             ]
 
-        async def chat(self, chat, provider=None):
+        async def chat(self, chat, provider=None, context=None):
             headers = {"Authorization": f"Bearer {self.api_key}"}
             if provider is not None:
                 headers["Authorization"] = f"Bearer {provider.api_key}"