flamapy-fw 2.6.0.dev4__tar.gz → 2.6.0.dev5__tar.gz

{flamapy_fw-2.6.0.dev4/flamapy_fw.egg-info → flamapy_fw-2.6.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamapy-fw
-Version: 2.6.0.dev4
+Version: 2.6.0.dev5
 Summary: Flamapy is a Python-based AAFM framework that takes into consideration previous AAFM tool designs and enables multi-solver and multi-metamodel support for the integration of AAFM tooling on the Python ecosystem.
 Author-email: Flamapy <flamapy@us.es>
 License-Expression: GPL-3.0-or-later

{flamapy_fw-2.6.0.dev4 → flamapy_fw-2.6.0.dev5}/flamapy/core/discover.py

@@ -15,6 +15,7 @@ from flamapy.core.plugins import Operations, Plugin, Plugins
 from flamapy.core.transformations import Transformation
 from flamapy.core.transformations.text_to_model import TextToModel
 from flamapy.core.transformations.model_to_model import ModelToModel
+from flamapy.core.utils import filename_matches_extension
 from flamapy.metamodels.configuration_metamodel.models.configuration import Configuration
 
 
@@ -256,14 +257,15 @@ class DiscoverMetamodels:
 
     def __transform_to_model_from_file(self, file: str) -> VariabilityModel:
         t2m_transformations = self.get_transformations_t2m()
-        extension = file.rsplit(".", maxsplit=1)[-1]
-        t2m_filters = filter(
-            lambda t2m: t2m.get_source_extension() == extension, t2m_transformations
-        )
-
-        t2m = next(t2m_filters, None)
-        if t2m is None:
+        # Prefer the most specific matching extension (e.g. 'uvl.json' over 'json').
+        candidates = [
+            t2m
+            for t2m in t2m_transformations
+            if filename_matches_extension(file, t2m.get_source_extension())
+        ]
+        if not candidates:
             raise TransformationNotFound()
+        t2m = max(candidates, key=lambda t: len(t.get_source_extension()))
 
         return t2m(file).transform()
 

{flamapy_fw-2.6.0.dev4 → flamapy_fw-2.6.0.dev5}/flamapy/core/models/ast.py

@@ -1,6 +1,8 @@
 from typing import Any, Optional
 from enum import Enum
 
+from flamapy.core.exceptions import FlamaException
+
 
 class ASTOperation(Enum):
     # logical operators
@@ -187,10 +189,31 @@ class AST:
     def to_cnf(self) -> "AST":
         return convert_into_cnf(self)
 
-    def get_clauses(self) -> list[list[Any]]:
+    def get_clauses(self, method: str = 'distributive') -> list[list[Any]]:
+        """Return the CNF clauses of this AST.
+
+        ``method='distributive'`` (default) uses the classic distributive expansion and
+        returns clauses over the formula's own variables. ``method='tseytin'`` uses the
+        Tseytin transformation; the returned clauses may contain fresh auxiliary
+        variables. Use :meth:`get_clauses_with_aux` when those auxiliary variable names
+        are needed (e.g. to register them as non-feature solver variables).
+        """
+        if method == 'tseytin':
+            clauses, _ = tseytin_cnf(self)
+            return clauses
         ast = self.to_cnf()
         return get_clauses(ast)
 
+    def get_clauses_with_aux(self, method: str = 'tseytin') -> tuple[list[list[Any]], list[str]]:
+        """Return ``(clauses, aux_names)`` for the given CNF ``method``.
+
+        For ``'tseytin'`` this exposes the auxiliary variable names introduced by the
+        encoding. For ``'distributive'`` the auxiliary list is always empty.
+        """
+        if method == 'tseytin':
+            return tseytin_cnf(self)
+        return get_clauses(self.to_cnf()), []
+
     def get_operators(self) -> list[ASTOperation]:
         operators = []
         stack = [self.root]
@@ -263,20 +286,22 @@ def simplify_formula(ast: AST) -> AST:
         )
     elif logic_op == ASTOperation.EQUIVALENCE:
         # Replace P <=> Q with P => Q ∧ Q => P.
