Add arg validation for global constraints & tests

Introduce ExprLike type alias and tighten type hints for global constraint wrappers to accept Sequence[ExprLike]. Add helper methods (_as_non_empty_list, _assert_same_length) and assertions to ensure non-empty inputs and matching lengths (with special-case handling in regular for set f). Update many Constraint.* static methods to use these checks and normalize inputs. Add an integration test (tests/test_global_constraints_integration.py) that exercises all global constraint wrappers and verifies generated MiniZinc output. These changes improve input validation and catch misuse earlier.

Author: Arthod

pyproject.toml

@@ -26,6 +26,37 @@ markers = [
   "no_mzn_verify: skip global MiniZinc CLI validation for tests that intentionally render unresolved include paths",
 ]
 
+[tool.ruff]
+target-version = "py38"
+
+[tool.ruff.lint]
+ignore = [
+  "F403", # package exports and core modules intentionally use wildcard imports
+  "F405", # project relies on re-export style imports in core DSL modules
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**/*.py" = [
+  "F401", # many scenario tests keep exploratory imports
+  "F841", # tests sometimes keep named variables for readability
+  "E741", # legacy variable names in classic combinatorics examples
+  "E712", # explicit boolean equality kept in tests for intent clarity
+]
+
+[tool.mypy]
+python_version = "3.12"
+ignore_missing_imports = true
+no_implicit_optional = false
+disable_error_code = [
+  "override",
+  "assignment",
+  "arg-type",
+  "return-value",
+  "operator",
+  "list-item",
+  "attr-defined",
+]
+
 [tool.coverage.run]
 source = ["pymzm"]
 

src/pymzm/constraint.py

@@ -1,5 +1,5 @@
 
-from typing import List
+from typing import Sequence, Union
 
 from .exceptions import *
 from .expression import *
@@ -27,6 +27,8 @@ class AnnotationConstraint:
     ]
 
 class Constraint:
+    ExprLike = Union[Expression, int, float, bool, str]
+
     CTYPES = [
         CTYPE_NORMAL,
         CTYPE_ALLDIFFERENT,
@@ -113,11 +115,21 @@ def _to_mz(self):
             return f"constraint {self.cstr}{annotation_suffix};\n"
 
     @staticmethod
-    def _from_global_constraint(func: str, ctype: str, *args):
+    def _from_global_constraint(func: str, ctype: str, *args) -> "Constraint":
         return Constraint(f"{func}({', '.join(str(a) for a in args)})", ctype)
 
     @staticmethod
-    def alldifferent(exprs: List[Expression]) -> "Constraint":
+    def _as_non_empty_list(values, arg_name: str):
+        values = list(values)
+        assert len(values) > 0, f"{arg_name} cannot be empty"
+        return values
+
+    @staticmethod
+    def _assert_same_length(arg_name_left: str, left, arg_name_right: str, right):
+        assert len(left) == len(right), f"{arg_name_left} and {arg_name_right} must have the same length"
+
+    @staticmethod
+    def alldifferent(exprs: Sequence[ExprLike]) -> "Constraint":
         """Constrain the elements in the passed List to be pairwise different.
 
         Args:
@@ -126,120 +138,210 @@ def alldifferent(exprs: List[Expression]) -> "Constraint":
         Returns:
             Constraint: Alldifferent constraint
         """
+        exprs = Constraint._as_non_empty_list(exprs, "exprs")
         return Constraint._from_global_constraint("alldifferent", Constraint.CTYPE_ALLDIFFERENT, exprs)
 
     @staticmethod
-    def all_different(exprs: List[Expression]) -> "Constraint":
+    def all_different(exprs: Sequence[ExprLike]) -> "Constraint":
         return Constraint.alldifferent(exprs)
 
     @staticmethod
-    def among(n: int, exprs: List[Expression], values: List[int]):
+    def among(n: ExprLike, exprs: Sequence[ExprLike], values: Sequence[ExprLike]) -> "Constraint":
+        exprs = Constraint._as_non_empty_list(exprs, "exprs")
+        values = Constraint._as_non_empty_list(values, "values")
         return Constraint._from_global_constraint("among", Constraint.CTYPE_AMONG, n, exprs, values)
 
     @staticmethod
-    def all_equal(exprs: List[Expression]):
+    def all_equal(exprs: Sequence[ExprLike]) -> "Constraint":
+        exprs = Constraint._as_non_empty_list(exprs, "exprs")
         return Constraint._from_global_constraint("all_equal", Constraint.CTYPE_ALL_EQUAL, exprs)
 
     @staticmethod
-    def count(exprs: List[Expression], val: int, count: int):
+    def count(exprs: Sequence[ExprLike], val: ExprLike, count: ExprLike) -> "Constraint":
+        exprs = Constraint._as_non_empty_list(exprs, "exprs")
         return Constraint._from_global_constraint("count", Constraint.CTYPE_COUNT, exprs, val, count)
 
     @staticmethod
-    def increasing(exprs: List[Expression]):
+    def increasing(exprs: Sequence[ExprLike]) -> "Constraint":
         # Requires that the array x is in (non-strictly) increasing order (duplicates are allowed).
+        exprs = Constraint._as_non_empty_list(exprs, "exprs")
         return Constraint._from_global_constraint("increasing", Constraint.CTYPE_INCREASING, exprs)
 
     @staticmethod
-    def strictly_increasing(exprs: List[Expression]):
+    def strictly_increasing(exprs: Sequence[ExprLike]) -> "Constraint":
+        exprs = Constraint._as_non_empty_list(exprs, "exprs")
         return Constraint._from_global_constraint("strictly_increasing", Constraint.CTYPE_STRICTLY_INCREASING, exprs)
 
     @staticmethod
-    def decreasing(exprs: List[Expression]):
+    def decreasing(exprs: Sequence[ExprLike]) -> "Constraint":
         # Requires that the array x is in (non-strictly) decreasing order (duplicates are allowed).
+        exprs = Constraint._as_non_empty_list(exprs, "exprs")
         return Constraint._from_global_constraint("decreasing", Constraint.CTYPE_DECREASING, exprs)
 
     @staticmethod
-    def strictly_decreasing(exprs: List[Expression]):
+    def strictly_decreasing(exprs: Sequence[ExprLike]) -> "Constraint":
+        exprs = Constraint._as_non_empty_list(exprs, "exprs")
         return Constraint._from_global_constraint("strictly_decreasing", Constraint.CTYPE_STRICTLY_DECREASING, exprs)
 
     @staticmethod
-    def element(index: Expression, values: List[Expression], value: Expression):
+    def element(index: ExprLike, values: Sequence[ExprLike], value: ExprLike) -> "Constraint":
+        values = Constraint._as_non_empty_list(values, "values")
         return Constraint._from_global_constraint("element", Constraint.CTYPE_ELEMENT, index, values, value)
 
     @staticmethod
-    def table(exprs: List[Expression], rows):
+    def table(exprs: Sequence[ExprLike], rows: Sequence[Sequence[ExprLike]]) -> "Constraint":
+        exprs = Constraint._as_non_empty_list(exprs, "exprs")
+        rows = Constraint._as_non_empty_list(rows, "rows")
+        assert all(len(row) == len(exprs) for row in rows), "all table rows must match exprs width"
         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):
+    def cumulative(s: Sequence[ExprLike], d: Sequence[ExprLike], r: Sequence[ExprLike], b: ExprLike) -> "Constraint":
+        s = Constraint._as_non_empty_list(s, "s")
+        d = Constraint._as_non_empty_list(d, "d")
+        r = Constraint._as_non_empty_list(r, "r")
+        Constraint._assert_same_length("s", s, "d", d)
+        Constraint._assert_same_length("s", s, "r", r)
         return Constraint._from_global_constraint("cumulative", Constraint.CTYPE_CUMULATIVE, s, d, r, b)
 
     @staticmethod
-    def disjunctive(s: List[Expression], d: List[Expression]):
+    def disjunctive(s: Sequence[ExprLike], d: Sequence[ExprLike]) -> "Constraint":
         # Requires that a set of tasks given by start times s and durations d do not overlap in time. 
         # Tasks with duration 0 can be scheduled at any time, even in the middle of other tasks.
+        s = Constraint._as_non_empty_list(s, "s")
+        d = Constraint._as_non_empty_list(d, "d")
+        Constraint._assert_same_length("s", s, "d", d)
         return Constraint._from_global_constraint("disjunctive", Constraint.CTYPE_DISJUNCTIVE, s, d)
 
     @staticmethod
-    def disjunctive_strict(s: List[Expression], d: List[Expression]):
+    def disjunctive_strict(s: Sequence[ExprLike], d: Sequence[ExprLike]) -> "Constraint":
         # 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.
+        s = Constraint._as_non_empty_list(s, "s")
+        d = Constraint._as_non_empty_list(d, "d")
+        Constraint._assert_same_length("s", s, "d", d)
         return Constraint._from_global_constraint("disjunctive_strict", Constraint.CTYPE_DISJUNCTIVE, s, d)
 
     @staticmethod
-    def circuit(successors: List[Expression]):
+    def circuit(successors: Sequence[ExprLike]) -> "Constraint":
+        successors = Constraint._as_non_empty_list(successors, "successors")
         return Constraint._from_global_constraint("circuit", Constraint.CTYPE_CIRCUIT, successors)
 
     @staticmethod
-    def path(successors: List[Expression], start: Expression, end: Expression):
+    def path(successors: Sequence[ExprLike], start: ExprLike, end: ExprLike) -> "Constraint":
+        successors = Constraint._as_non_empty_list(successors, "successors")
         return Constraint._from_global_constraint("path", Constraint.CTYPE_PATH, successors, start, end)
 
     @staticmethod
-    def bin_packing(capacity: Expression, bins: List[Expression], weights: List[Expression]):
+    def bin_packing(capacity: ExprLike, bins: Sequence[ExprLike], weights: Sequence[ExprLike]) -> "Constraint":
+        bins = Constraint._as_non_empty_list(bins, "bins")
+        weights = Constraint._as_non_empty_list(weights, "weights")
+        Constraint._assert_same_length("bins", bins, "weights", weights)
         return Constraint._from_global_constraint("bin_packing", Constraint.CTYPE_BIN_PACKING, capacity, bins, weights)
 
     @staticmethod
-    def inverse(forward: List[Expression], backward: List[Expression]):
+    def inverse(forward: Sequence[ExprLike], backward: Sequence[ExprLike]) -> "Constraint":
+        forward = Constraint._as_non_empty_list(forward, "forward")
+        backward = Constraint._as_non_empty_list(backward, "backward")
+        Constraint._assert_same_length("forward", forward, "backward", backward)
         return Constraint._from_global_constraint("inverse", Constraint.CTYPE_INVERSE, forward, backward)
 
     @staticmethod
-    def lex_less(left: List[Expression], right: List[Expression]):
+    def lex_less(left: Sequence[ExprLike], right: Sequence[ExprLike]) -> "Constraint":
+        left = Constraint._as_non_empty_list(left, "left")
+        right = Constraint._as_non_empty_list(right, "right")
+        Constraint._assert_same_length("left", left, "right", right)
         return Constraint._from_global_constraint("lex_less", Constraint.CTYPE_LEX_LESS, left, right)
 
     @staticmethod
-    def lex_lesseq(left: List[Expression], right: List[Expression]):
+    def lex_lesseq(left: Sequence[ExprLike], right: Sequence[ExprLike]) -> "Constraint":
+        left = Constraint._as_non_empty_list(left, "left")
+        right = Constraint._as_non_empty_list(right, "right")
+        Constraint._assert_same_length("left", left, "right", right)
         return Constraint._from_global_constraint("lex_lesseq", Constraint.CTYPE_LEX_LESSEQ, left, right)
 
     @staticmethod
-    def lex_greater(left: List[Expression], right: List[Expression]):
+    def lex_greater(left: Sequence[ExprLike], right: Sequence[ExprLike]) -> "Constraint":
+        left = Constraint._as_non_empty_list(left, "left")
+        right = Constraint._as_non_empty_list(right, "right")
+        Constraint._assert_same_length("left", left, "right", right)
         return Constraint._from_global_constraint("lex_greater", Constraint.CTYPE_LEX_GREATER, left, right)
 
     @staticmethod
-    def lex_greatereq(left: List[Expression], right: List[Expression]):
+    def lex_greatereq(left: Sequence[ExprLike], right: Sequence[ExprLike]) -> "Constraint":
+        left = Constraint._as_non_empty_list(left, "left")
+        right = Constraint._as_non_empty_list(right, "right")
+        Constraint._assert_same_length("left", left, "right", right)
         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):
+    def regular(
+        exprs: Sequence[ExprLike],
+        q: ExprLike,
+        s: ExprLike,
+        d: Sequence[Sequence[ExprLike]],
+        q0: ExprLike,
+        f: Sequence[ExprLike],
+    ) -> "Constraint":
+        exprs = Constraint._as_non_empty_list(exprs, "exprs")
+        d = Constraint._as_non_empty_list(d, "d")
+        if (isinstance(f, set)):
+            assert len(f) > 0, "f cannot be empty"
+        else:
+            f = Constraint._as_non_empty_list(f, "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]):
+    def arg_sort(x: Sequence[ExprLike], p: Sequence[ExprLike]) -> "Constraint":
         # Constrains p to be the permutation which causes x to be in sorted order hence x[p[i]] <= x[p[i+1]].
+        x = Constraint._as_non_empty_list(x, "x")
+        p = Constraint._as_non_empty_list(p, "p")
+        Constraint._assert_same_length("x", x, "p", p)
         return Constraint._from_global_constraint("arg_sort", Constraint.CTYPE_ARG_SORT, x, p)
 
     @staticmethod
-    def diffn(x: List[Expression], y: List[Expression], dx: List[Expression], dy: List[Expression]):
+    def diffn(x: Sequence[ExprLike], y: Sequence[ExprLike], dx: Sequence[ExprLike], dy: Sequence[ExprLike]) -> "Constraint":
         # Constrains rectangles i, given by their origins (x[i], y[i]) and sizes (dx[i], dy[i]),
         # to be non-overlapping. Zero-width rectangles can still not overlap with any other rectangle.
+        x = Constraint._as_non_empty_list(x, "x")
+        y = Constraint._as_non_empty_list(y, "y")
+        dx = Constraint._as_non_empty_list(dx, "dx")
+        dy = Constraint._as_non_empty_list(dy, "dy")
+        Constraint._assert_same_length("x", x, "y", y)
+        Constraint._assert_same_length("x", x, "dx", dx)
+        Constraint._assert_same_length("x", x, "dy", dy)
         return Constraint._from_global_constraint("diffn", Constraint.CTYPE_DIFFN, x, y, dx, dy)
 
     @staticmethod
-    def connected(node_from: List[int], node_to: List[int], ns: List[ExpressionBool], es: List[ExpressionBool]):
+    def connected(
+        node_from: Sequence[int],
+        node_to: Sequence[int],
+        ns: Sequence[ExprLike],
+        es: Sequence[ExprLike],
+    ) -> "Constraint":
         # Constrains the subgraph ns and es of a given undirected graph to be connected.
+        node_from = Constraint._as_non_empty_list(node_from, "node_from")
+        node_to = Constraint._as_non_empty_list(node_to, "node_to")
+        ns = Constraint._as_non_empty_list(ns, "ns")
+        es = Constraint._as_non_empty_list(es, "es")
+        Constraint._assert_same_length("node_from", node_from, "node_to", node_to)
+        Constraint._assert_same_length("node_from", node_from, "es", es)
         return Constraint._from_global_constraint("connected", Constraint.CTYPE_CONNECTED, node_from, node_to, ns, es)
 
     @staticmethod
-    def reachable(node_from: List[int], node_to: List[int], r: List[Expression], ns: List[ExpressionBool], es: List[ExpressionBool]):
+    def reachable(
+        node_from: Sequence[int],
+        node_to: Sequence[int],
+        r: ExprLike,
+        ns: Sequence[ExprLike],
+        es: Sequence[ExprLike],
+    ) -> "Constraint":
         # Constrains the subgraph ns and es of a given undirected graph to be reachable from r.
         # TODO: this can have other parameters.
+        node_from = Constraint._as_non_empty_list(node_from, "node_from")
+        node_to = Constraint._as_non_empty_list(node_to, "node_to")
+        ns = Constraint._as_non_empty_list(ns, "ns")
+        es = Constraint._as_non_empty_list(es, "es")
+        Constraint._assert_same_length("node_from", node_from, "node_to", node_to)
+        Constraint._assert_same_length("node_from", node_from, "es", es)
         return Constraint._from_global_constraint("reachable", Constraint.CTYPE_REACHABLE, node_from, node_to, r, ns, es)

src/pymzm/exceptions.py

@@ -66,4 +66,4 @@ class PymzmInvalidSearchAnnotation(PymzmException):
     def __init__(self):
         pass
     def __str__(self):
-        return f"PymzmInvalidSearchAnnotation."
+        return "PymzmInvalidSearchAnnotation."

src/pymzm/expression.py

@@ -386,7 +386,7 @@ def _func(cls, func_symbol: str, exprs):
                 exprs2.append(expr.name)
             else:
                 exprs2.append(expr)
-        out = f", ".join(str(a) for a in exprs2)
+        out = ", ".join(str(a) for a in exprs2)
         return cls(f"{func_symbol}({out})")
 
     @staticmethod

src/pymzm/model.py

@@ -131,11 +131,11 @@ def __init__(self, search_type: str, variables: List["Variable"], varchoice: str
         self.variables = variables
 
         self.varchoice = varchoice
-        if (not self.varchoice in AnnotationVariableChoice.VARCHOICES):
+        if (self.varchoice not in AnnotationVariableChoice.VARCHOICES):
             raise PymzmInvalidVarchoiceAnnotation("varchoice")
 
         self.valchoice = valchoice
-        if (not self.valchoice in AnnotationValueChoice.VALCHOICES):
+        if (self.valchoice not in AnnotationValueChoice.VALCHOICES):
             raise PymzmInvalidValchoiceAnnotation("valchoice")
 
     def __str__(self):
@@ -328,25 +328,27 @@ def add_enum(self, type_name: str, members: List[str]) -> EnumDomain:
         self.enums[type_name] = enum_domain
         return enum_domain
 
-    def add_variable(self, name: str, vtype: int=Variable.VTYPE_INTEGER, val_min: int=None, val_max: int=None, domain: set=None, annotations=None):
+    def add_variable(self, name: str, vtype: int=Variable.VTYPE_INTEGER, val_min: int=None, val_max: int=None, domain=None, annotations=None):
         variable = Variable(name, vtype, val_min, val_max, domain, annotations=annotations)
         self.variables.append(variable)
         return variable
 
-    def add_variables(self, name: str, indices: List[Tuple[int]], vtype: int=Variable.VTYPE_INTEGER, val_min: int=None, val_max: int=None, domains: set=None, annotations=None) -> ValueDict:
+    def add_variables(self, name: str, indices: List[Tuple[int]], vtype: int=Variable.VTYPE_INTEGER, val_min: int=None, val_max: int=None, domains=None, annotations=None) -> ValueDict:
 
         # Domain
         if (domains is None):
-            domains = {}
+            domain_map = {}
         elif (type(domains) is set):
-            domains = {idx: domains for idx in indices}
+            domain_map = {idx: domains for idx in indices}
         elif (type(domains) is list):
             assert len(domains) == len(indices)
-            domains = {idx: domains[i] for i, idx in enumerate(indices)}
+            domain_map = {idx: domains[i] for i, idx in enumerate(indices)}
         elif (type(domains) is dict):
             assert len(domains) == len(indices)
             assert set(domains.keys()) == set(indices)
-            domains = {idx: domains[idx] for idx in indices}
+            domain_map = {idx: domains[idx] for idx in indices}
+        else:
+            raise TypeError("domains must be None, set, list, or dict")
 
         # Annotations
         if (annotations is None):
@@ -368,7 +370,7 @@ def add_variables(self, name: str, indices: List[Tuple[int]], vtype: int=Variabl
                 vtype,
                 val_min,
                 val_max,
-                domains.get(idx, None),
+                domain_map.get(idx, None),
                 annotations=annotations.get(idx, None),
             )
             self.variables.append(variable)

src/pymzm/result.py

@@ -1,8 +1,6 @@
 from enum import Enum
 from typing import Any
 
-import minizinc
-
 
 _STATUS_MAP = {
     "SATISFIED": "SAT",