downloadable json having the right format

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+test.json

Pipfile

@@ -0,0 +1,11 @@
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+
+[dev-packages]
+
+[requires]
+python_version = "3.12"

README.md

@@ -12,3 +12,5 @@ short_description: Create a report in BoAmps format
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+This project was initiated by a group of students from Sud Telecom Paris.

app.py

@@ -16,21 +16,24 @@ from ui.form_components import (
 # Initialize Hugging Face
 init_huggingface()
 
+
 def handle_submit(*inputs):
     message, file_output, json_output = generate_json(*inputs)
-    
+
     # Check if the message indicates validation failure
     if message.startswith("The following fields are required"):
         return message, file_output, json_output
-    
+
     # If validation passed, proceed to update_dataset
     update_output = update_dataset(json_output)
+    print(json_output)
     return update_output, file_output, json_output
 
+
 # Create Gradio interface
 with gr.Blocks() as demo:
     gr.Markdown("## Data Collection Form")
-    gr.Markdown("Welcome to this Huggingface space that helps you fill in a form for monitoring the energy consumption of an AI model.")
+    gr.Markdown("Welcome to this Huggingface space, where you can create a report on the energy consumption of an AI task in BoAmps format, by filling in a form.")
 
     # Create form tabs
     header_components = create_header_tab()
@@ -46,12 +49,13 @@ with gr.Blocks() as demo:
     # Submit and Download Buttons
     submit_button = gr.Button("Submit")
     output = gr.Textbox(label="Output", lines=1)
+    # je comprend pas pq le fichier est vide ???
     json_output = gr.Textbox(visible=False)
     file_output = gr.File(label="Downloadable JSON")
 
     # Event Handlers
     submit_button.click(
-        handle_submit,  
+        handle_submit,
         inputs=[
             *header_components,
             *task_components,
@@ -67,4 +71,4 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()

config.py

@@ -5,12 +5,13 @@ HF_TOKEN = os.environ.get("HF_TOKEN")
 DATASET_NAME = "soprasteria/BoAmps_leaderboard"
 
 # Form Field Configurations
+MANDATORY_SECTIONS = ["task", "measures", "infrastructure", "environment"]
 OBLIGATORY_FIELDS = [
     "formatVersion", "reportId", "reportStatus", "confidentialityLevel",
     "taskType", "taskFamily", "taskStage", "algorithmName", "dataType",
     "volume", "volumeUnit", "nbRequest", "measurementMethod", "unit",
-    "powerConsumption", "os", "language", "infraType", "componentName",
-    "nbComponent", "country", "hashAlgorithm", "cryptographicAlgorithm", "ecryptedValue"
+    "powerConsumption", "os", "language", "infraType", "componentType",
+    "nbComponent", "country", "hashAlgorithm", "cryptographicAlgorithm", "value"
 ]
 
 # Dropdown Options
@@ -18,6 +19,8 @@ REPORT_STATUS_OPTIONS = ["draft", "final", "corrective", "$other"]
 CONFIDENTIALITY_LEVELS = ["public", "internal", "confidential", "secret"]
 DATA_TYPES = ["tabular", "audio", "boolean",
               "image", "video", "object", "text", "$other"]
+DATA_UNITS = ['kilobyte', 'megabyte', 'gigabyte', 'terabyte',
+              'petabyte', 'exabyte', 'zettabyte', 'yottabyte']
 ACCURACY_LEVELS = ["veryPoor", "poor", "average", "good", "veryGood"]
 MEASUREMENT_UNITS = ["Wh", "kWh", "MWh", "GWh", "kJoule", "MJoule", "GJoule", "TJoule", "PJoule",
                      "BTU", "kiloFLOPS", "megaFLOPS", "gigaFLOPS", "teraFLOPS", "petaFLOPS",

services/huggingface.py

@@ -3,12 +3,15 @@ from datasets import load_dataset, Dataset, concatenate_datasets
 import json
 from config import HF_TOKEN, DATASET_NAME
 
+
 def init_huggingface():
     """Initialize Hugging Face authentication."""
     if HF_TOKEN is None:
-        raise ValueError("Hugging Face token not found in environment variables.")
+        raise ValueError(
+            "Hugging Face token not found in environment variables.")
     login(token=HF_TOKEN)
 
+
 def update_dataset(json_data):
     """Update the Hugging Face dataset with new data."""
     if json_data is None or json_data.startswith("The following fields are required"):
@@ -18,7 +21,9 @@ def update_dataset(json_data):
         data = json.loads(json_data)
     except json.JSONDecodeError:
         return "Invalid JSON data. Please ensure all required fields are filled correctly."
-    
+
+    # data flattening and saving to dataset
+    """ 
     try:
         dataset = load_dataset(DATASET_NAME, split="train")
     except:
@@ -26,19 +31,22 @@ def update_dataset(json_data):
 
     new_data = create_flattened_data(data)
     new_dataset = Dataset.from_dict(new_data)
-    
+
     if len(dataset) > 0:
         updated_dataset = concatenate_datasets([dataset, new_dataset])
     else:
         updated_dataset = new_dataset
 
     updated_dataset.push_to_hub(DATASET_NAME)
+    """
     return "Data submitted successfully and dataset updated!"
 
+
 def create_flattened_data(data):
     """Create a flattened data structure for the dataset."""
     # Handle hyperparameters
-    hyperparameters = data.get("task", {}).get("algorithms", [{}])[0].get("hyperparameters", {}).get("values", [])
+    hyperparameters = data.get("task", {}).get("algorithms", [{}])[
+        0].get("hyperparameters", {}).get("values", [])
 
     # Process hyperparameters
     hyperparameter_names = []
@@ -48,16 +56,19 @@ def create_flattened_data(data):
             hyperparameter_names.append(hp["name"])
             hyperparameter_values.append(str(hp["value"]))
 
-    hyperparameter_name_str = ", ".join(hyperparameter_names) if hyperparameter_names else None
-    hyperparameter_value_str = ", ".join(hyperparameter_values) if hyperparameter_values else None
+    hyperparameter_name_str = ", ".join(
+        hyperparameter_names) if hyperparameter_names else None
+    hyperparameter_value_str = ", ".join(
+        hyperparameter_values) if hyperparameter_values else None
 
     # Handle inference properties
-    inference_props = data.get("task", {}).get("dataset", [{}])[0].get("inferenceProperties", [])
+    inference_props = data.get("task", {}).get(
+        "dataset", {}).get("inferenceProperties", [])
 
     # Process inference properties
     inference_data = []
     for props in inference_props:
-        if props:  
+        if props:
             inference_data.append({
                 "nbRequest": props.get("nbRequest"),
                 "nbTokensInput": props.get("nbTokensInput"),
@@ -68,19 +79,26 @@ def create_flattened_data(data):
                 "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
+    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:  
+        if comp:
             component_data.append({
                 "componentName": comp.get("componentName"),
                 "nbComponent": comp.get("nbComponent"),
@@ -91,13 +109,20 @@ def create_flattened_data(data):
                 "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
+    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
@@ -112,7 +137,7 @@ def create_flattened_data(data):
         "publisher_projectName": [data["header"]["publisher"]["projectName"]],
         "publisher_confidentialityLevel": [data["header"]["publisher"]["confidentialityLevel"]],
         "publisher_publicKey": [data["header"]["publisher"]["publicKey"]],
-        
+
         # Task
         "taskType": [data["task"]["taskType"]],
         "taskFamily": [data["task"]["taskFamily"]],
@@ -143,7 +168,7 @@ def create_flattened_data(data):
         "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"]],
@@ -159,16 +184,16 @@ def create_flattened_data(data):
         "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"]],
@@ -180,7 +205,7 @@ def create_flattened_data(data):
         "family": [family_str],
         "series": [series_str],
         "share": [share_str],
-        
+
         # Environment
         "country": [data["environment"]["country"]],
         "latitude": [data["environment"]["latitude"]],
@@ -189,12 +214,12 @@ def create_flattened_data(data):
         "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"]]
-    }
+    }

