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

llms/extensions/app/db.py

@@ -1,10 +1,9 @@
 import json
 import os
-import threading
 from datetime import datetime, timedelta
 from typing import Any, Dict
 
-from .db_manager import DbManager
+from llms.db import DbManager, order_by, select_columns, to_dto, valid_columns
 
 
 def with_user(data, user):
@@ -17,44 +16,6 @@ def with_user(data, user):
         return data
 
 
-def valid_columns(all_columns, fields):
-    if fields:
-        if not isinstance(fields, list):
-            fields = fields.split(",")
-        cols = []
-        for k in fields:
-            k = k.strip()
-            if k in all_columns:
-                cols.append(k)
-        return cols
-    return []
-
-
-def table_columns(all_columns, fields):
-    cols = valid_columns(all_columns, fields)
-    return ", ".join(cols) if len(cols) > 0 else ", ".join(all_columns)
-
-
-def select_columns(all_columns, fields, select=None):
-    columns = table_columns(all_columns, fields)
-    if select == "distinct":
-        return f"SELECT DISTINCT {columns}"
-    return f"SELECT {columns}"
-
-
-def order_by(all_columns, sort):
-    cols = []
-    for k in sort.split(","):
-        k = k.strip()
-        by = ""
-        if k[0] == "-":
-            by = " DESC"
-            k = k[1:]
-        if k in all_columns:
-            cols.append(f"{k}{by}")
-    return f"ORDER BY {', '.join(cols)} " if len(cols) > 0 else ""
-
-
 class AppDB:
     def __init__(self, ctx, db_path):
         if db_path is None:
@@ -81,6 +42,7 @@ class AppDB:
                 "modalities": "JSON",
                 "messages": "JSON",
                 "args": "JSON",
+                "tools": "JSON",
                 "toolHistory": "JSON",
                 "cost": "REAL",
                 "inputTokens": "INTEGER",
@@ -94,6 +56,7 @@ class AppDB:
                 "metadata": "JSON",
                 "error": "TEXT",
                 "ref": "TEXT",
+                "providerResponse": "JSON",
             },
             "request": {
                 "id": "INTEGER",
@@ -300,6 +263,9 @@ class AppDB:
             sql_params,
         ).lastrowid
 
+    def to_dto(self, row, json_columns):
+        return to_dto(self.ctx, row, json_columns)
+
     def get_user_filter(self, user=None, params=None):
         if user is None:
             return "WHERE user IS NULL", params or {}
@@ -309,12 +275,8 @@ class AppDB:
             return "WHERE user = :user", args
 
     def get_thread(self, id, user=None):
-        try:
-            sql_where, params = self.get_user_filter(user, {"id": id})
-            return self.db.one(f"SELECT * FROM thread {sql_where} AND id = :id", params)
-        except Exception as e:
-            self.ctx.err(f"get_thread ({id}, {user})", e)
-            return None
+        sql_where, params = self.get_user_filter(user, {"id": id})
+        return self.db.one(f"SELECT * FROM thread {sql_where} AND id = :id", params)
 
     def get_thread_column(self, id, column, user=None):
         if column not in self.columns["thread"]:
@@ -375,76 +337,6 @@ class AppDB:
             self.ctx.err(f"query_threads ({take}, {skip})", e)
             return []
 
-    def insert(self, table, info, callback=None):
-        if not info:
-            raise Exception("info is required")
-
-        columns = self.columns[table]
-        args = {}
-        known_columns = columns.keys()
-        for k, val in info.items():
-            if k in known_columns and k != "id":
-                args[k] = self.db.value(val)
-
-        insert_keys = list(args.keys())
-        insert_body = ", ".join(insert_keys)
-        insert_values = ", ".join(["?" for _ in insert_keys])
-
-        sql = f"INSERT INTO {table} ({insert_body}) VALUES ({insert_values})"
-
-        self.db.write(sql, tuple(args[k] for k in insert_keys), callback)
-
-    async def insert_async(self, table, info):
-        event = threading.Event()
-
-        ret = [None]
-
-        def cb(lastrowid, rowcount, error=None):
-            nonlocal ret
-            if error:
-                raise error
-            ret[0] = lastrowid
-            event.set()
-
-        self.insert(table, info, cb)
-        event.wait()
-        return ret[0]
-
-    def update(self, table, info, callback=None):
-        if not info:
-            raise Exception("info is required")
-
-        columns = self.columns[table]
-        args = {}
-        known_columns = columns.keys()
-        for k, val in info.items():
-            if k in known_columns and k != "id":
-                args[k] = self.db.value(val)
-
-        update_keys = list(args.keys())
-        update_body = ", ".join([f"{k} = :{k}" for k in update_keys])
-
-        args["id"] = info["id"]
-        sql = f"UPDATE {table} SET {update_body} WHERE id = :id"
-
-        self.db.write(sql, args, callback)
-
-    async def update_async(self, table, info):
-        event = threading.Event()
-
-        ret = [None]
-
-        def cb(lastrowid, rowcount, error=None):
-            nonlocal ret
-            if error:
-                raise error
-            ret[0] = rowcount
-            event.set()
-
-        self.update(table, info, cb)
-        event.wait()
-        return ret[0]
-
     def prepare_thread(self, thread, id=None, user=None):
         now = datetime.now()
         if id:
