split code

app.py

@@ -1,105 +0,0 @@
-import asyncio  # <--- Добавили импорт
-import json
-
-import uvicorn
-from fastapi import FastAPI, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse, StreamingResponse
-from gradio import mount_gradio_app
-
-import config
-from model import engine
-from ui import create_ui
-from utils import get_clean_text
-
-model_lock = asyncio.Lock()
-
-app = FastAPI()
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-@app.post("/v1/chat/completions")
-async def chat_completions(request: Request):
-    if model_lock.locked():
-        pass
-
-    if not engine.llm:
-        return JSONResponse(content={"error": "Model not loaded"}, status_code=500)
-
-    try:
-        data = await request.json()
-        raw_messages = data.get("messages", [])
-
-        messages = []
-        for msg in raw_messages:
-            messages.append(
-                {
-                    "role": msg.get("role", "user"),
-                    "content": get_clean_text(msg.get("content")),
-                }
-            )
-
-        stream = data.get("stream", True)
-        temperature = data.get("temperature", config.DEFAULT_TEMP)
-        max_tokens = data.get("max_tokens", config.DEFAULT_MAX_TOKENS)
-
-        async def iter_content_locked():
-            async with model_lock:
-                try:
-                    output = engine.generate(
-                        messages=messages,
-                        max_tokens=max_tokens,
-                        temperature=temperature,
-                        stream=True,
-                    )
-
-                    for chunk in output:
-                        if "model" not in chunk:
-                            chunk["model"] = config.REPO_ID
-                        yield f"data: {json.dumps(chunk)}\n\n"
-                        await asyncio.sleep(0)
-
-                    yield "data: [DONE]\n\n"
-                except Exception as e:
-                    print(f"Streaming error: {e}")
-                    yield f"data: {json.dumps({'error': str(e)})}\n\n"
-
-        if stream:
-            return StreamingResponse(
-                iter_content_locked(),
-                media_type="text/event-stream",
-                headers={
-                    "Cache-Control": "no-cache",
-                    "Connection": "keep-alive",
-                    "X-Accel-Buffering": "no",
-                },
-            )
-        else:
-            async with model_lock:
-                output = engine.generate(
-                    messages=messages,
-                    max_tokens=max_tokens,
-                    temperature=temperature,
-                    stream=False,
-                )
-            return JSONResponse(content=output)
-
-    except Exception as e:
-        import traceback
-
-        traceback.print_exc()
-        return JSONResponse(content={"error": str(e)}, status_code=500)
-
-
-# --- Mount Gradio ---
-demo = create_ui()
-app = mount_gradio_app(app, demo, path="/")
-
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)

config.py

@@ -1,9 +0,0 @@
-REPO_ID = "Qwen/Qwen2.5-Coder-7B-Instruct-GGUF"
-FILENAME = "qwen2.5-coder-7b-instruct-q5_k_m.gguf"
-
-# Параметры модели
-CONTEXT_SIZE = 8192
-DEFAULT_MAX_TOKENS = 4096
-DEFAULT_TEMP = 0.4
-N_THREADS = 2
-N_GPU_LAYERS = 0  # 0 для CPU, -1 для GPU

main.py

@@ -0,0 +1,26 @@
+import uvicorn
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from gradio import mount_gradio_app
+
+from src.api.routes import router as api_router
+from src.ui.components import create_ui
+
+app = FastAPI(title="Code LLM Service")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Подключаем API эндпоинты OpenAI-типа
+app.include_router(api_router, prefix="/v1")
+
+# Подключаем Gradio интерфейс
+ui_app = create_ui()
+app = mount_gradio_app(app, ui_app, path="/")
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -5,3 +5,4 @@ huggingface_hub>=0.27.0
 gradio>=5.9.0
 python-multipart
 psutil
+pydantic-settings

src/api/routes.py

