Pass random length list tests with sparse/thorough solver

Naive solver worked already, this commit makes the
sparse solver work for the basic test cases already added.

Refactor vargroup to make random length list work cleanly.

Fully delegate control of CSP to VarGroup, not half in one class
and half in another as it was before.

Author: will-keen

constrainedrandom/internal/multivar.py

@@ -1,14 +1,13 @@
 # SPDX-License-Identifier: MIT
 # Copyright (c) 2023 Imagination Technologies Ltd. All Rights Reserved
 
-import constraint
 from collections import defaultdict
-from typing import Any, Dict, Iterable, List, Optional, TYPE_CHECKING, Tuple, Union
+from typing import Any, Dict, Iterable, List, Optional, TYPE_CHECKING, Union
 
 from .vargroup import VarGroup
 
 from .. import utils
-from ..debug import RandomizationDebugInfo, RandomizationFail
+from ..debug import RandomizationDebugInfo
 
 if TYPE_CHECKING:
     from ..randobj import RandObj
@@ -138,74 +137,65 @@ def solve_groups(
         '''
         constraints = self.constraints
         sparse_solver = solutions_per_group is not None
-        solutions = []
-        solved_vars = []
+        solutions : List[Dict[str, Any]] = []
+        solved_vars : List[str] = []
 
-        # Respect assigned temporary values
+        # Respect assigned temporary values.
         if len(with_values) > 0:
             for var_name in with_values.keys():
                 solved_vars.append(var_name)
             solutions.append(with_values)
 
-        # If solving sparsely, we'll create a new problem for each group.
-        # If not solving sparsely, just create one big problem that we add to
-        # as we go along.
-        if not sparse_solver:
-            problem = constraint.Problem()
-            for var_name, value in with_values.items():
-                problem.addVariable(var_name, (value,))
-
+        # For each group, construct a problem and solve it.
         for group in groups:
-            if sparse_solver:
-                # Construct one problem per group, add solved variables from previous groups.
-                problem = constraint.Problem()
-            # Construct the appropriate group variable problem
-            group_problem = VarGroup(
-                group,
-                solved_vars,
-                problem,
-                constraints,
-                self.max_domain_size,
-                self.debug,
-            )
-
             group_solutions = None
+            group_problem = None
             attempts = 0
             while group_solutions is None or len(group_solutions) == 0:
+                # Early loop exit cases
                 if attempts >= max_iterations:
                     # We have failed, give up
                     return None
                 if attempts > 0 and not group_problem.can_retry():
                     # Not worth retrying - the same result will be obtained.
                     return None
-                if sparse_solver:
-                    if len(solutions) > 0:
-                        # Respect a proportion of the solution space, determined
-                        # by the sparsity/solutions_per_group.
+
+                # Determine what the starting state space for this group
+                # should be.
+                if sparse_solver and len(solutions) > 0:
+                    # Respect a proportion of the solution space, determined
+                    # by the sparsity/solutions_per_group.
+                        # Start by choosing a subset of the possible solutions.
                         if solutions_per_group >= len(solutions):
-                            solution_subset = solutions
+                            solution_subset = list(solutions)
                         else:
                             solution_subset = self.parent._get_random().choices(
                                 solutions,
                                 k=solutions_per_group
                             )
-                        if solutions_per_group == 1:
-                            for var_name, value in solution_subset[0].items():
-                                if var_name in problem._variables:
-                                    del problem._variables[var_name]
-                                problem.addVariable(var_name, (value,))
-                        else:
-                            solution_space = defaultdict(list)
-                            for soln in solution_subset:
-                                for var_name, value in soln.items():
-                                    # List is ~2x slower than set for 'in',
-                                    # but variables might be non-hashable.
-                                    if value not in solution_space[var_name]:
-                                        solution_space[var_name].append(value)
-                            for var_name, values in solution_space.items():
-                                if var_name in problem._variables:
-                                    del problem._variables[var_name]
-                                problem.addVariable(var_name, values)
+                else:
+                    # If not sparse, maintain the entire list of possible solutions.
+                    solution_subset = list(solutions)
+
+                # Translate this subset into a dictionary of the
+                # possible values for each variable.
+                solution_space = defaultdict(list)
+                for soln in solution_subset:
+                    for var_name, value in soln.items():
+                        # List is ~2x slower than set for 'in',
+                        # but variables might be non-hashable.
+                        if value not in solution_space[var_name]:
+                            solution_space[var_name].append(value)
+
+                # Construct the appropriate group variable problem.
+                # Must be done after selecting the solution space.
+                group_problem = VarGroup(
+                    group,
+                    solution_space,
+                    constraints,
+                    self.max_domain_size,
+                    self.debug,
+                )
 
                 # Attempt to solve the group
                 group_solutions = group_problem.solve(

constrainedrandom/internal/randvar.py

@@ -253,6 +253,14 @@ def get_length(self) -> int:
                 " but none was given when get_length was called.")
         return self.rand_length_val
 
+    def is_list(self) -> bool:
+        '''
+        Returns ``True`` if this is a list variable.
+
+        :return: ``True`` if this is a list variable, otherwise ``False``.
+        '''
+        return self.length is not None or self.rand_length is not None
+
     def set_rand_length(self, length: int) -> None:
         '''
         Function to set the random length.
@@ -282,31 +290,48 @@ def _get_random(self) -> random.Random:
             return random
         return self._random
 
-    def get_domain_size(self) -> int:
+    def get_domain_size(self, possible_lengths: Optional[List[int]]=None) -> int:
         '''
         Return total domain size, accounting for length of this random variable.
 
+        :param possible_lengths: Optional, when there is more than one possiblity
+            for the value of the random length, specifies a list of the
+            possibilities.
         :return: domain size, integer.
         '''
         if self.domain is None:
             # If there's no domain, it means we can't estimate the complexity
             # of this variable. Return 1.
             return 1
         else:
-            length = self.get_length()
-            if length is None:
-                # length is None implies a scalar variable.
-                return len(self.domain)
-            elif length == 0:
-                # This is a zero-length list, adding no complexity.
-                return 1
-            elif length == 1:
-                return len(self.domain)
+            # possible_lengths is used when the variable has a random
+            # length and that length is not yet fully determined.
+            if possible_lengths is None:
+                # Normal, fixed length of some description.
+                length = self.get_length()
+                if length is None:
+                    # length is None implies a scalar variable.
+                    return len(self.domain)
+                elif length == 0:
+                    # This is a zero-length list, adding no complexity.
+                    return 1
+                elif length == 1:
+                    return len(self.domain)
+                else:
+                    # In this case it is effectively cartesian product, i.e.
+                    # n ** k, where n is the size of the domain and k is the length
+                    # of the list.
+                    return len(self.domain) ** length
             else:
-                # In this case it is effectively cartesian product, i.e.
-                # n ** k, where n is the size of the domain and k is the length
-                # of the list.
-                return len(self.domain) ** length
+                # Random length which could be one of a number of values.
+                assert self.rand_length is not None, "Cannot use possible_lengths " \
+                    "for a variable with non-random length."
+                # For each possible length, the domain is the cartesian
+                # product as above, but added together.
+                total = 0
+                for poss_len in possible_lengths:
+                    total += len(self.domain) ** poss_len
+                return total
 
     def can_use_with_constraint(self) -> bool:
         '''
@@ -321,30 +346,42 @@ def can_use_with_constraint(self) -> bool:
         # and the domain isn't a dictionary.
         return self.domain is not None and not isinstance(self.domain, dict)
 
-    def get_constraint_domain(self) -> utils.Domain:
+    def get_constraint_domain(self, possible_lengths: Optional[List[int]]=None) -> utils.Domain:
         '''
         Get a ``constraint`` package friendly version of the domain
         of this random variable.
 
+        :param possible_lengths: Optional, when there is more than one possiblity
+            for the value of the random length, specifies a list of the
+            possibilities.
         :return: the variable's domain in a format that will work
             with the ``constraint`` package.
         '''
-        length = self.get_length()
-        if length is None:
-            # Straightforward, scalar
-            return self.domain
-        elif length == 0:
-            # List of length zero - an empty list is only correct choice.
-            return [[]]
-        elif length == 1:
-            # List of length one
-            return [[x] for x in self.domain]
+        if possible_lengths is None:
+            length = self.get_length()
+            if length is None:
+                # Straightforward, scalar
+                return self.domain
+            elif length == 0:
+                # List of length zero - an empty list is only correct choice.
+                return [[]]
+            elif length == 1:
+                # List of length one
+                return [[x] for x in self.domain]
+            else:
+                # List of greater length, cartesian product.
+                # Beware that this may be an extremely large domain.
+                # Ensure each element is of type list, which is what
+                # we want to return.
+                return [list(x) for x in product(self.domain, repeat=length)]
         else:
-            # List of greater length, cartesian product.
-            # Beware that this may be an extremely large domain.
-            # Ensure each element is of type list, which is what
-            # we want to return.
-            return [list(x) for x in product(self.domain, repeat=length)]
+            # For each possible length, return the possible domains.
+            # This can get extremely large, even more so than
+            # the regular product.
+            result = []
+            for poss_len in possible_lengths:
+                result += [list(x) for x in product(self.domain, repeat=poss_len)]
+            return result
 
     def randomize_once(self, constraints: Iterable[utils.Constraint], check_constraints: bool, debug: bool) -> Any:
         '''