llms-py 3.0.1__tar.gz → 3.0.2__tar.gz

{llms_py-3.0.1 → llms_py-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llms-py
-Version: 3.0.1
+Version: 3.0.2
 Summary: A lightweight CLI tool and OpenAI-compatible server for querying multiple Large Language Model (LLM) providers
 Home-page: https://github.com/ServiceStack/llms
 Author: ServiceStack

llms_py-3.0.1/llms/extensions/app/db_manager.py → llms_py-3.0.2/llms/db.py

@@ -1,11 +1,17 @@
 import json
 import sqlite3
+import threading
 from queue import Empty, Queue
 from threading import Event, Thread
 
+POOL = True
+
 
 def create_reader_connection(db_path):
-    conn = sqlite3.connect(db_path, timeout=1.0)  # Lower - reads should be fast
+    # isolation_level=None leaves the connection in autocommit mode
+    conn = sqlite3.connect(
+        db_path, timeout=1.0, check_same_thread=False, isolation_level=None
+    )  # Lower - reads should be fast
     conn.execute("PRAGMA query_only=1")  # Read-only optimization
     return conn
 
@@ -33,7 +39,7 @@ def writer_thread(ctx, db_path, task_queue, stop_event):
                 sql, args, callback = task  # Optional callback for results
 
                 try:
-                    ctx.dbg("SQL>" + ("\n" if "\n" in sql else " ") + sql)
+                    ctx.dbg("SQL>" + ("\n" if "\n" in sql else " ") + sql + ("\n" if args else "") + str(args))
                     cursor = conn.execute(sql, args)
                     conn.commit()
                     ctx.dbg(f"lastrowid {cursor.lastrowid}, rowcount {cursor.rowcount}")
@@ -53,17 +59,79 @@ def writer_thread(ctx, db_path, task_queue, stop_event):
         conn.close()
 
 
+def to_dto(ctx, row, json_columns):
+    # as=column -> [0,1,2]
+    if not isinstance(row, dict):
+        return row
+
+    to = {}
+    for k, v in row.items():
+        if k in json_columns and v is not None and isinstance(v, str):
+            try:
+                to[k] = json.loads(v)
+            except Exception as e:
+                print(f"Failed to parse JSON for {k}: {v} ({type(v)})", e)
+                to[k] = v
+        else:
+            to[k] = v
+    return to
+
+
+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 DbManager:
-    def __init__(self, ctx, db_path):
+    def __init__(self, ctx, db_path, clone=None):
         if db_path is None:
             raise ValueError("db_path is required")
         self.ctx = ctx
         self.db_path = db_path
-        self.task_queue = Queue()
-        self.stop_event = Event()
-        self.writer_thread = Thread(target=writer_thread, args=(ctx, db_path, self.task_queue, self.stop_event))
-        self.writer_thread.start()
         self.read_only_pool = Queue()
+        if not clone:
+            self.task_queue = Queue()
+            self.stop_event = Event()
+            self.writer_thread = Thread(target=writer_thread, args=(ctx, db_path, self.task_queue, self.stop_event))
+            self.writer_thread.start()
+        else:
+            # share singleton writer thread in clones
+            self.task_queue = clone.task_queue
+            self.stop_event = clone.stop_event
+            self.writer_thread = clone.writer_thread
 
     def create_reader_connection(self):
         return create_reader_connection(self.db_path)
@@ -72,11 +140,21 @@ class DbManager:
         return create_writer_connection(self.db_path)
 
     def resolve_connection(self):
-        try:
-            return self.read_only_pool.get_nowait()
-        except Empty:
+        if POOL:
+            try:
+                return self.read_only_pool.get_nowait()
+            except Empty:
+                return self.create_reader_connection()
+        else:
             return self.create_reader_connection()
 
+    def release_connection(self, conn):
+        if POOL:
+            conn.rollback()
+            self.read_only_pool.put(conn)
+        else:
+            conn.close()
+
     def write(self, query, args=None, callback=None):
         """
         Execute a write operation asynchronously.
@@ -101,6 +179,9 @@ class DbManager:
         return connection.execute(sql, parameters or ())
 
     def all(self, sql, parameters=None, connection=None):
+        """
+        Execute a query and return all rows as a list of dictionaries.
+        """
         conn = self.resolve_connection() if connection is None else connection
 
         try:
@@ -112,9 +193,12 @@ class DbManager:
         finally:
             if connection is None:
                 conn.row_factory = None
-                self.read_only_pool.put(conn)
+                self.release_connection(conn)
 
     def one(self, sql, parameters=None, connection=None):
+        """
+        Execute a query and return the first row as a dictionary.
+        """
         conn = self.resolve_connection() if connection is None else connection
 
         try:
@@ -126,9 +210,12 @@ class DbManager:
         finally:
             if connection is None:
                 conn.row_factory = None
-                self.read_only_pool.put(conn)
+                self.release_connection(conn)
 
     def scalar(self, sql, parameters=None, connection=None):
+        """
+        Execute a scalar query and return the first column of the first row.
+        """
         conn = self.resolve_connection() if connection is None else connection
 
         try:
@@ -140,7 +227,7 @@ class DbManager:
         finally:
             if connection is None:
                 conn.row_factory = None
-                self.read_only_pool.put(conn)
+                self.release_connection(conn)
 
     def column(self, sql, parameters=None, connection=None):
         """
@@ -154,7 +241,7 @@ class DbManager:
             return [row[0] for row in cursor.fetchall()]
         finally:
             if connection is None:
-                self.read_only_pool.put(conn)
+                self.release_connection(conn)
 
     def dict(self, sql, parameters=None, connection=None):
         """
@@ -171,7 +258,7 @@ class DbManager:
         finally:
             if connection is None:
                 conn.row_factory = None
-                self.read_only_pool.put(conn)
+                self.release_connection(conn)
 
     # Helper to safely dump JSON if value exists
     def value(self, val):
@@ -181,6 +268,74 @@ class DbManager:
             return json.dumps(val)
         return val
 
+    def insert(self, table, columns, info, callback=None):
+        if not info:
+            raise Exception("info is required")
+
+        args = {}
+        known_columns = columns.keys()
+        for k, val in info.items():
+            if k in known_columns and k != "id":
+                args[k] = self.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.write(sql, tuple(args[k] for k in insert_keys), callback)
+
+    async def insert_async(self, table, columns, 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, columns, info, cb)
+        event.wait()
+        return ret[0]
+
+    def update(self, table, columns, info, callback=None):
+        if not info:
+            raise Exception("info is required")
+
+        args = {}
+        known_columns = columns.keys()
+        for k, val in info.items():
+            if k in known_columns and k != "id":
+                args[k] = self.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.write(sql, args, callback)
+
+    async def update_async(self, table, columns, 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, columns, info, cb)
+        event.wait()
+        return ret[0]
+
     def close(self):
         self.ctx.dbg("Closing database")
         self.stop_event.set()

{llms_py-3.0.1 → llms_py-3.0.2}/llms/extensions/app/__init__.py

@@ -7,13 +7,9 @@ from typing import Any
 
 from aiohttp import web
 
-g_db = None
+from .db import AppDB
 
-try:
-    from llms.extensions.app.db import AppDB
-except ImportError as e:
-    print(f"Failed to import AppDB: {e}")
-    AppDB = None
+g_db = None
 
 
 def install(ctx):
@@ -32,28 +28,49 @@ def install(ctx):
     if not get_db():
         return
 
-    def to_dto(row, json_columns):
-        # as=column -> [0,1,2]
-        if not isinstance(row, dict):
-            return row
-
-        to = {}
-        for k, v in row.items():
-            if k in json_columns and v is not None and isinstance(v, str):
-                try:
-                    to[k] = json.loads(v)
-                except Exception as e:
-                    ctx.err(f"Failed to parse JSON for {k}: {v} ({type(v)})", e)
-                    to[k] = v
-            else:
-                to[k] = v
-        return to
+    thread_fields = [
+        "id",
+        "threadId",
+        "createdAt",
+        "updatedAt",
+        "title",
+        "model",
+        "modelInfo",
+        "modalities",
+        "messages",
+        "args",
+        "cost",
+        "inputTokens",
+        "outputTokens",
+        "stats",
+        "provider",
+        "providerModel",
+        "publishedAt",
+        "startedAt",
+        "completedAt",
+        "metadata",
+        "error",
+        "ref",
+    ]
 
     def thread_dto(row):
-        return row and to_dto(row, ["messages", "modalities", "args", "modelInfo", "stats", "metadata"])
+        return row and g_db.to_dto(
+            row,
+            [
+                "messages",
+                "tools",
+                "toolHistory",
+                "modalities",
+                "args",
+                "modelInfo",
+                "stats",
+                "metadata",
+                "providerResponse",
+            ],
+        )
 
     def request_dto(row):
-        return row and to_dto(row, ["usage"])
+        return row and g_db.to_dto(row, ["usage"])
 
     def prompt_to_title(prompt):
         return prompt[:100] + ("..." if len(prompt) > 100 else "") if prompt else None
@@ -67,7 +84,10 @@ def install(ctx):
         return messages
 
     async def query_threads(request):
-        rows = g_db.query_threads(request.query, user=ctx.get_username(request))
+        query = request.query.copy()
+        if "fields" not in query:
+            query["fields"] = thread_fields
+        rows = g_db.query_threads(query, user=ctx.get_username(request))
         dtos = [thread_dto(row) for row in rows]
         return web.json_response(dtos)
 
@@ -81,6 +101,13 @@ def install(ctx):
 
     ctx.add_post("threads", create_thread)
 
+    async def get_thread(request):
+        id = request.match_info["id"]
+        row = g_db.get_thread(id, user=ctx.get_username(request))
+        return web.json_response(thread_dto(row) if row else "")
+
+    ctx.add_get("threads/{id}", get_thread)
+
     async def update_thread(request):
         thread = await request.json()
         id = request.match_info["id"]
@@ -119,8 +146,10 @@ def install(ctx):
         if not thread:
             raise Exception("Thread not found")
 
+        tools = chat.get("tools", thread.get("tools", []))
         update_thread = {
             "messages": messages,
+            "tools": tools,
             "startedAt": datetime.now(),
             "completedAt": None,
             "error": None,
@@ -164,24 +193,28 @@ def install(ctx):
         if not thread:
             raise Exception("Thread not found")
 
-        metadata = thread.get("metadata", {})
+        metadata = thread.get("metadata") or {}
         chat = {
             "model": thread.get("model"),
             "messages": thread.get("messages"),
             "modalities": thread.get("modalities"),
             "systemPrompt": thread.get("systemPrompt"),
+            "tools": thread.get("tools"),  # tools request
             "metadata": metadata,
         }
-        for k, v in thread.get("args", {}).items():
+        args = thread.get("args") or {}
+        for k, v in args.items():
             if k in ctx.request_args:
                 chat[k] = v
 
+        ctx.dbg("CHAT\n" + json.dumps(chat, indent=2))
+
         context = {
             "chat": chat,
             "user": user,
             "threadId": id,
             "metadata": metadata,
-            "tools": metadata.get("tools", "all"),
+            "tools": metadata.get("tools", "all"),  # only tools: all|none|<tool1>,<tool2>,...
         }
 
         # execute chat in background thread
@@ -295,6 +328,7 @@ def install(ctx):
         metadata = chat.get("metadata", {})
         model = chat.get("model", None)
         messages = timestamp_messages(chat.get("messages", []))
+        tools = chat.get("tools", [])
         title = context.get("title") or prompt_to_title(ctx.last_user_prompt(chat) if chat else None)
         started_at = context.get("startedAt")
         if not started_at:
@@ -307,6 +341,7 @@ def install(ctx):
                 "modelInfo": model_info,
                 "title": title,
                 "messages": messages,
+                "tools": tools,
                 "systemPrompt": ctx.chat_to_system_prompt(chat),
                 "modalities": chat.get("modalities", ["text"]),
                 "startedAt": started_at,
@@ -321,6 +356,7 @@ def install(ctx):
                 "modelInfo": model_info,
                 "startedAt": started_at,
                 "messages": messages,
+                "tools": tools,
                 "completedAt": None,
                 "error": None,
                 "metadata": metadata,
@@ -355,6 +391,29 @@ def install(ctx):
 
     ctx.register_chat_tool_filter(tool_request)
 
+    def truncate_long_strings(obj, max_length=10000):
+        """
+        Recursively traverse a dictionary/list structure and replace
+        string values longer than max_length with their length indicator.
+
+        Args:
+            obj: The object to process (dict, list, or other value)
+            max_length: Maximum string length before truncation (default 10000)
+
+        Returns:
+            A new object with long strings replaced by "({length})"
+        """
+        if isinstance(obj, dict):
+            return {key: truncate_long_strings(value, max_length) for key, value in obj.items()}
+        elif isinstance(obj, list):
+            return [truncate_long_strings(item, max_length) for item in obj]
+        elif isinstance(obj, str):
+            if len(obj) > max_length:
+                return f"({len(obj)})"
+            return obj
+        else:
+            return obj
+
     async def chat_response(openai_response, context):
         ctx.dbg("create_response")
         o = openai_response
@@ -406,7 +465,6 @@ def install(ctx):
             "totalTokens": total_tokens,
             "usage": usage,
             "completedAt": completed_at,
-            "toolHistory": o.get("tool_history", None),
             "ref": o.get("id", None),
         }
         tasks.append(g_db.create_request_async(request, user=user))
@@ -436,15 +494,23 @@ def install(ctx):
             }
             messages.append(assistant_message)
 
+            tools = chat.get("tools", [])
             update_thread = {
                 "model": model,
                 "providerModel": o.get("model"),
                 "modelInfo": model_info,
                 "messages": messages,
+                "tools": tools,
                 "completedAt": completed_at,
             }
+            tool_history = o.get("tool_history", None)
+            if tool_history:
+                update_thread["toolHistory"] = tool_history
             if "error" in metadata:
                 update_thread["error"] = metadata["error"]
+            provider_response = context.get("providerResponse", None)
+            if provider_response:
+                update_thread["providerResponse"] = truncate_long_strings(provider_response)
             tasks.append(g_db.update_thread_async(thread_id, update_thread, user=user))
         else:
             ctx.dbg("Missing thread_id")