python-constraint2 2.0.0__cp313-cp313-win_amd64.whl

python_constraint2-2.0.0.dist-info/METADATA

@@ -0,0 +1,238 @@
+Metadata-Version: 2.3
+Name: python-constraint2
+Version: 2.0.0
+Summary: python-constraint is a module for efficiently solving CSPs (Constraint Solving Problems) over finite domains.
+License: BSD-2-Clause
+Keywords: CSP,constraint solving problems,problem solver,SMT,satisfiability modulo theory,SAT
+Author: Gustavo Niemeyer
+Author-email: gustavo@niemeyer.net
+Maintainer: Floris-Jan Willemsen
+Maintainer-email: fjwillemsen97@gmail.com
+Requires-Python: >=3.9,<3.14
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development
+Project-URL: Documentation, http://python-constraint.github.io/python-constraint/
+Project-URL: Repository, https://github.com/python-constraint/python-constraint
+Description-Content-Type: text/x-rst
+
+|License| |Build Status| |Docs| |Python Versions| |Downloads| |Status| |Code Coverage|
+
+.. image:: https://github.com/python-constraint/python-constraint/raw/main/docs/assets/logo/N-Queens_problem_Python.svg
+    :align: center
+    :width: 50%
+
+python-constraint
+=================
+
+| This software is now back to active development / maintainance status.
+| IMPORTANT: the new version can be installed with `pip install python-constraint2`, as the original pip release will not be updated.
+| For an overview of recent changes, visit the `Changelog <https://github.com/python-constraint/python-constraint/blob/main/CHANGELOG.md>`_.
+| The complete documentation can be found `here <http://python-constraint.github.io/python-constraint/>`_.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Introduction
+------------
+The :code:`python-constraint` module offers efficient solvers for `Constraint Satisfaction Problems (CSPs) <https://en.wikipedia.org/wiki/Constraint_satisfaction_problem>`_ over finite domains in an accessible Python package.
+CSP is class of problems which may be represented in terms of variables (a, b, ...), domains (a in [1, 2, 3], ...), and constraints (a < b, ...).
+
+Examples
+--------
+
+Basics
+~~~~~~
+
+This interactive Python session demonstrates basic operations:
+
+.. code-block:: python
+
+    >>> from constraint import *
+    >>> problem = Problem()
+    >>> problem.addVariable("a", [1,2,3])
+    >>> problem.addVariable("b", [4,5,6])
+    >>> problem.getSolutions()
+    [{'a': 3, 'b': 6}, {'a': 3, 'b': 5}, {'a': 3, 'b': 4},
+     {'a': 2, 'b': 6}, {'a': 2, 'b': 5}, {'a': 2, 'b': 4},
+     {'a': 1, 'b': 6}, {'a': 1, 'b': 5}, {'a': 1, 'b': 4}]
+
+    >>> problem.addConstraint(lambda a, b: a*2 == b,
+                              ("a", "b"))
+    >>> problem.getSolutions()
+    [{'a': 3, 'b': 6}, {'a': 2, 'b': 4}]
+
+    >>> problem = Problem()
+    >>> problem.addVariables(["a", "b"], [1, 2, 3])
+    >>> problem.addConstraint(AllDifferentConstraint())
+    >>> problem.getSolutions()
+    [{'a': 3, 'b': 2}, {'a': 3, 'b': 1}, {'a': 2, 'b': 3},
+     {'a': 2, 'b': 1}, {'a': 1, 'b': 2}, {'a': 1, 'b': 3}]
+
+Rooks problem
+~~~~~~~~~~~~~
+
+The following example solves the classical Eight Rooks problem:
+
+.. code-block:: python
+
+    >>> problem = Problem()
+    >>> numpieces = 8
+    >>> cols = range(numpieces)
+    >>> rows = range(numpieces)
+    >>> problem.addVariables(cols, rows)
+    >>> for col1 in cols:
+    ...     for col2 in cols:
+    ...         if col1 < col2:
+    ...             problem.addConstraint(lambda row1, row2: row1 != row2,
+    ...                                   (col1, col2))
+    >>> solutions = problem.getSolutions()
+    >>> solutions
+    >>> solutions
+    [{0: 7, 1: 6, 2: 5, 3: 4, 4: 3, 5: 2, 6: 1, 7: 0},
+     {0: 7, 1: 6, 2: 5, 3: 4, 4: 3, 5: 2, 6: 0, 7: 1},
+     {0: 7, 1: 6, 2: 5, 3: 4, 4: 3, 5: 1, 6: 2, 7: 0},
+     {0: 7, 1: 6, 2: 5, 3: 4, 4: 3, 5: 1, 6: 0, 7: 2},
+     ...
+     {0: 7, 1: 5, 2: 3, 3: 6, 4: 2, 5: 1, 6: 4, 7: 0},
+     {0: 7, 1: 5, 2: 3, 3: 6, 4: 1, 5: 2, 6: 0, 7: 4},
+     {0: 7, 1: 5, 2: 3, 3: 6, 4: 1, 5: 2, 6: 4, 7: 0},
+     {0: 7, 1: 5, 2: 3, 3: 6, 4: 1, 5: 4, 6: 2, 7: 0},
+     {0: 7, 1: 5, 2: 3, 3: 6, 4: 1, 5: 4, 6: 0, 7: 2},
+     ...]
+
+
+Magic squares
+~~~~~~~~~~~~~
+
+This example solves a 4x4 magic square:
+
+.. code-block:: python
+
+    >>> problem = Problem()
+    >>> problem.addVariables(range(0, 16), range(1, 16 + 1))
+    >>> problem.addConstraint(AllDifferentConstraint(), range(0, 16))
+    >>> problem.addConstraint(ExactSumConstraint(34), [0, 5, 10, 15])
+    >>> problem.addConstraint(ExactSumConstraint(34), [3, 6, 9, 12])
+    >>> for row in range(4):
+    ...     problem.addConstraint(ExactSumConstraint(34),
+                                  [row * 4 + i for i in range(4)])
+    >>> for col in range(4):
+    ...     problem.addConstraint(ExactSumConstraint(34),
+                                  [col + 4 * i for i in range(4)])
+    >>> solutions = problem.getSolutions()
+
+Features
+--------
+
+The following solvers are available:
+
+- Backtracking solver
+- Optimized backtracking solver
+- Recursive backtracking solver
+- Minimum conflicts solver
+
+.. role:: python(code)
+   :language: python
+
+Predefined constraint types currently available:
+
+- :python:`FunctionConstraint`
+- :python:`AllDifferentConstraint`
+- :python:`AllEqualConstraint`
+- :python:`MaxSumConstraint`
+- :python:`ExactSumConstraint`
+- :python:`MinSumConstraint`
+- :python:`MaxProdConstraint`
+- :python:`MinProdConstraint`
+- :python:`InSetConstraint`
+- :python:`NotInSetConstraint`
+- :python:`SomeInSetConstraint`
+- :python:`SomeNotInSetConstraint`
+
+API documentation
+-----------------
+Documentation for the module is available at: http://python-constraint.github.io/python-constraint/.
+It can be built locally by running :code:`make clean html` from the `docs` folder.
+For viewing RST files locally, `restview <https://pypi.org/project/restview/>`_ is recommended.
+
+Download and install
+--------------------
+
+.. code-block:: shell
+
+    $ pip install python-constraint2
+
+Testing
+-------
+
+Run :code:`nox` (tests for all supported Python versions in own virtual environment).
+
+To test against your local Python version: make sure you have the development dependencies installed.
+Run :code:`pytest` (optionally add :code:`--no-cov` if you have the C-extensions enabled).
+
+Contributing
+------------
+
+Feel free to contribute by `submitting pull requests <https://github.com/python-constraint/python-constraint/pulls>`_ or `opening issues <https://github.com/python-constraint/python-constraint/issues>`_.
+Please refer to the `contribution guidelines <https://github.com/python-constraint/python-constraint/contribute>`_ before doing so.
+
+Roadmap
+-------
+
+This GitHub organization and repository is a global effort to help to maintain :code:`python-constraint`, which was written by Gustavo Niemeyer and originaly located at https://labix.org/python-constraint.
+For an overview of recent changes, visit the `Changelog <https://github.com/python-constraint/python-constraint/blob/main/CHANGELOG.md>`_.
+
+Planned development:
+
+- Add parallel-capable solver
+- Add a string parser for constraints
+- Versioned documentation
+
+Contact
+-------
+- `Floris-Jan Willemsen <https://github.com/fjwillemsen>`_ <fjwillemsen97@gmail.com> (current maintainer)
+- `Sébastien Celles <https://github.com/s-celles/>`_ <s.celles@gmail.com> (former maintainer)
+- `Gustavo Niemeyer <https://github.com/niemeyer/>`_ <gustavo@niemeyer.net> (initial developer)
+
+But it's probably better to `open an issue <https://github.com/python-constraint/python-constraint/issues>`_.
+
+.. |License| image:: https://img.shields.io/pypi/l/python-constraint2
+    :alt: PyPI - License
+
+.. |Build Status| image:: https://github.com/python-constraint/python-constraint/actions/workflows/build-test-python-package.yml/badge.svg
+   :target: https://github.com/python-constraint/python-constraint/actions/workflows/build-test-python-package.yml
+   :alt: Build Status
+
+.. |Docs| image:: https://img.shields.io/github/actions/workflow/status/python-constraint/python-constraint/publish-documentation.yml?label=Docs
+   :target: http://python-constraint.github.io/python-constraint/
+   :alt: Documentation Status
+
+.. |Python Versions| image:: https://img.shields.io/pypi/pyversions/python-constraint2
+    :alt: PyPI - Python Versions
+
+.. |Downloads| image:: https://img.shields.io/pypi/dm/python-constraint2
+    :alt: PyPI - Downloads
+
+.. |Status| image:: https://img.shields.io/pypi/status/python-constraint2
+    :alt: PyPI - Status
+
+.. |Code Coverage| image:: https://coveralls.io/repos/github/python-constraint/python-constraint/badge.svg
+   :target: https://coveralls.io/github/python-constraint/python-constraint
+   :alt: Code Coverage
+

