change from streamlit to gradio

app.py

@@ -1,18 +1,35 @@
-import streamlit as st
+import gradio as gr
 
-st.set_page_config(
-    page_title="Summarization Projects Demo",
-    page_icon=":rocket:",
-)
+from pages.arena import create_arena
+from pages.summarization_example import create_summarization_interface
 
-st.write("## Summarization Projects Demo :rocket:")
+def welcome_message():
+    return """
+    ## Summarization Projects Demo :rocket:
 
-st.markdown(
-    """
     This application is for **internal use** and is designed to facilitate **fast prototyping** and **experimentation.**
 
-    👈 Select a demo from the sidebar to begin experimentation.
+    Select a demo from the sidebar below to begin experimentation.
     """
-)
 
-st.sidebar.success("Select a demo above.")
+with gr.Blocks() as demo:
+    with gr.Column(scale=4):
+        content = content = gr.Blocks(
+            gr.Markdown(
+                welcome_message()
+            )
+        )
+
+        with gr.Tabs() as tabs:
+            with gr.TabItem("Streaming"):
+                create_arena()
+            with gr.TabItem("Summarization"):
+                create_summarization_interface()
+            # with gr.TabItem("Page 3"):
+            #     page3()
+
+
+if __name__ == "__main__":
+    demo.launch()
+
+#iface.launch()  # launch the Gradio app

pages/arena.py

@@ -1,21 +1,9 @@
-import sys
-from concurrent.futures import ThreadPoolExecutor
+import gradio as gr
+from utils.multiple_stream import create_interface
 
-import streamlit as st
-from streamlit.runtime.scriptrunner.script_run_context import \
-    get_script_run_ctx
+def create_arena():
+    demo = create_interface()
+    #demo.queue()
+    #demo.launch()
 
-sys.path.append(".")  # Add parent directory to Python path
-
-from utils.multiple_stream import stream_data_in_column
-
-if st.button("Stream data"):
-    # Define layout
-    columns = st.columns(2)
-
-    # Submit concurrent tasks
-    with ThreadPoolExecutor(max_workers=2) as executor:
-        ctx = get_script_run_ctx()
-        futures = [
-            executor.submit(stream_data_in_column, col, ctx) for col in columns
-        ]
+    return demo

pages/summarization_example.py

@@ -1,10 +1,8 @@
 from dotenv import load_dotenv
-from openai import OpenAI
-
-import streamlit as st
+from transformers import pipeline
+import gradio as gr
 
 load_dotenv()
-st.write('## This is an example to show summarization')
 
 examples = {
     "example 1": """Boston's injury reporting for Kristaps Porziņģis has been fairly coy. He missed Game 3, but his coach told reporters just before Game 4 that was technically available, but with a catch.
@@ -21,63 +19,46 @@ All of that has led to postseason averages of 8.2 points, 7.6 rebounds, 1.4 assi
 Back in Boston, Kidd is going to rely on Lively even more. He'll play close to 30 minutes and reach double-figures in both scoring and rebounding again.""",
 }
 