@@ -458,16 +350,16 @@ class AppDB:
         return with_user(thread, user=user)
 
     def create_thread(self, thread: Dict[str, Any], user=None):
-        return self.insert("thread", self.prepare_thread(thread, user=user))
+        return self.db.insert("thread", self.columns["thread"], self.prepare_thread(thread, user=user))
 
     async def create_thread_async(self, thread: Dict[str, Any], user=None):
-        return await self.insert_async("thread", self.prepare_thread(thread, user=user))
+        return await self.db.insert_async("thread", self.columns["thread"], self.prepare_thread(thread, user=user))
 
     def update_thread(self, id, thread: Dict[str, Any], user=None):
-        return self.update("thread", self.prepare_thread(thread, id, user=user))
+        return self.db.update("thread", self.columns["thread"], self.prepare_thread(thread, id, user=user))
 
     async def update_thread_async(self, id, thread: Dict[str, Any], user=None):
-        return await self.update_async("thread", self.prepare_thread(thread, id, user=user))
+        return await self.db.update_async("thread", self.columns["thread"], self.prepare_thread(thread, id, user=user))
 
     def delete_thread(self, id, user=None, callback=None):
         sql_where, params = self.get_user_filter(user, {"id": id})
@@ -609,21 +501,21 @@ class AppDB:
 
     def create_request(self, request: Dict[str, Any], user=None):
         request["createdAt"] = request["updatedAt"] = datetime.now()
-        return self.insert("request", with_user(request, user=user))
+        return self.db.insert("request", self.columns["request"], with_user(request, user=user))
 
     async def create_request_async(self, request: Dict[str, Any], user=None):
         request["createdAt"] = request["updatedAt"] = datetime.now()
-        return await self.insert_async("request", with_user(request, user=user))
+        return await self.db.insert_async("request", self.columns["request"], with_user(request, user=user))
 
     def update_request(self, id, request: Dict[str, Any], user=None):
         request["id"] = id
         request["updatedAt"] = datetime.now()
-        return self.update("request", with_user(request, user=user))
+        return self.db.update("request", self.columns["request"], with_user(request, user=user))
 
     async def update_request_async(self, id, request: Dict[str, Any], user=None):
         request["id"] = id
         request["updatedAt"] = datetime.now()
-        return await self.update_async("request", with_user(request, user=user))
+        return await self.db.update_async("request", self.columns["request"], with_user(request, user=user))
 
     def delete_request(self, id, user=None, callback=None):
         sql_where, params = self.get_user_filter(user, {"id": id})

llms/extensions/app/ui/threadStore.mjs