python_constraint2-2.0.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+constraint/__init__.py,sha256=7on8Mi-QJJbw8EwG9dahObY7MgpOdTVkgky0Vs68kJA,1845
+constraint/constraints.c,sha256=sLlLgqvL9ZFLe8-5DWPRj5qdbtJDEDUGQN_uPX89BkQ,1288172
+constraint/constraints.py,sha256=rPdVdTTQflJVneGeTZ5q6WNYOU7mmmjx5boR7VC2uQs,31371
+constraint/domain.c,sha256=j_4sp_6FzlDsn7UpF4oe3cgFiIOxAZSt5dST8jrgptU,359677
+constraint/domain.py,sha256=XLzl619prCdB8vxSLAVQWQiFwEV2qRzyLqUJLqxmWrk,3031
+constraint/problem.c,sha256=LP1YGVG46BA7ZJmpBlOmJ5Rr1tx0L-nxxUgfbmZJ2Xo,670534
+constraint/problem.py,sha256=VnBMDLDSBmbqsHmzfh17TDraiXBM93IVA1wxz3XtOgs,9561
+constraint/solvers.c,sha256=Ay7M4-l79f1ec8K6ZjXFaR4brwSLZuQfbg0UCjwWbz8,1020661
+constraint/solvers.py,sha256=Wzt6THvpr3-LeuAZUWTl1cIundOwb5UFv0JJweMec20,23024
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/setup_teardown.py,sha256=z4g_jdHrz4Lnd22MCkIE9HCpr-wipQKX7-5p46ZFnj4,1390
+tests/test_compilation.py,sha256=En9Z9NcOxG9N0qIUCGwFib5Jq_uxdqg5_I79mm37Gj0,472
+tests/test_constraint.py,sha256=mKhbaKr0kN77qXGHQPsnDrNs5lzEInpDzP9L84HwDaI,3426
+tests/test_doctests.py,sha256=PUD7QeB-OufzwywquWS0NkVAU1zTUtkk_tcZikCtBzI,425
+tests/test_problem.py,sha256=k01G64kzZ969mC6iQxW87oYisvDIPQiZi5Y8fJa02qw,806
+tests/test_solvers.py,sha256=M28578HKaoRL5nBqBXSTktDCwNhqbN0ZdhcM6RyXZbA,2853
+tests/test_some_not_in_set.py,sha256=xgSairFNF4T-CYdAWhIv3qoOixnhGjWUdY01GzIjwds,3496
+tests/test_toml_file.py,sha256=JYpsOPWOY_-hIVPLw4J5kvLMf7qWxXN8c56JoNDhl3Y,2230
+python_constraint2-2.0.0.dist-info/LICENSE,sha256=-29wB_JJKS4anSogQEG0yZqx5lPZc2m8iPJhKL-p45A,1358
+python_constraint2-2.0.0.dist-info/METADATA,sha256=WwzCbJK7CQ3T8SMyNclOuNj5tlbub8DXd6qP9hhpguQ,9144
+python_constraint2-2.0.0.dist-info/WHEEL,sha256=CAXnmTOdevtyHhGbx1uQxRlUnaXo4-LVkad_lFClKZs,98
+python_constraint2-2.0.0.dist-info/RECORD,,

