Add initial implementation of data collection form

app.py

@@ -0,0 +1,63 @@
+import gradio as gr
+from services.huggingface import init_huggingface, update_dataset
+from services.json_generator import generate_json
+from ui.form_components import (
+    create_header_tab,
+    create_task_tab,
+    create_measures_tab,
+    create_system_tab,
+    create_software_tab,
+    create_infrastructure_tab,
+    create_environment_tab,
+    create_quality_tab,
+    create_hash_tab
+)
+
+# Initialize Hugging Face
+init_huggingface()
+
+# 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.")
+
+    # Create form tabs
+    header_components = create_header_tab()
+    task_components = create_task_tab()
+    measures_components = create_measures_tab()
+    system_components = create_system_tab()
+    software_components = create_software_tab()
+    infrastructure_components = create_infrastructure_tab()
+    environment_components = create_environment_tab()
+    quality_components = create_quality_tab()
+    hash_components = create_hash_tab()
+
+    # Submit and Download Buttons
+    submit_button = gr.Button("Submit")
+    output = gr.Textbox(label="Output", lines=1)
+    json_output = gr.Textbox(visible=False)
+    file_output = gr.File(label="Downloadable JSON")
+
+    # Event Handlers
+    submit_button.click(
+        generate_json,
+        inputs=[
+            *header_components,
+            *task_components,
+            *measures_components,
+            *system_components,
+            *software_components,
+            *infrastructure_components,
+            *environment_components,
+            *quality_components,
+            *hash_components
+        ],
+        outputs=[output, file_output, json_output]
+    ).then(
+        update_dataset,
+        inputs=json_output,
+        outputs=output
+    )
+
+if __name__ == "__main__":
+    demo.launch()

config.py

@@ -0,0 +1,31 @@
+import os
+
+# Hugging Face Configuration
+HF_TOKEN = os.environ.get("HF_TOKEN")
+DATASET_NAME = "FILALIHicham/EcoMindAI-Data"
+
+# Form Field Configurations
+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", "value"
+]
+
+# Dropdown Options
+REPORT_STATUS_OPTIONS = ["draft", "final", "corrective", "$other"]
+CONFIDENTIALITY_LEVELS = ["public", "internal", "confidential", "secret"]
+DATA_TYPES = ["tabular", "audio", "boolean", "image", "video", "object", "text", "$other"]
+ACCURACY_LEVELS = ["veryPoor", "poor", "average", "good", "veryGood"]
+MEASUREMENT_UNITS = ["Wh", "kWh", "MWh", "GWh", "kJoule", "MJoule", "GJoule", "TJoule", "PJoule", 
+                    "BTU", "kiloFLOPS", "megaFLOPS", "gigaFLOPS", "teraFLOPS", "petaFLOPS", 
+                    "exaFLOPS", "zettaFLOPS", "yottaFLOPS"]
+INFRA_TYPES = ["publicCloud", "privateCloud", "onPremise", "$other"]
+POWER_SUPPLIER_TYPES = ["public", "private", "internal", "$other"]
+POWER_SOURCES = ["solar", "wind", "nuclear", "hydroelectric", "gas", "coal", "$other"]
+QUALITY_LEVELS = ["high", "medium", "low"]
+HASH_ALGORITHMS = ["MD5", "RIPEMD-128", "RIPEMD-160", "RIPEMD-256", "RIPEMD-320", 
+                  "SHA-1", "SHA-224", "SHA256", "SHA-384", "SHA-512"]
+CRYPTO_ALGORITHMS = ["RSA", "DSA", "ECDSA", "EDDSA"]
+CACHE_OPTIONS = ["true", "false"]

services/huggingface.py