-def generate_answer(lm, sources, model_name="gpt-4o"):  # noqa: ANN201, ANN001
+def generate_answer(sources, model_name):
     meta_prompt = """
 {sources}
 
-summarization: """  # noqa: E501
-    content = meta_prompt.format(
-        sources=sources,
-    )
-
-    from transformers import pipeline
+summarization: """
+    content = meta_prompt.format(sources=sources)
 
-    messages = [
-        {"role": "user", "content": content},
-    ]
     pipe = pipeline("text-generation", model="microsoft/Phi-3-mini-4k-instruct", trust_remote_code=True, max_length=500)
+    messages = [{"role": "user", "content": content}]
     answer = pipe(messages)
 
-    # answer = lm.chat.completions.create(
-    #     temperature=0.8,
-    #     max_tokens=800,
-    #     messages=[
-    #         {
-    #             "role": "user",
-    #             "content": content,
-    #         },
-    #     ],
-    #     model=model_name,
-    # )
-
-    return answer
-
-example_selection = st.selectbox("Choose an example", options=list(examples.keys()), index=0)
-model_selection = st.selectbox("Choose a model", options=[
-    "gpt-3.5-turbo",
-    "gpt-4o",
-    "gpt-4"
-], index=0)
-
-# Input fields
-input_text1 = st.text_area("question", height=None, \
-            placeholder="Enter first text here...", value=examples[example_selection])
-
-
-
-# Button to trigger processing
-#lm = OpenAI()
-
-if st.button('Submit'):
-    if input_text1:
-        response = generate_answer('', input_text1, model_selection)
-        st.write('## Orginal Article:')
-        st.markdown(examples[example_selection])
-
-        st.write('## Summarization:')
-        st.markdown(response.choices[0].message.content)
+    return answer[0]['generated_text']
 
+def process_input(input_text, model_selection):
+    if input_text:
+        response = generate_answer(input_text, model_selection)
+        return f"## Original Article:\n\n{input_text}\n\n## Summarization:\n\n{response}"
     else:
-        # Show an error message if the required input is missing
-        st.error("Please fill both inputs to generate outputs.")
-
+        return "Please fill the input to generate outputs."
+
+def update_input(example):
+    return examples[example]
+
+def create_summarization_interface():
+    with gr.Blocks() as demo:
+        gr.Markdown("## This is an example to show summarization")
+        
+        with gr.Row():
+            example_dropdown = gr.Dropdown(choices=list(examples.keys()), label="Choose an example")
+            model_dropdown = gr.Dropdown(choices=["gpt-3.5-turbo", "gpt-4o", "gpt-4"], label="Choose a model", value="gpt-3.5-turbo")
+        
+        input_text = gr.Textbox(label="Input Text", lines=10, placeholder="Enter text here...")
+        submit_button = gr.Button("Submit")
+        output = gr.Markdown()
+
+        example_dropdown.change(update_input, inputs=[example_dropdown], outputs=[input_text])
+        submit_button.click(process_input, inputs=[input_text, model_dropdown], outputs=[output])
+
+    return demo
+
+if __name__ == "__main__":
+    demo = create_summarization_interface()
+    demo.launch()

test.py

@@ -0,0 +1,57 @@
+import gradio as gr
+import numpy as np
+
+def page1():
+    with gr.Group():
+        gr.Markdown("# Page 1 Content")
+        input_text = gr.Textbox(label="Enter some text")
+        output_text = gr.Textbox(label="Output")
+        button = gr.Button("Process")
+        
+        def process_text(text):
+            return text.upper()
+        
+        button.click(fn=process_text, inputs=input_text, outputs=output_text)
+
+def page2():
+    with gr.Group():
+        gr.Markdown("# Page 2 Content")
+        num1 = gr.Number(label="Number 1")
+        num2 = gr.Number(label="Number 2")
+        result = gr.Number(label="Result")
+        add_btn = gr.Button("Add")
+        
+        def add_numbers(a, b):
+            return a + b
+        
+        add_btn.click(fn=add_numbers, inputs=[num1, num2], outputs=result)
+
+def page3():
+    with gr.Group():
+        gr.Markdown("# Page 3 Content")
+        image_input = gr.Image()
+        image_output = gr.Image()
+        flip_btn = gr.Button("Flip Image")
+        
+        def flip_image(img):
+            return np.fliplr(img) if img is not None else None
+        
+        flip_btn.click(fn=flip_image, inputs=image_input, outputs=image_output)
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        with gr.Column(scale=1):
+            # Sidebar
+            gr.Markdown("### Navigation")
+        
+        with gr.Column(scale=4):
+            # Main content area using Tabs
+            with gr.Tabs() as tabs:
+                with gr.TabItem("Page 1"):
+                    page1()
+                with gr.TabItem("Page 2"):
+                    page2()
+                with gr.TabItem("Page 3"):
+                    page3()
+
+demo.launch()

utils/multiple_stream.py

@@ -1,34 +1,60 @@
 import copy
 import random
-from threading import currentThread
 from time import sleep
+import gradio as gr
 
-import streamlit as st
-from streamlit.runtime.scriptrunner.script_run_context import \
-    add_script_run_ctx
-
-_TEST_ = """
-Test of Time. A Benchmark for Evaluating LLMs on Temporal Reasoning. Large language models (LLMs) have \
-showcased remarkable reasoning capabilities, yet they remain susceptible to errors, particularly in temporal \
-reasoning tasks involving complex temporal logic.
-"""
+TEST = """ Test of Time. A Benchmark for Evaluating LLMs on Temporal Reasoning. Large language models (LLMs) have 
+showcased remarkable reasoning capabilities, yet they remain susceptible to errors, particularly in temporal 
+reasoning tasks involving complex temporal logic. """
 
 def generate_data_test():
-    """A generator to pass to st.write_stream"""
-    temp = copy.deepcopy(_TEST_)
+    """Generator to yield words"""
+    temp = copy.deepcopy(TEST)
     l1 = temp.split()
     random.shuffle(l1)
     temp = ' '.join(l1)
-
     for word in temp.split(" "):
         yield word + " "
-        sleep(0.1)
 
+def stream_data(progress=gr.Progress()):
+    """Stream data to all columns"""
+    outputs = ["", "", ""]
+    generators = [generate_data_test() for _ in range(3)]
+    
+    while True:
+        updated = False
+        for i, gen in enumerate(generators):
+            try:
+                word = next(gen)
+                outputs[i] += word
+                updated = True
+            except StopIteration:
+                pass
+        
+        if not updated:
+            break
+        
+        yield tuple(outputs)
+        sleep(0.01)
+
+def create_interface():
+    with gr.Group():
+        with gr.Row():
+            col1 = gr.Textbox(label="Column 1", lines=10)
+            col2 = gr.Textbox(label="Column 2", lines=10)
+            col3 = gr.Textbox(label="Column 3", lines=10)
+        
+        start_btn = gr.Button("Start Streaming")
+        
+        start_btn.click(
+            fn=stream_data,
+            outputs=[col1, col2, col3],
+            show_progress=False
+        )
 
-def stream_data_in_column(column, ctx):
-    """Populate columns simultaneously"""
+    #return demo
 
-    add_script_run_ctx(currentThread(), ctx)
-    print("11111111")
-    with column:
-        st.write_stream(generate_data_test)
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.queue()
+    demo.launch()