def test_using_weights(): def take(generator, count): return list(itertools.islice(generator, 0, count)) # Check distribution. data = take(take_using_weights(['A', 'B', 'C'], [5, 10, 20]), 35) assert data.count('A') == 5 assert data.count('B') == 10 assert data.count('C') == 20 assert data == [ 'A', 'B', 'C', 'C', 'B', 'C', 'C', 'A', 'B', 'C', 'C', 'B', 'C', 'C', 'A', 'B', 'C', 'C', 'B', 'C', 'C', 'A', 'B', 'C', 'C', 'B', 'C', 'C', 'A', 'B', 'C', 'C', 'B', 'C', 'C' ] # Another order. data = take(take_using_weights(['A', 'B', 'C'], [20, 10, 5]), 35) assert data.count('A') == 20 assert data.count('B') == 10 assert data.count('C') == 5 # Bigger numbers. data = take(take_using_weights(['A', 'B', 'C'], [20, 10, 5]), 70) assert data.count('A') == 40 assert data.count('B') == 20 assert data.count('C') == 10 # Negative numbers. data = take(take_using_weights(['A', 'B', 'C'], [-20, 10, 0]), 70) assert data.count('A') == 0 assert data.count('B') == 70 assert data.count('C') == 0
def test_using_weights(): def take(generator, count): return list(itertools.islice(generator, 0, count)) # Check distribution. data = take(take_using_weights(['A', 'B', 'C'], [5, 10, 20]), 35) assert data.count('A') == 5 assert data.count('B') == 10 assert data.count('C') == 20 assert data == [ 'A', 'B', 'C', 'C', 'B', 'C', 'C', 'A', 'B', 'C', 'C', 'B', 'C', 'C', 'A', 'B', 'C', 'C', 'B', 'C', 'C', 'A', 'B', 'C', 'C', 'B', 'C', 'C', 'A', 'B', 'C', 'C', 'B', 'C', 'C'] # Another order. data = take(take_using_weights(['A', 'B', 'C'], [20, 10, 5]), 35) assert data.count('A') == 20 assert data.count('B') == 10 assert data.count('C') == 5 # Bigger numbers. data = take(take_using_weights(['A', 'B', 'C'], [20, 10, 5]), 70) assert data.count('A') == 40 assert data.count('B') == 20 assert data.count('C') == 10 # Negative numbers. data = take(take_using_weights(['A', 'B', 'C'], [-20, 10, 0]), 70) assert data.count('A') == 0 assert data.count('B') == 70 assert data.count('C') == 0
def test_using_weights(self): def take(generator, count): return list(itertools.islice(generator, 0, count)) # Check distribution. data = take(take_using_weights(['A', 'B', 'C'], [5, 10, 20]), 35) self.assertEqual(data.count('A'), 5) self.assertEqual(data.count('B'), 10) self.assertEqual(data.count('C'), 20) self.assertEqual(data, [ 'A', 'B', 'C', 'C', 'B', 'C', 'C', 'A', 'B', 'C', 'C', 'B', 'C', 'C', 'A', 'B', 'C', 'C', 'B', 'C', 'C', 'A', 'B', 'C', 'C', 'B', 'C', 'C', 'A', 'B', 'C', 'C', 'B', 'C', 'C' ]) # Another order. data = take(take_using_weights(['A', 'B', 'C'], [20, 10, 5]), 35) self.assertEqual(data.count('A'), 20) self.assertEqual(data.count('B'), 10) self.assertEqual(data.count('C'), 5) # Bigger numbers. data = take(take_using_weights(['A', 'B', 'C'], [20, 10, 5]), 70) self.assertEqual(data.count('A'), 40) self.assertEqual(data.count('B'), 20) self.assertEqual(data.count('C'), 10) # Negative numbers. data = take(take_using_weights(['A', 'B', 'C'], [-20, 10, 0]), 70) self.assertEqual(data.count('A'), 0) self.assertEqual(data.count('B'), 70) self.assertEqual(data.count('C'), 0)
def test_using_weights(self): def take(generator, count): return list(itertools.islice(generator, 0, count)) # Check distribution. data = take(take_using_weights(['A', 'B', 'C'], [5, 10, 20]), 35) self.assertEqual(data.count('A'), 5) self.assertEqual(data.count('B'), 10) self.assertEqual(data.count('C'), 20) self.assertEqual(data, ['A', 'B', 'C', 'C', 'B', 'C', 'C', 'A', 'B', 'C', 'C', 'B', 'C', 'C', 'A', 'B', 'C', 'C', 'B', 'C', 'C', 'A', 'B', 'C', 'C', 'B', 'C', 'C', 'A', 'B', 'C', 'C', 'B', 'C', 'C']) # Another order. data = take(take_using_weights(['A', 'B', 'C'], [20, 10, 5]), 35) self.assertEqual(data.count('A'), 20) self.assertEqual(data.count('B'), 10) self.assertEqual(data.count('C'), 5) # Bigger numbers. data = take(take_using_weights(['A', 'B', 'C'], [20, 10, 5]), 70) self.assertEqual(data.count('A'), 40) self.assertEqual(data.count('B'), 20) self.assertEqual(data.count('C'), 10) # Negative numbers. data = take(take_using_weights(['A', 'B', 'C'], [-20, 10, 0]), 70) self.assertEqual(data.count('A'), 0) self.assertEqual(data.count('B'), 70) self.assertEqual(data.count('C'), 0)
def _divide_heigths(self, cli, write_position): """ Return the heights for all rows. Or None when there is not enough space. """ if not self.children: return [] # Calculate heights. given_dimensions = self.get_dimensions( cli) if self.get_dimensions else None def get_dimension_for_child(c, index): if given_dimensions and given_dimensions[index] is not None: return given_dimensions[index] else: return c.preferred_height(cli, write_position.width) dimensions = [ get_dimension_for_child(c, index) for index, c in enumerate(self.children) ] # Sum dimensions sum_dimensions = sum_layout_dimensions(dimensions) # If there is not enough space for both. # Don't do anything. if sum_dimensions.min > write_position.extended_height: return # Find optimal sizes. (Start with minimal size, increase until we cover # the whole height.) sizes = [d.min for d in dimensions] child_generator = take_using_weights( items=list(range(len(dimensions))), weights=[d.weight for d in dimensions]) i = next(child_generator) while sum(sizes) < min(write_position.extended_height, sum_dimensions.preferred): # Increase until we meet at least the 'preferred' size. if sizes[i] < dimensions[i].preferred: sizes[i] += 1 i = next(child_generator) if not any([cli.is_returning, cli.is_exiting, cli.is_aborting]): while sum(sizes) < min(write_position.height, sum_dimensions.max): # Increase until we use all the available space. (or until "max") if sizes[i] < dimensions[i].max: sizes[i] += 1 i = next(child_generator) return sizes
def _divide_heigths(self, cli, write_position): """ Return the heights for all rows. Or None when there is not enough space. """ if not self.children: return [] # Calculate heights. given_dimensions = self.get_dimensions(cli) if self.get_dimensions else None def get_dimension_for_child(c, index): if given_dimensions and given_dimensions[index] is not None: return given_dimensions[index] else: return c.preferred_height(cli, write_position.width) dimensions = [get_dimension_for_child(c, index) for index, c in enumerate(self.children)] # Sum dimensions sum_dimensions = sum_layout_dimensions(dimensions) # If there is not enough space for both. # Don't do anything. if sum_dimensions.min > write_position.extended_height: return # Find optimal sizes. (Start with minimal size, increase until we cover # the whole height.) sizes = [d.min for d in dimensions] child_generator = take_using_weights( items=list(range(len(dimensions))), weights=[d.weight for d in dimensions]) i = next(child_generator) while sum(sizes) < min(write_position.extended_height, sum_dimensions.preferred): # Increase until we meet at least the 'preferred' size. if sizes[i] < dimensions[i].preferred: sizes[i] += 1 i = next(child_generator) if not any([cli.is_returning, cli.is_exiting, cli.is_aborting]): while sum(sizes) < min(write_position.height, sum_dimensions.max): # Increase until we use all the available space. (or until "max") if sizes[i] < dimensions[i].max: sizes[i] += 1 i = next(child_generator) return sizes
def test_using_weights(): def take(generator, count): return list(itertools.islice(generator, 0, count)) # Check distribution. data = take(take_using_weights(["A", "B", "C"], [5, 10, 20]), 35) assert data.count("A") == 5 assert data.count("B") == 10 assert data.count("C") == 20 assert data == [ "A", "B", "C", "C", "B", "C", "C", "A", "B", "C", "C", "B", "C", "C", "A", "B", "C", "C", "B", "C", "C", "A", "B", "C", "C", "B", "C", "C", "A", "B", "C", "C", "B", "C", "C", ] # Another order. data = take(take_using_weights(["A", "B", "C"], [20, 10, 5]), 35) assert data.count("A") == 20 assert data.count("B") == 10 assert data.count("C") == 5 # Bigger numbers. data = take(take_using_weights(["A", "B", "C"], [20, 10, 5]), 70) assert data.count("A") == 40 assert data.count("B") == 20 assert data.count("C") == 10 # Negative numbers. data = take(take_using_weights(["A", "B", "C"], [-20, 10, 0]), 70) assert data.count("A") == 0 assert data.count("B") == 70 assert data.count("C") == 0 # All zero-weight items. with pytest.raises(ValueError): take(take_using_weights(["A", "B", "C"], [0, 0, 0]), 70)
def _divide_widths(self, width): """ Return the widths for all columns. Or None when there is not enough space. """ children = self._all_children if not children: return [] # Calculate widths. dimensions = list(self.table.preferred_dimensions(width)) preferred_dimensions = [d.preferred for d in dimensions] # Sum dimensions sum_dimensions = sum_layout_dimensions(dimensions) # If there is not enough space for both. # Don't do anything. if sum_dimensions.min > width: return # Find optimal sizes. (Start with minimal size, increase until we cover # the whole width.) sizes = [d.min for d in dimensions] child_generator = take_using_weights( items=list(range(len(dimensions))), weights=[d.weight for d in dimensions]) i = next(child_generator) # Increase until we meet at least the 'preferred' size. preferred_stop = min(width, sum_dimensions.preferred) while sum(sizes) < preferred_stop: if sizes[i] < preferred_dimensions[i]: sizes[i] += 1 i = next(child_generator) # Increase until we use all the available space. max_dimensions = [d.max for d in dimensions] max_stop = min(width, sum_dimensions.max) while sum(sizes) < max_stop: if sizes[i] < max_dimensions[i]: sizes[i] += 1 i = next(child_generator) # perform merges if necessary if len(children) != len(sizes): tmp = [] i = 0 for c in children: if isinstance(c, _Cell): inc = (c.merge * 2) - 1 tmp.append(sum(sizes[i:i + inc])) else: inc = 1 tmp.append(sizes[i]) i += inc sizes = tmp return sizes