implement editing existing entries

datasets_resource.py

@@ -359,10 +359,372 @@ def create_contribute_tab():
         )
 
 
+def search_entries(query: str) -> pd.DataFrame:
+    """Search for entries by name or URL."""
+    if not query.strip():
+        return pd.DataFrame()
+
+    df = load_data()
+    if df.empty:
+        return df
+
+    # Search in name, github_url, huggingface_url, and zenodo_url columns
+    mask = (
+        df["name"].str.contains(query, case=False, na=False)
+        | df["github_url"].str.contains(query, case=False, na=False)
+        | df["huggingface_url"].str.contains(query, case=False, na=False)
+        | df["zenodo_url"].str.contains(query, case=False, na=False)
+    )
+
+    return df[mask]
+
+
+def load_entry_for_edit(selected_entry: str) -> tuple:
+    """Load a specific entry for editing."""
+    if not selected_entry:
+        return ("",) * 11  # Return empty values for all fields
+
+    df = load_data()
+    if df.empty:
+        return ("",) * 11
+
+    # Find the entry by name
+    entry = df[df["name"] == selected_entry].iloc[0]
+
+    # Convert comma-separated strings back to lists for multi-select components
+    task_list = [t.strip() for t in entry["task"].split(",")] if entry["task"] else []
+    domain_list = (
+        [d.strip() for d in entry["domain"].split(",")] if entry["domain"] else []
+    )
+    countries_list = (
+        [c.strip() for c in entry["countries"].split(",")] if entry["countries"] else []
+    )
+    languages_list = (
+        [l.strip() for l in entry["languages"].split(",")] if entry["languages"] else []
+    )
+
+    return (
+        entry["name"],
+        entry["github_url"],
+        entry["huggingface_url"],
+        entry["zenodo_url"],
+        entry["paper_url"],
+        entry["dataset_type"],
+        task_list,
+        domain_list,
+        entry["website_url"],
+        countries_list,
+        languages_list,
+    )
+
+
+def update_entry(
+    original_name: str,
+    name: str,
+    github_url: str,
+    huggingface_url: str,
+    zenodo_url: str,
+    paper_url: str,
+    dataset_type: str,
+    task: list,
+    domain: list,
+    website_url: str,
+    countries: list,
+    languages: list,
+    profile: gr.OAuthProfile | None,
+):
+    """Update an existing entry."""
+    if not profile:
+        return "❌ Please log in to edit entries."
+
+    username = profile.username
+    if not username:
+        return "❌ Could not get username from profile."
+
+    if not original_name:
+        return "❌ No entry selected to edit."
+
+    if not name.strip():
+        return "❌ Name is required."
+
+    # Validate that at least one URL is provided
+    urls = [github_url.strip(), huggingface_url.strip(), zenodo_url.strip()]
+    if not any(urls):
+        return "❌ At least one URL (GitHub, Hugging Face, or Zenodo) is required."
+
+    # Validate URLs
+    for url_field, url_value in [
+        ("GitHub URL", github_url),
+        ("Hugging Face URL", huggingface_url),
+        ("Zenodo URL", zenodo_url),
+        ("Paper URL", paper_url),
+        ("Website URL", website_url),
+    ]:
+        if url_value.strip() and not validate_url(url_value):
+            return f"❌ Invalid {url_field}. Please provide a valid URL."
+
+    try:
+        # Load existing dataset
+        existing_dataset = load_dataset(DATASET_NAME, CONFIG_NAME, split="train")
+        existing_df = existing_dataset.to_pandas()
+
+        # Find and update the entry
+        mask = existing_df["name"] == original_name
+        if not mask.any():
+            return f"❌ Entry '{original_name}' not found."
+
+        # Update the entry
+        current_time = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+        existing_df.loc[mask, "name"] = name
+        existing_df.loc[mask, "github_url"] = github_url
+        existing_df.loc[mask, "huggingface_url"] = huggingface_url
+        existing_df.loc[mask, "zenodo_url"] = zenodo_url
+        existing_df.loc[mask, "paper_url"] = paper_url
+        existing_df.loc[mask, "dataset_type"] = dataset_type
+        existing_df.loc[mask, "task"] = ", ".join(task) if task else ""
+        existing_df.loc[mask, "domain"] = ", ".join(domain) if domain else ""
+        existing_df.loc[mask, "website_url"] = website_url
+        existing_df.loc[mask, "countries"] = ", ".join(countries) if countries else ""
+        existing_df.loc[mask, "languages"] = ", ".join(languages) if languages else ""
+        existing_df.loc[mask, "date_submitted"] = current_time
+
+        # Convert back to Dataset and push to hub
+        updated_dataset = Dataset.from_pandas(existing_df)
+        updated_dataset.push_to_hub(
+            DATASET_NAME,
+            config_name=CONFIG_NAME,
+            commit_message=f"Update dataset entry: {name} (edited by {username})",
+        )
+
+        return f"✅ Successfully updated '{name}'!"
+
+    except Exception as e:
+        return f"❌ Error updating entry: {str(e)}"
+
+
+def create_edit_tab():
+    """Create the edit tab for modifying existing entries."""
+    with gr.TabItem("✏️ Edit", id=f"{RESOURCE_TYPE}_edit"):
+        gr.Markdown(f"### Edit Existing {RESOURCE_TITLE}")
+        gr.Markdown("Please log in to edit entries:")
+        login_button = gr.LoginButton(elem_id=f"{RESOURCE_TYPE}-edit-oauth-button")
+
+        gr.Markdown("Search for an entry to edit:")
+
+        with gr.Row():
+            search_input = gr.Textbox(
+                label="Search by name or URL",
+                placeholder="Enter dataset name or URL to search...",
+                scale=3,
+            )
+            search_btn = gr.Button("🔍 Search", scale=1)
+
+        search_results = gr.Dropdown(
+            label="Select entry to edit", choices=[], interactive=True
+        )
+
+        gr.Markdown("---")
+        gr.Markdown("**Edit the selected entry:**")
+
+        with gr.Column(visible=False) as edit_form:
+            name_input = gr.Textbox(label="Name *", placeholder="Dataset name")
+            dataset_type_input = gr.Dropdown(
+                label="Dataset Type *",
+                choices=[
+                    "pretraining",
+                    "benchmark",
+                    "supervised fine-tuning",
+                    "alignment",
+                ],
+                value="benchmark",
+            )
+
+            gr.Markdown("**URLs** (at least one required)")
+            with gr.Row():
+                github_url_input = gr.Textbox(
+                    label="GitHub URL", placeholder="https://github.com/..."
+                )
+                huggingface_url_input = gr.Textbox(
+                    label="Hugging Face URL",
+                    placeholder="https://huggingface.co/datasets/...",
+                )
+            zenodo_url_input = gr.Textbox(
+                label="Zenodo URL", placeholder="https://zenodo.org/..."
+            )
+
+            gr.Markdown("**Optional Information**")
+            paper_url_input = gr.Textbox(
+                label="Paper URL", placeholder="https://arxiv.org/..."
+            )
+            website_url_input = gr.Textbox(
+                label="Website URL", placeholder="https://..."
+            )
+
+            task_input = gr.CheckboxGroup(
+                label="Tasks",
+                choices=[
+                    "text classification",
+                    "sentiment analysis",
+                    "named entity recognition",
+                    "part-of-speech tagging",
+                    "question answering",
+                    "text summarization",
+                    "machine translation",
+                    "language modeling",
+                    "text generation",
+                    "information extraction",
+                    "semantic similarity",
+                    "natural language inference",
+                ],
+            )
+
+            domain_input = gr.CheckboxGroup(
+                label="Domain",
+                choices=[
+                    "clinical",
+                    "legal",
+                    "financial",
+                    "scientific",
+                    "news",
+                    "social media",
+                    "literature",
+                    "general",
+                ],
+            )
+
+            countries_input = gr.CheckboxGroup(
+                label="Countries",
+                choices=[
+                    "Spain",
+                    "Mexico",
+                    "Argentina",
+                    "Colombia",
+                    "Peru",
+                    "Venezuela",
+                    "Chile",
+                    "Ecuador",
+                    "Guatemala",
+                    "Cuba",
+                    "Bolivia",
+                    "Dominican Republic",
+                    "Honduras",
+                    "Paraguay",
+                    "El Salvador",
+                    "Nicaragua",
+                    "Costa Rica",
+                    "Panama",
+                    "Uruguay",
+                    "Puerto Rico",
+                ],
+            )
+
+            languages_input = gr.CheckboxGroup(
+                label="Languages",
+                choices=[
+                    "spanish",
+                    "catalan",
+                    "basque",
+                    "galician",
+                    "guarani",
+                    "quechua",
+                    "aymara",
+                ],
+            )
+
+            update_btn = gr.Button("💾 Update Entry", variant="primary")
+            result_msg = gr.Markdown()
+
+        # Store the original name for updating
+        original_name_state = gr.State("")
+
+        def search_and_update_dropdown(query):
+            results_df = search_entries(query)
+            if results_df.empty:
+                return gr.Dropdown(choices=[], value=None)
+            else:
+                choices = results_df["name"].tolist()
+                return gr.Dropdown(choices=choices, value=None)
+
+        def load_entry_and_show_form(selected_entry):
+            if not selected_entry:
+                return (gr.Column(visible=False), "", *[("",) * 11])
+
+            entry_data = load_entry_for_edit(selected_entry)
+            return (gr.Column(visible=True), selected_entry, *entry_data)
+
+        # Event handlers
+        search_btn.click(
+            fn=search_and_update_dropdown,
+            inputs=[search_input],
+            outputs=[search_results],
+        )
+
+        search_results.change(
+            fn=load_entry_and_show_form,
+            inputs=[search_results],
+            outputs=[
+                edit_form,
+                original_name_state,
+                name_input,
+                github_url_input,
+                huggingface_url_input,
+                zenodo_url_input,
+                paper_url_input,
+                dataset_type_input,
+                task_input,
+                domain_input,
+                website_url_input,
+                countries_input,
+                languages_input,
+            ],
+        )
+
+        update_btn.click(
+            fn=update_entry,
+            inputs=[
+                original_name_state,
+                name_input,
+                github_url_input,
+                huggingface_url_input,
+                zenodo_url_input,
+                paper_url_input,
+                dataset_type_input,
+                task_input,
+                domain_input,
+                website_url_input,
+                countries_input,
+                languages_input,
+            ],
+            outputs=[result_msg],
+        )
+
+        return (
+            search_input,
+            search_btn,
+            search_results,
+            edit_form,
+            name_input,
+            dataset_type_input,
+            github_url_input,
+            huggingface_url_input,
+            zenodo_url_input,
+            paper_url_input,
+            website_url_input,
+            task_input,
+            domain_input,
+            countries_input,
+            languages_input,
+            update_btn,
+            result_msg,
+        )
+
+
 def create_tab():
     """Create the complete tab for this resource type."""
     with gr.TabItem(f"📊 {RESOURCE_TITLE}", id=RESOURCE_TYPE):
         with gr.Tabs():
             table = create_all_tab()
             inputs = create_contribute_tab()
