app.py

import os
import re
import base64
import json
from typing import Dict, List, Optional, Tuple

import gradio as gr
from loguru import logger
try:
  from utils import init_logger
  logger = init_logger()
except Exception as e:
    logger.info(f"import_error: {str(e)}")

import sambanova_gradio
from sambanova_gradio import get_fn

import modelscope_studio.components.base as ms
import modelscope_studio.components.legacy as legacy
import modelscope_studio.components.antd as antd
from config import DEMO_LIST, SystemPrompt

YOUR_API_TOKEN = os.getenv('SAMBANOVA_API_KEY')

History = List[Tuple[str, str]]
Messages = List[Dict[str, str]]

from tree_sitter_languages import get_parser
def check_code_error(code, language='python'):
    language_ext = {'go': 'go', 
                    'html': 'html', 
                    'python': 'python', 
                    'cpp': 'cpp', 
                    # 'sql': 'sql', 
                    'php': 'php', 
                    'javascript': 'javascript', 
                    # 'R': 'r', 
                    'typescript': 'typescript', 
                    'ruby': 'ruby', 
                    'bash': 'bash', 
                    'rust': 'rust', 
                    # 'D': 'd', 
                    'scala': 'scala', 
                    'csharp': 'c_sharp', 
                    'java': 'java',
                    'json': 'json',
                    'julia': 'julia',
                    'css': 'css',
                    'jsdoc': 'jsdoc',
                    'swift': 'swift',
                    'cli': 'cli',
                    }    
    if language not in language_ext.keys():
        return {'result': True, 'error': 'no language in tree_sitter_languages'}
    try:
        parser = get_parser(language_ext[language])
        code_bytes = code.encode('utf-8')
        tree = parser.parse(code_bytes)
        root_node = tree.root_node
        
        visit_list = [root_node]
        ans = []
        while visit_list:
            node = visit_list.pop() 
            if node.type == 'ERROR':
                return {'result': True, 'error': True, 'root_node': root_node}
            is_inner = True if node.children else False
            ans.append([node, is_inner])
            for child in node.children:
                visit_list.append(child)

        return {'result': True, 'error': False, 'root_node': root_node}
    except Exception as e:
        return {'result': False, 'error': f"error:{str(e)}"}

def history_to_messages(history: History, system: str) -> Messages:
    messages = [{'role': 'system', 'content': system}]
    for h in history:
        messages.append({'role': 'user', 'content': h[0]})
        messages.append({'role': 'assistant', 'content': h[1]})
    return messages

def messages_to_history(messages: Messages) -> History:
    assert messages[0]['role'] == 'system'
    history = []
    for q, r in zip(messages[1::2], messages[2::2]):
        history.append([q['content'], r['content']])
    return history

def remove_code_block(text, language='html'):
    pattern = r'```' + language.lower() + '\n(.+?)\n```'
    match = re.search(pattern, text, re.DOTALL)
    if match:
        return match.group(1).strip()
    else:
        return text.strip()

def replace_newlines_outside_code_blocks(text):
    pattern = r'(```.*?```)|(\\n)'    
    def replacement(match):
        if match.group(1):
            return match.group(1)
        elif match.group(2):
            return '<br>'
    
    result = re.sub(pattern, replacement, text, flags=re.DOTALL)
    return result

def history_render(history: History):
    local_history = history.copy()
    render_history = []
    for his in local_history:
        replace_newline = replace_newlines_outside_code_blocks(his[0])
        render_history.append([replace_newline, his[1]])
    return gr.update(open=True), render_history

def clear_history():
    return []

def send_to_sandbox(code):
    encoded_html = base64.b64encode(code.encode('utf-8')).decode('utf-8')
    data_uri = f"data:text/html;charset=utf-8;base64,{encoded_html}"
    return f"<iframe src=\"{data_uri}\" width=\"100%\" height=\"920px\"></iframe>"

def demo_card_click(e: gr.EventData):
    index = e._data['component']['index']
    return DEMO_LIST[index]['description']


def read_jsonl(fn):
    with open(fn, encoding="utf-8") as f:
        return [json.loads(l) for l in f.readlines()]    

def get_item_by_index(item_list, index, val=None):
    if val is not None and val in item_list:
        return val
    if len(item_list) > index:
        return item_list[index]
    return ""

