repair deployment & doc

src/app.py → app.py

@@ -13,7 +13,7 @@ from src.ui.form_components import (
     create_quality_tab,
     create_hash_tab
 )
-css_path = path.join(path.dirname(__file__), "../assets/styles/app.css")
+css_path = path.join(path.dirname(__file__), "./assets/styles/app.css")
 
 # Initialize Hugging Face
 init_huggingface()
@@ -71,3 +71,6 @@ with gr.Blocks(css_paths=css_path) as app:
         ],
         outputs=[output, file_output, json_output]
     )
+
+if __name__ == "__main__":
+    app.launch()

main.py

@@ -1,4 +0,0 @@
-from src.app import app
-
-print("Launching BoAmps form")
-app.launch()

src/services/huggingface.py

@@ -42,163 +42,19 @@ def update_dataset(json_data):
 
 
 def create_flattened_data(data):
-    """Create a flattened data structure for the dataset."""
-
-    # Handle inference properties
-    inference_props = data.get("task", {}).get(
-        "dataset", {}).get("inferenceProperties", [])
-
-    # Process inference properties
-    inference_data = []
-    for props in inference_props:
-        if props:
-            inference_data.append({
-                "nbRequest": props.get("nbRequest"),
-                "nbTokensInput": props.get("nbTokensInput"),
-                "nbWordsInput": props.get("nbWordsInput"),
-                "nbTokensOutput": props.get("nbTokensOutput"),
-                "nbWordsOutput": props.get("nbWordsOutput"),
-                "contextWindowSize": props.get("contextWindowSize"),
-                "cache": props.get("cache")
-            })
-
-    nbRequest_str = ", ".join([str(p["nbRequest"]) for p in inference_data if p.get(
-        "nbRequest")]) if inference_data else None
-    nbTokensInput_str = ", ".join([str(p["nbTokensInput"]) for p in inference_data if p.get(
-        "nbTokensInput")]) if inference_data else None
-    nbWordsInput_str = ", ".join([str(p["nbWordsInput"]) for p in inference_data if p.get(
-        "nbWordsInput")]) if inference_data else None
-    nbTokensOutput_str = ", ".join([str(p["nbTokensOutput"]) for p in inference_data if p.get(
-        "nbTokensOutput")]) if inference_data else None
-    nbWordsOutput_str = ", ".join([str(p["nbWordsOutput"]) for p in inference_data if p.get(
-        "nbWordsOutput")]) if inference_data else None
-    contextWindowSize_str = ", ".join([str(p["contextWindowSize"]) for p in inference_data if p.get(
-        "contextWindowSize")]) if inference_data else None
-    cache_str = ", ".join([str(p["cache"]) for p in inference_data if p.get(
-        "cache")]) if inference_data else None
-
-    # Handle components
-    components = data.get("infrastructure", {}).get("components", [])
-    component_data = []
-    for comp in components:
-        if comp:
-            component_data.append({
-                "componentName": comp.get("componentName"),
-                "nbComponent": comp.get("nbComponent"),
-                "memorySize": comp.get("memorySize"),
-                "manufacturer": comp.get("manufacturer"),
-                "family": comp.get("family"),
-                "series": comp.get("series"),
-                "share": comp.get("share")
-            })
-
-    componentName_str = ", ".join([str(p["componentName"]) for p in component_data if p.get(
-        "componentName")]) if component_data else None
-    nbComponent_str = ", ".join([str(p["nbComponent"]) for p in component_data if p.get(
-        "nbComponent")]) if component_data else None
-    memorySize_str = ", ".join([str(p["memorySize"]) for p in component_data if p.get(
-        "memorySize")]) if component_data else None
-    manufacturer_infra_str = ", ".join([str(p["manufacturer"]) for p in component_data if p.get(
-        "manufacturer")]) if component_data else None
-    family_str = ", ".join([str(p["family"]) for p in component_data if p.get(
-        "family")]) if component_data else None
-    series_str = ", ".join([str(p["series"]) for p in component_data if p.get(
-        "series")]) if component_data else None
-    share_str = ", ".join([str(p["share"]) for p in component_data if p.get(
-        "share")]) if component_data else None
-
-    return {
-        # Header
-        "licensing": [data["header"]["licensing"]],
-        "formatVersion": [data["header"]["formatVersion"]],
-        "formatVersionSpecificationUri": [data["header"]["formatVersionSpecificationUri"]],
-        "reportId": [data["header"]["reportId"]],
-        "reportDatetime": [data["header"]["reportDatetime"]],
-        "reportStatus": [data["header"]["reportStatus"]],
-        "publisher_name": [data["header"]["publisher"]["name"]],
-        "publisher_division": [data["header"]["publisher"]["division"]],
-        "publisher_projectName": [data["header"]["publisher"]["projectName"]],
-        "publisher_confidentialityLevel": [data["header"]["publisher"]["confidentialityLevel"]],
-        "publisher_publicKey": [data["header"]["publisher"]["publicKey"]],
-
-        # Task
-        "taskFamily": [data["task"]["taskFamily"]],
-        "taskStage": [data["task"]["taskStage"]],
-        "algorithmName": [data["task"]["algorithms"][0]["algorithmName"]],
-        "framework": [data["task"]["algorithms"][0]["framework"]],
-        "frameworkVersion": [data["task"]["algorithms"][0]["frameworkVersion"]],
-        "classPath": [data["task"]["algorithms"][0]["classPath"]],
-        "quantization": [data["task"]["algorithms"][0]["quantization"]],
-        "dataType": [data["task"]["dataset"][0]["dataType"]],
-        "fileType": [data["task"]["dataset"][0]["fileType"]],
-        "volume": [data["task"]["dataset"][0]["volume"]],
-        "volumeUnit": [data["task"]["dataset"][0]["volumeUnit"]],
-        "items": [data["task"]["dataset"][0]["items"]],
-        "shape_item": [data["task"]["dataset"][0]["shape"][0]["item"]],
-        "nbRequest": [nbRequest_str],
-        "nbTokensInput": [nbTokensInput_str],
-        "nbWordsInput": [nbWordsInput_str],
-        "nbTokensOutput": [nbTokensOutput_str],
-        "nbWordsOutput": [nbWordsOutput_str],
-        "contextWindowSize": [contextWindowSize_str],
-        "cache": [cache_str],
-        "source": [data["task"]["dataset"][0]["source"]],
-        "sourceUri": [data["task"]["dataset"][0]["sourceUri"]],
-        "owner": [data["task"]["dataset"][0]["owner"]],
-        "measuredAccuracy": [data["task"]["measuredAccuracy"]],
-        "estimatedAccuracy": [data["task"]["estimatedAccuracy"]],
-
-        # Measures
-        "measurementMethod": [data["measures"][0]["measurementMethod"]],
-        "manufacturer": [data["measures"][0]["manufacturer"]],
-        "version": [data["measures"][0]["version"]],
-        "cpuTrackingMode": [data["measures"][0]["cpuTrackingMode"]],
-        "gpuTrackingMode": [data["measures"][0]["gpuTrackingMode"]],
-        "averageUtilizationCpu": [data["measures"][0]["averageUtilizationCpu"]],
-        "averageUtilizationGpu": [data["measures"][0]["averageUtilizationGpu"]],
-        "serverSideInference": [data["measures"][0]["serverSideInference"]],
-        "unit": [data["measures"][0]["unit"]],
-        "powerCalibrationMeasurement": [data["measures"][0]["powerCalibrationMeasurement"]],
-        "durationCalibrationMeasurement": [data["measures"][0]["durationCalibrationMeasurement"]],
-        "powerConsumption": [data["measures"][0]["powerConsumption"]],
-        "measurementDuration": [data["measures"][0]["measurementDuration"]],
-        "measurementDateTime": [data["measures"][0]["measurementDateTime"]],
-
-        # System
-        "os": [data["system"]["os"]],
-        "distribution": [data["system"]["distribution"]],
-        "distributionVersion": [data["system"]["distributionVersion"]],
-
-        # Software
-        "language": [data["software"]["language"]],
-        "version_software": [data["software"]["version"]],
-
-        # Infrastructure
-        "infraType": [data["infrastructure"]["infraType"]],
-        "cloudProvider": [data["infrastructure"]["cloudProvider"]],
-        "cloudInstance": [data["infrastructure"]["cloudInstance"]],
-        "componentName": [componentName_str],
-        "nbComponent": [nbComponent_str],
-        "memorySize": [memorySize_str],
-        "manufacturer_infra": [manufacturer_infra_str],
-        "family": [family_str],
-        "series": [series_str],
-        "share": [share_str],
-
-        # Environment
-        "country": [data["environment"]["country"]],
-        "latitude": [data["environment"]["latitude"]],
-        "longitude": [data["environment"]["longitude"]],
-        "location": [data["environment"]["location"]],
-        "powerSupplierType": [data["environment"]["powerSupplierType"]],
-        "powerSource": [data["environment"]["powerSource"]],
-        "powerSourceCarbonIntensity": [data["environment"]["powerSourceCarbonIntensity"]],
-
-        # Quality
-        "quality": [data["quality"]],
-
-        # Hash
-        "hashAlgorithm": [data["$hash"]["hashAlgorithm"]],
-        "cryptographicAlgorithm": [data["$hash"]["cryptographicAlgorithm"]],
-        "value": [data["$hash"]["ecryptedValue"]]
-    }
+    out = {}
+
+    def flatten(x, name=''):
+        if type(x) is dict:
+            for a in x:
+                flatten(x[a], name + a + '_')
+        elif type(x) is list:
+            i = 0
+            for a in x:
+                flatten(a, name + str(i) + '_')
+                i += 1
+        else:
+            out[name[:-1]] = x
+
+    flatten(data)
+    return out