-            return table, inputs
+            edit_components = create_edit_tab()
+            return table, inputs, edit_components

events_resource.py

@@ -306,10 +306,267 @@ def create_contribute_tab():
         )
 
 
+def search_entries(query: str) -> pd.DataFrame:
+    """Search for entries by titulo or ponente."""
+    if not query.strip():
+        return pd.DataFrame()
+
+    df = load_data()
+    if df.empty:
+        return df
+
+    # Search in titulo and ponente columns
+    mask = df["titulo"].str.contains(query, case=False, na=False) | df[
+        "ponente"
+    ].str.contains(query, case=False, na=False)
+
+    return df[mask]
+
+
+def load_entry_for_edit(selected_entry: str) -> tuple:
+    """Load a specific entry for editing."""
+    if not selected_entry:
+        return ("",) * 9  # Return empty values for all fields
+
+    df = load_data()
+    if df.empty:
+        return ("",) * 9
+
+    # Find the entry by titulo
+    entry = df[df["titulo"] == selected_entry].iloc[0]
+
+    return (
+        entry["titulo"],
+        entry["ponente"],
+        entry["bio"],
+        entry["tipo"],
+        entry["etiquetas"],
+        entry["tema"],
+        str(entry["nivel_tecnico"]),
+        entry["fecha"],
+        entry["youtube"],
+    )
+
+
+def update_entry(
+    original_titulo: str,
+    titulo: str,
+    ponente: str,
+    bio: str,
+    tipo: str,
+    etiquetas: str,
+    tema: str,
+    nivel_tecnico: str,
+    fecha: str,
+    youtube: str,
+    profile: gr.OAuthProfile | None,
+):
+    """Update an existing entry."""
+    if not profile:
+        return "❌ Please log in to edit entries."
+
+    username = profile.username
+    if not username:
+        return "❌ Could not get username from profile."
+
+    if not original_titulo:
+        return "❌ No entry selected to edit."
+
+    # Validate required fields
+    required_fields = [
+        titulo,
+        ponente,
+        bio,
+        tipo,
+        etiquetas,
+        tema,
+        nivel_tecnico,
+        fecha,
+        youtube,
+    ]
+    if not all(field.strip() for field in required_fields):
+        return "❌ All fields are required."
+
+    # Validate YouTube URL
+    if not validate_url(youtube):
+        return "❌ Invalid YouTube URL. Please provide a valid URL."
+
+    # Validate technical level
+    if not validate_nivel_tecnico(nivel_tecnico):
+        return "❌ Invalid technical level. Please select a value from 1 to 5."
+
+    # Validate date format
+    if not validate_date(fecha):
+        return "❌ Invalid date format. Please use DD/MM/YYYY format."
+
+    try:
+        # Load existing dataset
+        existing_dataset = load_dataset(DATASET_NAME, CONFIG_NAME, split="train")
+        existing_df = existing_dataset.to_pandas()
+
+        # Find and update the entry
+        mask = existing_df["titulo"] == original_titulo
+        if not mask.any():
+            return f"❌ Entry '{original_titulo}' not found."
+
+        # Update the entry
+        current_time = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+        existing_df.loc[mask, "titulo"] = titulo
+        existing_df.loc[mask, "ponente"] = ponente
+        existing_df.loc[mask, "bio"] = bio
+        existing_df.loc[mask, "tipo"] = tipo
+        existing_df.loc[mask, "etiquetas"] = etiquetas
+        existing_df.loc[mask, "tema"] = tema
+        existing_df.loc[mask, "nivel_tecnico"] = nivel_tecnico
+        existing_df.loc[mask, "fecha"] = fecha
+        existing_df.loc[mask, "youtube"] = youtube
+        existing_df.loc[mask, "date_submitted"] = current_time
+
+        # Convert back to Dataset and push to hub
+        updated_dataset = Dataset.from_pandas(existing_df)
+        updated_dataset.push_to_hub(
+            DATASET_NAME,
+            config_name=CONFIG_NAME,
+            commit_message=f"Update event entry: {titulo} (edited by {username})",
+        )
+
+        return f"✅ Successfully updated '{titulo}'!"
+
+    except Exception as e:
+        return f"❌ Error updating entry: {str(e)}"
+
+
+def create_edit_tab():
+    """Create the edit tab for modifying existing entries."""
+    with gr.TabItem("✏️ Edit", id=f"{RESOURCE_TYPE}_edit"):
+        gr.Markdown(f"### Edit Existing {RESOURCE_TITLE}")
+        gr.Markdown("Please log in to edit entries:")
+        login_button = gr.LoginButton(elem_id=f"{RESOURCE_TYPE}-edit-oauth-button")
+
+        gr.Markdown("Search for an entry to edit:")
+
+        with gr.Row():
+            search_input = gr.Textbox(
+                label="Search by title or speaker",
+                placeholder="Enter event title or speaker name...",
+                scale=3,
+            )
+            search_btn = gr.Button("🔍 Search", scale=1)
+
+        search_results = gr.Dropdown(
+            label="Select entry to edit", choices=[], interactive=True
+        )
+
+        gr.Markdown("---")
+        gr.Markdown("**Edit the selected entry:**")
+
+        with gr.Column(visible=False) as edit_form:
+            titulo_input = gr.Textbox(label="Título *", placeholder="Event title")
+            ponente_input = gr.Textbox(label="Ponente *", placeholder="Speaker name")
+            bio_input = gr.Textbox(label="Bio *", lines=2, placeholder="Speaker bio")
+            tipo_input = gr.Dropdown(
+                label="Tipo *",
+                choices=["workshop", "talk", "AMA", "round table"],
+                value="talk",
+            )
+            etiquetas_input = gr.Textbox(label="Etiquetas *", placeholder="Tags")
+            tema_input = gr.Textbox(label="Tema *", placeholder="Topic")
+            nivel_tecnico_input = gr.Dropdown(
+                label="Nivel Técnico *", choices=["1", "2", "3", "4", "5"], value="3"
+            )
+            fecha_input = gr.Textbox(label="Fecha *", placeholder="DD/MM/YYYY")
+            youtube_input = gr.Textbox(
+                label="YouTube *", placeholder="https://youtube.com/..."
+            )
+
+            update_btn = gr.Button("💾 Update Entry", variant="primary")
+            result_msg = gr.Markdown()
+
+        # Store the original titulo for updating
+        original_titulo_state = gr.State("")
+
+        def search_and_update_dropdown(query):
+            results_df = search_entries(query)
+            if results_df.empty:
+                return gr.Dropdown(choices=[], value=None)
+            else:
+                choices = results_df["titulo"].tolist()
+                return gr.Dropdown(choices=choices, value=None)
+
+        def load_entry_and_show_form(selected_entry):
+            if not selected_entry:
+                return (gr.Column(visible=False), "", *[("",) * 9])
+
+            entry_data = load_entry_for_edit(selected_entry)
+            return (gr.Column(visible=True), selected_entry, *entry_data)
+
+        # Event handlers
+        search_btn.click(
+            fn=search_and_update_dropdown,
+            inputs=[search_input],
+            outputs=[search_results],
+        )
+
+        search_results.change(
+            fn=load_entry_and_show_form,
+            inputs=[search_results],
+            outputs=[
+                edit_form,
+                original_titulo_state,
+                titulo_input,
+                ponente_input,
+                bio_input,
+                tipo_input,
+                etiquetas_input,
+                tema_input,
+                nivel_tecnico_input,
+                fecha_input,
+                youtube_input,
+            ],
+        )
+
+        update_btn.click(
+            fn=update_entry,
+            inputs=[
+                original_titulo_state,
+                titulo_input,
+                ponente_input,
+                bio_input,
+                tipo_input,
+                etiquetas_input,
+                tema_input,
+                nivel_tecnico_input,
+                fecha_input,
+                youtube_input,
+            ],
+            outputs=[result_msg],
+        )
+
+        return (
+            search_input,
+            search_btn,
+            search_results,
+            edit_form,
+            titulo_input,
+            ponente_input,
+            bio_input,
+            tipo_input,
+            etiquetas_input,
+            tema_input,
+            nivel_tecnico_input,
+            fecha_input,
+            youtube_input,
+            update_btn,
+            result_msg,
+        )
+
+
 def create_tab():
     """Create the complete tab for this resource type."""
     with gr.TabItem(f"📅 {RESOURCE_TITLE}", id=RESOURCE_TYPE):
         with gr.Tabs():
             table = create_all_tab()
             inputs = create_contribute_tab()
