Update app.py

app.py

@@ -1,646 +1,10 @@
-import uuid
-import time
-import json
+from llama_cpp import Llama
 import gradio as gr
-import modelscope_studio.components.antd as antd
-import modelscope_studio.components.antdx as antdx
-import modelscope_studio.components.base as ms
-import modelscope_studio.components.pro as pro
-import dashscope
-from config import DEFAULT_LOCALE, DEFAULT_SETTINGS, DEFAULT_THEME, DEFAULT_SUGGESTIONS, save_history, get_text, user_config, bot_config, welcome_config, api_key, MODEL_OPTIONS_MAP
-from ui_components.logo import Logo
-from ui_components.settings_header import SettingsHeader
-from ui_components.thinking_button import ThinkingButton
-from dashscope import Generation
 
-dashscope.api_key = api_key
+llm = Llama(model_path="./qwen1_8b.gguf")
 
+def chat_fn(prompt):
+    result = llm(prompt, max_tokens=200)
+    return result['choices'][0]['text']
 
-def format_history(history, sys_prompt):
-    # messages = [{
-    #     "role": "system",
-    #     "content": sys_prompt,
-    # }]
-    messages = []
-    for item in history:
-        if item["role"] == "user":
-            messages.append({"role": "user", "content": item["content"]})
-        elif item["role"] == "assistant":
-            contents = [{
-                "type": "text",
-                "text": content["content"]
-            } for content in item["content"] if content["type"] == "text"]
-            messages.append({
-                "role":
-                "assistant",
-                "content":
-                contents[0]["text"] if len(contents) > 0 else ""
-            })
-    return messages
-
-
-class Gradio_Events:
-
-    @staticmethod
-    def submit(state_value):
-
-        history = state_value["conversation_contexts"][
-            state_value["conversation_id"]]["history"]
-        settings = state_value["conversation_contexts"][
-            state_value["conversation_id"]]["settings"]
-        enable_thinking = state_value["conversation_contexts"][
-            state_value["conversation_id"]]["enable_thinking"]
-        model = settings.get("model")
-        messages = format_history(history,
-                                  sys_prompt=settings.get("sys_prompt", ""))
-
-        history.append({
-            "role":
-            "assistant",
-            "content": [],
-            "key":
-            str(uuid.uuid4()),
-            "header":
-            MODEL_OPTIONS_MAP.get(model, {}).get("label", None),
-            "loading":
-            True,
-            "status":
-            "pending"
-        })
-
-        yield {
-            chatbot: gr.update(value=history),
-            state: gr.update(value=state_value),
-        }
-        try:
-            response = Generation.call(
-                model=model,
-                messages=messages,
-                stream=True,
-                result_format='message',
-                incremental_output=True,
-                enable_thinking=enable_thinking,
-                thinking_budget=settings.get("thinking_budget", 1) * 1024)
-            start_time = time.time()
-            reasoning_content = ""
-            answer_content = ""
-            is_thinking = False
-            is_answering = False
-            contents = [None, None]
-            for chunk in response:
-                if (not chunk.output.choices[0].message.get("content")
-                        and not chunk.output.choices[0].message.get(
-                            "reasoning_content")):
-                    pass
-                else:
-                    delta = chunk.output.choices[0].message
-                    if hasattr(
-                            delta,
-                            'reasoning_content') and delta.reasoning_content:
-                        if not is_thinking:
-                            contents[0] = {
-                                "type": "tool",
-                                "content": "",
-                                "options": {
-                                    "title": get_text("Thinking...", "思考中..."),
-                                    "status": "pending"
-                                },
-                                "copyable": False,
-                                "editable": False
-                            }
-                            is_thinking = True
-                        reasoning_content += delta.reasoning_content
-                    if hasattr(delta, 'content') and delta.content:
-                        if not is_answering:
-                            thought_cost_time = "{:.2f}".format(time.time() -
-                                                                start_time)
-                            if contents[0]:
-                                contents[0]["options"]["title"] = get_text(
-                                    f"End of Thought ({thought_cost_time}s)",
-                                    f"已深度思考 (用时{thought_cost_time}s)")
-                                contents[0]["options"]["status"] = "done"
-                            contents[1] = {
-                                "type": "text",
-                                "content": "",
-                            }
-
-                            is_answering = True
-                        answer_content += delta.content
-
-                    if contents[0]:
-                        contents[0]["content"] = reasoning_content
-                    if contents[1]:
-                        contents[1]["content"] = answer_content
-                history[-1]["content"] = [
-                    content for content in contents if content
-                ]
-
-                history[-1]["loading"] = False
-                yield {
-                    chatbot: gr.update(value=history),
-                    state: gr.update(value=state_value)
-                }
-            print("model: ", model, "-", "reasoning_content: ",
-                  reasoning_content, "\n", "content: ", answer_content)
-            history[-1]["status"] = "done"
-            cost_time = "{:.2f}".format(time.time() - start_time)
-            history[-1]["footer"] = get_text(f"{cost_time}s",
-                                             f"用时{cost_time}s")
-            yield {
-                chatbot: gr.update(value=history),
-                state: gr.update(value=state_value),
-            }
-        except Exception as e:
-            print("model: ", model, "-", "Error: ", e)
-            history[-1]["loading"] = False
-            history[-1]["status"] = "done"
-            history[-1]["content"] += [{
-                "type":
-                "text",
-                "content":
-                f'<span style="color: var(--color-red-500)">{str(e)}</span>'
-            }]
-            yield {
-                chatbot: gr.update(value=history),
-                state: gr.update(value=state_value)
-            }
-            raise e
-
-    @staticmethod
-    def add_message(input_value, settings_form_value, thinking_btn_state_value,
-                    state_value):
-        if not state_value["conversation_id"]:
-            random_id = str(uuid.uuid4())
-            history = []
-            state_value["conversation_id"] = random_id
-            state_value["conversation_contexts"][
-                state_value["conversation_id"]] = {
-                    "history": history
-                }
-            state_value["conversations"].append({
-                "label": input_value,
-                "key": random_id
-            })
-
-        history = state_value["conversation_contexts"][
-            state_value["conversation_id"]]["history"]
-
-        state_value["conversation_contexts"][
-            state_value["conversation_id"]] = {
-                "history": history,
-                "settings": settings_form_value,
-                "enable_thinking": thinking_btn_state_value["enable_thinking"]
-            }
-        history.append({
-            "role": "user",
-            "content": input_value,
-            "key": str(uuid.uuid4())
-        })
-        yield Gradio_Events.preprocess_submit(clear_input=True)(state_value)
-
-        try:
-            for chunk in Gradio_Events.submit(state_value):
-                yield chunk
-        except Exception as e:
-            raise e
-        finally:
-            yield Gradio_Events.postprocess_submit(state_value)
-
-    @staticmethod
-    def preprocess_submit(clear_input=True):
-
-        def preprocess_submit_handler(state_value):
-            history = state_value["conversation_contexts"][
-                state_value["conversation_id"]]["history"]
-            return {
-                **({
-                    input:
-                    gr.update(value=None, loading=True) if clear_input else gr.update(loading=True),
-                } if clear_input else {}),
-                conversations:
-                gr.update(active_key=state_value["conversation_id"],
-                          items=list(
-                              map(
-                                  lambda item: {
-                                      **item,
-                                      "disabled":
-                                      True if item["key"] != state_value[
-                                          "conversation_id"] else False,
-                                  }, state_value["conversations"]))),
-                add_conversation_btn:
-                gr.update(disabled=True),
-                clear_btn:
-                gr.update(disabled=True),
-                conversation_delete_menu_item:
-                gr.update(disabled=True),
-                chatbot:
-                gr.update(value=history,
-                          bot_config=bot_config(
-                              disabled_actions=['edit', 'retry', 'delete']),
-                          user_config=user_config(
-                              disabled_actions=['edit', 'delete'])),
-                state:
-                gr.update(value=state_value),
-            }
-
-        return preprocess_submit_handler
-
-    @staticmethod
-    def postprocess_submit(state_value):
-        history = state_value["conversation_contexts"][
-            state_value["conversation_id"]]["history"]
-        return {
-            input:
-            gr.update(loading=False),
-            conversation_delete_menu_item:
-            gr.update(disabled=False),
-            clear_btn:
-            gr.update(disabled=False),
-            conversations:
-            gr.update(items=state_value["conversations"]),
-            add_conversation_btn:
-            gr.update(disabled=False),
-            chatbot:
-            gr.update(value=history,
-                      bot_config=bot_config(),
-                      user_config=user_config()),
-            state:
-            gr.update(value=state_value),
-        }
-
-    @staticmethod
-    def cancel(state_value):
-        history = state_value["conversation_contexts"][
-            state_value["conversation_id"]]["history"]
-        history[-1]["loading"] = False
-        history[-1]["status"] = "done"
-        history[-1]["footer"] = get_text("Chat completion paused", "对话已暂停")
-        return Gradio_Events.postprocess_submit(state_value)
-
-    @staticmethod
-    def delete_message(state_value, e: gr.EventData):
-        index = e._data["payload"][0]["index"]
-        history = state_value["conversation_contexts"][
-            state_value["conversation_id"]]["history"]
-        history = history[:index] + history[index + 1:]
-
-        state_value["conversation_contexts"][
-            state_value["conversation_id"]]["history"] = history
-
-        return gr.update(value=state_value)
-
-    @staticmethod
-    def edit_message(state_value, chatbot_value, e: gr.EventData):
-        index = e._data["payload"][0]["index"]
-        history = state_value["conversation_contexts"][
-            state_value["conversation_id"]]["history"]
-        history[index]["content"] = chatbot_value[index]["content"]
-        return gr.update(value=state_value)
-
-    @staticmethod
-    def regenerate_message(settings_form_value, thinking_btn_state_value,
-                           state_value, e: gr.EventData):
-        index = e._data["payload"][0]["index"]
-        history = state_value["conversation_contexts"][
-            state_value["conversation_id"]]["history"]
-        history = history[:index]
-
-        state_value["conversation_contexts"][
-            state_value["conversation_id"]] = {
-                "history": history,
-                "settings": settings_form_value,
-                "enable_thinking": thinking_btn_state_value["enable_thinking"]
-            }
-
-        yield Gradio_Events.preprocess_submit()(state_value)
-        try:
-            for chunk in Gradio_Events.submit(state_value):
-                yield chunk
-        except Exception as e:
-            raise e
-        finally:
-            yield Gradio_Events.postprocess_submit(state_value)
-
-    @staticmethod
-    def select_suggestion(input_value, e: gr.EventData):
-        input_value = input_value[:-1] + e._data["payload"][0]
-        return gr.update(value=input_value)
-
-    @staticmethod
-    def apply_prompt(e: gr.EventData):
-        return gr.update(value=e._data["payload"][0]["value"]["description"])
-
-    @staticmethod
-    def new_chat(thinking_btn_state, state_value):
-        if not state_value["conversation_id"]:
-            return gr.skip()
-        state_value["conversation_id"] = ""
-        thinking_btn_state["enable_thinking"] = True
-        return gr.update(active_key=state_value["conversation_id"]), gr.update(
-            value=None), gr.update(value=DEFAULT_SETTINGS), gr.update(
-                value=thinking_btn_state), gr.update(value=state_value)
-
-    @staticmethod
-    def select_conversation(thinking_btn_state_value, state_value,
-                            e: gr.EventData):
-        active_key = e._data["payload"][0]
-        if state_value["conversation_id"] == active_key or (
-                active_key not in state_value["conversation_contexts"]):
-            return gr.skip()
-        state_value["conversation_id"] = active_key
-        thinking_btn_state_value["enable_thinking"] = state_value[
-            "conversation_contexts"][active_key]["enable_thinking"]
-        return gr.update(active_key=active_key), gr.update(
-            value=state_value["conversation_contexts"][active_key]["history"]
-        ), gr.update(value=state_value["conversation_contexts"][active_key]
-                     ["settings"]), gr.update(
-                         value=thinking_btn_state_value), gr.update(
-                             value=state_value)
-
-    @staticmethod
-    def click_conversation_menu(state_value, e: gr.EventData):
-        conversation_id = e._data["payload"][0]["key"]
-        operation = e._data["payload"][1]["key"]
-        if operation == "delete":
-            del state_value["conversation_contexts"][conversation_id]
-
-            state_value["conversations"] = [
-                item for item in state_value["conversations"]
-                if item["key"] != conversation_id
-            ]
-
-            if state_value["conversation_id"] == conversation_id:
-                state_value["conversation_id"] = ""
-                return gr.update(
-                    items=state_value["conversations"],
-                    active_key=state_value["conversation_id"]), gr.update(
-                        value=None), gr.update(value=state_value)
-            else:
-                return gr.update(
-                    items=state_value["conversations"]), gr.skip(), gr.update(
-                        value=state_value)
-        return gr.skip()
-
-    @staticmethod
-    def toggle_settings_header(settings_header_state_value):
-        settings_header_state_value[
-            "open"] = not settings_header_state_value["open"]
-        return gr.update(value=settings_header_state_value)
-
-    @staticmethod
-    def clear_conversation_history(state_value):
-        if not state_value["conversation_id"]:
-            return gr.skip()
-        state_value["conversation_contexts"][
-            state_value["conversation_id"]]["history"] = []
-        return gr.update(value=None), gr.update(value=state_value)
-
-    @staticmethod
-    def update_browser_state(state_value):
-
-        return gr.update(value=dict(
-            conversations=state_value["conversations"],
-            conversation_contexts=state_value["conversation_contexts"]))
-
-    @staticmethod
-    def apply_browser_state(browser_state_value, state_value):
-        state_value["conversations"] = browser_state_value["conversations"]
-        state_value["conversation_contexts"] = browser_state_value[
-            "conversation_contexts"]
-        return gr.update(
-            items=browser_state_value["conversations"]), gr.update(
-                value=state_value)
-
-
-css = """
-.gradio-container {
-  padding: 0 !important;
-}
-
-.gradio-container > main.fillable {
-  padding: 0 !important;
-}
-
-#chatbot {
-  height: calc(100vh - 21px - 16px);
-  max-height: 1500px;
-}
-
-#chatbot .chatbot-conversations {
-  height: 100vh;
-  background-color: var(--ms-gr-ant-color-bg-layout);
-  padding-left: 4px;
-  padding-right: 4px;
-}
-
-
-#chatbot .chatbot-conversations .chatbot-conversations-list {
-  padding-left: 0;
-  padding-right: 0;
-}
-
-#chatbot .chatbot-chat {
-  padding: 32px;
-  padding-bottom: 0;
-  height: 100%;
-}
-
-@media (max-width: 768px) {
-  #chatbot .chatbot-chat {
-      padding: 0;
-  }
-}
-
-#chatbot .chatbot-chat .chatbot-chat-messages {
-  flex: 1;
-}
-
-
-#chatbot .setting-form-thinking-budget .ms-gr-ant-form-item-control-input-content {
-    display: flex;
-    flex-wrap: wrap;
-}
-"""
-
-model_options_map_json = json.dumps(MODEL_OPTIONS_MAP)
-js = "function init() { window.MODEL_OPTIONS_MAP=" + model_options_map_json + "}"
-
-with gr.Blocks(css=css, js=js, fill_width=True) as demo:
-    state = gr.State({
-        "conversation_contexts": {},
-        "conversations": [],
-        "conversation_id": "",
-    })
-
-    with ms.Application(), antdx.XProvider(
-            theme=DEFAULT_THEME, locale=DEFAULT_LOCALE), ms.AutoLoading():
-        with antd.Row(gutter=[20, 20], wrap=False, elem_id="chatbot"):
-            # Left Column
-            with antd.Col(md=dict(flex="0 0 260px", span=24, order=0),
-                          span=0,
-                          elem_style=dict(width=0),
-                          order=1):
-                with ms.Div(elem_classes="chatbot-conversations"):
-                    with antd.Flex(vertical=True,
-                                   gap="small",
-                                   elem_style=dict(height="100%")):
-                        # Logo
-                        Logo()
-
-                        # New Conversation Button
-                        with antd.Button(value=None,
-                                         color="primary",
-                                         variant="filled",
-                                         block=True) as add_conversation_btn:
-                            ms.Text(get_text("New Conversation", "新建对话"))
-                            with ms.Slot("icon"):
-                                antd.Icon("PlusOutlined")
-
-                        # Conversations List
-                        with antdx.Conversations(
-                                elem_classes="chatbot-conversations-list",
-                        ) as conversations:
-                            with ms.Slot('menu.items'):
-                                with antd.Menu.Item(
-                                        label="Delete", key="delete",
-                                        danger=True
-                                ) as conversation_delete_menu_item:
-                                    with ms.Slot("icon"):
-                                        antd.Icon("DeleteOutlined")
-            # Right Column
-            with antd.Col(flex=1, elem_style=dict(height="100%")):
-                with antd.Flex(vertical=True,
-                               gap="small",
-                               elem_classes="chatbot-chat"):
-                    # Chatbot
-                    chatbot = pro.Chatbot(elem_classes="chatbot-chat-messages",
-                                          height=0,
-                                          welcome_config=welcome_config(),
-                                          user_config=user_config(),
-                                          bot_config=bot_config())
-
-                    # Input
-                    with antdx.Suggestion(
-                            items=DEFAULT_SUGGESTIONS,
-                            # onKeyDown Handler in Javascript
-                            should_trigger="""(e, { onTrigger, onKeyDown }) => {
-                      switch(e.key) {
-                        case '/':
-                          onTrigger()
-                          break
-                        case 'ArrowRight':
-                        case 'ArrowLeft':
-                        case 'ArrowUp':
-                        case 'ArrowDown':
-                          break;
-                        default:
-                          onTrigger(false)
-                      }
-                      onKeyDown(e)
-                    }""") as suggestion:
-                        with ms.Slot("children"):
-                            with antdx.Sender(placeholder=get_text(
-                                    "Enter \"/\" to get suggestions",
-                                    "输入 \"/\" 获取提示"), ) as input:
-                                with ms.Slot("header"):
-                                    settings_header_state, settings_form = SettingsHeader(
-                                    )
-                                with ms.Slot("prefix"):
-                                    with antd.Flex(
-                                            gap=4,
-                                            wrap=True,
-                                            elem_style=dict(maxWidth='40vw')):
-                                        with antd.Button(
-                                                value=None,
-                                                type="text") as setting_btn:
-                                            with ms.Slot("icon"):
-                                                antd.Icon("SettingOutlined")
-                                        with antd.Button(
-                                                value=None,
-                                                type="text") as clear_btn:
-                                            with ms.Slot("icon"):
-                                                antd.Icon("ClearOutlined")
-                                        thinking_btn_state = ThinkingButton()
-
-    # Events Handler
-    # Browser State Handler
-    if save_history:
-        browser_state = gr.BrowserState(
-            {
-                "conversation_contexts": {},
-                "conversations": [],
-            },
-            storage_key="qwen3_chat_demo_storage")
-        state.change(fn=Gradio_Events.update_browser_state,
-                     inputs=[state],
-                     outputs=[browser_state])
-
-        demo.load(fn=Gradio_Events.apply_browser_state,
-                  inputs=[browser_state, state],
-                  outputs=[conversations, state])
-
-    # Conversations Handler
-    add_conversation_btn.click(fn=Gradio_Events.new_chat,
-                               inputs=[thinking_btn_state, state],
-                               outputs=[
-                                   conversations, chatbot, settings_form,
-                                   thinking_btn_state, state
-                               ])
-    conversations.active_change(fn=Gradio_Events.select_conversation,
-                                inputs=[thinking_btn_state, state],
-                                outputs=[
-                                    conversations, chatbot, settings_form,
-                                    thinking_btn_state, state
-                                ])
-    conversations.menu_click(fn=Gradio_Events.click_conversation_menu,
-                             inputs=[state],
-                             outputs=[conversations, chatbot, state])
-    # Chatbot Handler
-    chatbot.welcome_prompt_select(fn=Gradio_Events.apply_prompt,
-                                  outputs=[input])
-
-    chatbot.delete(fn=Gradio_Events.delete_message,
-                   inputs=[state],
-                   outputs=[state])
-    chatbot.edit(fn=Gradio_Events.edit_message,
-                 inputs=[state, chatbot],
-                 outputs=[state])
-
-    regenerating_event = chatbot.retry(
-        fn=Gradio_Events.regenerate_message,
-        inputs=[settings_form, thinking_btn_state, state],
-        outputs=[
-            input, clear_btn, conversation_delete_menu_item,
-            add_conversation_btn, conversations, chatbot, state
-        ])
-
-    # Input Handler
-    submit_event = input.submit(
-        fn=Gradio_Events.add_message,
-        inputs=[input, settings_form, thinking_btn_state, state],
-        outputs=[
-            input, clear_btn, conversation_delete_menu_item,
-            add_conversation_btn, conversations, chatbot, state
-        ])
-    input.cancel(fn=Gradio_Events.cancel,
-                 inputs=[state],
-                 outputs=[
-                     input, conversation_delete_menu_item, clear_btn,
-                     conversations, add_conversation_btn, chatbot, state
-                 ],
-                 cancels=[submit_event, regenerating_event],
-                 queue=False)
-    # Input Actions Handler
-    setting_btn.click(fn=Gradio_Events.toggle_settings_header,
-                      inputs=[settings_header_state],
-                      outputs=[settings_header_state])
-    clear_btn.click(fn=Gradio_Events.clear_conversation_history,
-                    inputs=[state],
-                    outputs=[chatbot, state])
-    suggestion.select(fn=Gradio_Events.select_suggestion,
-                      inputs=[input],
-                      outputs=[input])
-
-if __name__ == "__main__":
-    demo.queue(default_concurrency_limit=100,
-               max_size=100).launch(ssr_mode=False, max_threads=100)
+gr.Interface(fn=chat_fn, inputs="text", outputs="text", title="Qwen 1.8B на CPU").launch()