better handling of dynamic sections to keep in memory fields that are already filled

app.py

@@ -23,7 +23,9 @@ def handle_submit(*inputs):
 
     # Check if the message indicates validation failure
     if message.startswith("The following fields are required"):
-        return message, file_path, json_output
+        publish_button = gr.Button(
+            "Share your data to the public repository", interactive=False, elem_classes="pubbutton")
+        return message, file_path, json_output, publish_button
 
     publish_button = gr.Button(
         "Share your data to the public repository", interactive=True, elem_classes="pubbutton")

src/services/huggingface.py

@@ -1,10 +1,6 @@
 from huggingface_hub import HfApi, login
-import json
 from src.services.util import HF_TOKEN, DATASET_NAME
-import tempfile
 import os
-import json
-import re
 
 
 def init_huggingface():

src/services/json_generator.py

@@ -7,6 +7,37 @@ import tempfile
 import os
 
 
+def process_component_list(fields_dict):
+    """
+    Fonction générique pour traiter une liste de composants à partir d'un dictionnaire de champs.
+
+    Args:
+        fields_dict (dict): Dictionnaire où les clés sont les noms des champs
+                           et les valeurs sont des listes de valeurs.
+
+    Returns:
+        list: Liste de dictionnaires représentant les composants.
+    """
+    component_list = []
+
+    # Trouver le nombre maximum d'éléments parmi tous les champs
+    max_items = 0
+    for field_values in fields_dict.values():
+        if field_values:
+            max_items = max(max_items, len(field_values))
+
+    # Créer les composants
+    for i in range(max_items):
+        component = {}
+        for field_name, field_values in fields_dict.items():
+            if i < len(field_values) and field_values[i]:
+                component[field_name] = field_values[i]
+        if component:  # Ajouter seulement si le composant n'est pas vide
+            component_list.append(component)
+
+    return component_list
+
+
 def generate_json(
     # Header
     licensing, formatVersion, formatVersionSpecificationUri, reportId,
@@ -37,65 +68,68 @@ def generate_json(
     quality
 ):
     """Generate JSON data from form inputs."""
-    # Process algorithms
-    algorithms_list = []
-    algorithm_fields = {"trainingType": trainingType, "algorithmType": algorithmType, "algorithmName": algorithmName, "algorithmUri": algorithmUri, "foundationModelName": foundationModelName, "foundationModelUri": foundationModelUri,
-                        "parametersNumber": parametersNumber, "framework": framework,  "frameworkVersion": frameworkVersion, "classPath": classPath, "layersNumber": layersNumber, "epochsNumber": epochsNumber, "optimizer": optimizer, "quantization": quantization}
-    nb_algo = 0
-    # ça ça marche pas
-    for f in algorithm_fields:
-        nb_algo = max(nb_algo, len(algorithm_fields[f]))
-    for i in range(nb_algo):
-        algortithm = {}
-        for f in algorithm_fields:
-            if i < len(algorithm_fields[f]) and algorithm_fields[f][i]:
-                algortithm[f] = algorithm_fields[f][i]
-        algorithms_list.append(algortithm)
-
-    # Process dataset
-    dataset_list = []
-    dataset_fields = {"dataUsage": dataUsage, "dataType": dataType, "dataFormat": dataFormat, "dataSize": dataSize,
-                      "dataQuantity": dataQuantity, "shape": shape, "source": source, "sourceUri": sourceUri, "owner": owner}
-    nb_data = 0
-    for f in dataset_fields:
-        nb_data = max(nb_data, len(dataset_fields[f]))
-    for i in range(nb_data):
-        data = {}
-        for f in dataset_fields:
-            if i < len(dataset_fields[f]) and dataset_fields[f][i]:
-                data[f] = dataset_fields[f][i]
-        dataset_list.append(data)
-
-    # Process measures
-    measures_list = []
-    measure_fields = {"measurementMethod": measurementMethod, "manufacturer": manufacturer, "version": version, "cpuTrackingMode": cpuTrackingMode,
-                      "gpuTrackingMode": gpuTrackingMode, "averageUtilizationCpu": averageUtilizationCpu, "averageUtilizationGpu": averageUtilizationGpu,
-                      "powerCalibrationMeasurement": powerCalibrationMeasurement,  "durationCalibrationMeasurement": durationCalibrationMeasurement,
-                      "powerConsumption": powerConsumption, "measurementDuration": measurementDuration, "measurementDateTime": measurementDateTime}
-    nb_measures = 0
-    for f in measure_fields:
-        nb_measures = max(nb_measures, len(measure_fields[f]))
-    for i in range(nb_measures):
-        measure = {}
-        for f in measure_fields:
-            if i < len(measure_fields[f]) and measure_fields[f][i]:
-                measure[f] = measure_fields[f][i]
-        measures_list.append(measure)
-
-    # Process components
-    components_list = []
-    component_fields = {"componentName": componentName, "componentType": componentType, "nbComponent": nbComponent,
-                        "memorySize": memorySize, "manufacturer_infra": manufacturer_infra, "family": family,
-                        "series": series, "share": share}
-    nb_components = 0
-    for f in component_fields:
-        nb_components = max(nb_components, len(component_fields[f]))
-    for i in range(nb_components):
-        component = {}
-        for f in component_fields:
-            if i < len(component_fields[f]) and component_fields[f][i]:
-                component[f] = component_fields[f][i]
-        components_list.append(component)
+    # Process algorithms using the generic function
+    algorithm_fields = {
+        "trainingType": trainingType,
+        "algorithmType": algorithmType,
+        "algorithmName": algorithmName,
+        "algorithmUri": algorithmUri,
+        "foundationModelName": foundationModelName,
+        "foundationModelUri": foundationModelUri,
+        "parametersNumber": parametersNumber,
+        "framework": framework,
+        "frameworkVersion": frameworkVersion,
+        "classPath": classPath,
+        "layersNumber": layersNumber,
+        "epochsNumber": epochsNumber,
+        "optimizer": optimizer,
+        "quantization": quantization
+    }
+    algorithms_list = process_component_list(algorithm_fields)
+
+    # Process dataset using the generic function
+    dataset_fields = {
+        "dataUsage": dataUsage,
+        "dataType": dataType,
+        "dataFormat": dataFormat,
+        "dataSize": dataSize,
+        "dataQuantity": dataQuantity,
+        "shape": shape,
+        "source": source,
+        "sourceUri": sourceUri,
+        "owner": owner
+    }
+    dataset_list = process_component_list(dataset_fields)
+
+    # Process measures using the generic function
+    measure_fields = {
+        "measurementMethod": measurementMethod,
+        "manufacturer": manufacturer,
+        "version": version,
+        "cpuTrackingMode": cpuTrackingMode,
+        "gpuTrackingMode": gpuTrackingMode,
+        "averageUtilizationCpu": averageUtilizationCpu,
+        "averageUtilizationGpu": averageUtilizationGpu,
+        "powerCalibrationMeasurement": powerCalibrationMeasurement,
+        "durationCalibrationMeasurement": durationCalibrationMeasurement,
+        "powerConsumption": powerConsumption,
+        "measurementDuration": measurementDuration,
+        "measurementDateTime": measurementDateTime
+    }
+    measures_list = process_component_list(measure_fields)
+
+    # Process components using the generic function
+    component_fields = {
+        "componentName": componentName,
+        "componentType": componentType,
+        "nbComponent": nbComponent,
+        "memorySize": memorySize,
+        "manufacturer": manufacturer_infra,
+        "family": family,
+        "series": series,
+        "share": share
+    }
+    components_list = process_component_list(component_fields)
 
     # process report
     report = {}

src/ui/form_components.py

@@ -11,124 +11,143 @@ from src.services.util import (
 
 def create_dynamic_section(section_name, fields_config, initial_count=1, layout="row"):
     """
-    Creates a dynamic section in a Gradio interface where users can add or remove rows of input fields.
+    Creates a simplified dynamic section with a fixed number of pre-created rows.
+    This approach prioritizes data preservation over true dynamic functionality.
 
     Args:
         section_name (str): The name of the section (e.g., "Algorithms", "Components").
-        fields_config (list): A list of dictionaries defining the configuration for each field in the section.
-                              Each dictionary should include:
-                              - "type": The Gradio component type (e.g., gr.Textbox, gr.Number).
-                              - "label": The label for the field.
-                              - "info": Additional information or tooltip for the field.
-                              - "value" (optional): The default value for the field.
-                              - "kwargs" (optional): Additional keyword arguments for the component.
-                              - "elem_classes" (optional): CSS classes for styling the field.
-        initial_count (int): The initial number of rows to render in the section.
+        fields_config (list): A list of dictionaries defining the configuration for each field.
+        initial_count (int): The initial number of rows to show (up to MAX_ROWS).
         layout (str): The layout of the fields in each row ("row" or "column").
 
     Returns:
-        tuple: A tuple containing:
-            - count_state: A Gradio state object tracking the number of rows.
-            - field_states: A list of Gradio state objects, one for each field, to store the values of the fields.
-            - add_btn: The "Add" button component for adding new rows.
+        tuple: A tuple containing states and the add button, compatible with existing code.
     """
-    # State management
-    # Tracks the number of rows in the section.
-    count_state = gr.State(value=initial_count+1)
-    # Stores the values for each field across all rows.
+    # Fixed number of rows - simple but reliable approach
+    MAX_ROWS = 5
+
+    # Create field states for compatibility with existing code
     field_states = [gr.State([]) for _ in fields_config]
-    # A list to store all dynamically generated components.
+
+    # Initialize field states with empty values for all possible rows
+    for field_state in field_states:
+        field_state.value = [""] * MAX_ROWS
+
+    # Create all rows upfront (some hidden initially)
     all_components = []
 
-    def update_fields(*states_and_values):
-        """
-        Updates the state of the fields when a value changes.
-
-        Args:
-            *states_and_values: A combination of the current states and the new values for the fields.
-
-        Returns:
-            tuple: Updated states for all fields.
-        """
-        # Split states and current values
-        # Extract the current states for each field.
-        states = list(states_and_values[:len(fields_config)])
-        # Extract the new values for the fields.
-        current_values = states_and_values[len(fields_config):-1]
-        index = states_and_values[-1]  # The index of the row being updated.
-
-        # Update each field's state
-        for field_idx, (state, value) in enumerate(zip(states, current_values)):
-            # Ensure the state list is long enough to accommodate the current index.
-            while len(state) <= index:
-                state.append("")
-            # Update the value at the specified index.
-            state[index] = value if value is not None else ""
-
-        return tuple(states)
-
-    @gr.render(inputs=count_state)
-    def render_dynamic_section(count):
-        """
-        Renders the dynamic section with the current number of rows and their states.
-
-        Args:
-            count (int): The number of rows to render.
-
-        Returns:
-            list: A list of dynamically generated components for the section.
-        """
-        nonlocal all_components
-        all_components = []  # Reset the list of components for re-rendering.
-
-        for i in range(count):
-            # Create a row or column layout for the current row of fields.
+    for row_idx in range(MAX_ROWS):
+        # Use accordion instead of Group for better visibility control
+        # Show only initial_count rows at the beginning
+        is_visible = row_idx < initial_count
+
+        # Use accordion that's open for visible rows
+        with gr.Accordion(f"{section_name} {row_idx + 1}", open=is_visible, visible=is_visible) as group:
             with (gr.Row() if layout == "row" else gr.Column()):
-                row_components = []  # Components for the current row.
-                field_refs = []  # References to the current row's components.
+                row_components = []
 
                 for field_idx, config in enumerate(fields_config):
-                    # Create a component for the field using its configuration.
+                    # Create component
                     component = config["type"](
-                        label=f"{config['label']} ({section_name}{i + 1})",
+                        label=f"{config['label']} ({section_name} {row_idx + 1})",
                         info=config.get("info", ""),
                         value=config.get("value", ""),
                         **config.get("kwargs", {}),
                         elem_classes=config.get("elem_classes", "")
                     )
                     row_components.append(component)
-                    field_refs.append(component)
 
-                    # Create a change event to update the field states when the value changes.
+                    # Simple change handler that updates field state
+                    def make_change_handler(field_idx, row_idx):
+                        def handle_change(value):
+                            field_states[field_idx].value[row_idx] = value if value is not None else ""
+                        return handle_change
+
                     component.change(
-                        fn=update_fields,
-                        inputs=[*field_states, *field_refs, gr.State(i)],
-                        outputs=field_states
+                        fn=make_change_handler(field_idx, row_idx),
+                        inputs=[component],
+                        outputs=[]
                     )
 
-                # Add a "Remove" button to delete the current row.
-                remove_btn = gr.Button("❌", variant="secondary")
-                remove_btn.click(
-                    lambda x, idx=i, fs=field_states: (
-                        max(0, x - 1),  # Decrease the count of rows.
-                        # Remove the row's values.
-                        *[fs[i].value[:idx] + fs[i].value[idx + 1:] for i in range(len(fs))]
-                    ),
-                    inputs=count_state,
-                    outputs=[count_state, *field_states]
-                )
+                # Add remove button for this row
+                remove_btn = gr.Button(
+                    "❌ Remove", variant="secondary", size="sm", visible=True)
                 row_components.append(remove_btn)
 
-                # Add the row's components to the list of all components.
-                all_components.extend(row_components)
-        return all_components
+        all_components.append((group, row_components))
 
-    # Initialize the section with the initial count of rows.
-    render_dynamic_section(count=initial_count)
+    # Visibility state
+    visible_count = gr.State(initial_count)
 
-    # Create an "Add" button to add new rows to the section.
+    # Add button
     add_btn = gr.Button(f"Add {section_name}")
-    add_btn.click(lambda x: x + 1, count_state, count_state)
+
+    def handle_add(current_count):
+        """Show one more row if available"""
+        new_count = min(current_count + 1, MAX_ROWS)
+
+        # Update visibility for all groups
+        visibility_updates = []
+        for i in range(MAX_ROWS):
+            # For accordion, we need to update both visible and open states
+            visibility_updates.append(
+                gr.update(visible=(i < new_count), open=(i < new_count)))
+
+        return new_count, *visibility_updates
+
+    def handle_remove(current_count):
+        """Hide the last visible row"""
+        new_count = max(current_count - 1,
+                        1)  # Always keep at least 1 row visible
+
+        # Update visibility for all groups
+        visibility_updates = []
+        for i in range(MAX_ROWS):
+            # For accordion, we need to update both visible and open states
+            visibility_updates.append(
+                gr.update(visible=(i < new_count), open=(i < new_count)))
+
+        return new_count, *visibility_updates
+
+    # Connect add button
+    group_outputs = [group for group, _ in all_components]
+    add_btn.click(
+        fn=handle_add,
+        inputs=[visible_count],
+        outputs=[visible_count] + group_outputs
+    )
+
+    # Connect remove buttons for each row
+    for row_idx, (group, row_components) in enumerate(all_components):
+        remove_btn = row_components[-1]  # Remove button is the last component
+        remove_btn.click(
+            fn=handle_remove,
+            inputs=[visible_count],
+            outputs=[visible_count] + group_outputs
+        )
+
+    # Force initial visibility on interface load
+    def force_initial_visibility():
+        """Force initial visibility when the interface loads"""
+        visibility_updates = []
+        for i in range(MAX_ROWS):
+            visibility_updates.append(
+                gr.update(visible=(i < initial_count), open=(i < initial_count)))
+        return visibility_updates
+
+    # Create a simple info display
+    info_display = gr.Markdown(f"**{section_name}** (Max {MAX_ROWS} items)")
+
+    # Dummy count state for compatibility
+    count_state = gr.State(initial_count)
+
+    # Apply initial visibility immediately after component creation
+    if initial_count > 0:
+        # Use app load event to ensure visibility
+        for i, (group, _) in enumerate(all_components):
+            if i < initial_count:
+                group.visible = True
+                group.open = True
 
     return (count_state, *field_states, add_btn)
 
@@ -265,7 +284,7 @@ def create_task_tab():
                         "info": "(the type of quantization used : fp32, fp16, b16, int8 ...)",
                     }
                 ],
-                initial_count=0,
+                initial_count=1,
                 layout="column"
             )
 
@@ -329,7 +348,7 @@ def create_task_tab():
                         "info": "(the owner of the dataset if available)",
                     }
                 ],
-                initial_count=0,
+                initial_count=1,
                 layout="column"
             )
 
@@ -427,7 +446,7 @@ def create_measures_tab():
                         "info": "(the date when the measurement began, in format YYYY-MM-DD HH:MM:SS)",
                     }
                 ],
-                initial_count=0,
+                initial_count=1,
                 layout="column"
             )
 
@@ -526,7 +545,7 @@ def create_infrastructure_tab():
                         "info": "(the percentage of the physical equipment used by the task, this sharing property should be set to 1 by default (if no share) and otherwise to the correct percentage, e.g. 0.5 if you share half-time.)",
                     }
                 ],
-                initial_count=0,
+                initial_count=1,
                 layout="column"
             )