services/json_generator.py

@@ -3,6 +3,7 @@ import tempfile
 from datetime import datetime
 from utils.validation import validate_obligatory_fields
 
+
 def generate_json(
     # Header
     licensing, formatVersion, formatVersionSpecificationUri, reportId, reportDatetime, reportStatus,
@@ -21,7 +22,7 @@ def generate_json(
     # Software
     language, version_software,
     # Infrastructure
-    infraType, cloudProvider, cloudInstance, componentName, nbComponent, memorySize, manufacturer_infra, family, series, share,
+    infraType, cloudProvider, cloudInstance, componentName, componentType, nbComponent, memorySize, manufacturer_infra, family, series, share,
     # Environment
     country, latitude, longitude, location, powerSupplierType, powerSource, powerSourceCarbonIntensity,
     # Quality
@@ -30,6 +31,7 @@ def generate_json(
     hashAlgorithm, cryptographicAlgorithm, value_hash
 ):
     """Generate JSON data from form inputs."""
+    # TO CHANGE
     # Process hyperparameters
     hyperparameters = []
     max_length = max(len(hyperparameter_names), len(hyperparameter_values))
@@ -38,35 +40,245 @@ def generate_json(
             "name": hyperparameter_names[i] if i < len(hyperparameter_names) and hyperparameter_names[i] else "",
             "value": hyperparameter_values[i] if i < len(hyperparameter_values) and hyperparameter_values[i] else ""
         })
-        
+
     # Process inference properties
     inference_props_list = []
-    max_length = max(len(nbRequest), len(nbTokensInput), len(nbWordsInput), len(nbTokensOutput), len(nbWordsOutput), len(contextWindowSize), len(cache))
+    max_length = max(len(nbRequest), len(nbTokensInput), len(nbWordsInput), len(
+        nbTokensOutput), len(nbWordsOutput), len(contextWindowSize), len(cache))
     for i in range(max_length):
-        inference_props_list.append({
-            "nbRequest": nbRequest[i] if i < len(nbRequest) and nbRequest[i] else "",
-            "nbTokensInput": nbTokensInput[i] if i < len(nbTokensInput) and nbTokensInput[i] else "",
-            "nbWordsInput": nbWordsInput[i] if i < len(nbWordsInput) and nbWordsInput[i] else "",
-            "nbTokensOutput": nbTokensOutput[i] if i < len(nbTokensOutput) and nbTokensOutput[i] else "",
-            "nbWordsOutput": nbWordsOutput[i] if i < len(nbWordsOutput) and nbWordsOutput[i] else "",
-            "contextWindowSize": contextWindowSize[i] if i < len(contextWindowSize) and contextWindowSize[i] else "",
-            "cache": cache[i] if i < len(cache) and cache[i] else ""
-        })
+        inference_props = {}
+        if i < len(nbRequest) and nbRequest[i]:
+            inference_props["nbRequest"] = nbRequest[i]
+        if i < len(nbTokensInput) and nbTokensInput[i]:
+            inference_props["nbTokensInput"] = nbTokensInput[i]
+        if i < len(nbWordsInput) and nbWordsInput[i]:
+            inference_props["nbWordsInput"] = nbWordsInput[i]
+        if i < len(nbTokensOutput) and nbTokensOutput[i]:
+            inference_props["nbTokensOutput"] = nbTokensOutput[i]
+        if i < len(nbWordsOutput) and nbWordsOutput[i]:
+            inference_props["nbWordsOutput"] = nbWordsOutput[i]
+        if i < len(contextWindowSize) and contextWindowSize[i]:
+            inference_props["contextWindowSize"] = contextWindowSize[i]
+        if i < len(cache) and cache[i]:
+            inference_props["cache"] = cache[i]
+        inference_props_list.append(inference_props)
 
     # Process components
     components_list = []
-    max_length = max(len(componentName), len(nbComponent), len(memorySize), len(manufacturer_infra), len(family), len(series), len(share))
+    max_length = max(len(componentName), len(componentType), len(nbComponent), len(memorySize), len(
+        manufacturer_infra), len(family), len(series), len(share))
     for i in range(max_length):
-        components_list.append({
-            "componentName": componentName[i] if i < len(componentName) and componentName[i] else "",
-            "nbComponent": nbComponent[i] if i < len(nbComponent) and nbComponent[i] else "",
-            "memorySize": memorySize[i] if i < len(memorySize) and memorySize[i] else "",
-            "manufacturer": manufacturer_infra[i] if i < len(manufacturer_infra) and manufacturer_infra[i] else "",
-            "family": family[i] if i < len(family) and family[i] else "",
-            "series": series[i] if i < len(series) and series[i] else "",
-            "share": share[i] if i < len(share) and share[i] else ""
-        })
-    
+        component = {}
+        if i < len(componentName) and componentName[i]:
+            component["componentName"] = componentName[i]
+        if i < len(componentType) and componentType[i]:
+            component["componentType"] = componentType[i]
+        if i < len(nbComponent) and nbComponent[i]:
+            component["nbComponent"] = nbComponent[i]
+        if i < len(memorySize) and memorySize[i]:
+            component["memorySize"] = memorySize[i]
+        if i < len(manufacturer_infra) and manufacturer_infra[i]:
+            component["manufacturer"] = manufacturer_infra[i]
+        if i < len(family) and family[i]:
+            component["family"] = family[i]
+        if i < len(series) and series[i]:
+            component["series"] = series[i]
+        if i < len(share) and share[i]:
+            component["share"] = share[i]
+        components_list.append(component)
+
+    # process report
+    report = {}
+
+    # Process header
+    header = {}
+    if licensing:
+        header["licensing"] = licensing
+    if formatVersion:
+        header["formatVersion"] = formatVersion
+    if formatVersionSpecificationUri:
+        header["formatVersionSpecificationUri"] = formatVersionSpecificationUri
+    if reportId:
+        header["reportId"] = reportId
+    if reportDatetime:
+        header["reportDatetime"] = reportDatetime or datetime.now().isoformat()
+    if reportStatus:
+        header["reportStatus"] = reportStatus
+
+    publisher = {}
+    if publisher_name:
+        publisher["name"] = publisher_name
+    if publisher_division:
+        publisher["division"] = publisher_division
+    if publisher_projectName:
+        publisher["projectName"] = publisher_projectName
+    if publisher_confidentialityLevel:
+        publisher["confidentialityLevel"] = publisher_confidentialityLevel
+    if publisher_publicKey:
+        publisher["publicKey"] = publisher_publicKey
+
+    if publisher:
+        header["publisher"] = publisher
+
+    if header:
+        report["header"] = header
+
+    # proceed task
+
+    # proceed algorithm
+    algorithm = {}
+    if algorithmName:
+        algorithm["algorithmName"] = algorithmName
+    if framework:
+        algorithm["framework"] = framework
+    if frameworkVersion:
+        algorithm["frameworkVersion"] = frameworkVersion
+    if classPath:
+        algorithm["classPath"] = classPath
+    if hyperparameters:
+        algorithm["hyperparameters"] = hyperparameters
+    if quantization:
+        algorithm["quantization"] = quantization
+
+    # proceed dataset
+    dataset = {}
+    if dataType:
+        dataset["dataType"] = dataType
+    if fileType:
+        dataset["fileType"] = fileType
+    if volume:
+        dataset["volume"] = volume
+    if volumeUnit:
+        dataset["volumeUnit"] = volumeUnit
+    if items:
+        dataset["items"] = items
+    if shape_item:
+        dataset["shape"] = [{"item": shape_item}]
+    if inference_props_list:
+        dataset["inferenceProperties"] = inference_props_list
+    if source:
+        dataset["source"] = source
+    if sourceUri:
+        dataset["sourceUri"] = sourceUri
+    if owner:
+        dataset["owner"] = owner
+
+    # proceed all task
+    task = {}
+    if taskType:
+        task["taskType"] = taskType
+    if taskFamily:
+        task["taskFamily"] = taskFamily
+    if taskStage:
+        task["taskStage"] = taskStage
+    if algorithm:
+        task["algorithms"] = [algorithm]
+    if dataset:
+        task["dataset"] = [dataset]
+    if measuredAccuracy:
+        task["measuredAccuracy"] = measuredAccuracy
+    if estimatedAccuracy:
+        task["estimatedAccuracy"] = estimatedAccuracy
+    report["task"] = task
+
+    # proceed measures
+    measures = {}
+    if measurementMethod:
+        measures["measurementMethod"] = measurementMethod
+    if manufacturer:
+        measures["manufacturer"] = manufacturer
+    if version:
+        measures["version"] = version
+    if cpuTrackingMode:
+        measures["cpuTrackingMode"] = cpuTrackingMode
+    if gpuTrackingMode:
+        measures["gpuTrackingMode"] = gpuTrackingMode
+    if averageUtilizationCpu:
+        measures["averageUtilizationCpu"] = averageUtilizationCpu
+    if averageUtilizationGpu:
+        measures["averageUtilizationGpu"] = averageUtilizationGpu
+    if serverSideInference:
+        measures["serverSideInference"] = serverSideInference
+    if unit:
+        measures["unit"] = unit
+    if powerCalibrationMeasurement:
+        measures["powerCalibrationMeasurement"] = powerCalibrationMeasurement
+    if durationCalibrationMeasurement:
+        measures["durationCalibrationMeasurement"] = durationCalibrationMeasurement
+    if powerConsumption:
+        measures["powerConsumption"] = powerConsumption
+    if measurementDuration:
+        measures["measurementDuration"] = measurementDuration
+    if measurementDateTime:
+        measures["measurementDateTime"] = measurementDateTime
+    report["measures"] = [measures]
+
+    # proceed system
+    system = {}
+    if os:
+        system["os"] = os
+    if distribution:
+        system["distribution"] = distribution
+    if distributionVersion:
+        system["distributionVersion"] = distributionVersion
+    if system:
+        report["system"] = system
+
+    # proceed software
+    software = {}
+    if language:
+        software["language"] = language
+    if version_software:
+        software["version"] = version_software
+    if software:
+        report["software"] = software
+
+    # proceed infrastructure
+    infrastructure = {}
+    if infraType:
+        infrastructure["infraType"] = infraType
+    if cloudProvider:
+        infrastructure["cloudProvider"] = cloudProvider
+    if cloudInstance:
+        infrastructure["cloudInstance"] = cloudInstance
+    if components_list:
+        infrastructure["components"] = components_list
+    report["infrastructure"] = infrastructure
+
+    # proceed environment
+    environment = {}
+    if country:
+        environment["country"] = country
+    if latitude:
+        environment["latitude"] = latitude
+    if longitude:
+        environment["longitude"] = longitude
+    if location:
+        environment["location"] = location
+    if powerSupplierType:
+        environment["powerSupplierType"] = powerSupplierType
+    if powerSource:
+        environment["powerSource"] = powerSource
+    if powerSourceCarbonIntensity:
+        environment["powerSourceCarbonIntensity"] = powerSourceCarbonIntensity
+    report["environment"] = environment
+
+    # proceed quality
+    if quality:
+        report["quality"] = quality
+
+    # proceed hash
+    hash = {}
+    if hashAlgorithm:
+        hash["hashAlgorithm"] = hashAlgorithm
+    if cryptographicAlgorithm:
+        hash["cryptographicAlgorithm"] = cryptographicAlgorithm
+    if value_hash:
+        hash["value"] = value_hash
+    if hash:
+        report["$hash"] = hash
+
+    """
     data = {
         "header": {
             "licensing": licensing,
@@ -170,16 +382,17 @@ def generate_json(
             "ecryptedValue": value_hash
         }
     }
+    """
 
     # Validate obligatory fields
-    is_valid, message = validate_obligatory_fields(data)
+    is_valid, message = validate_obligatory_fields(report)
     if not is_valid:
         return message, None, ""
-    
-    # Create the JSON string
-    json_str = json.dumps(data, indent=4)
 
+    # Create the JSON string
+    json_str = json.dumps(report)
+    print(json_str)
     # Create and save the JSON file
-    with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.json') as f:
-        json.dump(data, f, indent=4)
-        return message, f.name, json_str
+    with tempfile.NamedTemporaryFile(mode='w', prefix="report", delete=False, suffix='.json') as file:
+        json.dump(report, file, indent=4)
+        return message, file.name, json_str

ui/form_components.py

@@ -1,12 +1,13 @@
 import gradio as gr
 from config import (
     REPORT_STATUS_OPTIONS, CONFIDENTIALITY_LEVELS, DATA_TYPES,
-    ACCURACY_LEVELS, MEASUREMENT_UNITS, INFRA_TYPES,
+    DATA_UNITS, ACCURACY_LEVELS, MEASUREMENT_UNITS, INFRA_TYPES,
     POWER_SUPPLIER_TYPES, POWER_SOURCES, QUALITY_LEVELS,
     HASH_ALGORITHMS, CRYPTO_ALGORITHMS, CACHE_OPTIONS
 )
 
-def create_dynamic_section(section_name, fields_config, initial_count = 1, layout="row"):
+
+def create_dynamic_section(section_name, fields_config, initial_count=1, layout="row"):
     # State management
     count_state = gr.State(value=initial_count+1)
     field_states = [gr.State([]) for _ in fields_config]
@@ -33,12 +34,12 @@ def create_dynamic_section(section_name, fields_config, initial_count = 1, layou
     def render_dynamic_section(count):
         nonlocal all_components
         all_components = []
-        
+
         for i in range(count):
             with (gr.Row() if layout == "row" else gr.Column()):
                 row_components = []
                 field_refs = []  # To store references to current row's components
-                
+
                 for field_idx, config in enumerate(fields_config):
                     component = config["type"](
                         label=f"{config['label']} {i + 1}",
@@ -46,7 +47,7 @@ def create_dynamic_section(section_name, fields_config, initial_count = 1, layou
                         **config.get("kwargs", {})
                     )
                     row_components.append(component)
-                    field_refs.append(component)  
+                    field_refs.append(component)
 
                     # Create change event with ALL current field values
                     component.change(
@@ -54,7 +55,7 @@ def create_dynamic_section(section_name, fields_config, initial_count = 1, layou
                         inputs=[*field_states, *field_refs, gr.State(i)],
                         outputs=field_states
                     )
-                
+
                 # Remove button
                 remove_btn = gr.Button("❌", variant="secondary")
                 remove_btn.click(
@@ -66,63 +67,82 @@ def create_dynamic_section(section_name, fields_config, initial_count = 1, layou
                     outputs=[count_state, *field_states]
                 )
                 row_components.append(remove_btn)
-                
+
                 all_components.extend(row_components)
         return all_components
 
     # Initialize with initial count
     render_dynamic_section(count=initial_count)
-    
+
     add_btn = gr.Button(f"Add {section_name}")
     add_btn.click(lambda x: x + 1, count_state, count_state)
 
     return (count_state, *field_states, add_btn)
 
+
 def create_header_tab():
     """Create the header tab components."""
     with gr.Tab("Header"):
-        licensing = gr.Textbox(label="Licensing", info="(the type of licensing applicable for the sharing of the report)")
-        formatVersion = gr.Textbox(label="Format Version", info="Required field<br>(the version of the specification of this set of schemas defining the report's fields)")
-        formatVersionSpecificationUri = gr.Textbox(label="Format Version Specification URI", info="(the URI of the present specification of this set of schemas)")
-        reportId = gr.Textbox(label="Report ID", info="Required field<br>(the unique identifier of this report, preferably as a uuid4 string)")
-        reportDatetime = gr.Textbox(label="Report Datetime", info="(the publishing date of this report in format YYYY-MM-DD HH:MM:SS)")
+        licensing = gr.Textbox(
+            label="Licensing", info="(the type of licensing applicable for the sharing of the report)")
+        formatVersion = gr.Textbox(
+            label="Format Version", info="Required field<br>(the version of the specification of this set of schemas defining the report's fields)")
+        formatVersionSpecificationUri = gr.Textbox(
+            label="Format Version Specification URI", info="(the URI of the present specification of this set of schemas)")
+        reportId = gr.Textbox(
+            label="Report ID", info="Required field<br>(the unique identifier of this report, preferably as a uuid4 string)")
+        reportDatetime = gr.Textbox(
+            label="Report Datetime", info="(the publishing date of this report in format YYYY-MM-DD HH:MM:SS)")
         reportStatus = gr.Dropdown(value=None,
-            label="Report Status",
-            choices=REPORT_STATUS_OPTIONS,
-            info="Required field<br>(the status of this report)"
-        )
-        
+                                   label="Report Status",
+                                   choices=REPORT_STATUS_OPTIONS,
+                                   info="Required field<br>(the status of this report)"
+                                   )
+
         with gr.Accordion("Publisher"):
-            publisher_name = gr.Textbox(label="Name", info="(name of the organization)")
-            publisher_division = gr.Textbox(label="Division", info="(name of the publishing department within the organization)")
-            publisher_projectName = gr.Textbox(label="Project Name", info="(name of the publishing project within the organization)")
+            publisher_name = gr.Textbox(
+                label="Name", info="(name of the organization)")
+            publisher_division = gr.Textbox(
+                label="Division", info="(name of the publishing department within the organization)")
+            publisher_projectName = gr.Textbox(
+                label="Project Name", info="(name of the publishing project within the organization)")
             publisher_confidentialityLevel = gr.Dropdown(value=None,
-                label="Confidentiality Level",
-                choices=CONFIDENTIALITY_LEVELS,
-                info="Required field<br>(the confidentiality of the report)"
-            )
-            publisher_publicKey = gr.Textbox(label="Public Key", info="(the cryptographic public key to check the identity of the publishing organization)")
-        
+                                                         label="Confidentiality Level",
+                                                         choices=CONFIDENTIALITY_LEVELS,
+                                                         info="Required field<br>(the confidentiality of the report)"
+                                                         )
+            publisher_publicKey = gr.Textbox(
+                label="Public Key", info="(the cryptographic public key to check the identity of the publishing organization)")
+
         return [
             licensing, formatVersion, formatVersionSpecificationUri, reportId,
             reportDatetime, reportStatus, publisher_name, publisher_division,
             publisher_projectName, publisher_confidentialityLevel, publisher_publicKey
         ]
 
+
 def create_task_tab():
     """Create the task tab components."""
     with gr.Tab("Task"):
-        taskType = gr.Textbox(label="Task Type", info="Required field<br>(type of the computing task of machine learning, example : datacreation, preprocessing, supervisedLearning, unsupervisedLearning, semiSupervisedLearning ...)")
-        taskFamily = gr.Textbox(label="Task Family", info="Required field<br>(the family of task performed, example : classification, regression, chatbot, summarization, keyword extraction, image recognition...)")
-        taskStage = gr.Textbox(label="Task Stage", info="Required field<br>(stage of the task, example: training, finetuning, reinforcement, inference, rag...)")
-        
+        taskType = gr.Textbox(
+            label="Task Type", info="Required field<br>(type of the computing task of machine learning, example : datacreation, preprocessing, supervisedLearning, unsupervisedLearning, semiSupervisedLearning ...)")
+        taskFamily = gr.Textbox(
+            label="Task Family", info="Required field<br>(the family of task performed, example : classification, regression, chatbot, summarization, keyword extraction, image recognition...)")
+        taskStage = gr.Textbox(
+            label="Task Stage", info="Required field<br>(stage of the task, example: training, finetuning, reinforcement, inference, rag...)")
+
         with gr.Accordion("Algorithms"):
-            algorithmName = gr.Textbox(label="Algorithm Name", info="Required field<br>(the case-sensitive common name of the algorithm, example: randomForest, svm, xgboost...)")
-            framework = gr.Textbox(label="Framework", info="(the common name of the software framework implementing the algorithm)")
-            frameworkVersion = gr.Textbox(label="Framework Version", info="(the version of the software framework)")
-            classPath = gr.Textbox(label="Class Path", info="(the full class path of the algorithm within the framework)")
-            tuning_method = gr.Textbox(label="Tuning Method", info="(the method of hyperparameters tuning used (if any), example: gridSearch, randomizedSearch...)")
-            
+            algorithmName = gr.Textbox(
+                label="Algorithm Name", info="Required field<br>(the case-sensitive common name of the algorithm, example: randomForest, svm, xgboost...)")
+            framework = gr.Textbox(
+                label="Framework", info="(the common name of the software framework implementing the algorithm)")
+            frameworkVersion = gr.Textbox(
+                label="Framework Version", info="(the version of the software framework)")
+            classPath = gr.Textbox(
+                label="Class Path", info="(the full class path of the algorithm within the framework)")
+            tuning_method = gr.Textbox(
+                label="Tuning Method", info="(the method of hyperparameters tuning used (if any), example: gridSearch, randomizedSearch...)")
+
             with gr.Accordion("Hyperparameters"):
                 _, hyperparameter_names, hyperparameter_values, add_btn = create_dynamic_section(
                     section_name="Hyperparameter",
@@ -143,51 +163,65 @@ def create_task_tab():
                     initial_count=0,
                 )
 
-            quantization = gr.Textbox(label="Quantization", info="(the data weights (in bits) obtained thanks to the quantization, example: 2, 8, 16...)")
-        
+            quantization = gr.Textbox(
+                label="Quantization", info="(the data weights (in bits) obtained thanks to the quantization, example: 2, 8, 16...)")
+
         with gr.Accordion("Dataset"):
             dataType = gr.Dropdown(value=None,
-                label="Data Type",
-                choices=DATA_TYPES,
-                info="Required field<br>(the nature of the data)"
-            )
-            fileType = gr.Textbox(label="File Type", info="(the file type of the dataset)")
-            volume = gr.Textbox(label="Volume", info="Required field<br>(the size of the dataset)")
-            volumeUnit = gr.Textbox(label="Volume Unit", info="Required field<br>(the unit of the size)")
-            items = gr.Textbox(label="Items", info="(the number of items in the dataset)")
-            shape_item = gr.Textbox(label="Shape Item", info="(the shape of each dataset item)")
-            
+                                   label="Data Type",
+                                   choices=DATA_TYPES,
+                                   info="Required field<br>(the nature of the data)"
+                                   )
+            fileType = gr.Textbox(
+                label="File Type", info="(the file type of the dataset)")
+            volume = gr.Number(value=lambda: None,
+                               label="Volume", info="Required field<br>(the size of the dataset)")
+            volumeUnit = gr.Dropdown(value=None,
+                                     label="Volume Unit",
+                                     choices=DATA_UNITS,
+                                     info="Required field<br>(the unit of the size)")
+            items = gr.Number(value=lambda: None,
+                              label="Items", info="(the number of items in the dataset)")
+            shape_item = gr.Number(value=lambda: None,
+                                   label="Shape Item", info="(the shape of each dataset item)")
+
             with gr.Accordion("Inference Properties"):
-                    _, nbRequest, nbTokensInput, nbWordsInput,  nbTokensOutput, nbWordsOutput, contextWindowSize, cache, add_inference_btn = create_dynamic_section(
+                _, nbRequest, nbTokensInput, nbWordsInput,  nbTokensOutput, nbWordsOutput, contextWindowSize, cache, add_inference_btn = create_dynamic_section(
                     section_name="Inference Property",
                     fields_config=[
                         {
-                            "type": gr.Textbox,
+                            "type": gr.Number,
+                            "value": lambda: None,
                             "label": "Number of Requests",
                             "info": "Required field<br>(the number of requests the measure corresponds to)",
                         },
                         {
-                            "type": gr.Textbox,
+                            "type": gr.Number,
+                            "value": lambda: None,
                             "label": "Number of Tokens Input",
                             "info": "(the number of tokens in the input)",
                         },
                         {
-                            "type": gr.Textbox,
+                            "type": gr.Number,
+                            "value": lambda: None,
                             "label": "Number of Words Input",
                             "info": "(the number of words in the input)",
                         },
                         {
-                            "type": gr.Textbox,
+                            "type": gr.Number,
+                            "value": lambda: None,
                             "label": "Number of Tokens Output",
                             "info": "(the number of tokens in the output)",
                         },
                         {
-                            "type": gr.Textbox,
+                            "type": gr.Number,
+                            "value": lambda: None,
                             "label": "Number of Words Output",
                             "info": "(the number of words in the output)",
                         },
                         {
-                            "type": gr.Textbox,
+                            "type": gr.Number,
+                            "value": lambda: None,
                             "label": "Context Window Size",
                             "info": "(the number of tokens kept in memory)",
                         },
@@ -201,19 +235,23 @@ def create_task_tab():
                     initial_count=0,
                     layout="column"
                 )
-            
-            source = gr.Textbox(label="Source", info="(the kind of source of the dataset)")
-            sourceUri = gr.Textbox(label="Source URI", info="(the URI of the dataset)")
-            owner = gr.Textbox(label="Owner", info="(the owner of the dataset)")
+
+            source = gr.Textbox(
+                label="Source", info="(the kind of source of the dataset)")
+            sourceUri = gr.Textbox(
+                label="Source URI", info="(the URI of the dataset)")
+            owner = gr.Textbox(
+                label="Owner", info="(the owner of the dataset)")
 
         with gr.Row():
-            measuredAccuracy = gr.Textbox(label="Measured Accuracy", info="(the measured accuracy of your model (between 0 and 1))")
+            measuredAccuracy = gr.Number(value=lambda: None,
+                                         label="Measured Accuracy", info="(the measured accuracy of your model (between 0 and 1))")
             estimatedAccuracy = gr.Dropdown(value=None,
-                label="Estimated Accuracy",
-                choices=ACCURACY_LEVELS,
-                info="(estimated accuracy assessment)"
-            )
-        
+                                            label="Estimated Accuracy",
+                                            choices=ACCURACY_LEVELS,
+                                            info="(estimated accuracy assessment)"
+                                            )
+
         return [
             taskType, taskFamily, taskStage, algorithmName, framework,
             frameworkVersion, classPath, tuning_method, hyperparameter_names, hyperparameter_values,
@@ -223,28 +261,42 @@ def create_task_tab():
             cache, source, sourceUri, owner, measuredAccuracy, estimatedAccuracy
         ]
 
+
 def create_measures_tab():
     """Create the measures tab components."""
     with gr.Tab("Measures"):
-        measurementMethod = gr.Textbox(label="Measurement Method", info="Required field<br>(the method used to perform the energy or FLOPS measure)")
-        manufacturer = gr.Textbox(label="Manufacturer", info="(the builder of the measuring tool)")
-        version = gr.Textbox(label="Version", info="(the version of the measuring tool)")
-        cpuTrackingMode = gr.Textbox(label="CPU Tracking Mode", info="(the method used to track CPU consumption)")
-        gpuTrackingMode = gr.Textbox(label="GPU Tracking Mode", info="(the method used to track GPU consumption)")
-        averageUtilizationCpu = gr.Textbox(label="Average Utilization CPU", info="(the average percentage of CPU use)")
-        averageUtilizationGpu = gr.Textbox(label="Average Utilization GPU", info="(the average percentage of GPU use)")
-        serverSideInference = gr.Textbox(label="Server Side Inference", info="(inference server consumption estimation)")
+        measurementMethod = gr.Textbox(
+            label="Measurement Method", info="Required field<br>(the method used to perform the energy or FLOPS measure)")
+        manufacturer = gr.Textbox(
+            label="Manufacturer", info="(the builder of the measuring tool)")
+        version = gr.Textbox(
+            label="Version", info="(the version of the measuring tool)")
+        cpuTrackingMode = gr.Textbox(
+            label="CPU Tracking Mode", info="(the method used to track CPU consumption)")
+        gpuTrackingMode = gr.Textbox(
+            label="GPU Tracking Mode", info="(the method used to track GPU consumption)")
+        averageUtilizationCpu = gr.Number(value=lambda: None,
+                                          label="Average Utilization CPU", info="(the average percentage of CPU use)")
+        averageUtilizationGpu = gr.Number(value=lambda: None,
+                                          label="Average Utilization GPU", info="(the average percentage of GPU use)")
+        serverSideInference = gr.Textbox(
+            label="Server Side Inference", info="(inference server consumption estimation)")
         unit = gr.Dropdown(value=None,
-            label="Unit",
-            choices=MEASUREMENT_UNITS,
-            info="Required field<br>(the unit of power consumption measure)"
-        )
-        powerCalibrationMeasurement = gr.Textbox(label="Power Calibration Measurement", info="(power consumed during calibration)")
-        durationCalibrationMeasurement = gr.Textbox(label="Duration Calibration Measurement", info="(duration of calibration in seconds)")
-        powerConsumption = gr.Textbox(label="Power Consumption", info="Required field<br>(the power consumption measure)")
-        measurementDuration = gr.Textbox(label="Measurement Duration", info="(the duration of measurement in seconds)")
-        measurementDateTime = gr.Textbox(label="Measurement DateTime", info="(when measurement began)")
-        
+                           label="Unit",
+                           choices=MEASUREMENT_UNITS,
+                           info="Required field<br>(the unit of power consumption measure)"
+                           )
+        powerCalibrationMeasurement = gr.Number(value=lambda: None,
+                                                label="Power Calibration Measurement", info="(power consumed during calibration)")
+        durationCalibrationMeasurement = gr.Number(value=lambda: None,
+                                                   label="Duration Calibration Measurement", info="(duration of calibration in seconds)")
+        powerConsumption = gr.Number(value=lambda: None,
+                                     label="Power Consumption", info="Required field<br>(the power consumption measure)")
+        measurementDuration = gr.Number(value=lambda: None,
+                                        label="Measurement Duration", info="(the duration of measurement in seconds)")
+        measurementDateTime = gr.Textbox(
+            label="Measurement DateTime", info="(when measurement began)")
+
         return [
             measurementMethod, manufacturer, version, cpuTrackingMode,
             gpuTrackingMode, averageUtilizationCpu, averageUtilizationGpu,
@@ -253,49 +305,66 @@ def create_measures_tab():
             measurementDuration, measurementDateTime
         ]
 
+
 def create_system_tab():
     """Create the system tab components."""
     with gr.Tab("System"):
-        os = gr.Textbox(label="OS", info="Required field<br>(name of the operating system)")
-        distribution = gr.Textbox(label="Distribution", info="(distribution of the operating system)")
-        distributionVersion = gr.Textbox(label="Distribution Version", info="(distribution version)")
-        
+        os = gr.Textbox(
+            label="OS", info="Required field<br>(name of the operating system)")
+        distribution = gr.Textbox(
+            label="Distribution", info="(distribution of the operating system)")
+        distributionVersion = gr.Textbox(
+            label="Distribution Version", info="(distribution version)")
+
         return [os, distribution, distributionVersion]
 
+
 def create_software_tab():
     """Create the software tab components."""
     with gr.Tab("Software"):
-        language = gr.Textbox(label="Language", info="Required field<br>(programming language information)")
-        version_software = gr.Textbox(label="Version", info="(version of the programming language)")
-        
+        language = gr.Textbox(
+            label="Language", info="Required field<br>(programming language information)")
+        version_software = gr.Textbox(
+            label="Version", info="(version of the programming language)")
+
         return [language, version_software]
 
+
 def create_infrastructure_tab():
     """Create the infrastructure tab components."""
     with gr.Tab("Infrastructure"):
         infraType = gr.Dropdown(value=None,
-            label="Infrastructure Type",
-            choices=INFRA_TYPES,
-            info="Required field<br>(the type of infrastructure used)"
-        )
-        cloudProvider = gr.Textbox(label="Cloud Provider", info="(name of your cloud provider)")
-        cloudInstance = gr.Textbox(label="Cloud Instance", info="(name of your cloud instance)")
+                                label="Infrastructure Type",
+                                choices=INFRA_TYPES,
+                                info="Required field<br>(the type of infrastructure used)"
+                                )
+        cloudProvider = gr.Textbox(
+            label="Cloud Provider", info="(name of your cloud provider)")
+        cloudInstance = gr.Textbox(
+            label="Cloud Instance", info="(name of your cloud instance)")
         with gr.Accordion("Components"):
-            _, componentName, nbComponent, memorySize, manufacturer_infra, family, series, share, add_component_btn = create_dynamic_section(
+            _, componentName, componentType, nbComponent, memorySize, manufacturer_infra, family, series, share, add_component_btn = create_dynamic_section(
                 section_name="Component",
                 fields_config=[
                     {
                         "type": gr.Textbox,
                         "label": "Component Name",
-                        "info": "Required field<br>(type of subsystem part)",
+                        "info": "(the name of this subsystem part of your infrastructure, example returned by codecarbon: 1 x NVIDIA GeForce GTX 1080 Ti)",
                     },
                     {
                         "type": gr.Textbox,
+                        "label": "Component Type",
+                        "info": "Required field<br>(the type of this subsystem part of your infrastructure, example: cpu, gpu, ram, hdd, sdd...)",
+                    },
+                    {
+                        "type": gr.Number,
+                        "value": lambda: None,
                         "label": "Number of Components",
                         "info": "Required field<br>(number of items of this component)",
                     },
                     {
-                        "type": gr.Textbox,
+                        "type": gr.Number,
+                        "value": lambda: None,
                         "label": "Memory Size",
                         "info": "(size of memory in Gbytes)",
                     },
@@ -315,7 +384,8 @@ def create_infrastructure_tab():
                         "info": "(series of this component)",
                     },
                     {
-                        "type": gr.Textbox,
+                        "type": gr.Number,
+                        "value": lambda: None,
                         "label": "Share",
                         "info": "(percentage of equipment used)",
                     }
@@ -323,61 +393,66 @@ def create_infrastructure_tab():
                 initial_count=0,
                 layout="column"
             )
-        
+
         return [
-            infraType, cloudProvider, cloudInstance, componentName,
+            infraType, cloudProvider, cloudInstance, componentName, componentType,
             nbComponent, memorySize, manufacturer_infra, family,
             series, share
         ]
 
+
 def create_environment_tab():
     """Create the environment tab components."""
     with gr.Tab("Environment"):
         country = gr.Textbox(label="Country", info="Required field")
-        latitude = gr.Textbox(label="Latitude")
-        longitude = gr.Textbox(label="Longitude")
+        latitude = gr.Number(label="Latitude", value=lambda: None)
+        longitude = gr.Number(label="Longitude", value=lambda: None)
         location = gr.Textbox(label="Location")
-        powerSupplierType = gr.Dropdown(value=None,
-            label="Power Supplier Type",
-            choices=POWER_SUPPLIER_TYPES,
-            info="(the type of power supplier)"
-        )
+        powerSupplierType = gr.Dropdown(value=lambda: None,
+                                        label="Power Supplier Type",
+                                        choices=POWER_SUPPLIER_TYPES,
+                                        info="(the type of power supplier)"
+                                        )
         powerSource = gr.Dropdown(value=None,
-            label="Power Source",
-            choices=POWER_SOURCES,
-            info="(the source of power)"
-        )
-        powerSourceCarbonIntensity = gr.Textbox(label="Power Source Carbon Intensity")
-        
+                                  label="Power Source",
+                                  choices=POWER_SOURCES,
+                                  info="(the source of power)"
+                                  )
+        powerSourceCarbonIntensity = gr.Number(value=lambda: None,
+                                               label="Power Source Carbon Intensity")
+
         return [
             country, latitude, longitude, location,
             powerSupplierType, powerSource, powerSourceCarbonIntensity
         ]
 
+
 def create_quality_tab():
     """Create the quality tab components."""
     with gr.Tab("Quality"):
         quality = gr.Dropdown(value=None,
-            label="Quality",
-            choices=QUALITY_LEVELS,
-            info="(the quality of the information provided)"
-        )
-        
+                              label="Quality",
+                              choices=QUALITY_LEVELS,
+                              info="(the quality of the information provided)"
+                              )
+
         return [quality]
 