python_constraint2-2.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.0.1
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64

tests/setup_teardown.py

@@ -0,0 +1,40 @@
+"""General setup and teardown for the tests, and module-level tests."""
+from pathlib import Path
+import argparse
+
+
+def unuse_extensions():
+    """Make sure C-extensions are not used by adding an underscore to .so files."""
+    dir = Path("./constraint")
+    assert dir.exists()
+    files = dir.glob("*.so")
+    for file in files:
+        if file.name[0] != "_":
+            # add a leading underscore
+            file.rename(f"{dir}/_{file.name}")
+
+
+def use_extensions():
+    """Make sure C-extensions are used by removing the underscore to .so files."""
+    dir = Path("./constraint")
+    assert dir.exists()
+    files = dir.glob("_*.so")
+    for file in files:
+        if file.name[0] == "_":
+            # remove the leading underscore
+            file.rename(f"{dir}/{file.name[1:]}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--enable_extensions", action="store_true")
+    parser.add_argument("--no-enable_extensions", dest="enable_extensions", action="store_false")
+    parser.set_defaults(enable_extensions=True)
+    args = parser.parse_args()
+    enable_extensions = args.enable_extensions
+    if enable_extensions is True:
+        use_extensions()
+    elif enable_extensions is False:
+        unuse_extensions()
+    else:
+        raise ValueError(f"Invalid value for {enable_extensions=}")

