gradio-checkboxgroupmarkdown 0.0.4__tar.gz → 0.0.6__tar.gz

{gradio_checkboxgroupmarkdown-0.0.4 → gradio_checkboxgroupmarkdown-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gradio_checkboxgroupmarkdown
-Version: 0.0.4
+Version: 0.0.6
 Summary: Gradio component for CheckboxGroup with Markdown
 Author-email: YOUR NAME <YOUREMAIL@domain.com>
 License-Expression: Apache-2.0
@@ -48,216 +48,168 @@ pip install gradio_checkboxgroupmarkdown
 ## Usage
 
 ```python
+
 import gradio as gr
+
+
+from typing import List
+import gradio as gr
+from dataclasses import dataclass
 import random
-from typing import List, Dict
 from gradio_checkboxgroupmarkdown import CheckboxGroupMarkdown
 
-def generate_test_articles():
-    topics = ["Machine Learning", "Deep Learning", "Neural Networks", "Computer Vision", 
-              "Natural Language Processing"]
-    
-    subtopics = ["Introduction", "Tutorial", "Case Study"]
-    
-    articles = []
-    for i in range(10):
-        topic = random.choice(topics)
-        subtopic = random.choice(subtopics)
-        article_id = f"art_{i+1:02d}"
-        
-        title = f"{topic}: {subtopic}"
-        content = f"""# {title}
-This article covers {topic.lower()} {subtopic.lower()}.
-Key points:
-- Basic concepts
-- Implementation tips
-- Practical examples"""
-
-        articles.append({
-            "id": article_id,
-            "title": title,
-            "content": content,
-            "selected": False
-        })
-    
-    return articles
-
-def search_articles(search_text: str, master_articles: List[Dict]) -> List[Dict]:
-    print("search_articles")
-    
-    """Search articles based on input text"""
-    if not search_text.strip():
-        return master_articles
-    
-    search_terms = search_text.lower().split()
-    filtered_articles = []
-    
-    for article in master_articles:
-        text_to_search = (article["title"] + " " + article["content"]).lower()
-        if all(term in text_to_search for term in search_terms):
-            filtered_articles.append(article)
-    
-    return filtered_articles
+# Define two different sets of choices
+ai_choices = [
+    {
+        "id": "art_101",
+        "title": "Understanding Neural Networks",
+        "content": "# Understanding Neural Networks\nThis article explains the basics of neural networks, their architecture, and how they learn from data.",
+        "selected": False
+    },
+    {
+        "id": "art_102", 
+        "title": "A Gentle Introduction to Transformers",
+        "content": "# A Gentle Introduction to Transformers\nTransformers have revolutionized NLP. Learn about attention mechanisms, encoder-decoder architecture, and more.",
+        "selected": False
+    },
+    {
+        "id": "art_103",
+        "title": "Reinforcement Learning Basics",
+        "content": "# Reinforcement Learning Basics\nAn overview of RL concepts like agents, environments, rewards, and policies.",
+        "selected": False
+    }
+]
 
-def update_filtered_articles(search_text: str, master_articles: List[Dict]):
-    print("update_filtered_articles")
-    
-    """Update the first CheckboxGroupMarkdown with filtered articles"""
-    filtered = search_articles(search_text, master_articles)
-    
-    return {
-        filtered_checkbox: gr.update(
-            choices=filtered,
-            value=[art["id"] for art in filtered if art["selected"]]
-        ),
-        filtered_checkbox_state: filtered
+ml_choices = [
+    {
+        "id": "art_104",
+        "title": "Machine Learning Fundamentals",
+        "content": "# Machine Learning Fundamentals\nLearn about supervised, unsupervised, and reinforcement learning approaches.",
+        "selected": False
+    },
+    {
+        "id": "art_105",
+        "title": "Deep Learning vs Traditional ML",
+        "content": "# Deep Learning vs Traditional ML\nUnderstand the key differences between deep learning and traditional machine learning.",
+        "selected": False
+    },
+    {
+        "id": "art_106",
+        "title": "Feature Engineering",
+        "content": "# Feature Engineering\nMaster the art of creating meaningful features from raw data.",
+        "selected": False
     }
+]
+
+# def sentence_builder(selected):
+#     if not selected:
+#         return "You haven't selected any articles yet."
     
-def update_selected_checkbox_articles(selected_choices, filtered_checkbox, master_articles: List[Dict]):
-    print("handle_deselect_articles")
-    
-    """Update master articles by removing unselected ones"""
-    # Get IDs of articles that remain selected
-    selected_ids = {choice["id"] for choice in selected_choices}
-    
-    # Update selection status in master_articles
-    for article in master_articles:
-        article["selected"] = article["id"] in selected_ids
-            
-    # Update selection status in filtered_checkbox
-    for article in filtered_checkbox:
-        article["selected"] = article["id"] in selected_ids
-        
-    # Get selected articles for second tab
-    selected_articles = [
-        {
-            "id": art["id"],
-            "title": art["title"],
-            "content": art["content"],
-            "selected": True
-        }
-        for art in master_articles 
-        if art["selected"]
-    ]
-    
-    return [
-        gr.update(
-            choices=selected_articles,
-            value=[art["id"] for art in selected_articles]
-        ),
-        gr.update(
-            value=[art["id"] for art in filtered_checkbox if art["selected"]]
-        ),
-        master_articles,
-        filtered_checkbox
-    ]
-
-def update_filtered_checkbox_articles(selected_choices, filtered_checkbox, master_articles: List[Dict]):
-    print("update_selected_articles")
-    
-    """Update the second CheckboxGroupMarkdown when selections change in the first one"""
-    # Get IDs of newly selected articles
-    selected_ids = {choice["id"] for choice in selected_choices}
-    
-    # Update selection status in filtered_checkbox_state
-    for article in filtered_checkbox:
-        if article["id"] in selected_ids:
-            article["selected"] = True
-        else:
-            article["selected"] = False
-            
-    # Update selection status in master_articles based on filtered_checkbox
-    filtered_articles_dict = {art["id"]: art["selected"] for art in filtered_checkbox}
-    for article in master_articles:
-        if article["id"] in filtered_articles_dict:
-            article["selected"] = filtered_articles_dict[article["id"]]
+#     if isinstance(selected[0], dict) and "title" in selected[0]:
+#         formatted_choices = []
+#         for choice in selected:
+#             formatted_choices.append(
+#                 f"ID: {choice['id']}\nTitle: {choice['title']}\nContent: {choice['content']}"
+#             )
+#         return "Selected articles are:\n\n" + "\n\n".join(formatted_choices)
+#     else:
+#         return "Selected articles are:\n\n- " + "\n- ".join(selected)
+
+def sentence_builder(selected):
+    print("\nIn sentence_builder:")
+    print("Selected items:", selected)
     
-    # Get all selected articles for the second component
-    selected_articles = [
-        {
-            "id": art["id"],
-            "title": art["title"],
-            "content": art["content"],
-            "selected": True
-        }
-        for art in master_articles 
-        if art["selected"]
-    ]
+    if not selected:
+        return "You haven't selected any articles yet."
     
-    return {
-        selected_checkbox: gr.update(
-            choices=selected_articles,
-            value=[art["id"] for art in selected_articles]
-        ),
-        filtered_checkbox_state: filtered_checkbox,
-        master_articles_state: master_articles
-    }
+    if isinstance(selected[0], dict) and "title" in selected[0]:
+        formatted_choices = []
+        for choice in selected:
+            print(f"Processing choice: {choice}")
+            formatted_choices.append(
+                f"ID: {choice['id']}\nTitle: {choice['title']}\nContent: {choice['content']}"
+            )
+        return "Selected articles are:\n\n" + "\n\n".join(formatted_choices)
+    else:
+        return "Selected articles are:\n\n- " + "\n- ".join(selected)
+
+def update_choices(choice_type: str):
+    if choice_type == "AI":
+        return gr.update(choices=ai_choices, value=[]), ""
+    elif choice_type == "ML":
+        return gr.update(choices=ml_choices, value=["art_106"]), ""
+    else:  # Random mix
+        mixed_choices = random.sample(ai_choices + ml_choices, 3)
+        return gr.update(choices=mixed_choices, value=[]), ""
+
+# def update_choices(choice_type: str):
+#     if choice_type == "AI":
+#         choices = [{**c, "selected": False} for c in ai_choices]
+#         return gr.update(choices=choices, value=[]), ""
+#     elif choice_type == "ML":
+#         choices = [{**c, "selected": c["id"] == "art_106"} for c in ml_choices]
+#         return gr.update(choices=choices, value=["art_106"]), ""
+#     else:  # Random mix
+#         mixed = random.sample(ai_choices + ml_choices, 3)
+#         choices = [{**c, "selected": False} for c in mixed]
+#         return gr.update(choices=choices, value=[]), ""
 
-# Create the Gradio interface
 with gr.Blocks() as demo:
-    gr.Markdown("## Article Search and Selection Demo")
+    gr.Markdown("## Interactive Article Selection Demo")
     
-    # Create state to hold master articles list
-    master_articles_state = gr.State(generate_test_articles())
-    filtered_checkbox_state = gr.State(master_articles_state.value)
-    print("generate articles")
-    
-    # Search bar
     with gr.Row():
-        search_input = gr.Textbox(
-            label="Search Articles",
-            placeholder="Enter search terms...",
-            show_label=True
-        )
-        search_button = gr.Button("Search")
+        with gr.Column(scale=1):
+            gr.Markdown("### Change Article Categories")
+            with gr.Row():
+                ai_btn = gr.Button("AI Articles", variant="primary")
+                ml_btn = gr.Button("ML Articles", variant="secondary")
+                mix_btn = gr.Button("Random Mix", variant="secondary")
     
-    # Tabs for the two CheckboxGroupMarkdown components
-    with gr.Tabs() as tabs:
-        with gr.Tab("Search Results"):
-            filtered_checkbox = CheckboxGroupMarkdown(
-                choices=master_articles_state.value,
-                label="Available Articles",
-                info="Select articles to add to your collection",
+    with gr.Row():
+        with gr.Column(scale=2):
+            checkbox_group = CheckboxGroupMarkdown(
+                choices=ai_choices,  # Start with AI choices
+                label="Select Articles",
+                info="Choose articles to include in your collection",
                 type="all",
-                value=[art["id"] for art in master_articles_state.value if art["selected"]],
                 buttons=["select_all", "deselect_all"]
             )
-        print("filtered_checkbox")
         
-        with gr.Tab("Selected Collection"):
-            selected_checkbox = CheckboxGroupMarkdown(
-                choices=[art for art in master_articles_state.value if art["selected"]],
-                label="Your Selected Articles",
-                info="Your curated collection of articles",
-                type="all",
-                value=[art["id"] for art in master_articles_state.value if art["selected"]],
-                buttons=["select_all", "deselect_all"]
+        with gr.Column(scale=1):
+            output_text = gr.Textbox(
+                label="Selected Articles",
+                placeholder="Make selections to see results...",
+                info="Selected articles will be displayed here",
+                lines=10
             )
-        print("selected_checkbox")
     
     # Event handlers
-    search_button.click(
-        fn=update_filtered_articles,
-        inputs=[search_input, master_articles_state],
-        # outputs=[filtered_checkbox, master_articles_state]
-        outputs=[filtered_checkbox, filtered_checkbox_state]
+    checkbox_group.change(
+        fn=sentence_builder,
+        inputs=checkbox_group,
+        outputs=output_text
     )
     
-    filtered_checkbox.select(
-        fn=update_filtered_checkbox_articles,
-        inputs=[filtered_checkbox, filtered_checkbox_state, master_articles_state],
-        outputs=[selected_checkbox, filtered_checkbox_state, master_articles_state]
+    # Button click handlers to update choices
+    ai_btn.click(
+        fn=lambda: update_choices("AI"),
+        inputs=None,
+        outputs=[checkbox_group, output_text],
     )
-    
-    selected_checkbox.select(
-        fn=update_selected_checkbox_articles,
-        inputs=[selected_checkbox, filtered_checkbox_state, master_articles_state],
-        outputs=[selected_checkbox, filtered_checkbox, master_articles_state, filtered_checkbox_state]
+
+    ml_btn.click(
+        fn=lambda: update_choices("ML"),
+        inputs=None, 
+        outputs=[checkbox_group, output_text],
+    )
+
+    mix_btn.click(
+        fn=lambda: update_choices("MIX"),
+        inputs=None,
+        outputs=[checkbox_group, output_text],
     )
-    print("Block")
-    
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     demo.launch()
 ```