def get_item_list(locale="zh", programming_language="", category="", difficulty="", debugInfo=""):
    samples = read_jsonl(f'./FullStackBench_data/fsb_{locale}_20241204.jsonl')
    item_list_count = {}
    item_samples = []
    for sample in samples:
        labels = sample['labels']
        content = [sample['content']]
        sample_dict = [labels['programming_language'], f"/{labels['category']}/{labels['difficulty']}/", content]
        if (locale != "" and labels['locale'] == locale): 
            if programming_language == "":
                item = labels['programming_language']
                item_list_count[item] = item_list_count.get(item, 0) + 1
                item_samples.append(sample_dict)
            elif category == "" and labels['programming_language'] == programming_language:
                item = labels['category']
                item_list_count[item] = item_list_count.get(item, 0) + 1
                item_samples.append(sample_dict)
            elif difficulty == "" and labels['programming_language'] == programming_language and labels['category'] == category:
                item = labels['difficulty']
                item_list_count[item] = item_list_count.get(item, 0) + 1
                item_samples.append(sample_dict)
            elif labels['programming_language'] == programming_language and labels['category'] == category and labels['difficulty'] == difficulty:
                item = labels['difficulty']
                item_list_count[item] = item_list_count.get(item, 0) + 1
                item_samples.append(sample_dict)
    item_list = list(item_list_count.keys())
    item_list_dropdown = []
    all_count = 0
    for item in item_list:
        all_count += item_list_count[item]
        item_list_dropdown.append((f"{item}[{item_list_count[item]}]",item))
    item_list_dropdown.insert(0,(f"All[{all_count}]", ""))
    return item_list, item_list_dropdown, item_samples

item_list_locale = ["en", "zh"]
item_list_dropdown_locale = [("en[1687]", "en"), ("zh[1687]", "zh")]
item_list_programming_language, item_list_dropdown_programming_language, item_samples = get_item_list(locale=item_list_locale[0], programming_language="", category="", difficulty="")
item_list_category, item_list_dropdown_category, item_samples = get_item_list(locale=item_list_locale[0], programming_language=get_item_by_index(item_list_programming_language, 0, "python"), category="", difficulty="")
item_list_difficulty, item_list_dropdown_difficulty, item_samples = get_item_list(locale=item_list_locale[0], programming_language=get_item_by_index(item_list_programming_language, 0, "python"), category=get_item_by_index(item_list_category, 0, "Basic Programming"), difficulty="")
item_list_select, item_list_select_dropdown, item_samples = get_item_list(locale=item_list_locale[0], programming_language=get_item_by_index(item_list_programming_language, 0, "python"), category=get_item_by_index(item_list_category, 0, "Basic Programming"), difficulty=get_item_by_index(item_list_difficulty, 0))

def get_input_examples(): 
    input_examples = []
    for demo in DEMO_LIST:
        input_examples.append(['html', demo['title'], demo['description']])
    return input_examples

def code_syntax_check_fun(code, language='html'):
    check_result = check_code_error(code, language=language.lower())
    if check_result['result'] == True:
        if check_result['error'] == True:
            return 'No pass'
        elif check_result['error'] == False:
            return 'Pass'
        else:
            return f"No check ['{language}' not in check_languages]"
    else:
        return check_result['error']
    
