Remove optional-constraint toggling and APIs

Remove support for optional/redundant constraints and the related toggling API. Constraint no longer has is_redundant or enabled attributes; add_constraint and add_constraints signatures no longer accept is_redundant/enabled. Deleted add_optional_constraint, add_assumption, set_constraint_enabled, enable_constraint, disable_constraint, and the PymzmConstraintNotInModel exception. Adjusted add_function_call/add_predicate_call to drop redundancy flags and changed Model.generate to include all constraints (removed enabled filtering). Updated tests accordingly and removed the optional-constraints test file.

Author: Arthod

src/pymzm/constraint.py

@@ -94,8 +94,6 @@ def __init__(
         cstr: ExpressionBool,
         ctype: str = CTYPE_NORMAL,
         annotation: str = None,
-        is_redundant=False,
-        enabled=True,
     ):
         self.cstr = cstr
         if not isinstance(self.cstr, (ExpressionBool, bool, str)):
@@ -110,9 +108,6 @@ def __init__(
             if self.annotation not in AnnotationConstraint.ANNOTATIONS:
                 raise PymzmInvalidConstraintAnnotation("annotation", self.annotation)
 
-        self.is_redundant = is_redundant
-        self.enabled = enabled
-
     def __str__(self):
         return self.cstr
 
@@ -121,10 +116,7 @@ def _to_mz(self):
         if self.annotation is not None:
             annotation_suffix = f" :: {self.annotation}"
 
-        if self.is_redundant:
-            return f"constraint redundant_constraint({self.cstr}){annotation_suffix};\n"
-        else:
-            return f"constraint {self.cstr}{annotation_suffix};\n"
+        return f"constraint {self.cstr}{annotation_suffix};\n"
 
     @staticmethod
     def _from_global_constraint(func: str, ctype: str, *args) -> "Constraint":

src/pymzm/exceptions.py

@@ -149,17 +149,6 @@ def __str__(self):
         )
 
 
-class PymzmConstraintNotInModel(PymzmModelStateError):
-    def __init__(self, constraint):
-        self.constraint = constraint
-
-    def __str__(self):
-        return (
-            f"Constraint {self.constraint!r} is not registered in this model. "
-            "Only constraints added via model.add_constraint(...) can be toggled."
-        )
-
-
 class PymzmVariableTypeError(PymzmArgumentError):
     def __init__(self, argname, expected_vtype, actual_vtype):
         self.expected_vtype = expected_vtype

src/pymzm/model.py

@@ -513,60 +513,20 @@ def add_variables(
     def add_constraint(
         self,
         constraint: ConstraintInput,
-        is_redundant: bool = False,
-        enabled: bool = True,
     ) -> Constraint:
         if isinstance(constraint, Constraint):
-            constraint.is_redundant = is_redundant
-            constraint.enabled = enabled
             if constraint.ctype != Constraint.CTYPE_NORMAL:
                 self.global_constraints.add(constraint.ctype)
 
         elif isinstance(constraint, ExpressionBool):
-            constraint = Constraint(
-                constraint.name, is_redundant=is_redundant, enabled=enabled
-            )
+            constraint = Constraint(constraint.name)
 
         else:
             raise PymzmInvalidConstraintType("constraint", type(constraint).__name__)
 
         self.constraints.append(constraint)
         return constraint
 
-    def add_optional_constraint(
-        self,
-        constraint: ConstraintInput,
-        enabled: bool = False,
-        is_redundant: bool = False,
-    ) -> Constraint:
-        return self.add_constraint(
-            constraint, is_redundant=is_redundant, enabled=enabled
-        )
-
-    def add_assumption(
-        self,
-        constraint: ConstraintInput,
-        enabled: bool = True,
-        is_redundant: bool = False,
-    ) -> Constraint:
-        return self.add_optional_constraint(
-            constraint, enabled=enabled, is_redundant=is_redundant
-        )
-
-    def set_constraint_enabled(
-        self, constraint: Constraint, enabled: bool = True
-    ) -> Constraint:
-        if constraint not in self.constraints:
-            raise PymzmConstraintNotInModel(constraint)
-        constraint.enabled = enabled
-        return constraint
-
-    def enable_constraint(self, constraint: Constraint) -> Constraint:
-        return self.set_constraint_enabled(constraint, True)
-
-    def disable_constraint(self, constraint: Constraint) -> Constraint:
-        return self.set_constraint_enabled(constraint, False)
-
     def add_include(self, include_file: str) -> None:
         include_file = include_file.strip()
         if not include_file:
@@ -581,12 +541,9 @@ def add_includes(self, include_files: Iterable[str]) -> None:
     def add_constraints(
         self,
         constraints: Iterable[ConstraintInput],
-        is_redundant: bool = False,
-        enabled: bool = True,
     ) -> None:
-        constraints = list(constraints)
         for constraint in constraints:
-            self.add_constraint(constraint, is_redundant=is_redundant, enabled=enabled)
+            self.add_constraint(constraint)
 
     def add_function_declaration(self, declaration: str) -> None:
         declaration = declaration.strip()
@@ -656,21 +613,20 @@ def call_function(
         return Expression.function(name, *args, returns_bool=returns_bool)
 
     def add_function_call(
-        self, name: str, *args: Any, is_redundant: bool = False
+        self, name: str, *args: Any
     ) -> Constraint:
         return self.add_constraint(
-            self.call_function(name, *args, returns_bool=True),
-            is_redundant=is_redundant,
+            self.call_function(name, *args, returns_bool=True)
         )
 
     def call_predicate(self, name: str, *args: Any) -> ExpressionBool:
         return Expression.predicate(name, *args)
 
     def add_predicate_call(
-        self, name: str, *args: Any, is_redundant: bool = False
+        self, name: str, *args: Any
     ) -> Constraint:
         return self.add_constraint(
-            self.call_predicate(name, *args), is_redundant=is_redundant
+            self.call_predicate(name, *args)
         )
 
     def generate(self, debug: bool = False) -> None:
@@ -900,9 +856,7 @@ def to_ir(self) -> ModelIR:
         if self.solve_criteria is None:
             raise PymzmSolveNotConfigured()
 
-        enabled_constraints = tuple(
-            constraint for constraint in self.constraints if constraint.enabled
-        )
+        enabled_constraints = tuple(self.constraints)
         auto_includes = {
             f"{constraint.ctype}.mzn"
             for constraint in enabled_constraints

tests/test_invariants.py

@@ -14,7 +14,6 @@
     PymzmArgumentError,
     PymzmModelStateError,
     PymzmSolveNotConfigured,
-    PymzmConstraintNotInModel,
     PymzmVariableTypeError,
 )
 from pymzm.model import SOLVE_MAXIMIZE, SOLVE_SATISFY, SearchAnnotation, SeqSearch, RestartStrategy
@@ -68,23 +67,6 @@ def test_set_solve_method_wrong_restart_strategy_raises():
         m.set_solve_method(ann, restart_strategy="bad")
 
 
-# ---------------------------------------------------------------------------
-# Model.set_constraint_enabled()
-# ---------------------------------------------------------------------------
-
-
-def test_set_constraint_enabled_not_in_model_raises():
-    m = Model()
-    c = Constraint("x > 0")
-    with pytest.raises(PymzmConstraintNotInModel):
-        m.set_constraint_enabled(c, True)
-
-
-# ---------------------------------------------------------------------------
-# Model.add_include()
-# ---------------------------------------------------------------------------
-
-
 def test_add_include_empty_string_raises():
     m = Model()
     with pytest.raises(PymzmArgumentError):