feat(generator): full engine rewrite honouring every wizard knob

The vendored fm_generator was wiring a handful of parameters (feature
count, relation mix, bool-connective probs) and silently ignoring the
rest — Arithmetic level, Type level, aggregate functions, string
constraints, feature cardinality, GROUP_CARDINALITY toggle, attribute
type distribution, MIN/MAX_VARS_PER_CONSTRAINT, ENSURE_SATISFIABLE,
filename suffixes, PROB_LEN_FUNCTION, CTC_DIST_* — were all noop.

Changes
- Rewrite operations/generate_models.py so every Params field is
  consumed. Added arithmetic, aggregate and string constraint builders
  with correct operator distributions and gated by the level flags.
- Rewrite models/models.py with an ENSURE_SATISFIABLE retry loop
  (pysat) and filename suffix composition from counts of features /
  constraints.
- Expose missing knobs in the frontend: DIST_BOOLEAN/INTEGER/REAL/STRING
  in step4 and CTC_DIST_BOOLEAN/INTEGER/REAL/STRING in step3, each
  gated by the step2 major/minor level selection. Sum-to-1 validation
  with live badges. Disabled probability fields submit 0.0 so inactive
  types can't skew the distribution.
- Rebuild the fm_generator wheel shipped to Pyodide.

Tests
- New test_engine.py (31 cases): every level and probability knob
  asserted directly against generate_single_model output.
- New test_wizard_outputs.py (140 cases): POST full wizard configs,
  feed the resulting Params through the engine, parse the UVL and
  assert the output matches what the user selected — level combos,
  operator dominance, cardinality bounds, filename suffixes, etc.
- Updated legacy wizard-flow test defaults for the new required
  dist fields.

Author: drorganvidez

app/modules/generator/assets/js/fm_generator-0.0.1-py3-none-any.whl

@@ -732,6 +732,31 @@ def validate_step3_form(form, max_features: int = 10000):
         except Exception:
             errors["prob_len"] = "Value must be a decimal between 0 and 1."
 
+    # 8b) CTC TYPE DISTRIBUTION (CTC_DIST_BOOLEAN/INTEGER/REAL/STRING)
+    # Only required if the user has enabled any non-Boolean level in step2.
+    # Otherwise the section is hidden and the default 100% boolean holds.
+    arithmetic_level_checked = form.get("arithmetic_level") in ["on", "true", "1", True]
+    if arithmetic_level_checked or type_level_checked:
+        ctc_fields = [
+            ("ctc_dist_boolean", True),
+            ("ctc_dist_integer", arithmetic_level_checked),
+            ("ctc_dist_real", arithmetic_level_checked),
+            ("ctc_dist_string", type_level_checked and string_constraints_checked),
+        ]
+        active_sum = 0.0
+        for field, active in ctc_fields:
+            v = _safe_float(form.get(field), 0.0)
+            if not active:
+                v = 0.0
+            if not (0.0 <= v <= 1.0):
+                errors[field] = "Value must be between 0 and 1."
+            values[field] = v
+            if active:
+                active_sum += v
+        if abs(active_sum - 1.0) > 0.001:
+            errors["ctc_dist_sum"] = f"Current sum: {active_sum:.4f}. Active type probabilities must total 1.0."
+        values["ctc_dist_sum"] = f"{active_sum:.4f}"
+
     # 9) GUARDAR TODOS LOS VALORES PARA REPINTAR EL FORMULARIO
     for k in form:
         values[k] = form[k]
@@ -921,6 +946,28 @@ def step3():
         else:
             params_dict["PROB_LEN_FUNCTION"] = 0.0
 
+        # Cross-tree constraint TYPE distribution (CTC_DIST_*). Inactive
+        # levels are pinned to 0 so a stale POST value can't skew the mix.
+        params_dict["CTC_DIST_BOOLEAN"] = _safe_float(request.form.get("ctc_dist_boolean"), 0.7)
+        if arithmetic_level_enabled:
+            params_dict["CTC_DIST_INTEGER"] = _safe_float(request.form.get("ctc_dist_integer"), 0.2)
+            params_dict["CTC_DIST_REAL"] = _safe_float(request.form.get("ctc_dist_real"), 0.1)
+        else:
+            params_dict["CTC_DIST_INTEGER"] = 0.0
+            params_dict["CTC_DIST_REAL"] = 0.0
+        if type_level_enabled and string_constraints_enabled:
+            params_dict["CTC_DIST_STRING"] = _safe_float(request.form.get("ctc_dist_string"), 0.0)
+        else:
+            params_dict["CTC_DIST_STRING"] = 0.0
+        _ctc_keys = ["CTC_DIST_BOOLEAN", "CTC_DIST_INTEGER", "CTC_DIST_REAL", "CTC_DIST_STRING"]
+        _ctc_total = sum(params_dict[k] for k in _ctc_keys)
+        if _ctc_total > 0:
+            for k in _ctc_keys:
+                params_dict[k] = round(params_dict[k] / _ctc_total, 6)
+            params_dict[_ctc_keys[0]] += round(1.0 - sum(params_dict[k] for k in _ctc_keys), 6)
+        else:
+            params_dict["CTC_DIST_BOOLEAN"] = 1.0
+
         # Renormalise the Boolean-connective probabilities to sum EXACTLY 1.0.
         # Params.__post_init__ enforces a 1e-6 tolerance; the form-side
         # normaliser rounds to 4 decimals, which can leave residue.
