ai: Refactor the code for 2.1.1-ft-QwQ-32B.

jarvis.py

@@ -3,38 +3,22 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
+import asyncio
+import docx
 import gradio as gr
-import requests
+import httpx
 import json
 import os
-import random
-import time
-import pytesseract
-import pdfplumber
-import docx
 import pandas as pd
-import pptx
-import fitz
-import io
-import uuid
-import concurrent.futures
-import itertools
+import pdfplumber
+import pytesseract
+import random
+import requests
 import threading
-import httpx
-import asyncio
-
-from openai import OpenAI
-
-from optillm.cot_reflection import cot_reflection
-from optillm.leap import leap
-from optillm.plansearch import plansearch
-from optillm.reread import re2_approach
-from optillm.rto import round_trip_optimization
-from optillm.self_consistency import advanced_self_consistency_approach
-from optillm.z3_solver import Z3SymPySolverSystem
+import uuid
 
-from pathlib import Path
 from PIL import Image
+from pathlib import Path
 from pptx import Presentation
 
 os.system("apt-get update -q -y && apt-get install -q -y tesseract-ocr tesseract-ocr-eng tesseract-ocr-ind libleptonica-dev libtesseract-dev")
@@ -60,7 +44,7 @@ DEFAULT_CONFIG = json.loads(os.getenv("DEFAULT_CONFIG", "{}"))
 
 META_TAGS = os.getenv("META_TAGS")
 
-ALLOWED_EXTENSIONS = json.loads(os.getenv("ALLOWED_EXTENSIONS"))
+ALLOWED_EXTENSIONS = json.loads(os.getenv("ALLOWED_EXTENSIONS", "[]"))
 
 ACTIVE_CANDIDATE = None
 
@@ -100,11 +84,9 @@ def extract_file_content(file_path):
                     text = page.extract_text()
                     if text:
                         content += text + "\n"
-                    tables = page.extract_tables()
-                    if tables:
-                        for table in tables:
-                            table_str = "\n".join([", ".join(row) for row in table if row])
-                            content += "\n" + table_str + "\n"
+                    for table in page.extract_tables():
+                        table_str = "\n".join([", ".join(row) for row in table if row])
+                        content += "\n" + table_str + "\n"
         elif ext in [".doc", ".docx"]:
             doc = docx.Document(file_path)
             for para in doc.paragraphs:
@@ -119,51 +101,28 @@ def extract_file_content(file_path):
                     if hasattr(shape, "text") and shape.text:
                         content += shape.text + "\n"
         elif ext in [".png", ".jpg", ".jpeg", ".tiff", ".bmp", ".gif", ".webp"]:
-            try:
-                pytesseract.pytesseract.tesseract_cmd = "/usr/bin/tesseract"
-                image = Image.open(file_path)
-                text = pytesseract.image_to_string(image)
-                content += text + "\n"
-            except Exception as e:
-                content += f"{e}\n"
+            pytesseract.pytesseract.tesseract_cmd = "/usr/bin/tesseract"
+            image = Image.open(file_path)
+            content += pytesseract.image_to_string(image) + "\n"
         else:
             content = Path(file_path).read_text(encoding="utf-8")
     except Exception as e:
         content = f"{file_path}: {e}"
     return content.strip()
 
-def process_ai_response(ai_text):
-    try:
-        result = round_trip_optimization(ai_text)
-        result = re2_approach(result)
-        result = cot_reflection(result)
-        result = advanced_self_consistency_approach(result)
-        result = plansearch(result)
-        result = leap(result)
-        solver = Z3SymPySolverSystem()
-        result = solver.solve(result)
-        return result
-    except Exception:
-        return ai_text
-
 async def fetch_response_async(host, provider_key, selected_model, messages, model_config, session_id):
     timeouts = [60, 80, 120, 240]
     for timeout in timeouts:
         try:
             async with httpx.AsyncClient(timeout=timeout) as client:
                 data = {"model": selected_model, "messages": messages, **model_config}
-                extra = {"optillm_approach": "rto|re2|cot_reflection|self_consistency|plansearch|leap|z3|bon|moa|mcts|mcp|router|privacy|executecode|json", "session_id": session_id}
-                resp = await client.post(host, json={**data, "extra_body": extra, "session_id": session_id}, headers={"Authorization": f"Bearer {provider_key}"})
+                resp = await client.post(host, json={**data, "session_id": session_id}, headers={"Authorization": f"Bearer {provider_key}"})
                 resp.raise_for_status()
-                try:
-                    resp_json = resp.json()
-                except json.JSONDecodeError:
-                    return RESPONSES["RESPONSE_2"]
-                if isinstance(resp_json, dict) and "choices" in resp_json and isinstance(resp_json["choices"], list) and len(resp_json["choices"]) > 0 and isinstance(resp_json["choices"][0], dict):
+                resp_json = resp.json()
+                if isinstance(resp_json, dict) and resp_json.get("choices"):
                     choice = resp_json["choices"][0]
-                    if "message" in choice and isinstance(choice["message"], dict) and "content" in choice["message"] and isinstance(choice["message"]["content"], str):
-                        ai_text = choice["message"]["content"]
-                        return process_ai_response(ai_text)
+                    if choice.get("message") and isinstance(choice["message"].get("content"), str):
+                        return choice["message"]["content"]
                 return RESPONSES["RESPONSE_2"]
         except Exception:
             continue