+
 def create_hash_tab():
     """Create the hash tab components."""
     with gr.Tab("Hash"):
         hashAlgorithm = gr.Dropdown(value=None,
-            label="Hash Algorithm",
-            choices=HASH_ALGORITHMS,
-            info="Required field<br>(the hash function to apply)"
-        )
+                                    label="Hash Algorithm",
+                                    choices=HASH_ALGORITHMS,
+                                    info="Required field<br>(the hash function to apply)"
+                                    )
         cryptographicAlgorithm = gr.Dropdown(value=None,
-            label="Cryptographic Algorithm",
-            choices=CRYPTO_ALGORITHMS,
-            info="Required field<br>(the public key function to apply)"
-        )
-        value_hash = gr.Textbox(label="Value", info="Required field<br>(encrypted value of the hash)")
-        
-        return [hashAlgorithm, cryptographicAlgorithm, value_hash]
+                                             label="Cryptographic Algorithm",
+                                             choices=CRYPTO_ALGORITHMS,
+                                             info="Required field<br>(the public key function to apply)"
+                                             )
+        value_hash = gr.Textbox(
+            label="Value", info="Required field<br>(encrypted value of the hash)")
+
+        return [hashAlgorithm, cryptographicAlgorithm, value_hash]

utils/validation.py

@@ -1,5 +1,6 @@
 from config import OBLIGATORY_FIELDS
 
+
 def validate_obligatory_fields(data):
     """Validate that all required fields are present in the data."""
     def find_field(d, field):
@@ -17,13 +18,15 @@ def validate_obligatory_fields(data):
                         if result is not None:
                             return result
         return None
-    
+
     missing_fields = []
     for field in OBLIGATORY_FIELDS:
+        # if the field is mandatory, check if it is inside a mandatory section
+
         value = find_field(data, field)
         if not value and value != 0:  # Allow 0 as a valid value
             missing_fields.append(field)
-            
+
     if missing_fields:
         return False, f"The following fields are required: {', '.join(missing_fields)}"
-    return True, "All required fields are filled."
+    return True, "All required fields are filled."