-            return table, inputs
+            edit_components = create_edit_tab()
+            return table, inputs, edit_components

initiatives_resource.py

@@ -282,10 +282,281 @@ def create_contribute_tab():
         )
 
 
+def search_entries(query: str) -> pd.DataFrame:
+    """Search for entries by name or website URL."""
+    if not query.strip():
+        return pd.DataFrame()
+
+    df = load_data()
+    if df.empty:
+        return df
+
+    # Search in name and website_url columns
+    mask = df["name"].str.contains(query, case=False, na=False) | df[
+        "website_url"
+    ].str.contains(query, case=False, na=False)
+
+    return df[mask]
+
+
+def load_entry_for_edit(selected_entry: str) -> tuple:
+    """Load a specific entry for editing."""
+    if not selected_entry:
+        return ("",) * 5  # Return empty values for all fields
+
+    df = load_data()
+    if df.empty:
+        return ("",) * 5
+
+    # Find the entry by name
+    entry = df[df["name"] == selected_entry].iloc[0]
+
+    # Convert comma-separated strings back to lists for multi-select components
+    countries_list = (
+        [c.strip() for c in entry["countries"].split(",")] if entry["countries"] else []
+    )
+    languages_list = (
+        [l.strip() for l in entry["languages"].split(",")] if entry["languages"] else []
+    )
+
+    return (
+        entry["name"],
+        entry["type"],
+        countries_list,
+        languages_list,
+        entry["website_url"],
+    )
+
+
+def update_entry(
+    original_name: str,
+    name: str,
+    initiative_type: str,
+    countries: list,
+    languages: list,
+    website_url: str,
+    profile: gr.OAuthProfile | None,
+):
+    """Update an existing entry."""
+    if not profile:
+        return "❌ Please log in to edit entries."
+
+    username = profile.username
+    if not username:
+        return "❌ Could not get username from profile."
+
+    if not original_name:
+        return "❌ No entry selected to edit."
+
+    # Validate required fields
+    if not name.strip():
+        return "❌ Name is required."
+
+    if not initiative_type:
+        return "❌ Type is required."
+
+    if not countries:
+        return "❌ At least one country is required."
+
+    if not languages:
+        return "❌ At least one language is required."
+
+    if not website_url.strip():
+        return "❌ Website URL is required."
+
+    # Validate URL
+    if not validate_url(website_url):
+        return "❌ Invalid website URL. Please provide a valid URL."
+
+    try:
+        # Load existing dataset
+        existing_dataset = load_dataset(DATASET_NAME, CONFIG_NAME, split="train")
+        existing_df = existing_dataset.to_pandas()
+
+        # Find and update the entry
+        mask = existing_df["name"] == original_name
+        if not mask.any():
+            return f"❌ Entry '{original_name}' not found."
+
+        # Update the entry
+        current_time = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+        existing_df.loc[mask, "name"] = name
+        existing_df.loc[mask, "type"] = initiative_type
+        existing_df.loc[mask, "countries"] = ", ".join(countries) if countries else ""
+        existing_df.loc[mask, "languages"] = ", ".join(languages) if languages else ""
+        existing_df.loc[mask, "website_url"] = website_url
+        existing_df.loc[mask, "date_submitted"] = current_time
+
+        # Convert back to Dataset and push to hub
+        updated_dataset = Dataset.from_pandas(existing_df)
+        updated_dataset.push_to_hub(
+            DATASET_NAME,
+            config_name=CONFIG_NAME,
+            commit_message=f"Update initiative entry: {name} (edited by {username})",
+        )
+
+        return f"✅ Successfully updated '{name}'!"
+
+    except Exception as e:
+        return f"❌ Error updating entry: {str(e)}"
+
+
+def create_edit_tab():
+    """Create the edit tab for modifying existing entries."""
+    with gr.TabItem("✏️ Edit", id=f"{RESOURCE_TYPE}_edit"):
+        gr.Markdown(f"### Edit Existing {RESOURCE_TITLE}")
+        gr.Markdown("Please log in to edit entries:")
+        login_button = gr.LoginButton(elem_id=f"{RESOURCE_TYPE}-edit-oauth-button")
+
+        gr.Markdown("Search for an entry to edit:")
+
+        with gr.Row():
+            search_input = gr.Textbox(
+                label="Search by name or website URL",
+                placeholder="Enter initiative name or website URL...",
+                scale=3,
+            )
+            search_btn = gr.Button("🔍 Search", scale=1)
+
+        search_results = gr.Dropdown(
+            label="Select entry to edit", choices=[], interactive=True
+        )
+
+        gr.Markdown("---")
+        gr.Markdown("**Edit the selected entry:**")
+
+        with gr.Column(visible=False) as edit_form:
+            name_input = gr.Textbox(label="Name *", placeholder="Initiative name")
+            type_input = gr.Dropdown(
+                label="Type *",
+                choices=[
+                    "project",
+                    "event",
+                    "research group",
+                    "community",
+                    "research institute",
+                    "non-profit",
+                    "OS company",
+                ],
+                value="project",
+            )
+            countries_input = gr.CheckboxGroup(
+                label="Countries *",
+                choices=[
+                    "Spain",
+                    "Mexico",
+                    "Argentina",
+                    "Colombia",
+                    "Peru",
+                    "Venezuela",
+                    "Chile",
+                    "Ecuador",
+                    "Guatemala",
+                    "Cuba",
+                    "Bolivia",
+                    "Dominican Republic",
+                    "Honduras",
+                    "Paraguay",
+                    "El Salvador",
+                    "Nicaragua",
+                    "Costa Rica",
+                    "Panama",
+                    "Uruguay",
+                    "Puerto Rico",
+                ],
+            )
+            languages_input = gr.CheckboxGroup(
+                label="Languages *",
+                choices=[
+                    "spanish",
+                    "catalan",
+                    "basque",
+                    "galician",
+                    "guarani",
+                    "quechua",
+                    "aymara",
+                ],
+            )
+            website_url_input = gr.Textbox(
+                label="Website URL *", placeholder="https://..."
+            )
+
+            update_btn = gr.Button("💾 Update Entry", variant="primary")
+            result_msg = gr.Markdown()
+
+        # Store the original name for updating
+        original_name_state = gr.State("")
+
+        def search_and_update_dropdown(query):
+            results_df = search_entries(query)
+            if results_df.empty:
+                return gr.Dropdown(choices=[], value=None)
+            else:
+                choices = results_df["name"].tolist()
+                return gr.Dropdown(choices=choices, value=None)
+
+        def load_entry_and_show_form(selected_entry):
+            if not selected_entry:
+                return (gr.Column(visible=False), "", *[("",) * 5])
+
+            entry_data = load_entry_for_edit(selected_entry)
+            return (gr.Column(visible=True), selected_entry, *entry_data)
+
+        # Event handlers
+        search_btn.click(
+            fn=search_and_update_dropdown,
+            inputs=[search_input],
+            outputs=[search_results],
+        )
+
+        search_results.change(
+            fn=load_entry_and_show_form,
+            inputs=[search_results],
+            outputs=[
+                edit_form,
+                original_name_state,
+                name_input,
+                type_input,
+                countries_input,
+                languages_input,
+                website_url_input,
+            ],
+        )
+
+        update_btn.click(
+            fn=update_entry,
+            inputs=[
+                original_name_state,
+                name_input,
+                type_input,
+                countries_input,
+                languages_input,
+                website_url_input,
+            ],
+            outputs=[result_msg],
+        )
+
+        return (
+            search_input,
+            search_btn,
+            search_results,
+            edit_form,
+            name_input,
+            type_input,
+            countries_input,
+            languages_input,
+            website_url_input,
+            update_btn,
+            result_msg,
+        )
+
+
 def create_tab():
     """Create the complete tab for this resource type."""
     with gr.TabItem(f"🌟 {RESOURCE_TITLE}", id=RESOURCE_TYPE):
         with gr.Tabs():
             table = create_all_tab()
             inputs = create_contribute_tab()
