Add global constraint wrappers and tests

Introduce many global constraint types and convenience wrappers in Constraint (e.g. strictly_increasing/decreasing, element, table, cumulative, circuit, path, bin_packing, inverse, lex_* variants, regular) and add an all_different alias. Add unit tests for global constraints (tests/test_global_constraints.py) that verify rendering and required includes. Add a pytest marker no_mzn_verify (pyproject.toml) and update the test fixture to skip MiniZinc CLI validation when that marker is present; mark tests/test_includes.py accordingly. Misc test and tooling tweaks: use a distinct temp filename in mzn verifier, switch test runner bootstrap to invoke pytest in tests/test_all.py, and refactor solver utils imports/patching in tests/test_solver_utils.py.

Author: Arthod

pyproject.toml

@@ -23,6 +23,7 @@ markers = [
   "integration: tests that require MiniZinc solver/runtime",
   "snapshot: deterministic text rendering regression tests",
   "property: equivalence and property-style tests",
+  "no_mzn_verify: skip global MiniZinc CLI validation for tests that intentionally render unresolved include paths",
 ]
 
 [tool.coverage.run]

src/pymzm/constraint.py

@@ -34,8 +34,22 @@ class Constraint:
         CTYPE_ALL_EQUAL,
         CTYPE_COUNT,
         CTYPE_INCREASING,
+        CTYPE_STRICTLY_INCREASING,
         CTYPE_DECREASING,
+        CTYPE_STRICTLY_DECREASING,
+        CTYPE_ELEMENT,
+        CTYPE_TABLE,
+        CTYPE_CUMULATIVE,
         CTYPE_DISJUNCTIVE,
+        CTYPE_CIRCUIT,
+        CTYPE_PATH,
+        CTYPE_BIN_PACKING,
+        CTYPE_INVERSE,
+        CTYPE_LEX_LESS,
+        CTYPE_LEX_LESSEQ,
+        CTYPE_LEX_GREATER,
+        CTYPE_LEX_GREATEREQ,
+        CTYPE_REGULAR,
         CTYPE_ARG_SORT,
         CTYPE_DIFFN,
         CTYPE_CONNECTED,
@@ -47,8 +61,22 @@ class Constraint:
         "all_equal",
         "count",
         "increasing",
+        "strictly_increasing",
         "decreasing",
+        "strictly_decreasing",
+        "element",
+        "table",
+        "cumulative",
         "disjunctive",
+        "circuit",
+        "path",
+        "bin_packing",
+        "inverse",
+        "lex_less",
+        "lex_lesseq",
+        "lex_greater",
+        "lex_greatereq",
+        "regular",
         "arg_sort",
         "diffn",
         "connected",