@@ -967,6 +1014,11 @@ def step3():
         "boolop_sum": "1.0000",
         "arithmetic_sum": "1.0000",
         "cmp_sum": "1.0000",
+        "ctc_dist_sum": "1.0000",
+        "ctc_dist_boolean": params_dict.get("CTC_DIST_BOOLEAN", 0.7),
+        "ctc_dist_integer": params_dict.get("CTC_DIST_INTEGER", 0.2),
+        "ctc_dist_real": params_dict.get("CTC_DIST_REAL", 0.1),
+        "ctc_dist_string": params_dict.get("CTC_DIST_STRING", 0.0),
         "arithmetic_level": params_dict.get("ARITHMETIC_LEVEL", False),
         "aggregate_functions": params_dict.get("AGGREGATE_FUNCTIONS", False),
         "type_level": params_dict.get("TYPE_LEVEL", False),
@@ -1085,6 +1137,29 @@ def validate_step4_form(form, params_dict=None):
         values["min_attributes"] = min_attr_val
         values["max_attributes"] = max_attr_val
 
+        # Attribute-type distribution: must total 1.0 across active types.
+        # Disabled types are forced to 0 server-side so a stale POST value
+        # can't skew the distribution.
+        dist_fields = [
+            ("dist_boolean", True),
+            ("dist_integer", arithmetic_level_enabled),
+            ("dist_real", arithmetic_level_enabled),
+            ("dist_string", type_level_enabled),
+        ]
+        active_total = 0.0
+        for field, active in dist_fields:
+            v = _safe_float(form.get(field), 0.0)
+            if not active:
+                v = 0.0
+            if not (0.0 <= v <= 1.0):
+                errors[field] = "Value must be between 0 and 1."
+            values[field] = v
+            if active:
+                active_total += v
+        if abs(active_total - 1.0) > 0.001:
+            errors["attr_dist_sum"] = f"Current sum: {active_total:.4f}. Active type probabilities must total 1.0."
+        values["attr_dist_sum"] = f"{active_total:.4f}"
+
     else:
         values["min_attributes"] = ""
         values["max_attributes"] = ""
@@ -1300,6 +1375,27 @@ def _apply_step4_form(params_dict, form):
         params_dict["ATTRIBUTES_LIST"] = []
         params_dict["ATTRIBUTE_ATTACH_PROBS"] = []
         params_dict["ATTRIBUTE_IN_CONSTRAINTS"] = []
+        # Attribute-type distribution. Inactive types (gated by step2 levels)
+        # are forced to 0 here so the dataclass invariant "sum over active
+        # kinds == 1" survives even if the user tampers with the form.
+        arith_on = bool(params_dict.get("ARITHMETIC_LEVEL", False))
+        type_on = bool(params_dict.get("TYPE_LEVEL", False))
+        dist = {
+            "DIST_BOOLEAN": _safe_float(form.get("dist_boolean"), 0.7),
+            "DIST_INTEGER": _safe_float(form.get("dist_integer"), 0.0) if arith_on else 0.0,
+            "DIST_REAL": _safe_float(form.get("dist_real"), 0.0) if arith_on else 0.0,
+            "DIST_STRING": _safe_float(form.get("dist_string"), 0.0) if type_on else 0.0,
+        }
+        active_sum = sum(v for v in dist.values())
+        if active_sum > 0:
+            for k in dist:
+                dist[k] = round(dist[k] / active_sum, 6)
+            # Absorb rounding residue into the dominant active component so
+            # the sum lands exactly on 1.0.
+            residue = round(1.0 - sum(dist.values()), 6)
+            dominant = max(dist, key=dist.get)
+            dist[dominant] = round(dist[dominant] + residue, 6)
+        params_dict.update(dist)
     else:
         attrs, probs, in_ctc = _collect_step4_attributes(form, params_dict)
         params_dict["MIN_ATTRIBUTES"] = None