@@ -0,0 +1,47 @@
+import asyncio
+import json
+
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse, StreamingResponse
+from src.utils.helpers import get_clean_text
+
+from src.core.config import settings
+from src.core.engine import engine
+
+router = APIRouter()
+
+
+@router.post("/chat/completions")
+async def chat_completions(request: Request):
+    if not engine.llm:
+        return JSONResponse({"error": "Model not loaded"}, status_code=500)
+
+    data = await request.json()
+    messages = [
+        {"role": m.get("role", "user"), "content": get_clean_text(m.get("content"))}
+        for m in data.get("messages", [])
+    ]
+
+    stream = data.get("stream", True)
+
+    async def stream_generator():
+        async with engine.lock:
+            output = engine.generate(
+                messages,
+                data.get("max_tokens", settings.DEFAULT_MAX_TOKENS),
+                data.get("temperature", settings.DEFAULT_TEMP),
+            )
+            for chunk in output:
+                yield f"data: {json.dumps(chunk)}\n\n"
+            yield "data: [DONE]\n\n"
+
+    if stream:
+        return StreamingResponse(stream_generator(), media_type="text/event-stream")
+
+    async with engine.lock:
+        return engine.generate(
+            messages,
+            data.get("max_tokens", settings.DEFAULT_MAX_TOKENS),
+            data.get("temperature", settings.DEFAULT_TEMP),
+            stream=False,
+        )

src/core/config.py

@@ -0,0 +1,15 @@
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    REPO_ID: str = "Qwen/Qwen2.5-Coder-7B-Instruct-GGUF"
+    FILENAME: str = "qwen2.5-coder-7b-instruct-q5_k_m.gguf"
+
+    CONTEXT_SIZE: int = 8192
+    DEFAULT_MAX_TOKENS: int = 4096
+    DEFAULT_TEMP: float = 0.4
+    N_THREADS: int = 2
+    N_GPU_LAYERS: int = 0
+
+
+settings = Settings()

model.py → src/core/engine.py

@@ -1,37 +1,35 @@
-import json
+import asyncio
 
 from huggingface_hub import hf_hub_download
 from llama_cpp import Llama
 
-from config import CONTEXT_SIZE, FILENAME, N_GPU_LAYERS, N_THREADS, REPO_ID
+from src.core.config import settings
 
 
 class ModelEngine:
     def __init__(self):
         self.llm = None
+        self.lock = asyncio.Lock()
         self._load_model()
 
     def _load_model(self):
-        print(f"Loading model {REPO_ID}...")
         try:
-            model_path = hf_hub_download(repo_id=REPO_ID, filename=FILENAME)
+            model_path = hf_hub_download(
+                repo_id=settings.REPO_ID, filename=settings.FILENAME
+            )
             self.llm = Llama(
                 model_path=model_path,
-                n_ctx=CONTEXT_SIZE,
-                n_threads=N_THREADS,
-                n_gpu_layers=N_GPU_LAYERS,
-                n_batch=512,
+                n_ctx=settings.CONTEXT_SIZE,
+                n_threads=settings.N_THREADS,
+                n_gpu_layers=settings.N_GPU_LAYERS,
                 verbose=True,
             )
-            print("Model loaded successfully.")
         except Exception as e:
-            print(f"CRITICAL ERROR: Failed to load model. {e}")
-            self.llm = None
+            print(f"Error loading model: {e}")
 
     def generate(self, messages, max_tokens, temperature, stream=True):
         if not self.llm:
-            raise RuntimeError("Model is not loaded.")
-
+            raise RuntimeError("Model not loaded")
         return self.llm.create_chat_completion(
             messages=messages,
             max_tokens=int(max_tokens),
@@ -40,5 +38,5 @@ class ModelEngine:
         )
 
 
-# Создаем глобальный экземпляр (Singleton)
+# Создаем синглтон
 engine = ModelEngine()

chat_logic.py → src/ui/callbacks.py

@@ -1,56 +1,28 @@
-import traceback
-
 import gradio as gr
+from src.utils.helpers import get_clean_text
 
-from model import engine
-from utils import get_clean_text
+from src.core.engine import engine
 
 
 def user_input(user_message, history):
-    """Обработка ввода пользователя"""
     if not user_message:
         return None, history
-
-    if history is None:
-        history = []
-
-    clean_history = []
-    for msg in history:
-        raw_content = msg.get("content", "")
-        text_content = get_clean_text(raw_content)
-        clean_history.append({"role": msg["role"], "content": text_content})
-
-    clean_history.append({"role": "user", "content": str(user_message)})
-    return "", clean_history
+    history = history or []
+    history.append({"role": "user", "content": str(user_message)})
+    return "", history
 
 
 def bot_response(history, system_prompt, temperature, max_tokens):