@@ -15,6 +15,7 @@ export const nextId = (() => {
 
 
 const threads = ref([])
+const threadDetails = ref({})
 const currentThread = ref(null)
 const isLoading = ref(false)
 
@@ -196,7 +197,7 @@ async function loadThreads() {
     isLoading.value = true
 
     try {
-        const api = await ext.getJson('/threads?take=50')
+        const api = await ext.getJson('/threads?take=30')
         threads.value = api.response || []
         return threads.value
     } finally {
@@ -239,6 +240,7 @@ async function setCurrentThreadFromRoute(threadId, router) {
         return null
     }
 
+    loadThreadDetails(threadId)
     const thread = setCurrentThread(threadId)
     if (thread) {
         return thread
@@ -307,7 +309,7 @@ function getLatestCachedThread() {
     return threads.value[0]
 }
 
-async function startNewThread({ title, model, redirect }) {
+async function startNewThread({ title, model, tools, redirect }) {
     if (!model) {
         console.error('No model selected')
         return
@@ -330,6 +332,7 @@ async function startNewThread({ title, model, redirect }) {
         title,
         model: model.name,
         info: ctx.utils.toModelInfo(model),
+        tools,
     })
 
     console.log('newThread', newThread, model)
@@ -361,6 +364,19 @@ async function queueChat(ctxRequest, options = {}) {
     return api
 }
 
+async function loadThreadDetails(id, opt = null) {
+    if (!threadDetails.value[id] || opt?.force) {
+        const api = await ctx.getJson(`/ext/app/threads/${id}`)
+        if (api.response) {
+            threadDetails.value[id] = api.response
+        }
+        if (api.error) {
+            console.error(api.error)
+        }
+    }
+    return threadDetails.value[id]
+}
+
 // Export the store
 export function useThreadStore() {
     return {
@@ -388,6 +404,8 @@ export function useThreadStore() {
         startNewThread,
         replaceThread,
         queueChat,
+        threadDetails,
+        loadThreadDetails,
         isWatchingThread,
         startWatchingThread,
         stopWatchingThread,

llms/extensions/core_tools/__init__.py

@@ -102,6 +102,24 @@ def write_file(path: str, content: str) -> bool:
     return True
 
 
+def edit_file(path: str, old_str: str, new_str: str) -> Dict[str, Any]:
+    """
+    Replaces first occurrence of old_str with new_str in file. If old_str is empty,
+    create/overwrite file with new_str.
+    :return: A dictionary with the path to the file and the action taken.
+    """
+    safe_path = _resolve_safe_path(path)
+    if old_str == "":
+        safe_path.write_text(new_str, encoding="utf-8")
+        return {"path": str(safe_path), "action": "created_file"}
+    original = safe_path.read_text(encoding="utf-8")
+    if original.find(old_str) == -1:
+        return {"path": str(safe_path), "action": "old_str not found"}
+    edited = original.replace(old_str, new_str, 1)
+    safe_path.write_text(edited, encoding="utf-8")
+    return {"path": str(safe_path), "action": "edited"}
+
+
 def list_directory(path: str) -> str:
     """List directory contents"""
     safe_path = _resolve_safe_path(path)
@@ -526,6 +544,25 @@ def install(ctx):
     # ctx.register_tool(semantic_search) # TODO: implement
     ctx.register_tool(read_file)
     ctx.register_tool(write_file)
+    ctx.register_tool(
+        edit_file,
+        {
+            "type": "function",
+            "function": {
+                "name": "edit_file",
+                "description": "Replaces first occurrence of old_str with new_str in file. If old_str is empty, create/overwrite file with new_str.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "path": {"type": "string", "description": "Path to the file to edit."},
+                        "old_str": {"type": "string", "description": "String to replace."},
+                        "new_str": {"type": "string", "description": "String to replace with."},
+                    },
+                    "required": ["path", "old_str", "new_str"],
+                },
+            },
+        },
+    )
     ctx.register_tool(list_directory)
     ctx.register_tool(glob_paths)
     ctx.register_tool(calc)

llms/extensions/gallery/__init__.py

@@ -3,44 +3,46 @@ import os
 
 from aiohttp import web
 
-g_db = None
+from .db import GalleryDB
 
-try:
-    from llms.extensions.gallery.db import GalleryDB
-except ImportError as e:
-    print(f"Failed to import GalleryDB: {e}")
-    GalleryDB = None
+g_db = None
 
 
 def install(ctx):
-    def get_gallery_db():
+    def get_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)
+                ctx.register_shutdown_handler(g_db.db.close)
             except Exception as e:
                 ctx.err("Failed to init GalleryDB", e)
         return g_db
 
-    if not get_gallery_db():
+    if not get_db():
         return
 
+    def media_dto(row):
+        return row and g_db.to_dto(row, ["reactions", "category", "tags", "ratings", "objects", "metadata"])
+
     def on_cache_save(context):
-        url = context["url"]
-        info = context["info"]
+        url = context.get("url", None)
+        info = context.get("info", {})
+        user = context.get("user", None)
         ctx.log(f"cache saved: {url}")
-        ctx.log(json.dumps(info, indent=2))
+        ctx.dbg(json.dumps(info, indent=2))
 
         if "url" not in info:
             info["url"] = url
-        g_db.insert_media(info)
+        g_db.insert_media(info, user=user)
 
     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)
+        dtos = [media_dto(row) for row in rows]
+        return web.json_response(dtos)
 
     ctx.add_get("media", query_media)