@@ -1343,6 +1439,11 @@ def step4():
         "min_attributes": params_dict.get("MIN_ATTRIBUTES", 1),
         "max_attributes": params_dict.get("MAX_ATTRIBUTES", 5),
         "attributes_list": params_dict.get("ATTRIBUTES_LIST", []),
+        "dist_boolean": params_dict.get("DIST_BOOLEAN", 0.7),
+        "dist_integer": params_dict.get("DIST_INTEGER", 0.1),
+        "dist_real": params_dict.get("DIST_REAL", 0.1),
+        "dist_string": params_dict.get("DIST_STRING", 0.1),
+        "attr_dist_sum": "1.0000",
     }
 
     values = load_step_state(4, default_values)

app/modules/generator/routes.py

@@ -117,8 +117,8 @@ <h4 class="fw-bold text-gray-900 mb-1">{{ title }}</h4>
 </div>
 {%- endmacro %}
 
-{%- macro probability_field(name, label, tip, values, errors, default=0.0, symbol=None) -%}
-<div class="col">
+{%- macro probability_field(name, label, tip, values, errors, default=0.0, symbol=None, disabled=False) -%}
+<div class="col{% if disabled %} opacity-50{% endif %}">
     <label for="{{ name }}" class="form-label fs-7 text-gray-700 d-flex align-items-center">
         {% if symbol %}<span class="fs-5 fw-bold text-gray-900 me-1">{{ symbol }}</span>{% endif %}
         {{ label }}
@@ -129,7 +129,13 @@ <h4 class="fw-bold text-gray-900 mb-1">{{ title }}</h4>
            name="{{ name }}"
            class="form-control form-control-solid"
            step="0.01" min="0" max="1"
-           value="{{ values.get(name, default) }}">
+           value="{{ values.get(name, 0.0 if disabled else default) }}"
+           {% if disabled %}disabled data-force-zero="1"{% endif %}>
+    {% if disabled %}
+        {# A disabled input won't submit; mirror the value so the server still
+           sees 0 for this field and the distribution stays consistent. #}
+        <input type="hidden" name="{{ name }}" value="0.0">
+    {% endif %}
     {% if errors.get(name) %}
         <div class="text-danger fs-7 mt-1">{{ errors[name] }}</div>
     {% endif %}

app/modules/generator/templates/generator/_macros.html

@@ -31,6 +31,35 @@
             'Maximum times a feature can appear in each constraint. Must be ≤ Max variables per constraint.',
             values, errors, default=1, min=1, max=10000) }}
 
+        {% if values.get('arithmetic_level') or values.get('type_level') %}
+        <div class="separator separator-dashed my-9"></div>
+
+        {{ section('Constraint type distribution',
+            'How often a constraint is Boolean, arithmetic (integer/real attributes) or string. Disabled levels always score 0. Active values must add up to 1.') }}
+
+        <div class="row g-3 mb-2">
+            {{ probability_field('ctc_dist_boolean', 'Boolean',
+                'Probability of a pure Boolean constraint (features and negations only).',
+                values, errors, default=0.7, symbol='B') }}
+            {{ probability_field('ctc_dist_integer', 'Integer',
+                'Probability of a constraint involving integer attributes. Requires Arithmetic level.',
+                values, errors, default=0.2, symbol='ℤ',
+                disabled=(not values.get('arithmetic_level'))) }}
+            {{ probability_field('ctc_dist_real', 'Real',
+                'Probability of a constraint involving real attributes. Requires Arithmetic level.',
+                values, errors, default=0.1, symbol='ℝ',
+                disabled=(not values.get('arithmetic_level'))) }}
+            {{ probability_field('ctc_dist_string', 'String',
+                'Probability of a constraint involving string attributes. Requires Type level.',
+                values, errors, default=0.0, symbol='S',
+                disabled=(not values.get('string_constraints'))) }}
+        </div>
+        {{ sum_badge('ctc_dist_sum', 'Sum of active type probabilities', initial=values.get('ctc_dist_sum', '1.0000')) }}
+        {% if errors.get('ctc_dist_sum') %}
+            <div class="text-danger fs-7 mt-1">{{ errors['ctc_dist_sum'] }}</div>
+        {% endif %}
+        {% endif %}
+
         <div class="separator separator-dashed my-9"></div>
 
         <!-- Boolean operators -->
@@ -204,6 +233,22 @@
         });
         updateSum(cmp_ids, 'cmp_sum');
     }
