def _add_node_from_new_bucket(new_bucket: bucket_info.Bucket, constraint):
left_bucket = bucket_dict.get(new_bucket.left_neighbor_idx)
right_bucket = bucket_dict.get(new_bucket.right_neighbor_idx)
if constraint == 'mixture':
if left_bucket is not None and left_bucket.total_count + new_bucket.total_count <= max_item_num:
if not left_bucket.is_mixed and not new_bucket.is_mixed:
heap_node = heap.heap_node_factory(optimal_param, left_bucket=left_bucket,
right_bucket=new_bucket)
min_heap.insert(heap_node)
if right_bucket is not None and right_bucket.total_count + new_bucket.total_count <= max_item_num:
if not right_bucket.is_mixed and not new_bucket.is_mixed:
heap_node = heap.heap_node_factory(optimal_param, left_bucket=new_bucket,
right_bucket=right_bucket)
min_heap.insert(heap_node)
elif constraint == 'single_mixture':
if left_bucket is not None and left_bucket.total_count + new_bucket.total_count <= max_item_num:
if not (left_bucket.is_mixed and new_bucket.is_mixed):
heap_node = heap.heap_node_factory(optimal_param, left_bucket=left_bucket,
right_bucket=new_bucket)
min_heap.insert(heap_node)
if right_bucket is not None and right_bucket.total_count + new_bucket.total_count <= max_item_num:
if not (right_bucket.is_mixed and new_bucket.is_mixed):
heap_node = heap.heap_node_factory(optimal_param, left_bucket=new_bucket,
right_bucket=right_bucket)
min_heap.insert(heap_node)
elif constraint == 'small_size':
if left_bucket is not None and left_bucket.total_count + new_bucket.total_count <= max_item_num:
if left_bucket.total_count < min_item_num and new_bucket.total_count < min_item_num:
heap_node = heap.heap_node_factory(optimal_param, left_bucket=left_bucket,
right_bucket=new_bucket)
min_heap.insert(heap_node)
if right_bucket is not None and right_bucket.total_count + new_bucket.total_count <= max_item_num:
if right_bucket.total_count < min_item_num and new_bucket.total_count < min_item_num:
heap_node = heap.heap_node_factory(optimal_param, left_bucket=new_bucket,
right_bucket=right_bucket)
min_heap.insert(heap_node)
elif constraint == 'single_small_size':
if left_bucket is not None and left_bucket.total_count + new_bucket.total_count <= max_item_num:
if left_bucket.total_count < min_item_num or new_bucket.total_count < min_item_num:
heap_node = heap.heap_node_factory(optimal_param, left_bucket=left_bucket,
right_bucket=new_bucket)
min_heap.insert(heap_node)
if right_bucket is not None and right_bucket.total_count + new_bucket.total_count <= max_item_num:
if right_bucket.total_count < min_item_num or new_bucket.total_count < min_item_num:
heap_node = heap.heap_node_factory(optimal_param, left_bucket=new_bucket,
right_bucket=right_bucket)
min_heap.insert(heap_node)
else:
if left_bucket is not None and left_bucket.total_count + new_bucket.total_count <= max_item_num:
heap_node = heap.heap_node_factory(optimal_param, left_bucket=left_bucket,
right_bucket=new_bucket)
min_heap.insert(heap_node)
if right_bucket is not None and right_bucket.total_count + new_bucket.total_count <= max_item_num:
heap_node = heap.heap_node_factory(optimal_param, left_bucket=new_bucket,
right_bucket=right_bucket)
min_heap.insert(heap_node)
def _add_heap_nodes(constraint=None):
LOGGER.debug(
"Add heap nodes, constraint: {}, dict_length: {}".format(
constraint, len(bucket_dict)))
this_non_mixture_num = 0
this_small_size_num = 0
# Make bucket satisfy mixture condition
# for i in bucket_dict.keys():
for i in range(len(bucket_dict)):
left_bucket = bucket_dict[i]
right_bucket = bucket_dict.get(left_bucket.right_neighbor_idx)
if left_bucket.right_neighbor_idx == i:
raise RuntimeError(
"left_bucket's right neighbor == itself")
if not left_bucket.is_mixed:
this_non_mixture_num += 1
if left_bucket.total_count < min_item_num:
this_small_size_num += 1
if right_bucket is None:
continue
# Violate maximum items constraint
if left_bucket.total_count + right_bucket.total_count > max_item_num:
continue
if constraint == 'mixture':
if left_bucket.is_mixed or right_bucket.is_mixed:
continue
elif constraint == 'single_mixture':
if left_bucket.is_mixed and right_bucket.is_mixed:
continue
elif constraint == 'small_size':
if left_bucket.total_count >= min_item_num or right_bucket.total_count >= min_item_num:
continue
elif constraint == 'single_small_size':
if left_bucket.total_count >= min_item_num and right_bucket.total_count >= min_item_num:
continue
heap_node = heap.heap_node_factory(optimal_param,
left_bucket=left_bucket,
right_bucket=right_bucket)
min_heap.insert(heap_node)
return min_heap, this_non_mixture_num, this_small_size_num