@@ -99,6 +127,10 @@ def alldifferent(exprs: List[Expression]) -> "Constraint":
             Constraint: Alldifferent constraint
         """
         return Constraint._from_global_constraint("alldifferent", Constraint.CTYPE_ALLDIFFERENT, exprs)
+
+    @staticmethod
+    def all_different(exprs: List[Expression]) -> "Constraint":
+        return Constraint.alldifferent(exprs)
 
     @staticmethod
     def among(n: int, exprs: List[Expression], values: List[int]):
@@ -117,10 +149,30 @@ def increasing(exprs: List[Expression]):
         # Requires that the array x is in (non-strictly) increasing order (duplicates are allowed).
         return Constraint._from_global_constraint("increasing", Constraint.CTYPE_INCREASING, exprs)
 
+    @staticmethod
+    def strictly_increasing(exprs: List[Expression]):
+        return Constraint._from_global_constraint("strictly_increasing", Constraint.CTYPE_STRICTLY_INCREASING, exprs)
+
     @staticmethod
     def decreasing(exprs: List[Expression]):
         # Requires that the array x is in (non-strictly) decreasing order (duplicates are allowed).
         return Constraint._from_global_constraint("decreasing", Constraint.CTYPE_DECREASING, exprs)
+
+    @staticmethod
+    def strictly_decreasing(exprs: List[Expression]):
+        return Constraint._from_global_constraint("strictly_decreasing", Constraint.CTYPE_STRICTLY_DECREASING, exprs)
+
+    @staticmethod
+    def element(index: Expression, values: List[Expression], value: Expression):
+        return Constraint._from_global_constraint("element", Constraint.CTYPE_ELEMENT, index, values, value)
+
+    @staticmethod
+    def table(exprs: List[Expression], rows):
+        return Constraint._from_global_constraint("table", Constraint.CTYPE_TABLE, exprs, rows)
+
+    @staticmethod
+    def cumulative(s: List[Expression], d: List[Expression], r: List[Expression], b: Expression):
+        return Constraint._from_global_constraint("cumulative", Constraint.CTYPE_CUMULATIVE, s, d, r, b)
 
     @staticmethod
     def disjunctive(s: List[Expression], d: List[Expression]):
@@ -133,6 +185,42 @@ def disjunctive_strict(s: List[Expression], d: List[Expression]):
         # Requires that a set of tasks given by start times s and durations d do not overlap in time. 
         # Tasks with duration 0 CANNOT be scheduled at any time, but only when no other task is running.
         return Constraint._from_global_constraint("disjunctive_strict", Constraint.CTYPE_DISJUNCTIVE, s, d)
+
+    @staticmethod
+    def circuit(successors: List[Expression]):
+        return Constraint._from_global_constraint("circuit", Constraint.CTYPE_CIRCUIT, successors)
+
+    @staticmethod
+    def path(successors: List[Expression], start: Expression, end: Expression):
+        return Constraint._from_global_constraint("path", Constraint.CTYPE_PATH, successors, start, end)
+
+    @staticmethod
+    def bin_packing(capacity: Expression, bins: List[Expression], weights: List[Expression]):
+        return Constraint._from_global_constraint("bin_packing", Constraint.CTYPE_BIN_PACKING, capacity, bins, weights)
+
+    @staticmethod
+    def inverse(forward: List[Expression], backward: List[Expression]):
+        return Constraint._from_global_constraint("inverse", Constraint.CTYPE_INVERSE, forward, backward)
+
+    @staticmethod
+    def lex_less(left: List[Expression], right: List[Expression]):
+        return Constraint._from_global_constraint("lex_less", Constraint.CTYPE_LEX_LESS, left, right)
+
+    @staticmethod
+    def lex_lesseq(left: List[Expression], right: List[Expression]):
+        return Constraint._from_global_constraint("lex_lesseq", Constraint.CTYPE_LEX_LESSEQ, left, right)
+
+    @staticmethod
+    def lex_greater(left: List[Expression], right: List[Expression]):
+        return Constraint._from_global_constraint("lex_greater", Constraint.CTYPE_LEX_GREATER, left, right)
+
+    @staticmethod
+    def lex_greatereq(left: List[Expression], right: List[Expression]):
+        return Constraint._from_global_constraint("lex_greatereq", Constraint.CTYPE_LEX_GREATEREQ, left, right)
+
+    @staticmethod
+    def regular(exprs: List[Expression], q: Expression, s: Expression, d, q0: Expression, f):
+        return Constraint._from_global_constraint("regular", Constraint.CTYPE_REGULAR, exprs, q, s, d, q0, f)
 
     @staticmethod
     def arg_sort(x: List[Expression], p: List[Expression]):

tests/conftest.py

@@ -24,12 +24,16 @@ def pytest_collection_modifyitems(config, items):
 
 
 @pytest.fixture(autouse=True)
-def verify_rendered_mzn_models(monkeypatch):
+def verify_rendered_mzn_models(monkeypatch, request):
     # Keep local/unit workflow fast when CLI is unavailable.
     if (shutil.which("minizinc") is None):
         yield
         return
 
+    if (request.node.get_closest_marker("no_mzn_verify") is not None):
+        yield
+        return
+
     import pymzm
 
     original_render = pymzm.Model._render_model_string

tests/mzn_verifier.py

@@ -27,7 +27,7 @@ def _verify_with_minizinc_cli(model_path: Path):
 
 def verify_mzn_text(mzn_text: str):
     with tempfile.TemporaryDirectory() as tmpdir:
-        model_path = Path(tmpdir) / "model.mzn"
+        model_path = Path(tmpdir) / "pymzm_verify_input.mzn"
         model_path.write_text(mzn_text, encoding="utf-8")
         return _verify_with_minizinc_cli(model_path)
 

tests/test_all.py

@@ -1,10 +1,12 @@
-import unittest
+from pathlib import Path
+import sys
+
+import pytest
 
-from test_expression import TestExpression
-from test_examples import TestExamples
-from test_misc import TestMisc
-    
 
 if __name__ == "__main__":
-    suite = unittest.TestLoader().discover('tests')
-    unittest.TextTestRunner(verbosity=1).run(suite)
+    repo_root = Path(__file__).resolve().parents[1]
+    if (str(repo_root) not in sys.path):
+        sys.path.insert(0, str(repo_root))
+
+    raise SystemExit(pytest.main([str(Path(__file__).resolve().parent)]))

tests/test_global_constraints.py

@@ -0,0 +1,109 @@
+import unittest
+import pytest
+
+import pymzm
+from tests.mzn_verifier import assert_valid_mzn
+
+
+pytestmark = [pytest.mark.unit, pytest.mark.snapshot]
+
+
+class TestGlobalConstraints(unittest.TestCase):
+    def test_ordering_element_and_table_wrappers_render_with_includes(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)
+        z = model.add_variable("z", val_min=1, val_max=3)
+        idx = model.add_variable("idx", val_min=1, val_max=3)
+        picked = model.add_variable("picked", val_min=1, val_max=9)
+
+        model.add_constraint(pymzm.Constraint.all_different([x, y, z]))
+        model.add_constraint(pymzm.Constraint.strictly_increasing([x, y, z]))
+        model.add_constraint(pymzm.Constraint.strictly_decreasing([z, y, x]))
+        model.add_constraint(pymzm.Constraint.element(idx, [2, 4, 9], picked))
+        model.add_constraint(pymzm.Constraint.table([x, y], [[1, 2], [2, 3], [3, 1]]))
+        model.set_solve_criteria(pymzm.SOLVE_SATISFY)
+        model.generate()
+
+        lines = model.model_mzn_str.splitlines()
+        self.assertIn('include "alldifferent.mzn";', lines)
+        self.assertIn('include "strictly_increasing.mzn";', lines)
+        self.assertIn('include "strictly_decreasing.mzn";', lines)
+        self.assertIn('include "element.mzn";', lines)
+        self.assertIn('include "table.mzn";', lines)
+        self.assertIn('constraint alldifferent([x, y, z]);', lines)
+        self.assertIn('constraint strictly_increasing([x, y, z]);', lines)
+        self.assertIn('constraint strictly_decreasing([z, y, x]);', lines)
+        self.assertIn('constraint element(idx, [2, 4, 9], picked);', lines)
+        self.assertIn('constraint table([x, y], [[1, 2], [2, 3], [3, 1]]);', lines)
+        assert_valid_mzn(self, model.model_mzn_str)
+
+    def test_scheduling_graph_and_other_wrapper_families_render(self):
+        model = pymzm.Model()
+        s1 = model.add_variable("s1", val_min=0, val_max=5)
+        s2 = model.add_variable("s2", val_min=0, val_max=5)
+        n1 = model.add_variable("n1", val_min=1, val_max=3)
+        n2 = model.add_variable("n2", val_min=1, val_max=3)
+        n3 = model.add_variable("n3", val_min=1, val_max=3)
+        p1 = model.add_variable("p1", val_min=1, val_max=3)
+        p2 = model.add_variable("p2", val_min=1, val_max=3)
+        p3 = model.add_variable("p3", val_min=1, val_max=3)
+        b1 = model.add_variable("b1", val_min=1, val_max=2)
+        b2 = model.add_variable("b2", val_min=1, val_max=2)
+        left1 = model.add_variable("left1", val_min=0, val_max=3)
+        left2 = model.add_variable("left2", val_min=0, val_max=3)
+        right1 = model.add_variable("right1", val_min=0, val_max=3)
+        right2 = model.add_variable("right2", val_min=0, val_max=3)
+        sel1 = model.add_variable("sel1", vtype=pymzm.Variable.VTYPE_BOOL)
+        sel2 = model.add_variable("sel2", vtype=pymzm.Variable.VTYPE_BOOL)
+        edge1 = model.add_variable("edge1", vtype=pymzm.Variable.VTYPE_BOOL)
+        edge2 = model.add_variable("edge2", vtype=pymzm.Variable.VTYPE_BOOL)
+
+        model.add_constraint(pymzm.Constraint.cumulative([s1, s2], [2, 3], [1, 1], 2))
+        model.add_constraint(pymzm.Constraint.disjunctive([s1, s2], [2, 3]))
+        model.add_constraint(pymzm.Constraint.disjunctive_strict([s1, s2], [2, 3]))
+        model.add_constraint(pymzm.Constraint.circuit([n1, n2, n3]))
+        model.add_constraint(pymzm.Constraint.path([p1, p2, p3], 1, 3))
+        model.add_constraint(pymzm.Constraint.bin_packing(5, [b1, b2], [2, 3]))
+        model.add_constraint(pymzm.Constraint.inverse([n1, n2, n3], [p1, p2, p3]))
+        model.add_constraint(pymzm.Constraint.lex_lesseq([left1, left2], [right1, right2]))
+        model.add_constraint(pymzm.Constraint.lex_less([left1, left2], [right1, right2]))
+        model.add_constraint(pymzm.Constraint.regular([b1, b2], 2, 2, [[1, 2], [2, 1]], 1, {1}))
+        model.add_constraint(pymzm.Constraint.connected([1, 2], [2, 3], [sel1, sel2], [edge1, edge2]))
+        model.add_constraint(pymzm.Constraint.reachable([1, 2], [2, 3], 1, [sel1, sel2], [edge1, edge2]))
+        model.set_solve_criteria(pymzm.SOLVE_SATISFY)
+
+        ir = model.to_ir()
+
+        self.assertEqual(
+            ir.includes,
+            (
+                "bin_packing.mzn",
+                "circuit.mzn",
+                "connected.mzn",
+                "cumulative.mzn",
+                "disjunctive.mzn",
+                "inverse.mzn",
+                "lex_less.mzn",
+                "lex_lesseq.mzn",
+                "path.mzn",
+                "reachable.mzn",
+                "regular.mzn",
+            ),
+        )
+        self.assertIn('constraint cumulative([s1, s2], [2, 3], [1, 1], 2);', ir.constraints)
+        self.assertIn('constraint disjunctive([s1, s2], [2, 3]);', ir.constraints)
+        self.assertIn('constraint disjunctive_strict([s1, s2], [2, 3]);', ir.constraints)
+        self.assertIn('constraint circuit([n1, n2, n3]);', ir.constraints)
+        self.assertIn('constraint path([p1, p2, p3], 1, 3);', ir.constraints)
+        self.assertIn('constraint bin_packing(5, [b1, b2], [2, 3]);', ir.constraints)
+        self.assertIn('constraint inverse([n1, n2, n3], [p1, p2, p3]);', ir.constraints)
+        self.assertIn('constraint lex_lesseq([left1, left2], [right1, right2]);', ir.constraints)
+        self.assertIn('constraint lex_less([left1, left2], [right1, right2]);', ir.constraints)
+        self.assertIn('constraint regular([b1, b2], 2, 2, [[1, 2], [2, 1]], 1, {1});', ir.constraints)
+        self.assertIn('constraint connected([1, 2], [2, 3], [sel1, sel2], [edge1, edge2]);', ir.constraints)
+        self.assertIn('constraint reachable([1, 2], [2, 3], 1, [sel1, sel2], [edge1, edge2]);', ir.constraints)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_includes.py

@@ -4,7 +4,7 @@
 import pymzm
 
 
-pytestmark = [pytest.mark.unit, pytest.mark.snapshot]
+pytestmark = [pytest.mark.unit, pytest.mark.snapshot, pytest.mark.no_mzn_verify]
 
 
 class TestIncludes(unittest.TestCase):

tests/test_solver_utils.py

@@ -3,21 +3,21 @@
 import pytest
 
 import pymzm
-from tests.solver_utils import (
-    DEFAULT_RANDOM_SEED,
-    DEFAULT_SOLVER_TAG,
-    DEFAULT_THREADS,
-    deterministic_instance_solve,
-    deterministic_solver_config,
-    lookup_default_solver,
-)
+from tests import solver_utils as solver_utils_module
+
+DEFAULT_RANDOM_SEED = solver_utils_module.DEFAULT_RANDOM_SEED
+DEFAULT_SOLVER_TAG = solver_utils_module.DEFAULT_SOLVER_TAG
+DEFAULT_THREADS = solver_utils_module.DEFAULT_THREADS
+deterministic_instance_solve = solver_utils_module.deterministic_instance_solve
+deterministic_solver_config = solver_utils_module.deterministic_solver_config
+lookup_default_solver = solver_utils_module.lookup_default_solver
 
 
 pytestmark = [pytest.mark.unit]
 
 
 class TestSolverUtils(unittest.TestCase):
-    @patch("tests.solver_utils.minizinc.Solver.lookup")
+    @patch.object(solver_utils_module.minizinc.Solver, "lookup")
     def test_lookup_default_solver_uses_gecode(self, lookup_mock):
         sentinel = object()
         lookup_mock.return_value = sentinel