flamapy-z3 2.1.0.dev1__tar.gz → 2.5.0.dev0__tar.gz

flamapy_z3-2.5.0.dev0/PKG-INFO

@@ -0,0 +1,202 @@
+Metadata-Version: 2.4
+Name: flamapy-z3
+Version: 2.5.0.dev0
+Summary: z3-plugin for the automated analysis of feature models
+Author-email: Flamapy <flamapy@us.es>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/flamapy/z3_metamodel
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: flamapy-fw~=2.5.0.dev0
+Requires-Dist: flamapy-fm~=2.5.0.dev0
+Requires-Dist: z3-solver~=4.14.1.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: prospector; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+
+# Automated Analysis of UVL using Satisfiability Modulo Theories
+
+
+## Description
+This repository contains the plugin that supports z3 representations for feature models.
+
+The plugin is based on [flamapy](https://flamapy.github.io/), and relies on the [Z3 solver](https://github.com/Z3Prover/z3?tab=readme-ov-file) library. The architecture is as follows:
+
+<p align="center">
+  <img width="750" src="resources/images/z3metamodel.png">
+</p>
+
+
+## Requirements and Installation
+- [Python 3.11+](https://www.python.org/)
+- [Flamapy](https://www.flamapy.org/)
+
+The framework has been tested in Linux and Windows 11 with Python 3.12. Python 3.13+ may not be still supported.
+
+### Download and installation
+1. Install [Python 3.11+](https://www.python.org/).
+2. Download/Clone this repository and enter into the main directory.
+3. Create a virtual environment: `python -m venv env`
+4. Activate the environment: 
+   
+   In Linux: `source env/bin/activate`
+
+   In Windows: `.\env\Scripts\Activate`
+
+5. Install dependencies (flamapy): `pip install -r requirements.txt`
+     
+    ** In case that you are running Ubuntu and get an error installing flamapy, please install the package python3-dev with the command `sudo apt update && sudo apt install python3-dev` and update wheel and setuptools with the command `pip  install --upgrade pip wheel setuptools` before step 5.
+
+
+## Functionality and usage
+The executable script [test.py](/test.py) serves as an entry point to show the plugin in action.
+
+Simply run: `python test.py` to see it in action over the running feature model presented in the paper.
+
+The following functionality is provided:
+
+
+### Load a feature model in UVL and translate to SMT
+```python
+from flamapy.metamodels.fm_metamodel.transformations import UVLReader
+from flamapy.metamodels.z3_metamodel.transformations import FmToZ3
+
+# Load the feature model from UVL
+fm_model = UVLReader('resources/models/uvl_models/Pizza_z3.uvl').transform()
+# Transform the feature model to SMT
+z3_model = FmToZ3(fm_model).transform()
+```
+
+### Analysis operations
+The following operations are available:
+```python
+from flamapy.metamodels.z3_metamodel.operations import (
+    Z3Satisfiable,
+    Z3Configurations,
+    Z3ConfigurationsNumber,
+    Z3CoreFeatures,
+    Z3DeadFeatures,
+    Z3FalseOptionalFeatures,
+    Z3AttributeOptimization,
+    Z3SatisfiableConfiguration,
+    Z3FeatureBounds,
+    Z3AllFeatureBounds,
+)
+```
+
+- **Satisfiable**
+
+    Return whether the model is satisfiable (valid):
+    ```python
+    satisfiable = Z3Satisfiable().execute(z3_model).get_result()
+    print(f'Satisfiable? (valid?): {satisfiable}')
+    ```
+
+- **Core features**
+
+    Return the core features of the model:
+    ```python
+    core_features = Z3CoreFeatures().execute(z3_model).get_result()
+    print(f'Core features: {core_features}')
+    ```
+
+- **Dead features**
+
+    Return the dead features of the model:
+    ```python
+    dead_features = Z3DeadFeatures().execute(z3_model).get_result()
+    print(f'Dead features: {dead_features}')
+    ```
+
+- **False-Optional features**
+
+    Return the false-optional features of the model:
+    ```python
+    false_optional_features = Z3FalseOptionalFeatures().execute(z3_model).get_result()
+    print(f'False-optional features: {false_optional_features}')
+    ```    
+
+- **Configurations**
+
+    Enumerate the configurations of the model:
+    ```python
+    configurations = Z3Configurations().execute(z3_model).get_result()
+    print(f'Configurations: {len(configurations)}')
+    for i, config in enumerate(configurations, 1):
+        config_str = ', '.join(f'{f}={v}' if not isinstance(v, bool) else f'{f}' for f,v in config.elements.items() if config.is_selected(f))
+        print(f'Config. {i}: {config_str}')
+    ```
+
+- **Configurations number**
+
+    Return the number of configurations:
+    ```python
+    n_configs = Z3ConfigurationsNumber().execute(z3_model).get_result()
+    print(f'Configurations number: {n_configs}')
+    ```
+
+- **Boundaries analysis of typed features**
+
+    Return the boundaries of the numerical features (Integer, Real, String) of the model:
+    ```python
+    attributes = fm_model.get_attributes()
+    print('Attributes in the model')
+    for attr in attributes:
+        print(f' - {attr.name} ({attr.attribute_type})')
+    
+    variable_bounds = Z3AllFeatureBounds().execute(z3_model).get_result()
+    print('Variable bounds for all typed variables:')
+    for var_name, bounds in variable_bounds.items():
+        print(f' - {var_name}: {bounds}')
+    ```    
+
+- **Configuration optimization based on feature attributes:**
+
+    Return the set of configurations that optimize the given goals (i.e., the pareto front):
+    ```python
+    attribute_optimization_op = Z3AttributeOptimization()
+    attributes = {'Price': OptimizationGoal.MAXIMIZE,
+                  'Kcal': OptimizationGoal.MINIMIZE}
+    attribute_optimization_op.set_attributes(attributes)
+    configurations_with_values = attribute_optimization_op.execute(z3_model).get_result()
+    print(f'Optimum configurations: {len(configurations_with_values)} configs.')
+    for i, config_value in enumerate(configurations_with_values, 1):
+        config, values = config_value
+        config_str = ', '.join(f'{f}={v}' if not isinstance(v, bool) else f'{f}' for f,v in config.elements.items() if config.is_selected(f))
+        values_str = ', '.join(f'{k}={v}' for k,v in values.items())
+        print(f'Config. {i}: {config_str} | Values: {values_str}')
+    ```    
+
+- Configuration validation:
+
+    Return whether a given partial or full configuration is valid:
+    ```python
+    from flamapy.metamodels.configuration_metamodel.transformations import ConfigurationJSONReader
+    configuration = ConfigurationJSONReader('resources/configs/pizza_z3_config1.json').transform()
+    configuration.set_full(False)
+    print(f'Configuration: {configuration.elements}')
+    satisfiable_configuration_op = Z3SatisfiableConfiguration()
+    satisfiable_configuration_op.set_configuration(configuration)
+    is_satisfiable = satisfiable_configuration_op.execute(z3_model).get_result()
+    print(f'Is the configuration satisfiable? {is_satisfiable}')
+    ```    
+
+**Note:** The Z3Configurations and Z3ConfigurationsNumber operations may takes longer if the number of configuration is huge, or even not finish if the model is unbounded.
+
+**Note:** The Z3Configurations and Z3ConfigurationsNumber operations support also a partial configuration as an additional argument, so the operation will return the result taking into account the given partial configuration. 
+For example:
+
+```python
+from flamapy.core.models import Configuration
+# Create a partial configuration
+elements = {'Pizza': True, 'SpicyLvl': 5}
+partial_config = Configuration(elements)
+# Calculate the number of configuration from the partial configuration
+configs_number_op = Z3ConfigurationsNumber()
+configs_number_op.set_partial_configuration(partial_config)
+n_configs = configs_number_op.execute(z3_model).get_result()
+print(f'#Configurations: {n_configs}')
+```

flamapy_z3-2.5.0.dev0/README.md

@@ -0,0 +1,183 @@
+# Automated Analysis of UVL using Satisfiability Modulo Theories
+
+
+## Description
+This repository contains the plugin that supports z3 representations for feature models.
+
+The plugin is based on [flamapy](https://flamapy.github.io/), and relies on the [Z3 solver](https://github.com/Z3Prover/z3?tab=readme-ov-file) library. The architecture is as follows:
+
+<p align="center">
+  <img width="750" src="resources/images/z3metamodel.png">
+</p>
+
+
+## Requirements and Installation
+- [Python 3.11+](https://www.python.org/)
+- [Flamapy](https://www.flamapy.org/)
+
+The framework has been tested in Linux and Windows 11 with Python 3.12. Python 3.13+ may not be still supported.
+
+### Download and installation
+1. Install [Python 3.11+](https://www.python.org/).
+2. Download/Clone this repository and enter into the main directory.
+3. Create a virtual environment: `python -m venv env`
+4. Activate the environment: 
+   
+   In Linux: `source env/bin/activate`
+
+   In Windows: `.\env\Scripts\Activate`
+
+5. Install dependencies (flamapy): `pip install -r requirements.txt`
+     
+    ** In case that you are running Ubuntu and get an error installing flamapy, please install the package python3-dev with the command `sudo apt update && sudo apt install python3-dev` and update wheel and setuptools with the command `pip  install --upgrade pip wheel setuptools` before step 5.
+
+
+## Functionality and usage
+The executable script [test.py](/test.py) serves as an entry point to show the plugin in action.
+
+Simply run: `python test.py` to see it in action over the running feature model presented in the paper.
+
+The following functionality is provided:
+
+
+### Load a feature model in UVL and translate to SMT
+```python
+from flamapy.metamodels.fm_metamodel.transformations import UVLReader
+from flamapy.metamodels.z3_metamodel.transformations import FmToZ3
+
+# Load the feature model from UVL
+fm_model = UVLReader('resources/models/uvl_models/Pizza_z3.uvl').transform()
+# Transform the feature model to SMT
+z3_model = FmToZ3(fm_model).transform()
+```
+
+### Analysis operations
+The following operations are available:
+```python
+from flamapy.metamodels.z3_metamodel.operations import (
+    Z3Satisfiable,
+    Z3Configurations,
+    Z3ConfigurationsNumber,
+    Z3CoreFeatures,
+    Z3DeadFeatures,
+    Z3FalseOptionalFeatures,
+    Z3AttributeOptimization,
+    Z3SatisfiableConfiguration,
+    Z3FeatureBounds,
+    Z3AllFeatureBounds,
+)
+```
+
+- **Satisfiable**
+
+    Return whether the model is satisfiable (valid):
+    ```python
+    satisfiable = Z3Satisfiable().execute(z3_model).get_result()
+    print(f'Satisfiable? (valid?): {satisfiable}')
+    ```
+
+- **Core features**
+
+    Return the core features of the model:
+    ```python
+    core_features = Z3CoreFeatures().execute(z3_model).get_result()
+    print(f'Core features: {core_features}')
+    ```
+
+- **Dead features**
+
+    Return the dead features of the model:
+    ```python
+    dead_features = Z3DeadFeatures().execute(z3_model).get_result()
+    print(f'Dead features: {dead_features}')
+    ```
+
+- **False-Optional features**
+
+    Return the false-optional features of the model:
+    ```python
+    false_optional_features = Z3FalseOptionalFeatures().execute(z3_model).get_result()
+    print(f'False-optional features: {false_optional_features}')
+    ```    
+
+- **Configurations**
+
+    Enumerate the configurations of the model:
+    ```python
+    configurations = Z3Configurations().execute(z3_model).get_result()
+    print(f'Configurations: {len(configurations)}')
+    for i, config in enumerate(configurations, 1):
+        config_str = ', '.join(f'{f}={v}' if not isinstance(v, bool) else f'{f}' for f,v in config.elements.items() if config.is_selected(f))
+        print(f'Config. {i}: {config_str}')
+    ```
+
+- **Configurations number**
+
+    Return the number of configurations:
+    ```python
+    n_configs = Z3ConfigurationsNumber().execute(z3_model).get_result()
+    print(f'Configurations number: {n_configs}')
+    ```
+
+- **Boundaries analysis of typed features**
+
+    Return the boundaries of the numerical features (Integer, Real, String) of the model:
+    ```python
+    attributes = fm_model.get_attributes()
+    print('Attributes in the model')
+    for attr in attributes:
+        print(f' - {attr.name} ({attr.attribute_type})')
+    
+    variable_bounds = Z3AllFeatureBounds().execute(z3_model).get_result()
+    print('Variable bounds for all typed variables:')
+    for var_name, bounds in variable_bounds.items():
+        print(f' - {var_name}: {bounds}')
+    ```    
+
+- **Configuration optimization based on feature attributes:**
+
+    Return the set of configurations that optimize the given goals (i.e., the pareto front):
+    ```python
+    attribute_optimization_op = Z3AttributeOptimization()
+    attributes = {'Price': OptimizationGoal.MAXIMIZE,
+                  'Kcal': OptimizationGoal.MINIMIZE}
+    attribute_optimization_op.set_attributes(attributes)
+    configurations_with_values = attribute_optimization_op.execute(z3_model).get_result()
+    print(f'Optimum configurations: {len(configurations_with_values)} configs.')
+    for i, config_value in enumerate(configurations_with_values, 1):
+        config, values = config_value
+        config_str = ', '.join(f'{f}={v}' if not isinstance(v, bool) else f'{f}' for f,v in config.elements.items() if config.is_selected(f))
+        values_str = ', '.join(f'{k}={v}' for k,v in values.items())
+        print(f'Config. {i}: {config_str} | Values: {values_str}')
+    ```    
+
+- Configuration validation:
+
+    Return whether a given partial or full configuration is valid:
+    ```python
+    from flamapy.metamodels.configuration_metamodel.transformations import ConfigurationJSONReader
+    configuration = ConfigurationJSONReader('resources/configs/pizza_z3_config1.json').transform()
+    configuration.set_full(False)
+    print(f'Configuration: {configuration.elements}')
+    satisfiable_configuration_op = Z3SatisfiableConfiguration()
+    satisfiable_configuration_op.set_configuration(configuration)
+    is_satisfiable = satisfiable_configuration_op.execute(z3_model).get_result()
+    print(f'Is the configuration satisfiable? {is_satisfiable}')
+    ```    
+
+**Note:** The Z3Configurations and Z3ConfigurationsNumber operations may takes longer if the number of configuration is huge, or even not finish if the model is unbounded.
+
+**Note:** The Z3Configurations and Z3ConfigurationsNumber operations support also a partial configuration as an additional argument, so the operation will return the result taking into account the given partial configuration. 
+For example:
+
+```python
+from flamapy.core.models import Configuration
+# Create a partial configuration
+elements = {'Pizza': True, 'SpicyLvl': 5}
+partial_config = Configuration(elements)
+# Calculate the number of configuration from the partial configuration
+configs_number_op = Z3ConfigurationsNumber()
+configs_number_op.set_partial_configuration(partial_config)
+n_configs = configs_number_op.execute(z3_model).get_result()
+print(f'#Configurations: {n_configs}')
+```

{flamapy_z3-2.1.0.dev1 → flamapy_z3-2.5.0.dev0}/flamapy/metamodels/z3_metamodel/models/__init__.py

@@ -1,4 +1,4 @@
 from .z3_model import Z3Model, FeatureInfo
 
 
-__all__ = ['Z3Model', 'FeatureInfo']
+__all__ = ['FeatureInfo', 'Z3Model']

{flamapy_z3-2.1.0.dev1 → flamapy_z3-2.5.0.dev0}/flamapy/metamodels/z3_metamodel/models/z3_model.py

@@ -22,7 +22,7 @@ class FeatureInfo:
 
 
 class Z3Model(VariabilityModel):
-    
+
     DEFAULT_PRECISION = 4
 
     @staticmethod
@@ -52,15 +52,15 @@ class Z3Model(VariabilityModel):
     def add_boolean_feature(self, name: str) -> Any:
         """Add a boolean feature with the given name."""
         sel = z3.Bool(name, ctx=self.ctx)
-        self.features[name] = FeatureInfo(name=name, 
-                                          sel=sel, 
-                                          val=None, 
-                                          ftype=FeatureType.BOOLEAN, 
+        self.features[name] = FeatureInfo(name=name,
+                                          sel=sel,
+                                          val=None,
+                                          ftype=FeatureType.BOOLEAN,
                                           attributes={})
         return sel
 
-    def add_typed_feature(self, 
-                          name: str, 
+    def add_typed_feature(self,
+                          name: str,
                           ftype: FeatureType,
                           const_value: Optional[Any]=None,
                           neutral_when_unselected: Optional[Any]=None) -> tuple[Any, Any]:
@@ -110,39 +110,36 @@ class Z3Model(VariabilityModel):
     def get_variable(self, name: str) -> Optional[FeatureInfo]:
         """Get the FeatureInfo of a feature by name."""
         return self.features.get(name, None)
-    
-    def add_attribute(self, 
-                      feature_name: str, 
-                      attr_name: str, 
-                      attr_type: AttributeType, 
+
+    def _create_attribute_var(self,
+                              attr_type: AttributeType,
+                              var_name: str) -> tuple[Optional[Any], Optional[Any]]:
+        """Create a Z3 variable and default value for the given attribute type."""
+        if attr_type == AttributeType.INTEGER:
+            return z3.Int(var_name, ctx=self.ctx), self.create_const(AttributeType.INTEGER, 0)
+        if attr_type == AttributeType.REAL:
+            return z3.Real(var_name, ctx=self.ctx), self.create_const(AttributeType.REAL, 0.0)
+        if attr_type == AttributeType.STRING:
+            return z3.String(var_name, ctx=self.ctx), self.create_const(AttributeType.STRING, "")
+        if attr_type == AttributeType.BOOLEAN:
+            return z3.Bool(var_name, ctx=self.ctx), self.create_const(AttributeType.BOOLEAN, False)
+        if attr_type in (AttributeType.NESTED, AttributeType.VECTOR):
+            LOGGER.warning(f"Warning: Attribute {var_name} has {attr_type.name} type, "
+                           "which is not currently supported in Z3Model. Ignored.")
+            return None, None
+        raise ValueError("Unsupported attribute type")
+
+    def add_attribute(self,
+                      feature_name: str,
+                      attr_name: str,
+                      attr_type: AttributeType,
                       const_value: Optional[Any]=None) -> Optional[Any]:
         """Add an attribute to a feature (attributes are typed variables)."""
         if feature_name not in self.features:
             raise KeyError(feature_name)
         info = self.features[feature_name]
         var_name = f"{feature_name}.{attr_name}"
-        if attr_type == AttributeType.INTEGER:
-            var = z3.Int(var_name, ctx=self.ctx)
-            default_value = self.create_const(AttributeType.INTEGER, 0)
-        elif attr_type == AttributeType.REAL:
-            var = z3.Real(var_name, ctx=self.ctx)
-            default_value = self.create_const(AttributeType.REAL, 0.0)
-        elif attr_type == AttributeType.STRING:
-            var = z3.String(var_name, ctx=self.ctx)
-            default_value = self.create_const(AttributeType.STRING, "")
-        elif attr_type == AttributeType.BOOLEAN:
-            var = z3.Bool(var_name, ctx=self.ctx)
-            default_value = self.create_const(AttributeType.BOOLEAN, False)
-        elif attr_type == AttributeType.NESTED:
-            LOGGER.warning(f"Warning: Attribute {var_name} has NESTED type, " \
-                           "which is not currently supported in Z3Model. Ignored.")
-            var = None
-        elif attr_type == AttributeType.VECTOR:
-            LOGGER.warning(f"Warning: Attribute {var_name} has VECTOR type, " \
-                           "which is not currently supported in Z3Model. Ignored.")
-            var = None
-        else:
-            raise ValueError("Unsupported attribute type")
+        var, default_value = self._create_attribute_var(attr_type, var_name)
 
         if var is not None:
             info.attributes[attr_name] = {"var": var, "type": attr_type}
@@ -214,9 +211,9 @@ class Z3Model(VariabilityModel):
                     raise ValueError(f'Feature {feature_info.name} has no value expression.')
                 val_var = feature_info.val
                 z3_value = Z3Model.get_z3_value(feature_value, feature_info.ftype, context)
-                constraints.append(val_var == z3_value)    
+                constraints.append(val_var == z3_value)
         return constraints
-    
+
     @staticmethod
     def get_z3_value(value: Any, ftype: FeatureType, context: z3.Context) -> z3.ExprRef:
         """Return a Z3 expression for a given Python configuration value."""
@@ -237,7 +234,7 @@ class Z3Model(VariabilityModel):
 
     @staticmethod
     def sum_attribute(model: 'Z3Model', attr_name: str) -> z3.ArithRef:
-        """Return a Z3 expression representing the sum of the given attribute across 
+        """Return a Z3 expression representing the sum of the given attribute across
         all features."""
         exprs = []
         for _, feature_info in model.features.items():
@@ -249,4 +246,4 @@ class Z3Model(VariabilityModel):
                     zero_val = z3.RealVal(0.0, ctx=model.ctx)
                 expr = z3.If(feature_info.sel, attr['var'], zero_val)
                 exprs.append(expr)
-        return z3.Sum(exprs) if exprs else z3.RealVal(0.0, ctx=model.ctx)
+        return z3.Sum(exprs) if exprs else z3.RealVal(0.0, ctx=model.ctx)

{flamapy_z3-2.1.0.dev1 → flamapy_z3-2.5.0.dev0}/flamapy/metamodels/z3_metamodel/operations/__init__.py

@@ -6,13 +6,18 @@ from .z3_dead_features import Z3DeadFeatures
 from .z3_false_optional_features import Z3FalseOptionalFeatures
 from .z3_attribute_optimization import Z3AttributeOptimization
 from .z3_satisfiable_configuration import Z3SatisfiableConfiguration
+from .z3_feature_bounds import Z3FeatureBounds
+from .z3_all_feature_bounds import Z3AllFeatureBounds
 
-
-__all__ = ['Z3Satisfiable',
+__all__ = [
+           'Z3AllFeatureBounds',
+           'Z3AttributeOptimization',
            'Z3Configurations',
            'Z3ConfigurationsNumber',
            'Z3CoreFeatures',
            'Z3DeadFeatures',
            'Z3FalseOptionalFeatures',
-           'Z3AttributeOptimization',
-           'Z3SatisfiableConfiguration']
+           'Z3FeatureBounds',
+           'Z3Satisfiable',
+           'Z3SatisfiableConfiguration',
+]

{flamapy_z3-2.1.0.dev1 → flamapy_z3-2.5.0.dev0}/flamapy/metamodels/z3_metamodel/operations/interfaces/attribute_optimization.py

@@ -21,7 +21,7 @@ class AttributeOptimization(Operation):
     @abstractmethod
     def set_attributes(self, attributes: dict[Attribute, OptimizationGoal]) -> None:
         pass
-        
+
     @abstractmethod
     def optimize(self) -> list[Configuration]:
         pass

flamapy_z3-2.5.0.dev0/flamapy/metamodels/z3_metamodel/operations/z3_all_feature_bounds.py

@@ -0,0 +1,86 @@
+import logging
+from typing import Any, cast
+
+from flamapy.core.models import VariabilityModel
+from flamapy.core.operations import Operation
+from flamapy.metamodels.z3_metamodel.models import Z3Model
+from flamapy.metamodels.z3_metamodel.operations import Z3FeatureBounds
+from flamapy.metamodels.fm_metamodel.models import FeatureType
+
+
+LOGGER = logging.getLogger(__name__)
+
+
+class Z3AllFeatureBounds(Operation):
+    """Computes the effective bounds (min/max) for ALL typed feature
+    (Integer, Real, String length) in the Z3 model.
+    """
+
+    def __init__(self) -> None:
+        # El resultado será un diccionario donde la clave es el nombre de la variable
+        # y el valor es el diccionario de bounds (min, max, bounded).
+        self._result: dict[str, dict[str, Any]] = {}
+
+    def get_result(self) -> dict[str, dict[str, Any]]:
+        """
+        Devuelve un diccionario con los bounds de todas las variables tipadas.
+        Formato: {'var_name': {'min': ..., 'max': ..., 'bounded': True/False}, ...}
+        """
+        return self._result
+
+    def execute(self, model: VariabilityModel) -> 'Z3AllFeatureBounds':
+        z3_model = cast(Z3Model, model)
+        all_bounds_result: dict[str, dict[str, Any]] = {}
+
+        # Instanciamos la operación de bajo nivel que ya definiste
+        bounds_op = Z3FeatureBounds()
+
+        # Iterar sobre todas las features del modelo Z3
+        for var_name, feature_info in z3_model.features.items():
+            ftype = feature_info.ftype
+
+            # Solo procesar variables tipadas (Integer, Real, String)
+            if ftype in (FeatureType.INTEGER, FeatureType.REAL, FeatureType.STRING):
+
+                try:
+                    # 1. Configurar la operación con el nombre de la variable
+                    bounds_op.set_variable_name(var_name)
+
+                    # 2. Ejecutar la operación Z3VariableBounds para la variable actual
+                    bounds_op.execute(z3_model)
+
+                    # 3. Obtener el resultado unificado
+                    bounds = bounds_op.get_result()
+
+                    # 4. Almacenar el resultado en el diccionario final
+                    if 'error' not in bounds:
+                        # Aseguramos que solo guardamos los campos unificados y esenciales
+                        all_bounds_result[var_name] = {
+                            'feature_type': bounds.get('feature_type', ftype.name),
+                            'min': bounds.get('min', 'N/A'),
+                            'max': bounds.get('max', 'N/A'),
+                            'bounded': bounds.get('bounded', False)
+                        }
+                    else:
+                        LOGGER.warning(
+                            f"Error calculating bounds for {var_name}: {bounds['error']}"
+                        )
+                        all_bounds_result[var_name] = {
+                            'feature_type': ftype.name,
+                            'min': 'ERROR',
+                            'max': 'ERROR',
+                            'bounded': False
+                        }
+
+                except Exception as e:
+                    LOGGER.error(f"Execution error for variable {var_name}: {e}")
+                    all_bounds_result[var_name] = {
+                        'feature_type': ftype.name,
+                        'min': 'RUNTIME_ERROR',
+                        'max': 'RUNTIME_ERROR',
+                        'bounded': False
+                    }
+
+
+        self._result = all_bounds_result
+        return self