-            return table, inputs
+            edit_components = create_edit_tab()
+            return table, inputs, edit_components

models_resource.py

@@ -256,10 +256,208 @@ def create_contribute_tab():
         )
 
 
+
+def search_entries(query: str) -> pd.DataFrame:
+    """Search for entries by familia or URL."""
+    if not query.strip():
+        return pd.DataFrame()
+    
+    df = load_data()
+    if df.empty:
+        return df
+    
+    # Search in familia and hf_collection_url columns
+    mask = (
+        df['familia'].str.contains(query, case=False, na=False) |
+        df['hf_collection_url'].str.contains(query, case=False, na=False)
+    )
+    
+    return df[mask]
+
+
+def load_entry_for_edit(selected_entry: str) -> tuple:
+    """Load a specific entry for editing."""
+    if not selected_entry:
+        return ("",) * 5  # Return empty values for all fields
+    
+    df = load_data()
+    if df.empty:
+        return ("",) * 5
+    
+    # Find the entry by familia or hf_collection_url
+    entry = df[df['familia'] == selected_entry].iloc[0] if (df['familia'] == selected_entry).any() else df[df['hf_collection_url'] == selected_entry].iloc[0]
+    
+    return (
+        entry['familia'],
+        entry['available_sizes'],
+        entry['hf_collection_url'],
+        entry['website_url'],
+        entry['paper_url']
+    )
+
+
+def update_entry(
+    original_identifier: str,
+    familia: str, available_sizes: str, hf_collection_url: str,
+    website_url: str, paper_url: str, profile: gr.OAuthProfile | None
+):
+    """Update an existing entry."""
+    if not profile:
+        return "❌ Please log in to edit entries."
+    
+    username = profile.username
+    if not username:
+        return "❌ Could not get username from profile."
+    
+    if not original_identifier:
+        return "❌ No entry selected to edit."
+    
+    if not hf_collection_url.strip():
+        return "❌ Hugging Face Collection URL is required."
+    
+    # Validate URLs
+    for url_field, url_value in [("Hugging Face Collection URL", hf_collection_url), 
+                                  ("Website URL", website_url), ("Paper URL", paper_url)]:
+        if url_value.strip() and not validate_url(url_value):
+            return f"❌ Invalid {url_field}. Please provide a valid URL."
+    
+    # Validate available_sizes format
+    if available_sizes.strip() and not validate_sizes(available_sizes):
+        return "❌ Invalid available sizes format. Use comma-separated numbers (e.g., '0.1, 1.3, 7, 14')."
+    
+    try:
+        # Load existing dataset
+        existing_dataset = load_dataset(DATASET_NAME, CONFIG_NAME, split="train")
+        existing_df = existing_dataset.to_pandas()
+        
+        # Find and update the entry
+        mask = (existing_df['familia'] == original_identifier) | (existing_df['hf_collection_url'] == original_identifier)
+        if not mask.any():
+            return f"❌ Entry '{original_identifier}' not found."
+        
+        # Update the entry
+        current_time = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        
+        existing_df.loc[mask, 'familia'] = familia
+        existing_df.loc[mask, 'available_sizes'] = available_sizes
+        existing_df.loc[mask, 'hf_collection_url'] = hf_collection_url
+        existing_df.loc[mask, 'website_url'] = website_url
+        existing_df.loc[mask, 'paper_url'] = paper_url
+        existing_df.loc[mask, 'date_submitted'] = current_time
+        
+        # Convert back to Dataset and push to hub
+        updated_dataset = Dataset.from_pandas(existing_df)
+        updated_dataset.push_to_hub(
+            DATASET_NAME,
+            config_name=CONFIG_NAME,
+            commit_message=f"Update model entry: {familia or hf_collection_url} (edited by {username})",
+        )
+        
+        return f"✅ Successfully updated '{familia or hf_collection_url}'!"
+        
+    except Exception as e:
+        return f"❌ Error updating entry: {str(e)}"
+
+
+
+def create_edit_tab():
+    """Create the edit tab for modifying existing entries."""
+    with gr.TabItem("✏️ Edit", id=f"{RESOURCE_TYPE}_edit"):
+        gr.Markdown(f"### Edit Existing {RESOURCE_TITLE}")
+        gr.Markdown("Please log in to edit entries:")
+        login_button = gr.LoginButton(elem_id=f"{RESOURCE_TYPE}-edit-oauth-button")
+        
+        gr.Markdown("Search for an entry to edit:")
+        
+        with gr.Row():
+            search_input = gr.Textbox(
+                label="Search by familia or collection URL",
+                placeholder="Enter model familia or Hugging Face collection URL...",
+                scale=3
+            )
+            search_btn = gr.Button("🔍 Search", scale=1)
+        
+        search_results = gr.Dropdown(
+            label="Select entry to edit",
+            choices=[],
+            interactive=True
+        )
+        
+        gr.Markdown("---")
+        gr.Markdown("**Edit the selected entry:**")
+        
+        with gr.Column(visible=False) as edit_form:
+            hf_collection_url_input = gr.Textbox(label="Hugging Face Collection URL *", placeholder="https://huggingface.co/collections/...")
+            familia_input = gr.Textbox(label="Familia", placeholder="e.g., BERT, GPT, T5...")
+            available_sizes_input = gr.Textbox(
+                label="Available Sizes (in B parameters)",
+                placeholder="e.g., 0.1, 1.3, 7, 14",
+                info="Comma-separated list of model sizes in billions of parameters"
+            )
+            website_url_input = gr.Textbox(label="Website URL", placeholder="https://...")
+            paper_url_input = gr.Textbox(label="Paper URL", placeholder="https://arxiv.org/...")
+            
+            update_btn = gr.Button("💾 Update Entry", variant="primary")
+            result_msg = gr.Markdown()
+        
+        # Store the original identifier for updating
+        original_identifier_state = gr.State("")
+        
+        def search_and_update_dropdown(query):
+            results_df = search_entries(query)
+            if results_df.empty:
+                return gr.Dropdown(choices=[], value=None)
+            else:
+                # Use familia if available, otherwise use hf_collection_url
+                choices = [entry if entry else url for entry, url in zip(results_df['familia'].fillna(''), results_df['hf_collection_url'])]
+                return gr.Dropdown(choices=choices, value=None)
+        
+        def load_entry_and_show_form(selected_entry):
+            if not selected_entry:
+                return (gr.Column(visible=False), "", *[("",) * 5])
+            
+            entry_data = load_entry_for_edit(selected_entry)
+            return (gr.Column(visible=True), selected_entry, *entry_data)
+        
+        # Event handlers
+        search_btn.click(
+            fn=search_and_update_dropdown,
+            inputs=[search_input],
+            outputs=[search_results]
+        )
+        
+        search_results.change(
+            fn=load_entry_and_show_form,
+            inputs=[search_results],
+            outputs=[
+                edit_form, original_identifier_state,
+                familia_input, available_sizes_input, hf_collection_url_input,
+                website_url_input, paper_url_input
+            ]
+        )
+        
+        update_btn.click(
+            fn=update_entry,
+            inputs=[
+                original_identifier_state,
+                familia_input, available_sizes_input, hf_collection_url_input,
+                website_url_input, paper_url_input
+            ],
+            outputs=[result_msg]
+        )
+        
+        return (
+            search_input, search_btn, search_results, edit_form,
+            familia_input, available_sizes_input, hf_collection_url_input,
+            website_url_input, paper_url_input, update_btn, result_msg
+        )
+
+
 def create_tab():
     """Create the complete tab for this resource type."""
     with gr.TabItem(f"🤖 {RESOURCE_TITLE}", id=RESOURCE_TYPE):
         with gr.Tabs():
             table = create_all_tab()
             inputs = create_contribute_tab()