tests/test_compilation.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+
+
+def test_if_compiled():
+    """Test whether C-extensions are succesfully ran, if enabled."""
+    from constraint import check_if_compiled
+
+    # check if the .so files are commented
+    dir = Path("./constraint")
+    assert dir.exists()
+    files = list(dir.glob("_*.so"))
+
+    # check if the code uses C-extensions
+    if len(files) > 0:
+        assert check_if_compiled() is False
+    else:
+        assert check_if_compiled()

tests/test_constraint.py

@@ -0,0 +1,127 @@
+import constraint
+
+from examples.abc import abc
+from examples.coins import coins
+
+# from examples.crosswords import crosswords
+from examples.einstein import einstein
+from examples.queens import queens
+from examples.rooks import rooks
+from examples.studentdesks import studentdesks
+
+# from examples.sudoku import sudoku
+# from examples.wordmath import (seisseisdoze, sendmoremoney, twotwofour)
+# from examples.xsum import xsum
+
+
+def test_abc():
+    solutions = abc.solve()
+    minvalue, minsolution = solutions
+    assert minvalue == 37
+    assert minsolution == {"a": 1, "c": 2, "b": 1}
+
+
+def test_coins():
+    solutions = coins.solve()
+    assert len(solutions) == 2
+
+
+def test_einstein():
+    solutions = einstein.solve()
+    expected_solutions = [
+        {
+            "nationality2": "dane",
+            "nationality3": "brit",
+            "nationality1": "norwegian",
+            "nationality4": "german",
+            "nationality5": "swede",
+            "color1": "yellow",
+            "color3": "red",
+            "color2": "blue",
+            "color5": "white",
+            "color4": "green",
+            "drink4": "coffee",
+            "drink5": "beer",
+            "drink1": "water",
+            "drink2": "tea",
+            "drink3": "milk",
+            "smoke5": "bluemaster",
+            "smoke4": "prince",
+            "smoke3": "pallmall",
+            "smoke2": "blends",
+            "smoke1": "dunhill",
+            "pet5": "dogs",
+            "pet4": "fish",
+            "pet1": "cats",
+            "pet3": "birds",
+            "pet2": "horses",
+        }
+    ]
+    assert solutions == expected_solutions
+
+
+def test_queens():
+    solutions, size = queens.solve()
+    assert size == 8
+    for solution in solutions:
+        queens.showSolution(solution, size)
+
+
+def test_rooks():
+    size = 8
+    solutions = rooks.solve(size)
+    assert len(solutions) == rooks.factorial(size)
+
+
+def test_studentdesks():
+    solutions = studentdesks.solve()
+    expected_solutions = {
+        1: "A",
+        2: "E",
+        3: "D",
+        4: "E",
+        5: "D",
+        6: "A",
+        7: "C",
+        8: "B",
+        9: "C",
+        10: "B",
+        11: "E",
+        12: "D",
+        13: "E",
+        14: "D",
+        15: "A",
+        16: "C",
+        17: "B",
+        18: "C",
+        19: "B",
+        20: "A",
+    }
+    assert solutions == expected_solutions
+
+
+def test_constraint_without_variables():
+    problem = constraint.Problem()
+    problem.addVariable("a", [1, 2, 3])
+    problem.addConstraint(lambda a: a * 2 == 6)
+    solutions = problem.getSolutions()
+    assert solutions == [{"a": 3}]
+
+
+def test_multipliers():
+    """Test the multiplier functionality in the constraints."""
+    from constraint import MaxSumConstraint, ExactSumConstraint, MinSumConstraint
+
+    problem = constraint.Problem()
+    problem.addVariable("x", [-1, 0, 1, 2])
+    problem.addVariable("y", [1, 2])
+    problem.addConstraint(MaxSumConstraint(4, [2, 1]), ["x", "y"])
+    problem.addConstraint(ExactSumConstraint(4, [1, 2]), ["x", "y"])
+    problem.addConstraint(MinSumConstraint(0, [0.5, 1]), ["x"])
+
+    possible_solutions = [{"y": 2, "x": 0}, {"y": 1, "x": 2}]
+
+    # get the solutions
+    solutions = problem.getSolutions()
+    for solution in solutions:
+        assert solution in possible_solutions