-        left = simplify_formula(AST.create_binary_operation(ASTOperation.IMPLIES, left, right)).root
-        right = simplify_formula(
+        new_left = simplify_formula(
+            AST.create_binary_operation(ASTOperation.IMPLIES, left, right)
+        ).root
+        new_right = simplify_formula(
             AST.create_binary_operation(ASTOperation.IMPLIES, right, left)
         ).root
-        result = AST.create_binary_operation(ASTOperation.AND, left, right)
+        result = AST.create_binary_operation(ASTOperation.AND, new_left, new_right)
     elif logic_op == ASTOperation.XOR:
         # Replace P XOR Q with (P ∧ !Q) v (!P ∧ Q).
-        left = simplify_formula(
+        new_left = simplify_formula(
             AST.create_binary_operation(ASTOperation.AND, left, Node(ASTOperation.NOT, right))
         ).root
-        left = simplify_formula(
+        new_right = simplify_formula(
             AST.create_binary_operation(ASTOperation.AND, Node(ASTOperation.NOT, left), right)
         ).root
-        result = AST.create_binary_operation(ASTOperation.OR, left, right)
+        result = AST.create_binary_operation(ASTOperation.OR, new_left, new_right)
     elif logic_op == ASTOperation.AND:
         left = simplify_formula(AST(left)).root
         right = simplify_formula(AST(right)).root
@@ -376,6 +401,85 @@ def propagate_negation(node: Node, negated: bool = False) -> AST:
     return result
 
 
+TSEYTIN_AUX_PREFIX = "__tseytin_"
+
+
+def _negate_literal(literal: Any) -> Any:
+    """Flip the sign of a CNF literal that uses the ``"-name"`` string convention."""
+    if isinstance(literal, str) and literal.startswith("-"):
+        return literal[1:]
+    return "-" + str(literal)
+
+
+def _tseytin_gate_clauses(op: ASTOperation, gate: Any, a: Any, b: Any) -> list[list[Any]]:
+    """Biconditional clauses encoding ``gate <=> (a op b)`` for a binary logical ``op``.
+
+    ``a`` and ``b`` are literals; ``gate`` is the fresh auxiliary literal. Encoding each
+    connective directly (rather than expanding it first) is what keeps the transformation
+    linear in the formula size.
+    """
+    g, na, nb, ng = gate, _negate_literal(a), _negate_literal(b), _negate_literal(gate)
+    if op == ASTOperation.AND:
+        return [[ng, a], [ng, b], [g, na, nb]]
+    if op == ASTOperation.OR:
+        return [[g, na], [g, nb], [ng, a, b]]
+    if op in (ASTOperation.IMPLIES, ASTOperation.REQUIRES):  # a -> b  ==  (not a) or b
+        return [[g, a], [g, nb], [ng, na, b]]
+    if op == ASTOperation.EXCLUDES:  # (not a) or (not b)
+        return [[g, a], [g, b], [ng, na, nb]]
+    if op == ASTOperation.EQUIVALENCE:  # a <-> b
+        return [[ng, na, b], [ng, a, nb], [g, a, b], [g, na, nb]]
+    if op == ASTOperation.XOR:  # a xor b
+        return [[ng, a, b], [ng, na, nb], [g, na, b], [g, a, nb]]
+    raise FlamaException(
+        f"Operation '{op}' is not a propositional connective supported by the Tseytin "
+        f"transformation."
+    )
+
+
+def tseytin_cnf(ast: AST) -> tuple[list[list[Any]], list[str]]:
+    """Return an equisatisfiable CNF of ``ast`` using the Tseytin transformation.
+
+    Unlike the distributive :func:`to_cnf`, this produces a CNF whose size is linear
+    in the size of the formula by introducing one fresh auxiliary variable per gate.
+    Each logical connective is encoded directly (no distributive expansion), so formulas
+    that blow up under :func:`to_cnf` (XOR chains, wide equivalences) stay compact. Gates
+    are encoded as full biconditionals (``g <=> subformula``) so that every model of the
+    original formula extends to exactly one model of the encoding; this preserves model
+    counts and configuration enumeration (once auxiliary variables are projected out).
+
+    Returns a tuple ``(clauses, aux_names)`` where ``clauses`` is a list of clauses
+    (each a list of literals in the same ``"-name"`` string convention as
+    :func:`get_clauses`) and ``aux_names`` lists every auxiliary variable name
+    introduced (each prefixed with :data:`TSEYTIN_AUX_PREFIX`) so callers can register
+    them as solver variables that are not features.
+
+    Raises :class:`FlamaException` if the formula contains a non-propositional operator
+    (arithmetic, comparison or aggregation).
+    """
+    clauses: list[list[Any]] = []
+    aux_names: list[str] = []
+    counter = [0]
+
+    def literal_of(node: Node) -> Any:
+        if node.is_term():
+            return node.data
+        if node.data == ASTOperation.NOT:
+            # Negation of a single literal is free; no gate needed.
+            return _negate_literal(literal_of(node.left))
+        left_lit = literal_of(node.left)
+        right_lit = literal_of(node.right)
+        counter[0] += 1
+        gate = f"{TSEYTIN_AUX_PREFIX}{counter[0]}"
+        aux_names.append(gate)
+        clauses.extend(_tseytin_gate_clauses(node.data, gate, left_lit, right_lit))
+        return gate
+
+    root_literal = literal_of(ast.root)
+    clauses.append([root_literal])  # assert the whole formula is true
+    return clauses, aux_names
+
+
 def get_clauses(ast: AST) -> list[list[Any]]:
     """Return the list of clauses represented by the AST root node in conjunctive normal form."""
     node = ast.root

{flamapy_fw-2.6.0.dev4 → flamapy_fw-2.6.0.dev5}/flamapy/core/operations/__init__.py

@@ -17,9 +17,14 @@ from .variability import Variability  # pylint: disable=cyclic-import
 from .sampling import Sampling  # pylint: disable=cyclic-import
 from .atomic_sets import AtomicSets  # pylint: disable=cyclic-import
 from .metrics_operation import Metrics  # pylint: disable=cyclic-import
+from .attribute_optimization import (  # pylint: disable=cyclic-import
+    AttributeOptimization,
+    OptimizationGoal,
+)
 
 __all__ = [
     "AtomicSets",
+    "AttributeOptimization",
     "AverageBranchingFactor",
     "Commonality",
     "Configurations",
@@ -34,6 +39,7 @@ __all__ = [
     "Filter",
     "Metrics",
     "Operation",
+    "OptimizationGoal",
     "Sampling",
     "Satisfiable",
     "SatisfiableConfiguration",

flamapy_fw-2.6.0.dev5/flamapy/core/operations/attribute_optimization.py

@@ -0,0 +1,30 @@
+from abc import abstractmethod
+from enum import Enum
+from typing import Any
+
+from flamapy.core.operations import Operation
+
+
+class OptimizationGoal(Enum):
+    MAXIMIZE = 'Maximize'
+    MINIMIZE = 'Minimize'
+
+
+class AttributeOptimization(Operation):
+    """Return the configuration(s) that optimize the given numeric feature attribute(s).
+
+    Attributes are identified by name and mapped to an :class:`OptimizationGoal`. The
+    objective for each attribute is the sum of its values over the selected features.
+    """
+
+    @abstractmethod
+    def __init__(self) -> None:
+        pass
+
+    @abstractmethod
+    def set_attributes(self, attributes: dict[str, OptimizationGoal]) -> None:
+        """Set the attributes to optimize as a mapping ``{attribute_name: OptimizationGoal}``."""
+
+    @abstractmethod
+    def optimize(self) -> list[Any]:
+        """Return the optimal configuration(s)."""

{flamapy_fw-2.6.0.dev4 → flamapy_fw-2.6.0.dev5}/flamapy/core/operations/metrics_operation.py

@@ -19,10 +19,10 @@ class Metrics(Operation, metaclass=ABCMeta):
     """
 
     filter: Optional[list[str]] = None
-    result: list[dict[str, Any]] = []
 
     def __init__(self) -> None:
         self.model: Optional[VariabilityModel] = None
+        self.result: list[dict[str, Any]] = []
 
     @abstractmethod
     def calculate_metamodel_metrics(self, model: VariabilityModel) -> list[dict[str, Any]]:

{flamapy_fw-2.6.0.dev4 → flamapy_fw-2.6.0.dev5}/flamapy/core/plugins.py

@@ -15,7 +15,7 @@ from flamapy.core.transformations import (
     ModelToText,
     ModelToModel,
 )
-from flamapy.core.utils import extract_filename_extension
+from flamapy.core.utils import filename_matches_extension
 
 
 class Transformations(UserList[Type[Transformation]]):
@@ -30,11 +30,7 @@ class Operations(UserList[Type[Operation]]):
             lambda op: name in [op.__name__, op.__base__.__name__ if op.__base__ else ""], self.data
         )
 
-        try:
-            operation = next(candidates, None)
-        except StopIteration:
-            raise OperationNotFound(f"Operation '{name}' not found.") from StopIteration
-
+        operation = next(candidates, None)
         if not operation:
             raise OperationNotFound(f"Operation '{name}' not found.")
         return operation
@@ -51,11 +47,7 @@ class Plugin:
         self, filter_transformation: Callable[..., bool]
     ) -> Type[Transformation]:
         candidates = filter(filter_transformation, self.transformations)
-        try:
-            transformation = next(candidates, None)
-        except StopIteration:
-            raise TransformationNotFound from StopIteration
-
+        transformation = next(candidates, None)
         if not transformation:
             raise TransformationNotFound
         return transformation
@@ -74,32 +66,30 @@ class Plugin:
         return operation.execute(model=src)
 
     def use_transformation_t2m(self, src: str) -> VariabilityModel:
-        extension = extract_filename_extension(src)
-
-        def filter_transformations(transformation: Type[Transformation]) -> bool:
-            return (
-                issubclass(transformation, TextToModel)
-                and transformation.get_source_extension() == extension
-            )
-
-        transformation: Type[TextToModel] = cast(
-            Type[TextToModel], self.__get_transformation(filter_transformations)
-        )
+        # Prefer the most specific matching extension (e.g. 'uvl.json' over 'json').
+        candidates = [
+            transformation
+            for transformation in self.transformations
+            if issubclass(transformation, TextToModel)
+            and filename_matches_extension(src, transformation.get_source_extension())
+        ]
+        if not candidates:
+            raise TransformationNotFound
+        transformation = max(candidates, key=lambda t: len(t.get_source_extension()))
         result = transformation(src)
         return result.transform()
 
     def use_transformation_m2t(self, src: VariabilityModel, dst: str) -> str:
-        extension = extract_filename_extension(dst)
-
-        def filter_transformations(transformation: Type[Transformation]) -> bool:
-            return (
-                issubclass(transformation, ModelToText)
-                and transformation.get_destination_extension() == extension
-            )
-
-        transformation: Type[ModelToText] = cast(
-            Type[ModelToText], self.__get_transformation(filter_transformations)
-        )
+        # Prefer the most specific matching extension (e.g. 'uvl.json' over 'json').
+        candidates = [
+            transformation
+            for transformation in self.transformations
+            if issubclass(transformation, ModelToText)
+            and filename_matches_extension(dst, transformation.get_destination_extension())
+        ]
+        if not candidates:
+            raise TransformationNotFound
+        transformation = max(candidates, key=lambda t: len(t.get_destination_extension()))
         result = transformation(path=dst, source_model=src)
         return result.transform()
 

flamapy_fw-2.6.0.dev5/flamapy/core/utils.py

@@ -0,0 +1,17 @@
+import os.path
+
+
+def extract_filename_extension(filename: str) -> str:
+    return filename.rsplit(".", maxsplit=1)[-1]
+
+
+def filename_matches_extension(filename: str, extension: str) -> bool:
+    """Whether the filename ends with the given extension.
+
+    Supports compound extensions such as 'uvl.json'.
+    """
+    return filename.endswith(f".{extension}")
+
+
+def file_exists(filepath: str) -> bool:
+    return os.path.isfile(filepath)

{flamapy_fw-2.6.0.dev4 → flamapy_fw-2.6.0.dev5}/flamapy/metamodels/configuration_metamodel/models/configuration.py

@@ -30,10 +30,25 @@ class Configuration(VariabilityModel):
     def __init__(self, elements: dict[Any, Any]) -> None:
         self.elements: dict[Any, Any] = elements
         self.is_full: bool = False
+        # Optional decision provenance: element -> 'user' or 'propagated'. Empty by default
+        # and not part of the configuration's identity (equality/hash ignore it). Useful for
+        # interactive configurators that distinguish user choices from implied decisions.
+        self.provenance: dict[Any, str] = {}
 
     def set_full(self, is_full: bool) -> None:
         self.is_full = is_full
 
+    def set_provenance(self, element: Any, source: str) -> None:
+        """Record whether an element's value came from the user or from propagation."""
+        self.provenance[element] = source
+
+    def get_provenance(self, element: Any) -> str:
+        """Return 'user', 'propagated', or 'unknown' if not recorded."""
+        return self.provenance.get(element, 'unknown')
+
+    def is_user_decision(self, element: Any) -> bool:
+        return self.provenance.get(element) == 'user'
+
     def get_selected_elements(self) -> list[Any]:
         """Get the list of selected elements in the configuration."""
         return [e for e in self.elements if self.is_selected(e)]

{flamapy_fw-2.6.0.dev4 → flamapy_fw-2.6.0.dev5/flamapy_fw.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamapy-fw
-Version: 2.6.0.dev4
+Version: 2.6.0.dev5
 Summary: Flamapy is a Python-based AAFM framework that takes into consideration previous AAFM tool designs and enables multi-solver and multi-metamodel support for the integration of AAFM tooling on the Python ecosystem.
 Author-email: Flamapy <flamapy@us.es>
 License-Expression: GPL-3.0-or-later

{flamapy_fw-2.6.0.dev4 → flamapy_fw-2.6.0.dev5}/flamapy_fw.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ flamapy/core/models/variability_model.py
 flamapy/core/operations/__init__.py
 flamapy/core/operations/abstract_operation.py
 flamapy/core/operations/atomic_sets.py
+flamapy/core/operations/attribute_optimization.py
 flamapy/core/operations/average_branching_factor.py
 flamapy/core/operations/commonality.py
 flamapy/core/operations/configurations.py

{flamapy_fw-2.6.0.dev4 → flamapy_fw-2.6.0.dev5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flamapy-fw"
-version = "2.6.0.dev4"
+version = "2.6.0.dev5"
 description = "Flamapy is a Python-based AAFM framework that takes into consideration previous AAFM tool designs and enables multi-solver and multi-metamodel support for the integration of AAFM tooling on the Python ecosystem."
 readme = "README.md"
 license = "GPL-3.0-or-later"

flamapy_fw-2.6.0.dev4/flamapy/core/utils.py

@@ -1,9 +0,0 @@
-import os.path
-
-
-def extract_filename_extension(filename: str) -> str:
-    return filename.rsplit(".", maxsplit=1)[-1]
-
-
-def file_exists(filepath: str) -> bool:
-    return os.path.isfile(filepath)