llms-py 3.0.0__py3-none-any.whl → 3.0.0b1__py3-none-any.whl

llms/extensions/gallery/README.md

@@ -1,61 +0,0 @@
-# Gallery Extension
-
-The Gallery extension intercepts all generated image, audio & file assets and uploaded files in `~/.llms/cache` file storage whose metadata is maintained in a SQLite database.
-
-Dedicated UIs are available for quickly browsing and navigating or generated images / audio files with optimized UIs for viewing portrait, square and landscape images.
-
-## Generated Asset Interception
-
-The Gallery extension automatically monitors the creation of new cache entries. Whenever a file is saved to the LLMs cache (located at `~/.llms/cache`), the extension captures its metadata and stores it in the gallery database.
-
-This includes:
-- **Generated Images**: Images created by AI models (e.g., DALL-E, Stable Diffusion).
-- **Generated Audio**: Audio files generated by text-to-speech or audio models.
-- **Uploaded Files**: Any files uploaded through the UI.
-
-All metadata is stored in a dedicated SQLite database located at `~/.llms/user/default/gallery/gallery.sqlite`, in the `media` table.
-
-## User Interface
-
-The Gallery UI provides a rich, interactive way to explore your generated assets. You can access it via the **Gallery** tab in the sidebar or by navigating to `/gallery`.
-
-### Image Gallery
-
-The image view offers a responsive grid layout optimized for different aspect ratios.
-
-- **Filtering**:
-    - **By Format**: Easily switch between **Portrait**, **Square**, and **Landscape** views to see images in their best light.
-    - **Search**: Real-time search by prompt, model name, or other metadata.
-- **Interactions**:
-    - **Lightbox**: Click any image to view it in full screen.
-    - **Details**: View comprehensive metadata including the prompt used, generation model, dimensions, file size, creation date, and generation cost.
-    - **Download**: extensive download options.
-    - **Remix**: Quickly re-use the prompt and settings of an existing image to generate a new one.
-    - **Delete**: Remove unwanted images from the gallery.
-
-### Audio Gallery
-
-The audio view presents a list layout designed for easy listening and management.
-
-- **Playback**: Integrated audio player to preview generated sounds directly in the list.
-- **Metadata**: Displays the caption/prompt, model, and creation time.
-- **Actions**:
-    - **Remix**: Regenerate audio using the same prompt.
-    - **Delete**: Remove audio files.
-
-## Storage Data model
-
-The `media` table tracks extensive information about each asset to support the search and filtering capabilities:
-
-| Column | Description |
-|---|---|
-| `url` | Relative path to the file in `~/.llms/cache` |
-| `type` | Asset type (image, audio, video) |
-| `prompt` | The prompt used to generate the asset |
-| `model` | The AI model used |
-| `aspect_ratio` | Aspect ratio (e.g., "1:1", "16:9") |
-| `cost` | Generation cost |
-| `metadata` | Additional JSON metadata |
-| `created` | Timestamp of creation |
-
-This local database ensures your gallery remains fast and responsive, even with a large collection of generated assets.

llms/extensions/gallery/__init__.py

@@ -1,61 +0,0 @@
-import json
-import os
-
-from aiohttp import web
-
-g_db = None
-
-try:
-    from llms.extensions.gallery.db import GalleryDB
-except ImportError as e:
-    print(f"Failed to import GalleryDB: {e}")
-    GalleryDB = None
-
-
-def install(ctx):
-    def get_gallery_db():
-        global g_db
-        if g_db is None and GalleryDB:
-            try:
-                db_path = os.path.join(ctx.get_user_path(), "gallery", "gallery.sqlite")
-                g_db = GalleryDB(ctx, db_path)
-            except Exception as e:
-                ctx.err("Failed to init GalleryDB", e)
-        return g_db
-
-    if not get_gallery_db():
-        return
-
-    def on_cache_save(context):
-        url = context["url"]
-        info = context["info"]
-        ctx.log(f"cache saved: {url}")
-        ctx.log(json.dumps(info, indent=2))
-
-        if "url" not in info:
-            info["url"] = url
-        g_db.insert_media(info)
-
-    ctx.register_cache_saved_filter(on_cache_save)
-
-    async def query_media(request):
-        rows = g_db.query_media(request.query, user=ctx.get_username(request))
-        return web.json_response(rows)
-
-    ctx.add_get("media", query_media)
-
-    async def media_totals(request):
-        rows = g_db.media_totals(user=ctx.get_username(request))
-        return web.json_response(rows)
-
-    ctx.add_get("media/totals", media_totals)
-
-    async def delete_media(request):
-        hash = request.match_info["hash"]
-        g_db.delete_media(hash, user=ctx.get_username(request))
-        return web.json_response({})
-
-    ctx.add_delete("media/{hash}", delete_media)
-
-
-__install__ = install

llms/extensions/gallery/db.py