tests/test_doctests.py

@@ -0,0 +1,10 @@
+import doctest
+import constraint.problem as problem
+import constraint.domain as domain
+import constraint.constraints as constraints
+import constraint.solvers as solvers
+
+assert doctest.testmod(problem)[0] == 0
+assert doctest.testmod(domain)[0] == 0
+assert doctest.testmod(constraints, extraglobs={'Problem': problem.Problem})[0] == 0
+assert doctest.testmod(solvers, extraglobs={'Problem': problem.Problem})[0] == 0

tests/test_problem.py

@@ -0,0 +1,27 @@
+from constraint import Constraint, Domain, Problem
+
+
+def test_addVariable_support_domain_subclasses():
+    class MyCustomDomain(Domain):
+        pass
+
+    class MyConstraint(Constraint):
+        def __call__(self, variables, domains, assignments, forwardcheck=False):
+            assert isinstance(domains["x"], Domain)
+            assert isinstance(domains["y"], MyCustomDomain)
+            return True
+
+    problem = Problem()
+    problem.addVariable("x", [0, 1])
+    problem.addVariable("y", MyCustomDomain([0, 1]))
+    problem.addConstraint(MyConstraint())
+    solution = problem.getSolution()
+
+    possible_solutions = [
+        {"x": 0, "y": 0},
+        {"x": 0, "y": 1},
+        {"x": 1, "y": 0},
+        {"x": 1, "y": 1},
+    ]
+
+    assert solution in possible_solutions

