def _make_storehouse_menu_entries(
self,
abjad_material_packages_and_stylesheets=True,
example_score_packages=True,
library=True,
user_score_packages=True,
):
from scoremanager import idetools
display_strings, keys = [], []
keys.append(self._user_storehouse_path)
if self._in_library:
display_string = 'My {} library'.format(self._asset_identifier)
display_strings.append(display_string)
wrangler = idetools.ScorePackageWrangler(session=self._session)
paths = wrangler._list_asset_paths(
abjad_material_packages_and_stylesheets=abjad_material_packages_and_stylesheets,
example_score_packages=example_score_packages,
library=library,
user_score_packages=user_score_packages,
)
for path in paths:
manager = wrangler._initialize_manager(path)
display_strings.append(manager._get_title())
path_parts = (manager._path,)
path_parts = path_parts + self._score_storehouse_path_infix_parts
key = os.path.join(*path_parts)
keys.append(key)
sequences = [display_strings, [None], [None], keys]
return sequencetools.zip_sequences(sequences, cyclic=True)
def __init__(
self,
calculation_rate=None,
decay_scale=1,
frequency_offset=0,
frequency_scale=1,
source=None,
specifications=None,
):
frequencies, amplitudes, decay_times = specifications
assert len(frequencies)
if not amplitudes:
amplitudes = [1.0] * len(frequencies)
elif not isinstance(amplitudes, collections.Sequence):
amplitudes = [amplitudes] * len(frequencies)
if not decay_times:
decay_times = [1.0] * len(frequencies)
elif not isinstance(decay_times, collections.Sequence):
decay_times = [decay_times] * len(frequencies)
specifications = sequencetools.zip_sequences(
[frequencies, amplitudes, decay_times])
specifications = sequencetools.flatten_sequence(specifications)
specifications = tuple(specifications)
UGen.__init__(
self,
calculation_rate=calculation_rate,
decay_scale=decay_scale,
frequency_offset=frequency_offset,
frequency_scale=frequency_scale,
source=source,
specifications=specifications,
)
def _make_storehouse_menu_entries(
self,
abjad_library=True,
user_library=True,
abjad_score_packages=True,
user_score_packages=True,
):
from scoremanager import wranglers
keys, display_strings = [], []
keys.append(self._user_storehouse_path)
display_strings.append('My {}'.format(self._breadcrumb))
wrangler = wranglers.ScorePackageWrangler(session=self._session)
paths = wrangler._list_asset_paths(
abjad_library=abjad_library,
user_library=user_library,
abjad_score_packages=abjad_score_packages,
user_score_packages=user_score_packages,
)
for path in paths:
manager = wrangler._initialize_asset_manager(path)
display_strings.append(manager._get_title())
path_parts = (manager._path,)
path_parts = path_parts + self._score_storehouse_path_infix_parts
key = os.path.join(*path_parts)
keys.append(key)
sequences = [display_strings, [None], [None], keys]
return sequencetools.zip_sequences(sequences, cyclic=True)
def _make_asset_storehouse_menu_entries(
self,
in_built_in_asset_library=True,
in_user_asset_library=True,
in_built_in_score_packages=True,
in_user_score_packages=True,
):
from scoremanager import wranglers
keys, display_strings = [], []
keys.append(
self.asset_storehouse_filesystem_path_in_user_asset_library)
display_strings.append('My {}'.format(self._breadcrumb))
wrangler = wranglers.ScorePackageWrangler(
session=self.session)
for manager in wrangler.list_asset_managers(
in_built_in_asset_library=in_built_in_asset_library,
in_user_asset_library=in_user_asset_library,
in_built_in_score_packages=in_built_in_score_packages,
in_user_score_packages=in_user_score_packages,
):
display_strings.append(manager._get_title())
path_parts = (manager.filesystem_path,) + \
self.score_package_asset_storehouse_path_infix_parts
key = os.path.join(*path_parts)
keys.append(key)
sequences = [display_strings, [None], [None], keys]
return sequencetools.zip_sequences(sequences, cyclic=True)
def __init__(
self,
calculation_rate=None,
decay_scale=1,
frequency_offset=0,
frequency_scale=1,
source=None,
specifications=None,
):
frequencies, amplitudes, decay_times = specifications
assert len(frequencies)
if not amplitudes:
amplitudes = [1.0] * len(frequencies)
elif not isinstance(amplitudes, collections.Sequence):
amplitudes = [amplitudes] * len(frequencies)
if not decay_times:
decay_times = [1.0] * len(frequencies)
elif not isinstance(decay_times, collections.Sequence):
decay_times = [decay_times] * len(frequencies)
specifications = sequencetools.zip_sequences(
[frequencies, amplitudes, decay_times])
specifications = sequencetools.flatten_sequence(specifications)
specifications = tuple(specifications)
UGen.__init__(
self,
calculation_rate=calculation_rate,
decay_scale=decay_scale,
frequency_offset=frequency_offset,
frequency_scale=frequency_scale,
source=source,
specifications=specifications,
)
def _make_storehouse_menu_entries(
self,
abjad_material_packages_and_stylesheets=True,
example_score_packages=True,
library=True,
user_score_packages=True,
):
from scoremanager import idetools
display_strings, keys = [], []
keys.append(self._user_storehouse_path)
if self._in_library:
display_string = 'My {} library'.format(self._asset_identifier)
display_strings.append(display_string)
wrangler = idetools.ScorePackageWrangler(session=self._session)
paths = wrangler._list_asset_paths(
abjad_material_packages_and_stylesheets=
abjad_material_packages_and_stylesheets,
example_score_packages=example_score_packages,
library=library,
user_score_packages=user_score_packages,
)
for path in paths:
manager = wrangler._initialize_manager(path)
display_strings.append(manager._get_title())
path_parts = (manager._path, )
path_parts = path_parts + self._score_storehouse_path_infix_parts
key = os.path.join(*path_parts)
keys.append(key)
sequences = [display_strings, [None], [None], keys]
return sequencetools.zip_sequences(sequences, cyclic=True)
def _make_asset_menu_entries(self):
file_names = self._list_directory()
file_names = [x for x in file_names if x[0].isalpha()]
file_paths = []
for file_name in file_names:
file_path = os.path.join(self.filesystem_path, file_name)
file_paths.append(file_path)
display_strings = file_names[:]
menu_entries = []
if display_strings:
sequences = [display_strings, [None], [None], file_paths]
menu_entries = sequencetools.zip_sequences(sequences, cyclic=True)
return menu_entries
def make_multiplied_quarter_notes(
pitches,
multiplied_durations,
):
r'''Make quarter notes with `pitches` and `multiplied_durations`:
::
>>> args = [[0, 2, 4, 5], [(1, 4), (1, 5), (1, 6), (1, 7)]]
>>> scoretools.make_multiplied_quarter_notes(*args)
Selection(Note("c'4 * 1"), Note("d'4 * 4/5"), Note("e'4 * 2/3"), Note("f'4 * 4/7"))
Read `pitches` cyclically where the length of `pitches` is
less than the length of `multiplied_durations`:
::
>>> args = [[0], [(1, 4), (1, 5), (1, 6), (1, 7)]]
>>> scoretools.make_multiplied_quarter_notes(*args)
Selection(Note("c'4 * 1"), Note("c'4 * 4/5"), Note("c'4 * 2/3"), Note("c'4 * 4/7"))
Read `multiplied_durations` cyclically where the length of
`multiplied_durations` is less than the length of `pitches`:
::
>>> args = [[0, 2, 4, 5], [(1, 5)]]
>>> scoretools.make_multiplied_quarter_notes(*args)
Selection(Note("c'4 * 4/5"), Note("d'4 * 4/5"), Note("e'4 * 4/5"),
Note("f'4 * 4/5"))
Returns list of zero or more newly constructed notes.
'''
from abjad.tools import scoretools
multiplied_durations = [
durationtools.Duration(x) for x in multiplied_durations
]
quarter_notes = []
sequences = [pitches, multiplied_durations]
for pitch, duration in sequencetools.zip_sequences(sequences, cyclic=True):
quarter_note = scoretools.Note(pitch, durationtools.Duration(1, 4))
duration = durationtools.Duration(duration)
multiplier = durationtools.Multiplier(duration /
durationtools.Duration(1, 4))
attach(multiplier, quarter_note)
quarter_notes.append(quarter_note)
quarter_notes = selectiontools.Selection(quarter_notes)
return quarter_notes
def _make_asset_menu_entries(self, head=None, include_extension=False):
filesystem_paths = self.list_asset_filesystem_paths(head=head)
display_strings = []
for filesystem_path in filesystem_paths:
display_string = os.path.basename(filesystem_path)
annotation = self._filesystem_path_to_annotation(filesystem_path)
if annotation:
display_string = '{} ({})'.format(display_string, annotation)
display_strings.append(display_string)
menu_entries = []
if display_strings:
sequences = (display_strings, [None], [None], filesystem_paths)
menu_entries = sequencetools.zip_sequences(sequences, cyclic=True)
return menu_entries
def _make_bicolumnar(self, lines):
terminal_height = 50
column_width = 55
if len(lines) < terminal_height:
return lines
if 2 * terminal_height < len(lines):
message = 'too many lines to lay out in two columns: {!r}.'
message = message.format(len(lines))
raise ValueError(message)
split_lines = []
for line in lines:
line = line.strip()
if column_width < len(line):
width = column_width - 6
new_lines = textwrap.wrap(line, width=width)
tab_string = self._make_tab(1)
split_lines.append(tab_string + new_lines[0])
for new_line in new_lines[1:]:
split_lines.append(5 * ' ' + new_line)
elif line == '':
split_lines.append(line)
else:
tab_string = self._make_tab(1)
split_lines.append(tab_string + line)
lines = split_lines
left_column_lines = lines[:terminal_height]
for i, line in enumerate(reversed(left_column_lines)):
if line == '':
break
terminal_height -= i
left_column_lines = lines[:terminal_height-1]
right_column_lines = lines[terminal_height:]
pair = (left_column_lines, right_column_lines)
generator = sequencetools.zip_sequences(pair, truncate=False)
massaged_lines = []
for element in generator:
if len(element) == 2:
left_line, right_line = element
left_line = left_line.rstrip()
extra_count = column_width - len(left_line)
extra_space = extra_count * ' '
left_line = left_line + extra_space
right_line = right_line.strip()
else:
assert len(element) == 1
left_line = element[0]
right_line = ''
massaged_line = left_line + right_line
massaged_lines.append(massaged_line)
return massaged_lines
def columns(self):
r'''Gets columns of pitch array.
Returns tuple.
'''
from abjad.tools import pitchtools
columns = []
for i, cells in enumerate(
sequencetools.zip_sequences(self.rows, truncate=False)):
column = pitchtools.PitchArrayColumn(cells)
column._parent_array = self
column._column_index = i
columns.append(column)
return tuple(columns)
def __init__(
self,
amplitudes=(0, 1, 0),
durations=(1, 1),
curves='linear',
release_node=None,
loop_node=None,
offset=None,
):
from supriya.tools import synthdeftools
assert len(amplitudes)
assert len(durations) and len(durations) == (len(amplitudes) - 1)
amplitudes = list(amplitudes)
for i, amplitude in enumerate(amplitudes):
if isinstance(amplitude, int):
amplitudes[i] = float(amplitude)
durations = list(durations)
for i, duration in enumerate(durations):
if isinstance(duration, int):
durations[i] = float(duration)
if isinstance(curves, (
int,
float,
str,
synthdeftools.EnvelopeShape,
)):
curves = (curves, )
elif curves is None:
curves = ()
curves = tuple(curves)
if release_node is not None:
release_node = int(release_node)
assert 0 <= release_node < len(amplitudes)
self._release_node = release_node
if loop_node is not None:
assert self._release_node is not None
loop_node = int(loop_node)
assert 0 <= loop_node <= release_node
self._loop_node = loop_node
if offset is not None:
offset = float(offset)
self._offset = offset
self._initial_amplitude = amplitudes[0]
self._envelope_segments = tuple(
sequencetools.zip_sequences([
amplitudes[1:],
durations,
curves,
],
cyclic=True))
def columns(self):
r'''Columns of pitch array.
Returns tuple.
'''
columns = []
rows = self.rows
for i, cells in enumerate(
sequencetools.zip_sequences(self.rows, truncate=False)):
column = PitchArrayColumn(cells)
column._parent_array = self
column._column_index = i
columns.append(column)
return tuple(columns)
def make_multiplied_quarter_notes(
pitches,
multiplied_durations,
):
r'''Make quarter notes with `pitches` and `multiplied_durations`:
::
>>> args = [[0, 2, 4, 5], [(1, 4), (1, 5), (1, 6), (1, 7)]]
>>> scoretools.make_multiplied_quarter_notes(*args)
Selection(Note("c'4 * 1"), Note("d'4 * 4/5"), Note("e'4 * 2/3"), Note("f'4 * 4/7"))
Read `pitches` cyclically where the length of `pitches` is
less than the length of `multiplied_durations`:
::
>>> args = [[0], [(1, 4), (1, 5), (1, 6), (1, 7)]]
>>> scoretools.make_multiplied_quarter_notes(*args)
Selection(Note("c'4 * 1"), Note("c'4 * 4/5"), Note("c'4 * 2/3"), Note("c'4 * 4/7"))
Read `multiplied_durations` cyclically where the length of
`multiplied_durations` is less than the length of `pitches`:
::
>>> args = [[0, 2, 4, 5], [(1, 5)]]
>>> scoretools.make_multiplied_quarter_notes(*args)
Selection(Note("c'4 * 4/5"), Note("d'4 * 4/5"), Note("e'4 * 4/5"),
Note("f'4 * 4/5"))
Returns list of zero or more newly constructed notes.
'''
from abjad.tools import scoretools
multiplied_durations = [
durationtools.Duration(x) for x in multiplied_durations]
quarter_notes = []
sequences = [pitches, multiplied_durations]
for pitch, duration in sequencetools.zip_sequences(sequences, cyclic=True):
quarter_note = scoretools.Note(pitch, durationtools.Duration(1, 4))
duration = durationtools.Duration(duration)
multiplier = durationtools.Multiplier(
duration / durationtools.Duration(1, 4))
attach(multiplier, quarter_note)
quarter_notes.append(quarter_note)
quarter_notes = selectiontools.Selection(quarter_notes)
return quarter_notes
def partition(meter_list, weights_ratio, tempi):
new_meter_list = [int(2 * x) for x in meter_list]
assert sum(new_meter_list) == 2 * sum(meter_list)
parts = sequencetools.partition_sequence_by_ratio_of_weights(
new_meter_list, weights_ratio)
counts = [len(x) for x in parts]
#parts = sequencetools.partition_sequence_once_by_counts_without_overhang(
# meter_list, counts)
parts = sequencetools.partition_sequence_by_counts(
meter_list,
counts,
cyclic=False,
overhang=False,
)
parts = sequencetools.zip_sequences([parts, tempi], cyclic=True)
return parts
def __init__(
self,
amplitudes=(0, 1, 0),
durations=(1, 1),
curves='linear',
release_node=None,
loop_node=None,
offset=None,
):
from supriya.tools import synthdeftools
assert len(amplitudes)
assert len(durations) and len(durations) == (len(amplitudes) - 1)
amplitudes = list(amplitudes)
for i, amplitude in enumerate(amplitudes):
if isinstance(amplitude, int):
amplitudes[i] = float(amplitude)
durations = list(durations)
for i, duration in enumerate(durations):
if isinstance(duration, int):
durations[i] = float(duration)
if isinstance(curves, (
int, float, str, synthdeftools.EnvelopeShape,
)):
curves = (curves,)
elif curves is None:
curves = ()
curves = tuple(curves)
if release_node is not None:
release_node = int(release_node)
assert 0 <= release_node < len(amplitudes)
self._release_node = release_node
if loop_node is not None:
assert self._release_node is not None
loop_node = int(loop_node)
assert 0 <= loop_node <= release_node
self._loop_node = loop_node
if offset is not None:
offset = float(offset)
self._offset = offset
self._initial_amplitude = amplitudes[0]
self._envelope_segments = tuple(sequencetools.zip_sequences([
amplitudes[1:],
durations,
curves,
], cyclic=True))
def interlace_sequences(*sequences):
'''Interlaces `sequences`.
::
>>> k = range(100, 103)
>>> l = range(200, 201)
>>> m = range(300, 303)
>>> n = range(400, 408)
>>> sequencetools.interlace_sequences(k, l, m, n)
[100, 200, 300, 400, 101, 301, 401, 102, 302, 402, 403, 404, 405, 406, 407]
Returns list.
'''
from abjad.tools import sequencetools
result = sequencetools.zip_sequences(sequences, truncate=False)
result = sequencetools.flatten_sequence(result, depth=1)
return result
def __init__(
self,
amplitudes=(0, 1, 0),
durations=(1, 1),
curves='linear',
release_node=None,
loop_node=None,
offset=None,
):
assert len(amplitudes)
assert len(durations) and len(durations) == (len(amplitudes) - 1)
amplitudes = tuple(float(x) for x in amplitudes)
durations = tuple(float(x) for x in durations)
if isinstance(curves, (int, float, str)):
curves = (curves,)
elif curves is None:
curves = ()
curves = tuple(curves)
if release_node is not None:
release_node = int(release_node)
assert 0 <= release_node < len(amplitudes)
self._release_node = release_node
if loop_node is not None:
assert self._release_node is not None
loop_node = int(loop_node)
assert 0 <= loop_node <= release_node
self._loop_node = loop_node
if offset is not None:
offset = float(offset)
self._offset = offset
self._initial_amplitude = amplitudes[0]
#print(self._amplitudes)
#print(self._durations)
#print(self._curves)
self._envelope_segments = tuple(sequencetools.zip_sequences([
amplitudes[1:],
durations,
curves,
], cyclic=True))
def _make_asset_menu_entries(self, head=None):
names = self.list_asset_names(head=head)
keys = len(names) * [None]
prepopulated_return_values = len(names) * [None]
paths = self.list_visible_asset_packagesystem_paths(head=head)
assert len(names) == len(keys) == len(paths)
if names:
sequences = (names, [None], [None], paths)
entries = sequencetools.zip_sequences(sequences, cyclic=True)
package_manager = self._get_current_package_manager()
if package_manager:
view_name = package_manager._get_metadatum('view_name')
if view_name:
view_inventory = self._read_view_inventory_from_disk()
if view_inventory:
correct_view = view_inventory.get(view_name)
if correct_view:
entries = \
self._sort_asset_menu_entries_by_view(
entries,
correct_view,
)
return entries
def interlace_sequences(sequences):
'''Interlaces `sequences`.
.. container:: example
**Example 1.** Interlaces generators:
::
>>> sequences = []
>>> sequences.append(range(100, 103))
>>> sequences.append(range(200, 201))
>>> sequences.append(range(300, 303))
>>> sequences.append(range(400, 408))
>>> sequencetools.interlace_sequences(sequences)
[100, 200, 300, 400, 101, 301, 401, 102, 302, 402, 403, 404, 405, 406, 407]
.. container:: example
**Example 2.** Interlaces tuples:
::
>>> sequences = []
>>> sequences.append(tuple(range(100, 103)))
>>> sequences.append(tuple(range(200, 201)))
>>> sequences.append(tuple(range(300, 303)))
>>> sequences.append(tuple(range(400, 408)))
>>> sequencetools.interlace_sequences(sequences)
[100, 200, 300, 400, 101, 301, 401, 102, 302, 402, 403, 404, 405, 406, 407]
.. container:: example
**Example 3.** Interlaces lists:
::
>>> sequences = []
>>> sequences.append(list(range(100, 103)))
>>> sequences.append(list(range(200, 201)))
>>> sequences.append(list(range(300, 303)))
>>> sequences.append(list(range(400, 408)))
>>> sequencetools.interlace_sequences(sequences)
[100, 200, 300, 400, 101, 301, 401, 102, 302, 402, 403, 404, 405, 406, 407]
.. container:: example
**Example 4.** Interlaces strings:
::
>>> sequences = []
>>> sequences.append('first')
>>> sequences.append('second')
>>> sequencetools.interlace_sequences(sequences)
['f', 's', 'i', 'e', 'r', 'c', 's', 'o', 't', 'n', 'd']
Returns list.
'''
from abjad.tools import sequencetools
for sequence in sequences:
if not isinstance(sequence, collections.Iterable):
message = 'must be iterable: {!r}.'
message = message.format(sequence)
raise Exception(message)
result = sequencetools.zip_sequences(sequences, truncate=False)
result = sequencetools.flatten_sequence(result, depth=1)
assert isinstance(result, list), repr(result)
return result
def _make_bicolumnar(
self,
lines,
break_only_at_blank_lines=False,
strip=True,
):
# http://stackoverflow.com/questions/566746/
# how-to-get-console-window-width-in-python
result = os.popen('stty size', 'r').read().split()
if result:
terminal_height, terminal_width = result
terminal_height = int(terminal_height)
terminal_width = int(terminal_width)
# returns none when run under py.test
else:
terminal_height, terminal_width = 24, 80
if terminal_width <= 80:
return lines
if len(lines) < terminal_height - 8:
return lines
if strip:
lines = [_.strip() for _ in lines]
all_packages_lines = [_ for _ in lines if _.startswith('all')]
lines = [_ for _ in lines if not _.startswith('all')]
# remove consecutive blank lines from comprehension above
clean_lines = []
for line in lines:
if line == '':
if clean_lines and clean_lines[-1] == '':
continue
clean_lines.append(line)
# remove initial blank line
if clean_lines[0] == '':
clean_lines.pop(0)
lines = clean_lines
midpoint = int(len(lines)/2)
if break_only_at_blank_lines:
while lines[midpoint] != '':
midpoint += 1
assert lines[midpoint] == ''
left_lines = lines[:midpoint]
if break_only_at_blank_lines:
right_lines = lines[midpoint+1:]
assert len(left_lines) + len(right_lines) == len(lines) - 1
else:
right_lines = lines[midpoint:]
left_count, right_count = len(left_lines), len(right_lines)
#assert right_count <= left_count, repr((left_count, right_count))
if strip:
left_width = max(len(_.strip()) for _ in left_lines)
right_width = max(len(_.strip()) for _ in right_lines)
else:
left_width = max(len(_) for _ in left_lines)
right_width = max(len(_) for _ in right_lines)
left_lines = [self._ljust(_, left_width) for _ in left_lines]
right_lines = [self._ljust(_, right_width) for _ in right_lines]
if strip:
left_margin_width, gutter_width = 4, 4
else:
left_margin_width, gutter_width = 0, 4
left_margin = left_margin_width * ' '
gutter = gutter_width * ' '
conjoined_lines = []
for _ in sequencetools.zip_sequences(
[left_lines, right_lines],
truncate=False,
):
if len(_) == 1:
left_line = _[0]
conjoined_line = left_margin + left_line
elif len(_) == 2:
left_line, right_line = _
conjoined_line = left_margin + left_line + gutter + right_line
conjoined_lines.append(conjoined_line)
if all_packages_lines:
blank_line = left_margin
conjoined_lines.append(blank_line)
for line in all_packages_lines:
conjoined_line = left_margin + line
conjoined_lines.append(conjoined_line)
return conjoined_lines
def _make_asset_menu_entries(self, head=None):
names = self.list_asset_names(head=head)
paths = self.list_asset_packagesystem_paths(head=head)
assert len(names) == len(paths)
sequences = (names, [None], [None], paths)
return sequencetools.zip_sequences(sequences, cyclic=True)
def _make_bicolumnar(
self,
lines,
break_only_at_blank_lines=False,
strip=True,
):
# http://stackoverflow.com/questions/566746/
# how-to-get-console-window-width-in-python
result = os.popen('stty size', 'r').read().split()
if result:
terminal_height, terminal_width = result
terminal_height = int(terminal_height)
terminal_width = int(terminal_width)
# returns none when run under py.test
else:
terminal_height, terminal_width = 24, 80
if terminal_width <= 80:
return lines
if len(lines) < terminal_height - 8:
return lines
if strip:
lines = [_.strip() for _ in lines]
all_packages_lines = [_ for _ in lines if _.startswith('all')]
lines = [_ for _ in lines if not _.startswith('all')]
# remove consecutive blank lines from comprehension above
clean_lines = []
for line in lines:
if line == '':
if clean_lines and clean_lines[-1] == '':
continue
clean_lines.append(line)
# remove initial blank line
if clean_lines[0] == '':
clean_lines.pop(0)
lines = clean_lines
midpoint = int(len(lines) / 2)
if break_only_at_blank_lines:
while lines[midpoint] != '':
midpoint += 1
assert lines[midpoint] == ''
left_lines = lines[:midpoint]
if break_only_at_blank_lines:
right_lines = lines[midpoint + 1:]
assert len(left_lines) + len(right_lines) == len(lines) - 1
else:
right_lines = lines[midpoint:]
left_count, right_count = len(left_lines), len(right_lines)
#assert right_count <= left_count, repr((left_count, right_count))
if strip:
left_width = max(len(_.strip()) for _ in left_lines)
right_width = max(len(_.strip()) for _ in right_lines)
else:
left_width = max(len(_) for _ in left_lines)
right_width = max(len(_) for _ in right_lines)
left_lines = [self._ljust(_, left_width) for _ in left_lines]
right_lines = [self._ljust(_, right_width) for _ in right_lines]
if strip:
left_margin_width, gutter_width = 4, 4
else:
left_margin_width, gutter_width = 0, 4
left_margin = left_margin_width * ' '
gutter = gutter_width * ' '
conjoined_lines = []
for _ in sequencetools.zip_sequences(
[left_lines, right_lines],
truncate=False,
):
if len(_) == 1:
left_line = _[0]
conjoined_line = left_margin + left_line
elif len(_) == 2:
left_line, right_line = _
conjoined_line = left_margin + left_line + gutter + right_line
conjoined_lines.append(conjoined_line)
if all_packages_lines:
blank_line = left_margin
conjoined_lines.append(blank_line)
for line in all_packages_lines:
conjoined_line = left_margin + line
conjoined_lines.append(conjoined_line)
return conjoined_lines
