Beispiel #1
0
 def extract_simplelevel(self, block: Block, level: DerivedLevel) -> List[Dict[Factor, SimpleLevel]]:
     """Recursively deciphers the excluded level to a list of combinations
     basic levels."""
     excluded_levels = []
     excluded: List[Tuple[Level, ...]] = [cross for cross in level.get_dependent_cross_product()
                                          if level.window.predicate(*[level.name for level in cross])]
     for excluded_level_tuple in excluded:
         combos: List[Dict[Factor, SimpleLevel]] = [{}]
         for excluded_level in excluded_level_tuple:
             if isinstance(excluded_level, DerivedLevel):
                 result = self.extract_simplelevel(block, excluded_level)
                 newcombos = []
                 valid = True
                 for r in result:
                     for c in combos:
                         for f in c:
                             if f in r:
                                 if c[f] != r[f]:
                                     valid = False
                     if valid:
                         newcombos.append({**r, **c})
                 combos = newcombos
             else:
                 if not isinstance(excluded_level, SimpleLevel):
                     raise ValueError(f"Unexpected level type in exclusion: level {level.name} of type "
                                      f"{type(level).__name__}.")
                 for c in combos:
                     if block.factor_in_crossing(excluded_level.factor) and block.require_complete_crossing:
                         block.errors.add("WARNING: Some combinations have been excluded, this crossing may not be complete!")
                     c[excluded_level.factor] = excluded_level
         excluded_levels.extend(combos)
     return excluded_levels
Beispiel #2
0
 def extract_simplelevel(self, block: Block, level: DerivedLevel) -> List[Dict[Factor, SimpleLevel]]:
     excluded_levels = []
     excluded = list(filter(lambda c: level.window.fn(*list(map(lambda f: get_external_level_name(f[1]), c))), level.get_dependent_cross_product()))
     for i in excluded:
         combos = cast(List[Dict[Factor, SimpleLevel]], [dict()])
         for j in i:
             if type(j[1]) is DerivedLevel:
                 result = self.extract_simplelevel(block, j[1])
                 newcombos = []
                 valid = True
                 for r in result:
                     for c in combos:
                         for f in c:
                             if f in r:
                                 if c[f] != r[f]:
                                     valid = False
                     if valid:
                         newcombos.append({**r, **c})
                 combos = newcombos
             else:
                 for c in combos:
                     if block.factor_in_crossing(j[0]) and block.require_complete_crossing:
                         block.errors.add("WARNING: Some combinations have been excluded, this crossing may not be complete!")
                     c[j[0]] = j[1] 
         excluded_levels.extend(combos)
     return excluded_levels