-    """Генерация ответа модели (стриминг)"""
-    if not engine.llm:
-        history.append({"role": "assistant", "content": "Error: Model failed to load."})
-        yield history
-        return
-
     messages = [{"role": "system", "content": system_prompt}]
-
-    # Контекстное окно (последние 15 сообщений)
-    relevant_history = history[-15:] if len(history) > 15 else history
-
-    for msg in relevant_history:
-        raw_content = msg.get("content", "")
-        text_content = get_clean_text(raw_content)
-        messages.append({"role": msg["role"], "content": text_content})
+    for msg in history[-15:]:
+        messages.append(
+            {"role": msg["role"], "content": get_clean_text(msg["content"])}
+        )
 
     history.append({"role": "assistant", "content": ""})
 
     try:
-        stream = engine.generate(
-            messages=messages,
-            max_tokens=max_tokens,
-            temperature=temperature,
-            stream=True,
-        )
-
+        stream = engine.generate(messages, max_tokens, temperature, stream=True)
         partial_text = ""
         for chunk in stream:
             delta = chunk["choices"][0]["delta"]
@@ -58,19 +30,16 @@ def bot_response(history, system_prompt, temperature, max_tokens):
                 partial_text += delta["content"]
                 history[-1]["content"] = partial_text
                 yield history
-
     except Exception as e:
-        traceback.print_exc()
-        history[-1]["content"] = partial_text + f"\n\n❌ **Error:** {str(e)}"
+        history[-1]["content"] += f"\n\n❌ Error: {str(e)}"
         yield history
 
 
 def set_interactive(is_interactive):
-    """Переключение состояния кнопок во время генерации"""
     return (
         gr.update(
             interactive=is_interactive,
-            placeholder="Wait..." if not is_interactive else "Type code question...",
+            placeholder="Wait..." if not is_interactive else "Type...",
         ),
         gr.update(interactive=is_interactive),
     )

src/ui/components.py

@@ -0,0 +1,60 @@
+import os
+
+import gradio as gr
+import psutil
+
+from src.core.config import settings
+from src.ui.callbacks import bot_response, set_interactive, user_input
+from src.ui.styles import CSS
+
+
+def get_system_status():
+    cpu = psutil.cpu_percent()
+    ram = psutil.Process(os.getpid()).memory_info().rss / 1024 / 1024
+    return f"### 🖥️ Status\n**CPU:** {cpu}% | **RAM:** {ram:.1f}MB"
+
+
+def create_ui():
+    with gr.Blocks(css=CSS, title="Code LLM") as demo:
+        timer = gr.Timer(0.5, active=True)
+
+        with gr.Row(elem_id="main-row"):
+            with gr.Sidebar():
+                status = gr.Markdown(get_system_status())
+                sys_pt = gr.Textbox(
+                    label="System Prompt", value="Вы программист.", lines=3
+                )
+                temp = gr.Slider(0, 1, value=settings.DEFAULT_TEMP, label="Temp")
+                tokens = gr.Slider(
+                    512, 8192, value=settings.DEFAULT_MAX_TOKENS, label="Max Tokens"
+                )
+                clear = gr.Button("🗑️ Clear")
+
+            with gr.Column(elem_id="col-chat-main"):
+                chatbot = gr.Chatbot(elem_id="chatbot", type="messages")
+                with gr.Row(elem_id="input-area"):
+                    msg = gr.Textbox(show_label=False, scale=9, autofocus=True)
+                    submit = gr.Button("Run ➤", variant="primary", scale=1)
+
+        # Events
+        timer.tick(get_system_status, outputs=status, show_progress="hidden")
+
+        input_args = [msg, chatbot]
+        output_args = [msg, chatbot]
+        gen_args = [chatbot, sys_pt, temp, tokens]
+
+        msg.submit(user_input, input_args, output_args, queue=False).then(
+            lambda: set_interactive(False), None, [msg, submit]
+        ).then(bot_response, gen_args, chatbot).then(
+            lambda: set_interactive(True), None, [msg, submit]
+        )
+
+        submit.click(user_input, input_args, output_args, queue=False).then(
+            lambda: set_interactive(False), None, [msg, submit]
+        ).then(bot_response, gen_args, chatbot).then(
+            lambda: set_interactive(True), None, [msg, submit]
+        )
+
+        clear.click(lambda: [], None, chatbot)
+
+    return demo