tests/test_solvers.py

@@ -0,0 +1,72 @@
+from constraint import Problem, MinConflictsSolver, BacktrackingSolver, OptimizedBacktrackingSolver, RecursiveBacktrackingSolver, MaxProdConstraint, MinProdConstraint, MinSumConstraint, FunctionConstraint
+
+
+def test_min_conflicts_solver():
+    problem = Problem(MinConflictsSolver())
+    problem.addVariable("x", [0, 1])
+    problem.addVariable("y", [0, 1])
+
+    possible_solutions = [
+        {"x": 0, "y": 0},
+        {"x": 0, "y": 1},
+        {"x": 1, "y": 0},
+        {"x": 1, "y": 1},
+    ]
+
+    # test if all solutions are eventually found by iteration and adding the last solutions as a constraint
+    for _ in possible_solutions:
+        solution = problem.getSolution()
+        assert solution in possible_solutions
+        problem.addConstraint(FunctionConstraint(lambda x, y: (lambda x, y, xs, ys: x != xs or y != ys)(x, y, solution['x'], solution['y'])))
+
+def test_optimized_backtracking_solver():
+    # setup the solvers
+    problem_bt = Problem(BacktrackingSolver())
+    problem_opt = Problem(OptimizedBacktrackingSolver())
+    problem_opt_nfwd = Problem(OptimizedBacktrackingSolver(forwardcheck=False))
+    problems = [problem_bt, problem_opt, problem_opt_nfwd]
+
+    # define the problem for all solvers
+    for problem in problems:
+        problem.addVariable("x", [-1, 0, 1, 2])
+        problem.addVariable("y", [1, 2])
+        problem.addConstraint(MaxProdConstraint(2), ["x", "y"])
+        problem.addConstraint(MinProdConstraint(1), ["x", "y"])
+        problem.addConstraint(MinSumConstraint(0), ["x"])
+
+    # get the solutions
+    true_solutions = [(2, 1), (1, 2), (1, 1)]
+    order = ["x", "y"]
+    solution = problem_bt.getSolution()
+    solution_tuple = tuple(solution[key] for key in order)
+
+    # validate a single solution
+    solution_opt = problem_opt.getSolution()
+    assert tuple(solution_opt[key] for key in order) in true_solutions
+
+    # validate all solutions
+    def validate(solutions_list, solutions_dict, size):
+        assert size == len(true_solutions)
+        assert solution_tuple in solutions_list
+        assert solution_tuple in solutions_dict
+        assert all(sol in solutions_list for sol in true_solutions)
+
+    validate(*problem_opt.getSolutionsAsListDict(order=order))
+    validate(*problem_opt_nfwd.getSolutionsAsListDict(order=order))
+
+def test_recursive_backtracking_solver():
+    problem = Problem(RecursiveBacktrackingSolver())
+    problem.addVariable("x", [0, 1])
+    problem.addVariable("y", [0, 1])
+    solution = problem.getSolution()
+    solutions = problem.getSolutions()
+
+    possible_solutions = [
+        {"x": 0, "y": 0},
+        {"x": 0, "y": 1},
+        {"x": 1, "y": 0},
+        {"x": 1, "y": 1},
+    ]
+
+    assert solution in possible_solutions
+    assert all(sol in possible_solutions for sol in solutions)

tests/test_some_not_in_set.py

