Add optional constraints and enable/disable support

Introduce an enabled flag for Constraint (default True) and propagate it through Model APIs so constraints can be toggled on/off. Updated add_constraint and add_constraints to accept an enabled parameter, and added convenience methods: add_optional_constraint, add_assumption, set_constraint_enabled, enable_constraint, and disable_constraint. to_ir now ignores disabled constraints and only auto-includes global constraint files for enabled constraints. Added unit tests (tests/test_optional_constraints.py) to verify rendering and include emission behavior. This enables creating optional/global constraints that are omitted until explicitly enabled while preserving default behavior for existing constraints.

Author: Arthod

src/pymzm/constraint.py

@@ -54,7 +54,7 @@ class Constraint:
         "connected",
         "reachable"
     ]
-    def __init__(self, cstr: ExpressionBool, ctype: str=CTYPE_NORMAL, annotation: str=None, is_redundant=False):
+    def __init__(self, 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))):
             raise PymzmValueIsNotCondition("cstr", self.cstr)
@@ -69,6 +69,7 @@ def __init__(self, cstr: ExpressionBool, ctype: str=CTYPE_NORMAL, annotation: st
                 raise PymzmInvalidConstraintAnnotation("annotation")
 
         self.is_redundant = is_redundant
+        self.enabled = enabled
 
     def __str__(self):
         return self.cstr

src/pymzm/model.py

@@ -376,21 +376,39 @@ def add_variables(self, name: str, indices: List[Tuple[int]], vtype: int=Variabl
 
         return variables
 
-    def add_constraint(self, constraint: ExpressionBool, is_redundant=False):
+    def add_constraint(self, constraint: ExpressionBool, is_redundant=False, enabled=True):
         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)
+            constraint = Constraint(constraint.name, is_redundant=is_redundant, enabled=enabled)
 
         else:
             raise Exception("invalid constraint type")
 
         self.constraints.append(constraint)
         return constraint
 
+    def add_optional_constraint(self, constraint: ExpressionBool, enabled=False, is_redundant=False):
+        return self.add_constraint(constraint, is_redundant=is_redundant, enabled=enabled)
+
+    def add_assumption(self, constraint: ExpressionBool, enabled=True, is_redundant=False):
+        return self.add_optional_constraint(constraint, enabled=enabled, is_redundant=is_redundant)
+
+    def set_constraint_enabled(self, constraint: Constraint, enabled=True):
+        assert constraint in self.constraints
+        constraint.enabled = enabled
+        return constraint
+
+    def enable_constraint(self, constraint: Constraint):
+        return self.set_constraint_enabled(constraint, True)
+
+    def disable_constraint(self, constraint: Constraint):
+        return self.set_constraint_enabled(constraint, False)
+
     def add_include(self, include_file: str):
         assert isinstance(include_file, str)
         include_file = include_file.strip()
@@ -402,11 +420,11 @@ def add_includes(self, include_files):
         for include_file in include_files:
             self.add_include(include_file)
 
-    def add_constraints(self, constraints: List[Constraint], is_redundant=False):
+    def add_constraints(self, constraints: List[Constraint], is_redundant=False, enabled=True):
         constraints = list(constraints)
         assert all(isinstance(constraint, (Constraint, Expression, str, bool)) for constraint in constraints)
         for constraint in constraints:
-            self.add_constraint(constraint, is_redundant=is_redundant)
+            self.add_constraint(constraint, is_redundant=is_redundant, enabled=enabled)
 
     def add_function_declaration(self, declaration: str):
         assert isinstance(declaration, str)
@@ -636,7 +654,16 @@ def check_satisfiable(
     def to_ir(self) -> ModelIR:
         assert self.solve_criteria is not None
 
-        includes = tuple(sorted({*(f"{gconst}.mzn" for gconst in self.global_constraints), *self.includes}))
+        enabled_constraints = tuple(
+            constraint for constraint in self.constraints
+            if constraint.enabled
+        )
+        auto_includes = {
+            f"{constraint.ctype}.mzn"
+            for constraint in enabled_constraints
+            if constraint.ctype != Constraint.CTYPE_NORMAL
+        }
+        includes = tuple(sorted({*auto_includes, *self.includes}))
 
         constants_sorted = sorted(self.constants, key=lambda c: c.name)
         parameters_sorted = sorted(self.parameters, key=lambda p: p.name)
@@ -657,7 +684,7 @@ def to_ir(self) -> ModelIR:
         )
         constraints = tuple(
             line.rstrip("\n")
-            for line in (constraint._to_mz() for constraint in self.constraints)
+            for line in (constraint._to_mz() for constraint in enabled_constraints)
         )
         output_items = tuple(self.output_items)
         solve = SolveIR(

tests/test_optional_constraints.py

@@ -0,0 +1,61 @@
+import unittest
+import pytest
+
+import pymzm
+from pymzm.backends import MznTextBackend
+from tests.mzn_verifier import assert_valid_mzn
+
+
+pytestmark = [pytest.mark.unit, pytest.mark.snapshot]
+
+
+class TestOptionalConstraints(unittest.TestCase):
+    def test_disabled_constraint_is_omitted_until_enabled(self):
+        model = pymzm.Model()
+        x = model.add_variable("x", val_min=0, val_max=3)
+        active = model.add_constraint(x >= 1)
+        optional = model.add_optional_constraint(x <= 2)
+        model.set_solve_criteria(pymzm.SOLVE_SATISFY)
+
+        disabled_render = MznTextBackend().render_model(model.to_ir())
+        self.assertIn("constraint (x >= 1);", disabled_render)
+        self.assertNotIn("constraint (x <= 2);", disabled_render)
+
+        model.enable_constraint(optional)
+        enabled_render = MznTextBackend().render_model(model.to_ir())
+        self.assertIn("constraint (x >= 1);", enabled_render)
+        self.assertIn("constraint (x <= 2);", enabled_render)
+        self.assertIs(active.enabled, True)
+        assert_valid_mzn(self, enabled_render)
+
+    def test_disabled_global_constraint_does_not_emit_include(self):
+        model = pymzm.Model()
+        x = model.add_variable("x", val_min=1, val_max=3)
+        y = model.add_variable("y", val_min=1, val_max=3)
+        optional = model.add_optional_constraint(pymzm.Constraint.alldifferent([x, y]))
+        model.set_solve_criteria(pymzm.SOLVE_SATISFY)
+
+        disabled_render = MznTextBackend().render_model(model.to_ir())
+        self.assertNotIn('include "alldifferent.mzn";', disabled_render)
+        self.assertNotIn("constraint alldifferent", disabled_render)
+
+        model.enable_constraint(optional)
+        enabled_render = MznTextBackend().render_model(model.to_ir())
+        self.assertIn('include "alldifferent.mzn";', enabled_render)
+        self.assertIn("constraint alldifferent([x, y]);", enabled_render)
+
+    def test_add_assumption_alias_can_be_disabled(self):
+        model = pymzm.Model()
+        x = model.add_variable("x", val_min=0, val_max=2)
+        assumption = model.add_assumption(x >= 0)
+        model.set_solve_criteria(pymzm.SOLVE_SATISFY)
+
+        self.assertTrue(assumption.enabled)
+        model.disable_constraint(assumption)
+
+        rendered = MznTextBackend().render_model(model.to_ir())
+        self.assertNotIn("constraint (x >= 0);", rendered)
+
+
+if __name__ == "__main__":
+    unittest.main()