ui.py

@@ -1,108 +0,0 @@
-import os
-
-import gradio as gr
-import psutil
-
-import config
-from chat_logic import bot_response, set_interactive, user_input
-from styles import CSS
-
-
-def get_system_status():
-    """Возвращает текущую загрузку системы для отображения в Markdown"""
-    # CPU
-    cpu_usage = psutil.cpu_percent(interval=None)
-
-    # RAM (процесс приложения)
-    process = psutil.Process(os.getpid())
-    memory_info = process.memory_info()
-    ram_usage_mb = memory_info.rss / 1024 / 1024
-
-    # Общая память системы
-    virtual_mem = psutil.virtual_memory()
-    ram_percent = virtual_mem.percent
-
-    return f"""
-    ### 🖥️ System Health
-    **CPU:** {cpu_usage}%
-    **RAM (App):** {ram_usage_mb:.1f} MB
-    **RAM (Total):** {ram_percent}%
-    """
-
-
-def create_ui():
-    theme = gr.themes.Soft(primary_hue="blue", text_size="lg")
-
-    with gr.Blocks(theme=theme, css=CSS, title="Code LLM") as demo:
-        stats_timer = gr.Timer(value=0.1, active=True)
-
-        with gr.Row(equal_height=True, variant="default", elem_id="main-row"):
-            # --- ЛЕВАЯ КОЛОНКА (Сайдбар) ---
-            with gr.Sidebar(elem_classes=["sidebar"]):
-                gr.Markdown("### ⚙️ Settings")
-
-                # Мониторинг (обновляется автоматически)
-                system_status = gr.Markdown(value=get_system_status())
-
-                gr.Markdown("---")  # Разделительная линия
-
-                system_prompt = gr.Textbox(
-                    label="System Prompt",
-                    value="Вы опытный программист. Пишите чистый и эффективный код.",
-                    lines=5,
-                )
-                temperature = gr.Slider(
-                    0.0, 1.0, value=config.DEFAULT_TEMP, label="Temperature"
-                )
-                max_tokens = gr.Slider(
-                    512, 8192, value=config.DEFAULT_MAX_TOKENS, label="Max Tokens"
-                )
-                clear_btn = gr.Button("🗑️ Clear Chat", variant="secondary")
-
-            # --- ПРАВАЯ КОЛОНКА (Чат) ---
-            with gr.Column(scale=1, elem_id="col-chat-main"):
-                chatbot = gr.Chatbot(
-                    elem_id="chatbot",
-                    label="Code Assistant",
-                    avatar_images=(None, "https://api.iconify.design/noto:robot.svg"),
-                    layout="bubble",
-                    render_markdown=True,
-                )
-
-                with gr.Row(elem_id="input-area"):
-                    msg = gr.Textbox(
-                        show_label=False,
-                        placeholder="Type your code question here...",
-                        lines=1,
-                        scale=9,
-                        autofocus=True,
-                        max_lines=10,
-                        container=False,
-                    )
-                    submit_btn = gr.Button(
-                        "Run ➤", variant="primary", scale=1, min_width=80
-                    )
-
-        # --- СОБЫТИЯ ---
-
-        # Обновление статуса по таймеру
-        stats_timer.tick(
-            get_system_status, outputs=system_status, show_progress="hidden"
-        )
-
-        # Логика отправки сообщений
-        msg.submit(user_input, [msg, chatbot], [msg, chatbot], queue=False).then(
-            lambda: set_interactive(False), None, [msg, submit_btn], queue=False
-        ).then(
-            bot_response, [chatbot, system_prompt, temperature, max_tokens], chatbot
-        ).then(lambda: set_interactive(True), None, [msg, submit_btn], queue=False)
-
-        submit_btn.click(user_input, [msg, chatbot], [msg, chatbot], queue=False).then(
-            lambda: set_interactive(False), None, [msg, submit_btn], queue=False
-        ).then(
-            bot_response, [chatbot, system_prompt, temperature, max_tokens], chatbot
-        ).then(lambda: set_interactive(True), None, [msg, submit_btn], queue=False)
-
-        clear_btn.click(lambda: [], None, chatbot, queue=False)
-
-    return demo