@@ -177,29 +136,25 @@ async def chat_with_model_async(history, user_input, selected_model_display, ses
         sess.session_id = str(uuid.uuid4())
     selected_model = get_model_key(selected_model_display)
     model_config = MODEL_CONFIG.get(selected_model, DEFAULT_CONFIG)
-    messages = [{"role": "user", "content": user} for user, _ in history]
-    messages += [{"role": "assistant", "content": assistant} for _, assistant in history if assistant]
+    messages = [{"role": "user", "content": user} for user, _ in history] + [{"role": "assistant", "content": assistant} for _, assistant in history if assistant]
     if INTERNAL_TRAINING_DATA:
         messages.insert(0, {"role": "system", "content": INTERNAL_TRAINING_DATA})
     messages.append({"role": "user", "content": user_input})
     global ACTIVE_CANDIDATE
-    if ACTIVE_CANDIDATE is not None:
-        try:
-            return await fetch_response_async(ACTIVE_CANDIDATE[0], ACTIVE_CANDIDATE[1], selected_model, messages, model_config, sess.session_id)
-        except Exception:
-            ACTIVE_CANDIDATE = None
-    available_keys = get_available_items(LINUX_SERVER_PROVIDER_KEYS, LINUX_SERVER_PROVIDER_KEYS_MARKED)
-    available_servers = get_available_items(LINUX_SERVER_HOSTS, LINUX_SERVER_HOSTS_MARKED)
-    candidates = [(host, key) for host in available_servers for key in available_keys]
+    if ACTIVE_CANDIDATE:
+        result = await fetch_response_async(ACTIVE_CANDIDATE[0], ACTIVE_CANDIDATE[1], selected_model, messages, model_config, sess.session_id)
+        if result != RESPONSES["RESPONSE_2"]:
+            return result
+        ACTIVE_CANDIDATE = None
+    keys = get_available_items(LINUX_SERVER_PROVIDER_KEYS, LINUX_SERVER_PROVIDER_KEYS_MARKED)
+    hosts = get_available_items(LINUX_SERVER_HOSTS, LINUX_SERVER_HOSTS_MARKED)
+    candidates = [(host, key) for host in hosts for key in keys]
     random.shuffle(candidates)
-    tasks = [fetch_response_async(host, key, selected_model, messages, model_config, sess.session_id) for host, key in candidates]
-    for task in asyncio.as_completed(tasks):
-        try:
-            result = await task
-            ACTIVE_CANDIDATE = next(((host, key) for host, key in candidates if host and key), None)
+    for host, key in candidates:
+        result = await fetch_response_async(host, key, selected_model, messages, model_config, sess.session_id)
+        if result != RESPONSES["RESPONSE_2"]:
+            ACTIVE_CANDIDATE = (host, key)
             return result
-        except Exception:
-            continue
     return RESPONSES["RESPONSE_2"]
 
 async def respond_async(multi_input, history, selected_model_display, sess):
@@ -210,8 +165,7 @@ async def respond_async(multi_input, history, selected_model_display, sess):
     combined_input = ""
     for file_item in message["files"]:
         file_path = file_item["name"] if isinstance(file_item, dict) and "name" in file_item else file_item
-        file_content = extract_file_content(file_path)
-        combined_input += f"{Path(file_path).name}\n\n{file_content}\n\n"
+        combined_input += f"{Path(file_path).name}\n\n{extract_file_content(file_path)}\n\n"
     if message["text"]:
         combined_input += message["text"]
     history.append([combined_input, ""])
@@ -220,14 +174,13 @@ async def respond_async(multi_input, history, selected_model_display, sess):
     def convert_to_string(data):
         if isinstance(data, (str, int, float)):
             return str(data)
-        elif isinstance(data, bytes):
+        if isinstance(data, bytes):
             return data.decode("utf-8", errors="ignore")
-        elif isinstance(data, (list, tuple)):
+        if isinstance(data, (list, tuple)):
             return "".join(map(convert_to_string, data))
-        elif isinstance(data, dict):
+        if isinstance(data, dict):
             return json.dumps(data, ensure_ascii=False)
-        else:
-            return repr(data)
+        return repr(data)
     for character in ai_response:
         history[-1][1] += convert_to_string(character)
         await asyncio.sleep(0.0001)
@@ -239,11 +192,9 @@ def change_model(new_model_display):
 with gr.Blocks(fill_height=True, fill_width=True, title=AI_TYPES["AI_TYPE_4"], head=META_TAGS) as jarvis:
     user_history = gr.State([])
     user_session = gr.State(create_session())
-    selected_model = gr.State(MODEL_CHOICES[0])
+    selected_model = gr.State(MODEL_CHOICES[0] if MODEL_CHOICES else "")
     chatbot = gr.Chatbot(label=AI_TYPES["AI_TYPE_1"], show_copy_button=True, scale=1, elem_id=AI_TYPES["AI_TYPE_2"])
-    #model_dropdown = gr.Dropdown(show_label=False, choices=MODEL_CHOICES, value=MODEL_CHOICES[0])
     with gr.Row():
         msg = gr.MultimodalTextbox(show_label=False, placeholder=RESPONSES["RESPONSE_5"], interactive=True, file_count="single", file_types=ALLOWED_EXTENSIONS)
-    #model_dropdown.change(fn=change_model, inputs=[model_dropdown], outputs=[user_history, user_session, selected_model])
-    msg.submit(fn=respond_async, inputs=[msg, user_history, selected_model, user_session], outputs=[chatbot, msg, user_session], concurrency_limit=None, api_name=INTERNAL_AI_GET_SERVER)
+    msg.submit(fn=respond_async, inputs=[msg, user_history, selected_model, user_session], outputs=[chatbot, msg, user_session], api_name=INTERNAL_AI_GET_SERVER)
 jarvis.launch(max_file_size="1mb")

requirements.txt

@@ -1,11 +1,7 @@
-huggingface_hub
 httpx
-openai
-optillm
 pandas
 pdfplumber
-pillow
-pymupdf
+Pillow
 python-docx
 python-pptx
 pytesseract