with gr.Blocks(css_paths="app.css", title="Qwen2.5 Coder Artifacts (+SambaNova+FullStackBench)") as demo:
    history_state = gr.State([])
    setting = gr.State({
        "system": SystemPrompt,
    })

    with gr.Row():
        code_language_example = gr.Textbox(show_label=False, lines=1, container=False, visible=False)
        input_text_title= gr.TextArea(show_label=False, container=False, visible=False)
        input_text_example = gr.TextArea(show_label=False, container=False, visible=False)  
        with gr.Tab("Examples_HTML"): 
            input_examples = get_input_examples()
            gr.Examples(
                    examples=input_examples,
                    inputs=[code_language_example, input_text_title, input_text_example],
                    outputs=None,
                    label='',
                    examples_per_page=10,
                    cache_examples=False,
                )       
        with gr.Tab("Examples_from_FullStackBench"):
            with gr.Row():
                with gr.Column():
                    locale = gr.Dropdown(
                        choices=item_list_dropdown_locale,
                        label="locale",
                        value=get_item_by_index(item_list_locale, 0),
                    ) 
                with gr.Column():
                    programming_language = gr.Dropdown(
                        choices=item_list_dropdown_programming_language,
                        label="programming_language",
                        value=get_item_by_index(item_list_programming_language, 0, "python"),
                    )  
                with gr.Column():
                    category = gr.Dropdown(
                        choices=item_list_dropdown_category,
                        label="category",
                        value=get_item_by_index(item_list_category, 0,  "Basic Programming"),
                    )
                with gr.Column():
                    difficulty = gr.Dropdown(
                        choices=item_list_dropdown_difficulty,
                        label="difficulty",
                        value=get_item_by_index(item_list_difficulty, 0),
                    )
            with gr.Row():
                test_examples = gr.Examples(
                        examples=item_samples,
                        inputs=[code_language_example, input_text_title, input_text_example],
                        outputs=None,
                        label='Examples:',
                        examples_per_page=5,
                        cache_examples=False,
                    )
            def locale_select(locale):
                item_list_programming_language, item_list_dropdown_programming_language, item_samples = get_item_list(locale=locale, programming_language="", category="", difficulty="", debugInfo="locale_1_")
                item_list_category, item_list_dropdown_category, item_samples = get_item_list(locale=locale, programming_language=get_item_by_index(item_list_programming_language, 0), category="", difficulty="", debugInfo="locale_2_")
                item_list_difficulty, item_list_dropdown_difficulty, item_samples = get_item_list(locale=locale, programming_language=get_item_by_index(item_list_programming_language, 0), category=get_item_by_index(item_list_category, 0), difficulty="", debugInfo="locale_3_")
                _, _, item_samples = get_item_list(locale=locale, programming_language=get_item_by_index(item_list_programming_language, 0), category=get_item_by_index(item_list_category, 0), difficulty=get_item_by_index(item_list_difficulty, 0), debugInfo="locale_4_")
                return (gr.Dropdown(choices=item_list_dropdown_programming_language, value=item_list_dropdown_programming_language[0][1]),
                        gr.Dropdown(choices=item_list_dropdown_category, value=item_list_dropdown_category[0][1]),
                        gr.Dropdown(choices=item_list_dropdown_difficulty, value=item_list_dropdown_difficulty[0][1]),
                        gr.Dataset(samples=item_samples))
            locale.select(
                fn=locale_select,
                inputs=[locale],
                outputs=[programming_language, category, difficulty, test_examples.dataset]
            )
            def programming_language_select(locale, programming_language):
                item_list_category, item_list_dropdown_category, item_samples = get_item_list(locale=locale, programming_language=programming_language, category="", difficulty="", debugInfo="programming_language_1_")
                item_list_difficulty, item_list_dropdown_difficulty, item_samples = get_item_list(locale=locale, programming_language=programming_language, category=get_item_by_index(item_list_category, 0), difficulty="", debugInfo="programming_language_2_")
                _, _, item_samples = get_item_list(locale=locale, programming_language=programming_language, category=get_item_by_index(item_list_category, 0), difficulty=get_item_by_index(item_list_difficulty, 0), debugInfo="programming_language_3_")
                return (gr.Dropdown(choices=item_list_dropdown_category, value=item_list_dropdown_category[0][1]),
                        gr.Dropdown(choices=item_list_dropdown_difficulty, value=item_list_dropdown_difficulty[0][1]),
                        gr.Dataset(samples=item_samples))
            programming_language.select(
                fn=programming_language_select,
                inputs=[locale, programming_language],
                outputs=[category, difficulty, test_examples.dataset]
            )                
            def category_select(locale, programming_language, category):
                item_list_difficulty, item_list_dropdown_difficulty, item_samples = get_item_list(locale=locale, programming_language=programming_language, category=category, difficulty="", debugInfo="category_1_")
                _, _, item_samples = get_item_list(locale=locale, programming_language=programming_language, category=category, difficulty=get_item_by_index(item_list_difficulty, 0), debugInfo="category_2_")
                return (gr.Dropdown(choices=item_list_dropdown_difficulty, value=item_list_dropdown_difficulty[0][1]),
                        gr.Dataset(samples=item_samples))
            category.select(
                fn=category_select,
                inputs=[locale, programming_language, category],
                outputs=[difficulty, test_examples.dataset]
            )
            def difficulty_select(locale, programming_language, category, difficulty):
                _, _, item_samples = get_item_list(locale=locale, programming_language=programming_language, category=category, difficulty=difficulty, debugInfo="difficulty_1_")
                return gr.Dataset(samples=item_samples)
            difficulty.select(
                fn=difficulty_select,
                inputs=[locale, programming_language, category, difficulty],
                outputs=[test_examples.dataset]
            ) 

    with ms.Application() as app:
        with antd.ConfigProvider():
            with antd.Row(gutter=[32, 12]) as layout:
                with antd.Col(span=24, md=8):
                    with antd.Flex(vertical=True, gap="middle", wrap=True):
                        header = gr.HTML("""
                            <div style="text-align: center;">
                                <!-- Container for GIFs -->
                                <div style="display: flex; justify-content: center; gap: 20px; margin-bottom: 20px;">
                                    <!-- First GIF -->
                                    <img src="https://huggingface.co/spaces/sambanovasystems/SambaNova-Qwen2.5-Coder-Artifacts/resolve/main/logo.png" width="200px" />
                                </div>
                                <!-- Header Text -->
                                <h1>Qwen2.5-Coder-32B with SambaNova Cloud API</h1>
                            </div>
                        """)

                        input = antd.InputTextarea(size="middle", allow_clear=True, placeholder="Please enter what kind of application you want")
                        code_language = gr.Textbox(label="code language", lines=1)
                        llm_model = gr.Dropdown(
                            choices=[
                                "Qwen2.5-Coder-32B-Instruct",
                                "DeepSeek-R1-Distill-Llama-70B",
                                "Llama-3.1-Tulu-3-405B",
                                "Meta-Llama-3.3-70B-Instruct",
                                "Meta-Llama-3.2-3B-Instruct",
                                "Meta-Llama-3.2-1B-Instruct",
                                "Meta-Llama-3.1-70B-Instruct", 
                                "Meta-Llama-3.1-405B-Instruct", 
                                "Meta-Llama-3.1-8B-Instruct",
                                # "QwQ-32B-Preview",
                                "Qwen2.5-72B-Instruct",
                                ],
                            label="LLM model",
                            value="Qwen2.5-Coder-32B-Instruct",
                        )                         
                        btn = antd.Button("send", type="primary", size="large")                        

                        with antd.Flex(gap="small", wrap=True):
                            settingPromptBtn = antd.Button(
                                "⚙️ set system Prompt", type="default")
                            codeBtn = antd.Button("🧑‍💻 view code", type="default")
                            historyBtn = antd.Button("📜 history", type="default")
                        
                        clear_btn = antd.Button("clear history", type="default", size="large")

                    with antd.Modal(open=False, title="set system Prompt", width="800px") as system_prompt_modal:
                        systemPromptInput = antd.InputTextarea(
                            SystemPrompt, auto_size=True)

                    settingPromptBtn.click(lambda: gr.update(
                        open=True), inputs=[], outputs=[system_prompt_modal])
                    system_prompt_modal.ok(lambda input: ({"system": input}, gr.update(
                        open=False)), inputs=[systemPromptInput], outputs=[setting, system_prompt_modal])
                    system_prompt_modal.cancel(lambda: gr.update(
                        open=False), outputs=[system_prompt_modal])

                    with antd.Drawer(open=False, title="code", placement="left", width="750px") as code_drawer:
                        code_output = legacy.Markdown()

                    codeBtn.click(lambda: gr.update(open=True),
                                  inputs=[], outputs=[code_drawer])
                    code_drawer.close(lambda: gr.update(
                        open=False), inputs=[], outputs=[code_drawer])

                    with antd.Drawer(open=False, title="history", placement="left", width="900px") as history_drawer:
                        history_output = legacy.Chatbot(show_label=False, flushing=False, height=960, elem_classes="history_chatbot")

                    historyBtn.click(history_render, inputs=[history_state], outputs=[history_drawer, history_output])
                    history_drawer.close(lambda: gr.update(
                        open=False), inputs=[], outputs=[history_drawer])

                with antd.Col(span=24, md=16):
                    with ms.Div(elem_classes="right_panel"):
                        gr.HTML('<div class="render_header"><span class="header_btn"></span><span class="header_btn"></span><span class="header_btn"></span></div>')
                        with antd.Tabs(active_key="empty", render_tab_bar="() => null") as state_tab:
                            with antd.Tabs.Item(key="empty", label="Render_empty"):
                                empty = antd.Empty(description="empty input", elem_classes="right_content")
                            with antd.Tabs.Item(key="loading", label="Render_loading"):
                                loading = antd.Spin(True, tip="coding...", size="large", elem_classes="right_content")
                            with antd.Tabs.Item(key="render_html", label="Render_HTML") as render_html:
                                sandbox = gr.HTML(elem_classes="html_content")
                            with antd.Tabs.Item(key="render_other", label="Render_Code") as render_other:
                                sandbox_other = legacy.Markdown()
                    code_syntax_check = gr.Textbox(label="check code syntax: ", lines=1, interactive=False)
                    with gr.Row(visible=False) as think_content_row:
                        think_content = gr.Textbox(label="think_content: ", lines=10)

        def generation_code(query: Optional[str], code_language, _setting: Dict[str, str], _history: Optional[History], llm_model):
            if query is None:
                query = ''
            if _history is None:
                _history = []
            
            logger.info(f"code_language/llm_model/ = {code_language}/{llm_model}/")

            # Prepare the preprocess and postprocess functions
            def preprocess(message, history):
                if code_language.lower() == 'html':
                    messages = [{'role': 'system', 'content': _setting['system']}]
                else:
                    messages = [{'role': 'system', 'content': ""}]
                for user_msg, assistant_msg in history:
                    messages.append({'role': 'user', 'content': user_msg})
                    messages.append({'role': 'assistant', 'content': assistant_msg})
                messages.append({'role': 'user', 'content': message})
                return {'messages': messages}

            def postprocess(response_text):
                return response_text

            # Get the model from sambanova_gradio
            fn = get_fn(
                model_name=llm_model,
                preprocess=preprocess,
                postprocess=postprocess,
                api_key=YOUR_API_TOKEN
            )

            response_text = ''
            assistant_response = ''
            local_history = _history.copy()

            for content in fn(query, local_history):
                response_text = content
                # Update code_output
                yield {
                    code_output: response_text,
                    state_tab: gr.update(active_key="loading"),
                    code_drawer: gr.update(open=True),
                }

            assistant_response = response_text
            pattern = r'<think>\n(.*?)</think>\n'
            match = re.search(pattern, assistant_response, flags=re.DOTALL)
            if match:
                think_content_val = match.group(1)
            else:
                think_content_val = ""
            assistant_response = re.sub(pattern, '', assistant_response, flags=re.DOTALL)

            local_history.append([query, assistant_response])

            code = remove_code_block(assistant_response, language=code_language)

            if "```html" in assistant_response:
                sandbox_val = send_to_sandbox(code)
                state_tab_val = gr.update(active_key="render_html")
                render_html_val = gr.update(visible=True)
                render_other_val = gr.update(visible=False)
                sandbox_other_val = ""
            else:
                sandbox_val = ""
                state_tab_val = gr.update(active_key="render_other")
                render_html_val = gr.update(visible=False)
                render_other_val = gr.update(visible=True)
                sandbox_other_val = assistant_response

            code_syntax_check_val = code_syntax_check_fun(code, language=code_language)
            yield {
                code_output: assistant_response,
                history_state: local_history,
                sandbox: sandbox_val,
                state_tab: state_tab_val,
                code_drawer: gr.update(open=False),
                render_html: render_html_val,
                render_other: render_other_val,
                sandbox_other: sandbox_other_val,
                code_syntax_check: code_syntax_check_val,
                think_content: think_content_val,
                think_content_row: gr.update(visible=(think_content_val!="")),
            }

        def code_language_example_change(code_language):
            return code_language            
        code_language_example.change(
                fn=code_language_example_change,
                inputs=[code_language_example], 
                outputs=[code_language], 
            )
        def input_text_example_change(input_text_example):
            return input_text_example            
        input_text_example.change(
                fn=input_text_example_change,
                inputs=[input_text_example], 
                outputs=[input], 
            )
        
        btn.click(generation_code,
                  inputs=[input, code_language, setting, history_state, llm_model],
                  outputs=[code_output, history_state, sandbox, state_tab, code_drawer,
                           render_html, render_other, sandbox_other, code_syntax_check, think_content, think_content_row])

        clear_btn.click(clear_history, inputs=[], outputs=[history_state])

    with gr.Row():
        DESCRIPTION = f'### This demo from [SambaNova-Qwen2.5-Coder-Artifacts](https://huggingface.co/spaces/sambanovasystems/SambaNova-Qwen2.5-Coder-Artifacts). <br>'
        DESCRIPTION += f'More examples from [FullStackBench](https://github.com/bytedance/FullStackBench). <br>'
        DESCRIPTION += f'Thanks for their excellent work.'
        gr.Markdown(DESCRIPTION)

if __name__ == "__main__":
    demo.queue(default_concurrency_limit=20).launch(ssr_mode=False, show_api=False)