+
+    // CTC type distribution — sum only the *enabled* (non-disabled) inputs
+    // so the section stays coherent with step2's major/minor level toggles.
+    if (document.getElementById('ctc_dist_sum')) {
+        const ctc_ids = ['ctc_dist_boolean', 'ctc_dist_integer', 'ctc_dist_real', 'ctc_dist_string'];
+        const activeCtc = () => ctc_ids.filter(id => {
+            const el = document.getElementById(id);
+            return el && !el.disabled;
+        });
+        const updateCtcSum = () => updateSum(activeCtc(), 'ctc_dist_sum');
+        ctc_ids.forEach(id => {
+            const el = document.getElementById(id);
+            if (el) el.addEventListener('input', updateCtcSum);
+        });
+        updateCtcSum();
+    }
 })();
 </script>
 {% endblock %}

app/modules/generator/templates/generator/step3.html

@@ -1,5 +1,5 @@
 {% extends "generator/index.html" %}
-{% from "generator/_macros.html" import info, section, range_field %}
+{% from "generator/_macros.html" import info, section, range_field, probability_field, sum_badge %}
 
 {% block title %}Generate random feature models{% endblock %}
 
@@ -36,7 +36,32 @@
             {{ range_field('min_attributes', 'max_attributes', 'Number of attributes',
                 'Min / Max number of attributes sampled per model when the random mode is on.',
                 values, errors, default_min=1, default_max=5, hard_min=1, hard_max=10000) }}
-            <div class="text-gray-600 fs-7">Min must be ≤ Max.</div>
+            <div class="text-gray-600 fs-7 mb-5">Min must be ≤ Max.</div>
+
+            {{ section('Attribute type distribution',
+                'When sampling each attribute, how likely is each UVL type to be chosen. Integer/Real are only active with the Arithmetic level; String is only active with the Type level. Active values must add up to 1.') }}
+
+            <div class="row g-3 mb-2">
+                {{ probability_field('dist_boolean', 'Boolean',
+                    'Probability of a boolean attribute.',
+                    values, errors, default=0.7, symbol='B') }}
+                {{ probability_field('dist_integer', 'Integer',
+                    'Probability of an integer attribute. Requires Arithmetic level.',
+                    values, errors, default=0.1, symbol='ℤ',
+                    disabled=(not arithmetic_level)) }}
+                {{ probability_field('dist_real', 'Real',
+                    'Probability of a real-valued attribute. Requires Arithmetic level.',
+                    values, errors, default=0.1, symbol='ℝ',
+                    disabled=(not arithmetic_level)) }}
+                {{ probability_field('dist_string', 'String',
+                    'Probability of a string attribute. Requires Type level.',
+                    values, errors, default=0.1, symbol='S',
+                    disabled=(not type_level)) }}
+            </div>
+            {{ sum_badge('attr_dist_sum', 'Sum of active type probabilities', initial=values.get('attr_dist_sum', '1.0000')) }}
+            {% if errors.get('attr_dist_sum') %}
+                <div class="text-danger fs-7 mt-1">{{ errors['attr_dist_sum'] }}</div>
+            {% endif %}
         </div>
 
         <!-- Manual mode -->
@@ -316,6 +341,33 @@ <h5 class="fw-bold text-gray-900 mb-0">Attribute #${idx + 1}</h5>
 }
 updateManualAttributesGlobalError();
 
+// ─── Attribute-type distribution live sum ───────────────────────────────
+(function () {
+    const badge = document.getElementById('attr_dist_sum');
+    if (!badge) return;
+    const active = ['dist_boolean']
+        .concat(arithmeticLevelEnabled ? ['dist_integer', 'dist_real'] : [])
+        .concat(typeLevelEnabled ? ['dist_string'] : []);
+    function update() {
+        let s = 0;
+        active.forEach((id) => {
+            const el = document.getElementById(id);
+            if (el && !el.disabled) s += parseFloat(el.value) || 0;
+        });
+        badge.innerText = s.toFixed(4);
+        badge.classList.remove('badge-light-success', 'badge-light-danger');
+        badge.classList.add(Math.abs(s - 1.0) < 0.001 ? 'badge-light-success' : 'badge-light-danger');
+    }
+    active.forEach((id) => {
+        const el = document.getElementById(id);
+        if (el) {
+            el.addEventListener('input', update);
+            el.addEventListener('change', update);
+        }
+    });
+    update();
+})();
+
 function updateUseInConstraintsAvailability(card, type, idx) {
     const cb = card.querySelector(`[name="attr_use_in_constraints_${idx}"]`);
     const hint = card.querySelector('.attr-use-in-constraints-hint');