@@ -1,298 +0,0 @@
-import json
-import os
-import sqlite3
-from typing import Any, Dict
-
-
-def ratio_format(ratio):
-    w, h = ratio.split(":")
-    if int(w) < int(h):
-        return -1
-    if int(w) > int(h):
-        return 1
-    return 0
-
-
-class GalleryDB:
-    def __init__(self, ctx, db_path=None):
-        if db_path is None:
-            raise Exception("db_path is required")
-
-        self.ctx = ctx
-        self.db_path = str(db_path)
-        self.columns = {
-            "name": "TEXT",  # chutes-hunyuan-image-3.png (filename)
-            "type": "TEXT",  # image|audio|video
-            "prompt": "TEXT",
-            "model": "TEXT",  # gemini-2.5-flash-image
-            "created": "TIMESTAMP",
-            "cost": "REAL",  # 0.03836745
-            "seed": "INTEGER",  # 1
-            "url": "TEXT",  # /~cache/23/238841878a0ebeeea8d0034cfdafc82b15d3a6d00c344b0b5e174acbb19572ef.png
-            "hash": "TEXT",  # 238841878a0ebeeea8d0034cfdafc82b15d3a6d00c344b0b5e174acbb19572ef
-            "aspect_ratio": "TEXT",  # 9:16
-            "width": "INTEGER",  # 768
-            "height": "INTEGER",  # 1344
-            "size": "INTEGER",  # 1593817 (bytes)
-            "duration": "INTEGER",  # 100 (secs)
-            "user": "TEXT",
-            "reactions": "JSON",  # {"❤": 1, "👍": 2}
-            "caption": "TEXT",
-            "description": "TEXT",
-            "phash": "TEXT",  # 95482f9e1c3f63a1
-            "color": "TEXT",  # #040609
-            "category": "JSON",  # {"fantasy": 0.216552734375, "game character": 0.282470703125}
-            "tags": "JSON",  # {"bug": 0.9706085920333862, "mask": 0.9348311424255371, "glowing": 0.8394700884819031}
-            "rating": "TEXT",  # "M"
-            "ratings": "JSON",  # {"predicted_rating":"G","confidence":0.2164306640625,"all_scores":{"G":0.2164306640625,"PG":0.21240234375,"PG-13":0.1915283203125,"M":0.2069091796875,"R":0.2064208984375}}
-            "objects": "JSON",  # [{"model":"640m","class":"FACE_FEMALE","score":0.5220243334770203,"box":[361,346,367,451]},{"model":"640m","class":"FEMALE_BREAST_EXPOSED","score":0.31755316257476807,"box":[672,1068,212,272]}]
-            "variantId": "TEXT",  # 1
-            "variantName": "TEXT",  # 4x Upscaled
-            "published": "TIMESTAMP",
-            "metadata": "JSON",  # {"date":1767111852}
-        }
-
-        ratios = ctx.aspect_ratios.keys()
-
-        self.formats = {
-            "square": [ratio for ratio in ratios if ratio_format(ratio) == 0],
-            "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()
-
-    def closest_aspect_ratio(self, width, height):
-        target_ratio = width / height
-        closest_ratio = "1:1"
-        min_diff = float("inf")
-
-        for ratio in self.ctx.aspect_ratios:
-            w, h = ratio.split(":")
-            diff = abs(target_ratio - (int(w) / int(h)))
-            if diff < min_diff:
-                min_diff = diff
-                closest_ratio = ratio
-
-        return closest_ratio
-
-    def get_connection(self):
-        return sqlite3.connect(self.db_path)
-
-    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
-                )
-                """,
-            )
-
-            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)")
-
-            # Check for missing columns and migrate if necessary
-            cur = self.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)
-
-    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 get_user_filter(self, user=None):
-        if user is None:
-            return "WHERE user IS NULL ", {}
-        else:
-            return "WHERE user = :user ", {"user": user}
-
-    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 []
-
-    def query_media(self, query: Dict[str, Any], user=None):
-        try:
-            take = query.get("take", 50)
-            skip = query.get("skip", 0)
-            sort = query.get("sort", "-id")
-
-            # always filter by user
-            sql_where, params = self.get_user_filter(user)
-            params.update(
-                {
-                    "take": take,
-                    "skip": skip,
-                }
-            )
-
-            filter = {}
-            for k in query:
-                if k in self.columns:
-                    filter[k] = query[k]
-                    params[k] = query[k]
-
-            if len(filter) > 0:
-                sql_where += " AND " + " AND ".join([f"{k} = :{k}" for k in filter])
-
-            if "q" in query:
-                sql_where += " AND " if sql_where else "WHERE "
-                sql_where += "(prompt LIKE :q OR name LIKE :q OR description LIKE :q OR caption LIKE :q)"
-                params["q"] = f"%{query['q']}%"
-
-            if "format" in query:
-                sql_where += " AND " if sql_where else "WHERE "
-                format_ratios = self.formats.get(query["format"], [])
-                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,
-                )
-        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)