@@ -0,0 +1,99 @@
+from constraint import Domain, Variable, SomeNotInSetConstraint
+
+
+def test_empty_constraint():
+    constrainer = SomeNotInSetConstraint(set())
+    v1, v2 = variables = [Variable("v1"), Variable("v2")]
+    assignments = {v1: "a", v2: "b"}
+
+    assert constrainer(variables, {}, assignments)
+
+
+def test_no_overlap():
+    constrainer = SomeNotInSetConstraint(set("zy"))
+    v1, v2 = variables = [Variable("v1"), Variable("v2")]
+    assignments = {v1: "a", v2: "b"}
+
+    assert constrainer(variables, {}, assignments)
+
+
+def test_some_overlap():
+    constrainer = SomeNotInSetConstraint(set("b"))
+    v1, v2 = variables = [Variable("v1"), Variable("v2")]
+    assignments = {v1: "a", v2: "b"}
+
+    assert constrainer(variables, {}, assignments)
+
+
+def test_too_much_overlap():
+    constrainer = SomeNotInSetConstraint(set("ab"))
+    v1, v2 = variables = [Variable("v1"), Variable("v2")]
+    assignments = {v1: "a", v2: "b"}
+
+    assert not constrainer(variables, {}, assignments)
+
+
+def test_exact():
+    constrainer = SomeNotInSetConstraint(set("abc"), n=2, exact=True)
+    v1, v2, v3 = variables = [Variable("v1"), Variable("v2"), Variable("v3")]
+
+    assignments = {v1: "a", v2: "y", v3: "z"}
+    assert constrainer(variables, {}, assignments)
+
+    assignments = {v1: "a", v2: "y"}
+    assert constrainer(variables, {}, assignments)
+
+    assignments = {v1: "a", v2: "b", v3: "z"}
+    assert not constrainer(variables, {}, assignments)
+
+    assignments = {v1: "a", v2: "b"}
+    assert not constrainer(variables, {}, assignments)
+
+    assignments = {v1: "a", v2: "b", v3: "c"}
+    assert not constrainer(variables, {}, assignments)
+
+    assignments = {v1: "x", v2: "y", v3: "z"}
+    assert not constrainer(variables, {}, assignments)
+
+
+def test_forwardcheck():
+    constrainer = SomeNotInSetConstraint(set("abc"), n=2)
+    v1, v2, v3 = variables = [Variable("v1"), Variable("v2"), Variable("v3")]
+
+    domains = {v1: Domain(["a"]), v2: Domain(["b", "y"]), v3: Domain(["c", "z"])}
+    assert constrainer(variables, domains, {v1: "a"})
+    assert ["a"] == list(domains[v1])
+    assert ["b", "y"] == list(domains[v2])
+    assert ["c", "z"] == list(domains[v3])
+
+    assert constrainer(variables, domains, {v1: "a"}, True)
+    assert ["a"] == list(domains[v1])
+    assert ["y"] == list(domains[v2])
+    assert ["z"] == list(domains[v3])
+
+
+def test_forwardcheck_empty_domain():
+    constrainer = SomeNotInSetConstraint(set("abc"))
+    v1, v2 = variables = [Variable("v1"), Variable("v2")]
+
+    domains = {v1: Domain(["a"]), v2: Domain(["b"])}
+    assert constrainer(variables, domains, {v1: "a"})
+    assert not constrainer(variables, domains, {v1: "a"}, True)
+
+
+def test_forwardcheck_exact():
+    constrainer = SomeNotInSetConstraint(set("abc"), n=2, exact=True)
+    v1, v2, v3 = variables = [Variable("v1"), Variable("v2"), Variable("v3")]
+    assignments = {v1: "a"}
+
+    domains = {v1: Domain(["a", "x"]), v2: Domain(["b", "y"]), v3: Domain(["c", "z"])}
+    assert constrainer(variables, domains, assignments)
+    assert constrainer(variables, domains, assignments, True)
+    assert "b" not in domains[v2]
+    assert "y" in domains[v2]
+    assert "c" not in domains[v3]
+    assert "z" in domains[v3]
+
+    domains = {v1: Domain(["a", "x"]), v2: Domain(["b", "y"]), v3: Domain(["c"])}
+    assert constrainer(variables, domains, assignments)
+    assert not constrainer(variables, domains, assignments, True)