src/services/json_generator.py

@@ -13,7 +13,7 @@ def generate_json(
     taskFamily, taskStage, nbRequest,
     trainingType, algorithmType, algorithmName, algorithmUri, foundationModelName, foundationModelUri, parametersNumber, framework,  frameworkVersion, classPath, layersNumber, epochsNumber, optimizer, quantization,
     dataUsage, dataType, dataFormat, dataSize, dataQuantity, shape, source, sourceUri,  owner,
-    measuredAccuracy, estimatedAccuracy,
+    measuredAccuracy, estimatedAccuracy, taskDescription,
     # Measures
     measurementMethod, manufacturer, version, cpuTrackingMode, gpuTrackingMode,
     averageUtilizationCpu, averageUtilizationGpu, powerCalibrationMeasurement,
@@ -148,6 +148,8 @@ def generate_json(
         task["measuredAccuracy"] = measuredAccuracy
     if estimatedAccuracy:
         task["estimatedAccuracy"] = estimatedAccuracy
+    if taskDescription:
+        task["taskDescription"] = taskDescription
     report["task"] = task
 
     # proceed measures

src/ui/form_components.py

@@ -9,39 +9,85 @@ 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.
+
+    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.
+        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.
+    """
     # 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.
     field_states = [gr.State([]) for _ in fields_config]
+    # A list to store all dynamically generated components.
     all_components = []
 
     def update_fields(*states_and_values):
-        """Generic update function for multiple fields"""
+        """
+        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]
+        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 state list is long enough
+            # Ensure the state list is long enough to accommodate the current index.
             while len(state) <= index:
                 state.append("")
-            # Update the value at the correct index
+            # 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 = []
+        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.
             with (gr.Row() if layout == "row" else gr.Column()):
-                row_components = []
-                field_refs = []  # To store references to current row's components
+                row_components = []  # Components for the current row.
+                field_refs = []  # References to the current row's components.
 
                 for field_idx, config in enumerate(fields_config):
+                    # Create a component for the field using its configuration.
                     component = config["type"](
                         label=f"{config['label']} ({section_name}{i + 1})",
                         info=config.get("info", ""),
@@ -52,31 +98,34 @@ def create_dynamic_section(section_name, fields_config, initial_count=1, layout=
                     row_components.append(component)
                     field_refs.append(component)
 
-                    # Create change event with ALL current field values
+                    # Create a change event to update the field states when the value changes.
                     component.change(
                         fn=update_fields,
                         inputs=[*field_states, *field_refs, gr.State(i)],
                         outputs=field_states
                     )
 
-                # Remove button
+                # 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),
-                        *[fs[i].value[:idx] + fs[i].value[idx+1:] for i in range(len(fs))]
+                        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]
                 )
                 row_components.append(remove_btn)
 
+                # Add the row's components to the list of all components.
                 all_components.extend(row_components)
         return all_components
 
-    # Initialize with initial count
+    # Initialize the section with the initial count of rows.
     render_dynamic_section(count=initial_count)
 
+    # Create an "Add" button to add new rows to the section.
     add_btn = gr.Button(f"Add {section_name}")
     add_btn.click(lambda x: x + 1, count_state, count_state)
 
@@ -287,12 +336,15 @@ def create_task_tab():
                                             choices=ACCURACY_LEVELS,
                                             info="(estimated accuracy assessment)"
                                             )
+        with gr.Row():
+            taskDescription = gr.Textbox(
+                label="Task description", info="(free field, to be fillied in if you have more details to share about your task)")
 
     return [
         taskFamily, taskStage, nbRequest,
         trainingType, algorithmType, algorithmName, algorithmUri, foundationModelName, foundationModelUri, parametersNumber, framework,  frameworkVersion, classPath, layersNumber, epochsNumber, optimizer, quantization,
         dataUsage, dataType, dataFormat, dataSize, dataQuantity, shape, source, sourceUri,  owner,
-        measuredAccuracy, estimatedAccuracy
+        measuredAccuracy, estimatedAccuracy, taskDescription
     ]