-            return table, inputs
+            edit_components = create_edit_tab()
+            return table, inputs, edit_components

shared_tasks_resource.py

@@ -289,10 +289,222 @@ def create_contribute_tab():
         )
 
 
+
+def search_entries(query: str) -> pd.DataFrame:
+    """Search for entries by name or conference."""
+    if not query.strip():
+        return pd.DataFrame()
+    
+    df = load_data()
+    if df.empty:
+        return df
+    
+    # Search in name and conference_name columns
+    mask = (
+        df['name'].str.contains(query, case=False, na=False) |
+        df['conference_name'].str.contains(query, case=False, na=False)
+    )
+    
+    return df[mask]
+
+
+def load_entry_for_edit(selected_entry: str) -> tuple:
+    """Load a specific entry for editing."""
+    if not selected_entry:
+        return ("",) * 7  # Return empty values for all fields
+    
+    df = load_data()
+    if df.empty:
+        return ("",) * 7
+    
+    # Find the entry by name
+    entry = df[df['name'] == selected_entry].iloc[0]
+    
+    return (
+        entry['name'],
+        entry['conference_name'],
+        entry['workshop_date'],
+        entry['registration_deadline'],
+        entry['data_available_date'],
+        entry['submission_deadline'],
+        entry['more_info_url']
+    )
+
+
+def update_entry(
+    original_name: str,
+    name: str, conference_name: str, workshop_date: str, registration_deadline: str,
+    data_available_date: str, submission_deadline: str, more_info_url: str,
+    profile: gr.OAuthProfile | None,
+):
+    """Update an existing entry."""
+    if not profile:
+        return "❌ Please log in to edit entries."
+    
+    username = profile.username
+    if not username:
+        return "❌ Could not get username from profile."
+    
+    if not original_name:
+        return "❌ No entry selected to edit."
+    
+    # Validate required fields
+    required_fields = [name, conference_name, workshop_date, registration_deadline, 
+                      data_available_date, submission_deadline, more_info_url]
+    if not all(field.strip() for field in required_fields):
+        return "❌ All fields are required."
+    
+    # Validate URL
+    if not validate_url(more_info_url):
+        return "❌ Invalid URL. Please provide a valid URL."
+    
+    # Validate dates
+    date_fields = [("Workshop Date", workshop_date), ("Registration Deadline", registration_deadline),
+                   ("Data Available Date", data_available_date), ("Submission Deadline", submission_deadline)]
+    for field_name, date_value in date_fields:
+        if not validate_date(date_value):
+            return f"❌ Invalid {field_name}. Please use DD/MM/YYYY format."
+    
+    try:
+        # Load existing dataset
+        existing_dataset = load_dataset(DATASET_NAME, CONFIG_NAME, split="train")
+        existing_df = existing_dataset.to_pandas()
+        
+        # Find and update the entry
+        mask = existing_df['name'] == original_name
+        if not mask.any():
+            return f"❌ Entry '{original_name}' not found."
+        
+        # Update the entry
+        current_time = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        
+        existing_df.loc[mask, 'name'] = name
+        existing_df.loc[mask, 'conference_name'] = conference_name
+        existing_df.loc[mask, 'workshop_date'] = workshop_date
+        existing_df.loc[mask, 'registration_deadline'] = registration_deadline
+        existing_df.loc[mask, 'data_available_date'] = data_available_date
+        existing_df.loc[mask, 'submission_deadline'] = submission_deadline
+        existing_df.loc[mask, 'more_info_url'] = more_info_url
+        existing_df.loc[mask, 'date_submitted'] = current_time
+        
+        # Convert back to Dataset and push to hub
+        updated_dataset = Dataset.from_pandas(existing_df)
+        updated_dataset.push_to_hub(
+            DATASET_NAME,
+            config_name=CONFIG_NAME,
+            commit_message=f"Update shared task entry: {name} (edited by {username})",
+        )
+        
+        return f"✅ Successfully updated '{name}'!"
+        
+    except Exception as e:
+        return f"❌ Error updating entry: {str(e)}"
+
+
+
+def create_edit_tab():
+    """Create the edit tab for modifying existing entries."""
+    with gr.TabItem("✏️ Edit", id=f"{RESOURCE_TYPE}_edit"):
+        gr.Markdown(f"### Edit Existing {RESOURCE_TITLE}")
+        gr.Markdown("Please log in to edit entries:")
+        login_button = gr.LoginButton(elem_id=f"{RESOURCE_TYPE}-edit-oauth-button")
+        
+        gr.Markdown("Search for an entry to edit:")
+        
+        with gr.Row():
+            search_input = gr.Textbox(
+                label="Search by name or conference",
+                placeholder="Enter shared task name or conference name...",
+                scale=3
+            )
+            search_btn = gr.Button("🔍 Search", scale=1)
+        
+        search_results = gr.Dropdown(
+            label="Select entry to edit",
+            choices=[],
+            interactive=True
+        )
+        
+        gr.Markdown("---")
+        gr.Markdown("**Edit the selected entry:**")
+        
+        with gr.Column(visible=False) as edit_form:
+            name_input = gr.Textbox(label="Name *", placeholder="Shared task name")
+            conference_name_input = gr.Textbox(label="Conference Name *", placeholder="Conference or workshop name")
+            
+            gr.Markdown("**Important Dates** (all required, format: DD/MM/YYYY)")
+            with gr.Row():
+                workshop_date_input = gr.Textbox(label="Workshop Date *", placeholder="DD/MM/YYYY")
+                registration_deadline_input = gr.Textbox(label="Registration Deadline *", placeholder="DD/MM/YYYY")
+            with gr.Row():
+                data_available_date_input = gr.Textbox(label="Data Available Date *", placeholder="DD/MM/YYYY")
+                submission_deadline_input = gr.Textbox(label="Submission Deadline *", placeholder="DD/MM/YYYY")
+            
+            more_info_url_input = gr.Textbox(label="More Info URL *", placeholder="https://...")
+            
+            update_btn = gr.Button("💾 Update Entry", variant="primary")
+            result_msg = gr.Markdown()
+        
+        # Store the original name for updating
+        original_name_state = gr.State("")
+        
+        def search_and_update_dropdown(query):
+            results_df = search_entries(query)
+            if results_df.empty:
+                return gr.Dropdown(choices=[], value=None)
+            else:
+                choices = results_df['name'].tolist()
+                return gr.Dropdown(choices=choices, value=None)
+        
+        def load_entry_and_show_form(selected_entry):
+            if not selected_entry:
+                return (gr.Column(visible=False), "", *[("",) * 7])
+            
+            entry_data = load_entry_for_edit(selected_entry)
+            return (gr.Column(visible=True), selected_entry, *entry_data)
+        
+        # Event handlers
+        search_btn.click(
+            fn=search_and_update_dropdown,
+            inputs=[search_input],
+            outputs=[search_results]
+        )
+        
+        search_results.change(
+            fn=load_entry_and_show_form,
+            inputs=[search_results],
+            outputs=[
+                edit_form, original_name_state,
+                name_input, conference_name_input, workshop_date_input,
+                registration_deadline_input, data_available_date_input,
+                submission_deadline_input, more_info_url_input
+            ]
+        )
+        
+        update_btn.click(
+            fn=update_entry,
+            inputs=[
+                original_name_state,
+                name_input, conference_name_input, workshop_date_input,
+                registration_deadline_input, data_available_date_input,
+                submission_deadline_input, more_info_url_input,
+            ],
+            outputs=[result_msg]
+        )
+        
+        return (
+            search_input, search_btn, search_results, edit_form,
+            name_input, conference_name_input, workshop_date_input,
+            registration_deadline_input, data_available_date_input,
+            submission_deadline_input, more_info_url_input, update_btn, result_msg
+        )
+
+
 def create_tab():
     """Create the complete tab for this resource type."""
     with gr.TabItem(f"🏆 {RESOURCE_TITLE}", id=RESOURCE_TYPE):
         with gr.Tabs():
             table = create_all_tab()
             inputs = create_contribute_tab()
-            return table, inputs
+            edit_components = create_edit_tab()
+            return table, inputs, edit_components