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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gradio_checkboxgroupmarkdown
-Version: 0.0.2
+Version: 0.0.4
 Summary: Gradio component for CheckboxGroup with Markdown
 Author-email: YOUR NAME <YOUREMAIL@domain.com>
 License-Expression: Apache-2.0
@@ -48,168 +48,216 @@ 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
 
-# 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 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
 
-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 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
 
-# def sentence_builder(selected):
-#     if not selected:
-#         return "You haven't selected any articles yet."
+def update_filtered_articles(search_text: str, master_articles: List[Dict]):
+    print("update_filtered_articles")
     
-#     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)
+    """Update the first CheckboxGroupMarkdown with filtered articles"""
+    filtered = search_articles(search_text, master_articles)
     
-    if not selected:
-        return "You haven't selected any articles yet."
+    return {
+        filtered_checkbox: gr.update(
+            choices=filtered,
+            value=[art["id"] for art in filtered if art["selected"]]
+        ),
+        filtered_checkbox_state: filtered
+    }
     
-    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=[]), ""
+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"]]
+    
+    # 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"]
+    ]
+    
+    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
+    }
 
+# Create the Gradio interface
 with gr.Blocks() as demo:
-    gr.Markdown("## Interactive Article Selection Demo")
+    gr.Markdown("## Article Search and Selection Demo")
     
-    with gr.Row():
-        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")
+    # 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():
-        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",
+        search_input = gr.Textbox(
+            label="Search Articles",
+            placeholder="Enter search terms...",
+            show_label=True
+        )
+        search_button = gr.Button("Search")
+    
+    # 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",
                 type="all",
-                # value=["art_101"]
+                value=[art["id"] for art in master_articles_state.value if art["selected"]],
+                buttons=["select_all", "deselect_all"]
             )
+        print("filtered_checkbox")
         
-        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
+        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"]
             )
+        print("selected_checkbox")
     
     # Event handlers
-    checkbox_group.change(
-        fn=sentence_builder,
-        inputs=checkbox_group,
-        outputs=output_text
+    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]
     )
     
-    # Button click handlers to update choices
-    ai_btn.click(
-        fn=lambda: update_choices("AI"),
-        inputs=None,
-        outputs=[checkbox_group, output_text],
-    )
-
-    ml_btn.click(
-        fn=lambda: update_choices("ML"),
-        inputs=None, 
-        outputs=[checkbox_group, 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]
     )
-
-    mix_btn.click(
-        fn=lambda: update_choices("MIX"),
-        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]
     )
+    print("Block")
+    
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     demo.launch()
 ```
 
@@ -271,6 +319,19 @@ ChoiceType
 <td align="left">Type of value to be returned by component. "value" returns the list of strings of the choices selected, "index" returns the list of indices of the choices selected.</td>
 </tr>
 
+<tr>
+<td align="left"><code>buttons</code></td>
+<td align="left" style="width: 25%;">
+
+```python
+Optional[List[str]]
+```
+
+</td>
+<td align="left"><code>None</code></td>
+<td align="left">None</td>
+</tr>
+
 <tr>
 <td align="left"><code>label</code></td>
 <td align="left" style="width: 25%;">