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