@@ -0,0 +1,138 @@
+from huggingface_hub import login
+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.")
+    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"):
+        return json_data or "No data to submit. Please fill in all required fields."
+
+    try:
+        data = json.loads(json_data)
+    except json.JSONDecodeError:
+        return "Invalid JSON data. Please ensure all required fields are filled correctly."
+    
+    try:
+        dataset = load_dataset(DATASET_NAME, split="train")
+    except:
+        dataset = Dataset.from_dict({})
+
+    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."""
+    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
+        "taskType": [data["task"]["taskType"]],
+        "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"]],
+        "tuning_method": [data["task"]["algorithms"][0]["hyperparameters"]["tuning_method"]],
+        "hyperparameterName": [data["task"]["algorithms"][0]["hyperparameters"]["values"][0]["hyperparameterName"]],
+        "hyperparameterValue": [data["task"]["algorithms"][0]["hyperparameters"]["values"][0]["hyperparameterValue"]],
+        "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": [data["task"]["dataset"][0]["inferenceProperties"][0]["nbRequest"]],
+        "nbTokensInput": [data["task"]["dataset"][0]["inferenceProperties"][0]["parametersNLP"]["nbTokensInput"]],
+        "nbWordsInput": [data["task"]["dataset"][0]["inferenceProperties"][0]["parametersNLP"]["nbWordsInput"]],
+        "nbTokensOutput": [data["task"]["dataset"][0]["inferenceProperties"][0]["parametersNLP"]["nbTokensOutput"]],
+        "nbWordsOutput": [data["task"]["dataset"][0]["inferenceProperties"][0]["parametersNLP"]["nbWordsOutput"]],
+        "contextWindowSize": [data["task"]["dataset"][0]["inferenceProperties"][0]["parametersNLP"]["contextWindowSize"]],
+        "cache": [data["task"]["dataset"][0]["inferenceProperties"][0]["parametersNLP"]["cache"]],
+        "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": [data["infrastructure"]["components"][0]["componentName"]],
+        "nbComponent": [data["infrastructure"]["components"][0]["nbComponent"]],
+        "memorySize": [data["infrastructure"]["components"][0]["memorySize"]],
+        "manufacturer_infra": [data["infrastructure"]["components"][0]["manufacturer"]],
+        "family": [data["infrastructure"]["components"][0]["family"]],
+        "series": [data["infrastructure"]["components"][0]["series"]],
+        "share": [data["infrastructure"]["components"][0]["share"]],
+        
+        # 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"]["value"]]
+    }

services/json_generator.py

@@ -0,0 +1,175 @@
+import json
+import tempfile
+from datetime import datetime
+from utils.validation import validate_obligatory_fields
+
+def generate_json(
+    # Header
+    licensing, formatVersion, formatVersionSpecificationUri, reportId, reportDatetime, reportStatus,
+    publisher_name, publisher_division, publisher_projectName, publisher_confidentialityLevel, publisher_publicKey,
+    # Task
+    taskType, taskFamily, taskStage, algorithmName, framework, frameworkVersion, classPath, tuning_method,
+    hyperparameterName, hyperparameterValue, quantization, dataType, fileType, volume, volumeUnit, items,
+    shape_item, nbRequest, nbTokensInput, nbWordsInput, nbTokensOutput, nbWordsOutput, contextWindowSize, cache,
+    source, sourceUri, owner, measuredAccuracy, estimatedAccuracy,
+    # Measures
+    measurementMethod, manufacturer, version, cpuTrackingMode, gpuTrackingMode, averageUtilizationCpu,
+    averageUtilizationGpu, serverSideInference, unit, powerCalibrationMeasurement, durationCalibrationMeasurement,
+    powerConsumption, measurementDuration, measurementDateTime,
+    # System
+    os, distribution, distributionVersion,
+    # Software
+    language, version_software,
+    # Infrastructure
+    infraType, cloudProvider, cloudInstance, componentName, nbComponent, memorySize, manufacturer_infra, family, series, share,
+    # Environment
+    country, latitude, longitude, location, powerSupplierType, powerSource, powerSourceCarbonIntensity,
+    # Quality
+    quality,
+    # Hash
+    hashAlgorithm, cryptographicAlgorithm, value_hash
+):
+    """Generate JSON data from form inputs."""
+    data = {
+        "header": {
+            "licensing": licensing,
+            "formatVersion": formatVersion,
+            "formatVersionSpecificationUri": formatVersionSpecificationUri,
+            "reportId": reportId,
+            "reportDatetime": reportDatetime or datetime.now().isoformat(),
+            "reportStatus": reportStatus,
+            "publisher": {
+                "name": publisher_name,
+                "division": publisher_division,
+                "projectName": publisher_projectName,
+                "confidentialityLevel": publisher_confidentialityLevel,
+                "publicKey": publisher_publicKey
+            }
+        },
+        "task": {
+            "taskType": taskType,
+            "taskFamily": taskFamily,
+            "taskStage": taskStage,
+            "algorithms": [
+                {
+                    "algorithmName": algorithmName,
+                    "framework": framework,
+                    "frameworkVersion": frameworkVersion,
+                    "classPath": classPath,
+                    "hyperparameters": {
+                        "tuning_method": tuning_method,
+                        "values": [
+                            {
+                                "hyperparameterName": hyperparameterName,
+                                "hyperparameterValue": hyperparameterValue
+                            }
+                        ]
+                    },
+                    "quantization": quantization
+                }
+            ],
+            "dataset": [
+                {
+                    "dataType": dataType,
+                    "fileType": fileType,
+                    "volume": volume,
+                    "volumeUnit": volumeUnit,
+                    "items": items,
+                    "shape": [
+                        {
+                            "item": shape_item
+                        }
+                    ],
+                    "inferenceProperties": [
+                        {
+                            "nbRequest": nbRequest,
+                            "parametersNLP": {
+                                "nbTokensInput": nbTokensInput,
+                                "nbWordsInput": nbWordsInput,
+                                "nbTokensOutput": nbTokensOutput,
+                                "nbWordsOutput": nbWordsOutput,
+                                "contextWindowSize": contextWindowSize,
+                                "cache": cache
+                            }
+                        }
+                    ],
+                    "source": source,
+                    "sourceUri": sourceUri,
+                    "owner": owner
+                }
+            ],
+            "measuredAccuracy": measuredAccuracy,
+            "estimatedAccuracy": estimatedAccuracy
+        },
+        "measures": [
+            {
+                "measurementMethod": measurementMethod,
+                "manufacturer": manufacturer,
+                "version": version,
+                "cpuTrackingMode": cpuTrackingMode,
+                "gpuTrackingMode": gpuTrackingMode,
+                "averageUtilizationCpu": averageUtilizationCpu,
+                "averageUtilizationGpu": averageUtilizationGpu,
+                "serverSideInference": serverSideInference,
+                "unit": unit,
+                "powerCalibrationMeasurement": powerCalibrationMeasurement,
+                "durationCalibrationMeasurement": durationCalibrationMeasurement,
+                "powerConsumption": powerConsumption,
+                "measurementDuration": measurementDuration,
+                "measurementDateTime": measurementDateTime
+            }
+        ],
+        "system": {
+            "os": os,
+            "distribution": distribution,
+            "distributionVersion": distributionVersion
+        },
+        "software": {
+            "language": language,
+            "version": version_software
+        },
+        "infrastructure": {
+            "infraType": infraType,
+            "cloudProvider": cloudProvider,
+            "cloudInstance": cloudInstance,
+            "components": [
+                {
+                    "componentName": componentName,
+                    "nbComponent": nbComponent,
+                    "memorySize": memorySize,
+                    "manufacturer": manufacturer_infra,
+                    "family": family,
+                    "series": series,
+                    "share": share
+                }
+            ]
+        },
+        "environment": {
+            "country": country,
+            "latitude": latitude,
+            "longitude": longitude,
+            "location": location,
+            "powerSupplierType": powerSupplierType,
+            "powerSource": powerSource,
+            "powerSourceCarbonIntensity": powerSourceCarbonIntensity
+        },
+        "quality": quality,
+        "$hash": {
+            "hashAlgorithm": hashAlgorithm,
+            "cryptographicAlgorithm": cryptographicAlgorithm,
+            "value": value_hash
+        }
+    }
+
+    # Validate obligatory fields
+    is_valid, message = validate_obligatory_fields(data)
+    if not is_valid:
+        return message, None, ""
+    
+    # Create the JSON string
+    json_str = json.dumps(data, indent=4)
+
+    # 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

ui/form_components.py

@@ -0,0 +1,228 @@
+import gradio as gr
+from config import (
+    REPORT_STATUS_OPTIONS, CONFIDENTIALITY_LEVELS, DATA_TYPES,
+    ACCURACY_LEVELS, MEASUREMENT_UNITS, INFRA_TYPES,
+    POWER_SUPPLIER_TYPES, POWER_SOURCES, QUALITY_LEVELS,
+    HASH_ALGORITHMS, CRYPTO_ALGORITHMS, CACHE_OPTIONS
+)
+
+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)")
+        reportStatus = gr.Dropdown(value=None,
+            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_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)")
+        
+        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...)")
+        
+        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...)")
+            
+            with gr.Accordion("Hyperparameters"):
+                with gr.Row():
+                    hyperparameterName = gr.Textbox(label="Hyperparameter Name", info="(the name of the hyperparameter, example: c, kernel, gamma, class_weight...)")
+                    hyperparameterValue = gr.Textbox(label="Hyperparameter Value", info="(the value of the hyperparameter, example: rbf, 1e-4, 10, linear...)")
+            
+            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)")
+            
+            with gr.Accordion("Inference Properties"):
+                nbRequest = gr.Textbox(label="Number of Requests", info="Required field<br>(the number of requests the measure corresponds to)")
+                nbTokensInput = gr.Textbox(label="Number of Tokens Input", info="(the number of tokens in the input)")
+                nbWordsInput = gr.Textbox(label="Number of Words Input", info="(the number of words in the input)")
+                nbTokensOutput = gr.Textbox(label="Number of Tokens Output", info="(the number of tokens in the output)")
+                nbWordsOutput = gr.Textbox(label="Number of Words Output", info="(the number of words in the output)")
+                contextWindowSize = gr.Textbox(label="Context Window Size", info="(the number of tokens kept in memory)")
+                cache = gr.Dropdown(value=None,
+                    label="Cache",
+                    choices=CACHE_OPTIONS,
+                    info="(the presence of a cache function)"
+                )
+            
+            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))")
+            estimatedAccuracy = gr.Dropdown(value=None,
+                label="Estimated Accuracy",
+                choices=ACCURACY_LEVELS,
+                info="(estimated accuracy assessment)"
+            )
+        
+        return [
+            taskType, taskFamily, taskStage, algorithmName, framework,
+            frameworkVersion, classPath, tuning_method, hyperparameterName,
+            hyperparameterValue, quantization, dataType, fileType, volume,
+            volumeUnit, items, shape_item, nbRequest, nbTokensInput,
+            nbWordsInput, nbTokensOutput, nbWordsOutput, contextWindowSize,
+            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)")
+        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)")
+        
+        return [
+            measurementMethod, manufacturer, version, cpuTrackingMode,
+            gpuTrackingMode, averageUtilizationCpu, averageUtilizationGpu,
+            serverSideInference, unit, powerCalibrationMeasurement,
+            durationCalibrationMeasurement, powerConsumption,
+            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)")
+        
+        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)")
+        
+        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)")
+        componentName = gr.Textbox(label="Component Name", info="Required field<br>(type of subsystem part)")
+        nbComponent = gr.Textbox(label="Number of Components", info="Required field<br>(number of items of this component)")
+        memorySize = gr.Textbox(label="Memory Size", info="(size of memory in Gbytes)")
+        manufacturer_infra = gr.Textbox(label="Manufacturer", info="(name of the manufacturer)")
+        family = gr.Textbox(label="Family", info="(family of this component)")
+        series = gr.Textbox(label="Series", info="(series of this component)")
+        share = gr.Textbox(label="Share", info="(percentage of equipment used)")
+        
+        return [
+            infraType, cloudProvider, cloudInstance, componentName,
+            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")
+        location = gr.Textbox(label="Location")
+        powerSupplierType = gr.Dropdown(value=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")
+        
+        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)"
+        )
+        
+        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)"
+        )
+        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]

utils/validation.py

@@ -0,0 +1,29 @@
+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):
+        if field in d:
+            return d[field]
+        for k, v in d.items():
+            if isinstance(v, dict):
+                result = find_field(v, field)
+                if result is not None:
+                    return result
+            elif isinstance(v, list):
+                for item in v:
+                    if isinstance(item, dict):
+                        result = find_field(item, field)
+                        if result is not None:
+                            return result
+        return None
+    
+    missing_fields = []
+    for field in OBLIGATORY_FIELDS:
+        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."