wiliot-certificate 4.5.0a1__py3-none-any.whl → 4.5.0a3__py3-none-any.whl

gui_certificate/server.py

@@ -70,9 +70,32 @@ def get_mandatory_modules_for_flavor(flavor):
         return [MODULE_CLOUD_CONNECTIVITY, MODULE_EDGE_MGMT]
     return []
 
+def get_mandatory_modules_by_schema(schema_data, flavor):
+    """Get modules that are mandatory by schema (modules declared in schema)."""
+    if not schema_data or "modules" not in schema_data:
+        return []
+    
+    # Only apply to bridge flavors (bridge_only and combo)
+    if flavor not in (FLAVOR_BRIDGE_ONLY, FLAVOR_COMBO):
+        return []
+    
+    schema_modules = schema_data.get("modules", {})
+    if not isinstance(schema_modules, dict):
+        return []
+    
+    # Map schema module names to test module names
+    mandatory_by_schema = []    
+    for schema_mod_name in schema_modules.keys():
+        # Map schema module name to test module name
+        test_mod_name = test_module_and_schema_module_to_other(schema_mod_name)
+        if test_mod_name not in mandatory_by_schema:
+            mandatory_by_schema.append(test_mod_name)
+    
+    return mandatory_by_schema
+
 # TODO: This is a temporary mapping to map test module names to schema module names - remove this
-def test_module_to_schema_module(test_module_name):
-    """Map test module names to validation schema module names."""
+def test_module_and_schema_module_to_other(module_name):
+    """Map test module names and schema module names to one another."""
     mapping = {
         "calibration": "calibration",
         "datapath": "datapath",
@@ -82,7 +105,12 @@ def test_module_to_schema_module(test_module_name):
         "sensors": "externalSensor",  # different name
         "custom": "custom"
     }
-    return mapping.get(test_module_name, test_module_name)  # Return as-is if not in mapping
+    for k, v in mapping.items():
+        if module_name == k:
+            return v
+        if module_name == v:
+            return k
+    return module_name  # Return as-is if not in mapping
 
 def filter_modules_by_flavor(tests_schema, flavor, schema_data=None):
     """Filter modules and tests based on selected flavor."""
@@ -115,12 +143,17 @@ def filter_modules_by_flavor(tests_schema, flavor, schema_data=None):
                 # Include all tests for combo
                 filtered_tests.append(test)
         
-        # Only include module if it has tests or is mandatory
+        # Get modules mandatory by schema
+        mandatory_by_schema = get_mandatory_modules_by_schema(schema_data, flavor) if schema_data else []
+        is_mandatory_by_schema = mod_name in mandatory_by_schema
+        
+        # Only include module if it has tests or is mandatory (by flavor or schema)
         # For mandatory modules, include even if no tests match (they'll be shown but empty)
-        if filtered_tests or mod_name in mandatory_modules:
+        if filtered_tests or mod_name in mandatory_modules or is_mandatory_by_schema:
             mod_copy = mod.copy()
             mod_copy["tests"] = filtered_tests
             mod_copy["is_mandatory"] = mod_name in mandatory_modules
+            mod_copy["is_mandatory_by_schema"] = is_mandatory_by_schema
             filtered_modules.append(mod_copy)
     
     # Sort modules: cloud_connectivity first, then edge_mgmt, then by schema order
@@ -136,7 +169,7 @@ def filter_modules_by_flavor(tests_schema, flavor, schema_data=None):
         if schema_module_order:
             try:
                 # Map test module name to schema module name
-                schema_mod_name = test_module_to_schema_module(mod_name)
+                schema_mod_name = test_module_and_schema_module_to_other(mod_name)
                 idx = schema_module_order.index(schema_mod_name)
                 return (2, idx)
             except ValueError:
@@ -285,30 +318,37 @@ def verify_schema_matches_selection(schema_data, flavor, selected_modules, selec
             bridge_modules_to_check = [m for m in selected_modules if m not in (MODULE_CLOUD_CONNECTIVITY, MODULE_EDGE_MGMT)]
             for test_mod_name in bridge_modules_to_check:
                 # Map test module name to schema module name
-                schema_mod_name = test_module_to_schema_module(test_mod_name)
+                schema_mod_name = test_module_and_schema_module_to_other(test_mod_name)
                 if schema_mod_name not in schema_module_names:
                     warnings.append(f"Module '{test_mod_name}' may not be supported according to the uploaded schema")
     
     return len(errors) == 0, errors, warnings
 
-def check_certification_status(flavor, selected_modules, selected_tests, tests_schema):
+def check_certification_status(flavor, selected_modules, selected_tests, tests_schema, schema_data=None):
     """Check if the selection qualifies for certification or is test-only."""
     mandatory_modules = get_mandatory_modules_for_flavor(flavor)
+    mandatory_by_schema = get_mandatory_modules_by_schema(schema_data, flavor) if schema_data else []
     all_mandatory_tests = []
     
-    # Get all mandatory tests from mandatory modules
+    # Get selected module names (handle both dict and string formats)
+    selected_module_names = [m.get("name") if isinstance(m, dict) else m for m in selected_modules]
+    
+    # Get all mandatory tests from ALL selected modules (not just mandatory modules)
+    # When a module is selected, its mandatory tests become mandatory
     for mod in tests_schema.get("modules", []):
         mod_name = mod.get("name", "")
-        if mod_name in mandatory_modules:
+        if mod_name in selected_module_names:
             for test in mod.get("tests", []):
                 if test.get("meta", {}).get("mandatory", 0) == 1:
                     all_mandatory_tests.append(test.get("id"))
     
     # Check if all mandatory modules are selected
-    selected_module_names = [m.get("name") if isinstance(m, dict) else m for m in selected_modules]
     missing_modules = [m for m in mandatory_modules if m not in selected_module_names]
     
-    # Check if all mandatory tests are selected
+    # Check if all schema-mandatory modules are selected
+    missing_modules_by_schema = [m for m in mandatory_by_schema if m not in selected_module_names]
+    
+    # Check if all mandatory tests (from selected modules) are selected
     missing_tests = [t for t in all_mandatory_tests if t not in selected_tests]
     
     # Check for "at least one additional module" requirement for Bridge Only and Combo
@@ -319,9 +359,10 @@ def check_certification_status(flavor, selected_modules, selected_tests, tests_s
         if len(additional_modules) == 0:
             missing_additional_module = True
     
-    is_certified = len(missing_modules) == 0 and len(missing_tests) == 0 and not missing_additional_module
+    is_certified = (len(missing_modules) == 0 and len(missing_modules_by_schema) == 0 and 
+                   len(missing_tests) == 0 and not missing_additional_module)
     
-    return is_certified, missing_modules, missing_tests, missing_additional_module
+    return is_certified, missing_modules, missing_tests, missing_additional_module, missing_modules_by_schema
 
 def _prepare_form_data_for_template(session, cert_schema):
     """Prepare form_data for template, ensuring custom_broker_path is included if available."""
@@ -451,6 +492,7 @@ def step(step_num):
         session['selected_modules'] = []
         session['selected_tests'] = []
         session['form_data'] = {}
+        session['schema_mandatory_initialized'] = False
     
     title = "Run Certificate"
     tests_schema = web_utils.scan_tests_dir(CERT_TESTS_ROOT)
@@ -505,7 +547,22 @@ def step(step_num):
                             flavor = session.get('flavor')
                             if 'selected_modules' not in session or not session.get('selected_modules'):
                                 mandatory_modules = get_mandatory_modules_for_flavor(flavor)
-                                session['selected_modules'] = mandatory_modules
+                                # Add schema-mandatory modules
+                                schema_data = result  # result is the validated schema data
+                                mandatory_by_schema = get_mandatory_modules_by_schema(schema_data, flavor)
+                                all_mandatory = list(set(mandatory_modules + mandatory_by_schema))
+                                session['selected_modules'] = all_mandatory
+                                # Mark schema-mandatory modules as initialized
+                                session['schema_mandatory_initialized'] = True
+                            else:
+                                # If modules already exist, add schema-mandatory modules and mark as initialized
+                                schema_data = result
+                                mandatory_by_schema = get_mandatory_modules_by_schema(schema_data, flavor)
+                                current_modules = session.get('selected_modules', [])
+                                updated_modules = list(set(current_modules + mandatory_by_schema))
+                                if len(updated_modules) > len(current_modules):
+                                    session['selected_modules'] = updated_modules
+                                session['schema_mandatory_initialized'] = True
                             # For GW only, skip step 3 (modules)
                             if session.get('flavor') == FLAVOR_GW_ONLY:
                                 session['current_step'] = 4
@@ -681,9 +738,30 @@ def step(step_num):
     # This ensures mandatory items are only pre-checked at the beginning
     if flavor and not selected_modules:
         mandatory_modules = get_mandatory_modules_for_flavor(flavor)
-        selected_modules = mandatory_modules
+        # Add schema-mandatory modules if schema is available
+        schema_data = load_schema_data(schema_path) if schema_path else None
+        mandatory_by_schema = get_mandatory_modules_by_schema(schema_data, flavor) if schema_data else []
+        all_mandatory = list(set(mandatory_modules + mandatory_by_schema))
+        selected_modules = all_mandatory
         session['selected_modules'] = selected_modules
     
+    # Ensure schema-mandatory modules are added when first reaching step 3 (only if not already initialized)
+    # Use a session flag to track if schema-mandatory modules have been initialized
+    if step_num == 3 and flavor and schema_path:
+        schema_mandatory_initialized = session.get('schema_mandatory_initialized', False)
+        if not schema_mandatory_initialized:
+            schema_data = load_schema_data(schema_path) if schema_path else None
+            if schema_data:
+                mandatory_by_schema = get_mandatory_modules_by_schema(schema_data, flavor)
+                # Add schema-mandatory modules that aren't already selected
+                current_modules = session.get('selected_modules', [])
+                updated_modules = list(set(current_modules + mandatory_by_schema))
+                if len(updated_modules) > len(current_modules):
+                    selected_modules = updated_modules
+                    session['selected_modules'] = selected_modules
+                # Mark as initialized so we don't re-add them when going back
+                session['schema_mandatory_initialized'] = True
+    
     # Initialize mandatory tests only if not already in session and we have selected modules
     # Only initialize when first reaching step 4 (not on every GET request)
     if flavor and selected_modules and not selected_tests and step_num == 4:
@@ -720,11 +798,13 @@ def step(step_num):
     missing_tests = []
     missing_tests_details = []  # List of dicts with test id and label
     missing_additional_module = False
+    missing_modules_by_schema = []
     if step_num >= 4 and flavor and selected_modules and selected_tests:
         # Convert selected_modules to module dicts for check_certification_status
         module_dicts = [m for m in filtered_modules if m.get('name') in selected_modules]
-        is_certified, missing_modules, missing_tests, missing_additional_module = check_certification_status(
-            flavor, module_dicts, selected_tests, tests_schema
+        schema_data = load_schema_data(schema_path) if schema_path else None
+        is_certified, missing_modules, missing_tests, missing_additional_module, missing_modules_by_schema = check_certification_status(
+            flavor, module_dicts, selected_tests, tests_schema, schema_data
         )
         
         # Get test details (labels) for missing tests
@@ -751,6 +831,11 @@ def step(step_num):
             )
             schema_errors = errors
             schema_warnings = warnings
+            # Get missing schema-mandatory modules for display (recalculate if not already set)
+            if not missing_modules_by_schema and step_num >= 4 and flavor and selected_modules:
+                _, _, _, _, missing_modules_by_schema = check_certification_status(
+                    flavor, module_dicts, selected_tests, tests_schema, schema_data
+                )
     
     # Get CLI schemas for form fields - use certificate_cli for all flavors
     cert_cli = CertificateCLI()
@@ -770,6 +855,8 @@ def step(step_num):
     # Prepare data for JavaScript validation
     # Always initialize these to avoid Undefined errors in template
     mandatory_modules_for_js = get_mandatory_modules_for_flavor(flavor) if flavor else []
+    schema_data_for_js = load_schema_data(schema_path) if schema_path else None
+    mandatory_modules_by_schema_for_js = get_mandatory_modules_by_schema(schema_data_for_js, flavor) if (schema_data_for_js and flavor) else []
     mandatory_tests_for_js = []
     
     if step_num in [3, 4] and flavor:
@@ -839,7 +926,9 @@ def step(step_num):
                            missing_additional_module=missing_additional_module,
                            schema_errors=schema_errors,
                            schema_warnings=schema_warnings,
+                           missing_modules_by_schema=missing_modules_by_schema,
                            mandatory_modules_for_js=mandatory_modules_for_js,
+                           mandatory_modules_by_schema_for_js=mandatory_modules_by_schema_for_js,
                            mandatory_tests_for_js=mandatory_tests_for_js,
                            error=error,
                            warning=warning,
@@ -874,7 +963,8 @@ def execute_certificate():
     tests_schema = web_utils.scan_tests_dir(CERT_TESTS_ROOT)
     filtered_modules = filter_modules_by_flavor(tests_schema, flavor)
     module_dicts = [m for m in filtered_modules if m.get('name') in session.get('selected_modules', [])]
-    is_certified, _, _, _ = check_certification_status(flavor, module_dicts, selected_tests, tests_schema)
+    schema_data = load_schema_data(schema_path) if schema_path else None
+    is_certified, _, _, _, _ = check_certification_status(flavor, module_dicts, selected_tests, tests_schema, schema_data)
     
     full_cmd = []
     
@@ -1047,6 +1137,8 @@ def import_config():
 def clear_session():
     """Clear session and start fresh."""
     session.clear()
+    # Initialize session flags
+    session['schema_mandatory_initialized'] = False
     return redirect(url_for('step', step_num=1))
 
 @app.route("/parser")

gui_certificate/templates/cert_run.html

@@ -326,12 +326,15 @@
                                        name="modules[]" 
                                        id="module_{{ mod.name }}" 
                                        value="{{ mod.name }}"
-                                       {% if is_selected %}checked{% elif is_mandatory and not has_selections %}checked{% endif %}>
+                                       {% if is_selected or (is_mandatory and not has_selections) or (mod.is_mandatory_by_schema and not has_selections) %}checked{% endif %}>
                                 <label class="form-check-label" for="module_{{ mod.name }}" style="font-weight: bold; font-size: 1.1rem;">
                                     {{ mod.name }}
                                     {% if is_mandatory %}
                                         <span class="mandatory-badge">Mandatory</span>
                                     {% endif %}
+                                    {% if mod.is_mandatory_by_schema %}
+                                        <span class="mandatory-badge" style="background: #0066cc;">Mandatory by Schema</span>
+                                    {% endif %}
                                     {{ kb_link(mod_doc) }}
                                 </label>
                                 <p class="text-muted mt-1 mb-0">
@@ -644,12 +647,13 @@
                             {% endif %}
                             {% if missing_tests_details %}
                                 <div class="alert alert-warning">
-                                    <strong>Missing Mandatory Tests:</strong>
+                                    <strong>Missing Mandatory Tests from Selected Modules:</strong>
                                     <ul class="mb-0">
                                         {% for test in missing_tests_details %}
                                             <li>{{ test.label }} <small class="text-muted">({{ test.module }})</small></li>
                                         {% endfor %}
                                     </ul>
+                                    <small class="d-block mt-2">When a module is selected, its mandatory tests must also be selected.</small>
                                 </div>
                             {% endif %}
                         {% endif %}
@@ -662,7 +666,10 @@
                         <h5 class="mb-0">Schema Verification</h5>
                     </div>
                     <div class="card-body">
-                        {% if schema_errors or schema_warnings %}
+                        {% if schema_errors or schema_warnings or missing_modules_by_schema %}
+                            <p><strong>Schema Status:</strong> 
+                                <span class="badge bg-warning text-dark">SCHEMA DOES NOT MATCH RUN SETTINGS</span>
+                            </p>
                             {% if schema_errors %}
                                 <div class="alert alert-danger">
                                     <strong>Errors:</strong>
@@ -683,12 +690,24 @@
                                     </ul>
                                 </div>
                             {% endif %}
+                            {% if missing_modules_by_schema %}
+                                <div class="alert alert-warning mt-3">
+                                    <strong>Missing Modules Mandatory by Schema:</strong>
+                                    <ul class="mb-0">
+                                        {% for mod in missing_modules_by_schema %}
+                                            <li>{{ mod }}</li>
+                                        {% endfor %}
+                                    </ul>
+                                    <small class="d-block mt-2">These modules are declared in your validation schema but are not selected. They should be included for proper certification.</small>
+                                </div>
+                            {% endif %}
                         {% else %}
                             <p><strong>Schema Status:</strong> 
-                                <span class="badge bg-success">SCHEMA MATCHES TEST CONFIGURATION</span>
+                                <span class="badge bg-success">SCHEMA MATCHES RUN SETTINGS</span>
                                 <small class="text-muted d-block mt-1">The uploaded schema matches the selected flavor, modules, and tests</small>
                             </p>
                         {% endif %}
+                        
                     </div>
                 </div>
                 
@@ -843,6 +862,7 @@
             const brgCertSchema = {{ cert_schema|tojson|safe }};
             
             // Step 3: Module selection validation
+            const mandatoryModulesBySchema = {{ mandatory_modules_by_schema_for_js|tojson|safe }};
             function checkStep3Validation() {
                 if (stepNum !== 3) return;
                 
@@ -861,6 +881,14 @@
                     warnings.push('Missing mandatory modules: ' + missingMandatory.join(', '));
                 }
                 
+                // Check if schema-mandatory modules are deselected
+                if (mandatoryModulesBySchema && mandatoryModulesBySchema.length > 0) {
+                    const missingBySchema = mandatoryModulesBySchema.filter(m => !selectedModules.includes(m));
+                    if (missingBySchema.length > 0) {
+                        warnings.push('Missing modules mandatory by schema: ' + missingBySchema.join(', '));
+                    }
+                }
+                
                 // Check Bridge/Combo requirement for at least one additional module
                 if (selectedFlavor === 'bridge_only' || selectedFlavor === 'combo') {
                     const nonMandatorySelected = selectedModules.filter(m => !mandatoryModules.includes(m));
@@ -903,12 +931,21 @@
                     warnings.push('Missing mandatory modules: ' + missingMandatoryModules.join(', '));
                 }
                 
-                // Check if mandatory tests are deselected
+                // Check if schema-mandatory modules are deselected
+                if (mandatoryModulesBySchema && mandatoryModulesBySchema.length > 0) {
+                    const missingBySchema = mandatoryModulesBySchema.filter(m => !selectedModules.includes(m));
+                    if (missingBySchema.length > 0) {
+                        warnings.push('Missing modules mandatory by schema: ' + missingBySchema.join(', '));
+                    }
+                }
+                
+                // Check if mandatory tests from selected modules are deselected
+                // When a module is selected, its mandatory tests become mandatory
                 const missingMandatoryTests = mandatoryTests
                     .filter(t => selectedModules.includes(t.module) && !selectedTests.includes(t.id))
                     .map(t => t.label + ' (' + t.module + ')');
                 if (missingMandatoryTests.length > 0) {
-                    warnings.push('Missing mandatory tests: ' + missingMandatoryTests.length + ' test(s)');
+                    warnings.push('Missing mandatory tests from selected modules: ' + missingMandatoryTests.length + ' test(s)');
                 }
                 
                 if (warnings.length > 0) {

{wiliot_certificate-4.5.0a1.dist-info → wiliot_certificate-4.5.0a3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wiliot_certificate
-Version: 4.5.0a1
+Version: 4.5.0a3
 Summary: A library for certifying Wiliot-compliant boards
 Author-email: Wiliot <support@wiliot.com>
 License-Expression: MIT
@@ -30,35 +30,60 @@ Requires-Dist: reportlab>=4.3.1
 Requires-Dist: google-api-python-client>=2.162.0
 Dynamic: license-file
 
-# wiliot-certificate Version 4.5.0
+# wiliot-certificate
 
 <!-- Description -->
 wiliot-certificate is a Python library that provides tools for testing and certifying boards for compatibility with Wiliot’s ecosystem.
-This python package includes the following CLI utilities:
+This python package includes the following tools:
  - Certification Wizard (`wlt-cert`)
  - Certificate CLI (`wlt-cert-cli`)
  - Tester Upgrade (`wlt-cert-tester-upgrade`)
  - Registration Certificate (`wlt-cert-reg`)
 
-# Version: 
-wiliot-certificate versions 4.5.0 are compatible with firmware version >=4.5.0 (API VERSION: 13)
+# Versioning: 
+wiliot-certificate versions 4.5.x are compatible with firmware version >=4.5.0 (API VERSION: 13)
 
 ## Installing wiliot-certificate
-Install wiliot-certificate:
 ````commandline
 pip install wiliot-certificate
 ````
 
 ## Using wiliot-certificate
 ### Certification
-In terminal, run:
 ````commandline
 wlt-cert
 ````
-<!-- This tool walks you through... TODO -->
-<!-- You need to have a json validation schema <LINK>, certification tester & custom broker file <LINK> -->
+This tool is the default to test and certify your device.
+It runs a setup wizard that walks you through the initialization steps before running the tests.
+You'll need a [validation schema](https://community.wiliot.com/customers/s/article/Validation-Schema), tester device and custom broker json file ([more info here](https://community.wiliot.com/customers/s/article/Wiliot-Gateway-Certification)).
+Once set up it opens a terminal and tests your device.
 
-#### The following capabilities are not tested in this version
+
+
+### Certificate CLI
+````commandline
+wlt-cert-cli -h
+````
+CLI version of the certificate. Use -h for details on the different arguments.
+
+
+### Tester Upgrade
+````commandline
+wlt-cert-tester-upgrade
+````
+Upgrades the firmware of the tester device to the version required for certification.
+
+
+### Registration Certificate
+````commandline
+wlt-cert-reg
+````
+Certify the gateway registration process to Wiliot platform.
+The gateway must use Wiliot production MQTT broker, and mustn't be registered to any account on Wiliot platform.
+Use -h for details on the arguments. [More info here](https://community.wiliot.com/customers/s/article/Wiliot-Gateway-Certification)
+
+
+## The following capabilities are not tested in this version
 ##### Cloud Connectivity & Misc
  - Board type registered within the Board Type Management system
  - Bridge OTA progress reporting
@@ -82,29 +107,3 @@ wlt-cert
 ##### Calibration 
   - Functionality of output power and interval calibration 
   - Functionality of calibration transmission patterns for the configuration STANDARD & EU & DISABLE
-
-
-### Certificate CLI
-In terminal, run:
-````commandline
-wlt-cert-cli -h
-````
-CLI version of the certificate. Use -h for details on the different arguments.
-
-
-### Tester Upgrade
-In terminal, run:
-````commandline
-wlt-cert-tester-upgrade
-````
-Upgrades the firmware of the tester device to the version required for certification.
-
-
-### Registration Certificate
-In terminal, run:
-````commandline
-wlt-cert-reg
-````
-Certify the gateway registration process to Wiliot platform.
-The gateway must use Wiliot production MQTT broker, and mustn't be registered to any account on Wiliot platform.
-Use -h for details on the arguments. <!-- More info can be found in TODO link-->