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 _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