def test_QEventSequence_from_tempo_scaled_durations_01(): """ Test basic functionality. """ durations = [abjad.Duration(x) for x in [(1, 4), (1, 3), (1, 7), (2, 5), (3, 4)]] tempo = abjad.MetronomeMark((1, 4), 55) q_events = abjadext.nauert.QEventSequence.from_tempo_scaled_durations( durations, tempo ) assert q_events == abjadext.nauert.QEventSequence( ( abjadext.nauert.PitchedQEvent( abjad.Offset(0, 1), (abjad.NamedPitch("c'"),) ), abjadext.nauert.PitchedQEvent( abjad.Offset(12000, 11), (abjad.NamedPitch("c'"),) ), abjadext.nauert.PitchedQEvent( abjad.Offset(28000, 11), (abjad.NamedPitch("c'"),) ), abjadext.nauert.PitchedQEvent( abjad.Offset(244000, 77), (abjad.NamedPitch("c'"),) ), abjadext.nauert.PitchedQEvent( abjad.Offset(34400, 7), (abjad.NamedPitch("c'"),) ), abjadext.nauert.TerminalQEvent(abjad.Offset(630400, 77)), ) )
def test_QEventSequence_from_millisecond_pitch_attachment_tuples_01(): durations = [100, 200, 100, 300, 350, 400, 600] pitches = [0, None, None, [1, 4], None, 5, 7] attachments = [("foo",), None, None, (6,), None, ("foobar",), ("foo", "bar")] tuples = tuple(zip(durations, pitches, attachments)) q_events = nauert.QEventSequence.from_millisecond_pitch_attachment_tuples(tuples) assert q_events == nauert.QEventSequence( ( nauert.PitchedQEvent(abjad.Offset(0), (abjad.NamedPitch("c'"),), ("foo",)), nauert.SilentQEvent(abjad.Offset(100, 1)), nauert.PitchedQEvent( abjad.Offset(400, 1), (abjad.NamedPitch("cs'"), abjad.NamedPitch("e'")), (6,), ), nauert.SilentQEvent(abjad.Offset(700, 1)), nauert.PitchedQEvent( abjad.Offset(1050, 1), (abjad.NamedPitch("f'"),), ("foobar",) ), nauert.PitchedQEvent( abjad.Offset(1450, 1), (abjad.NamedPitch("g'"),), ("foo", "bar") ), nauert.TerminalQEvent(abjad.Offset(2050, 1)), ) ), repr(q_events)
def __sub__(self, argument): """ Subtracts `argument` from named pitch-class. .. container:: example >>> abjad.NamedPitchClass('cs') - abjad.NamedPitchClass('g') NamedInversionEquivalentIntervalClass('+A4') >>> abjad.NamedPitchClass('c') - abjad.NamedPitchClass('cf') NamedInversionEquivalentIntervalClass('+A1') >>> abjad.NamedPitchClass('cf') - abjad.NamedPitchClass('c') NamedInversionEquivalentIntervalClass('+A1') Returns named inversion-equivalent interval-class. """ import abjad if not isinstance(argument, type(self)): message = 'must be named pitch-class: {!r}.' message = message.format(argument) raise TypeError(message) pitch_1 = abjad.NamedPitch((self.name, 4)) pitch_2 = abjad.NamedPitch((argument.name, 4)) mdi = abjad.NamedInterval.from_pitch_carriers(pitch_1, pitch_2) pair = (mdi.quality, mdi.number) dic = abjad.NamedInversionEquivalentIntervalClass(pair) return dic
def test_QEventSequence_from_tempo_scaled_durations_02(): """ Silences are fused. """ durations = [ abjad.Duration(x) for x in [(1, 4), (-1, 4), (1, 4), (1, 4), (-1, 4), (-1, 4), (1, 4)] ] tempo = abjad.MetronomeMark((1, 4), 77) q_events = abjadext.nauert.QEventSequence.from_tempo_scaled_durations( durations, tempo ) assert q_events == abjadext.nauert.QEventSequence( ( abjadext.nauert.PitchedQEvent( abjad.Offset(0, 1), (abjad.NamedPitch("c'"),) ), abjadext.nauert.SilentQEvent(abjad.Offset(60000, 77)), abjadext.nauert.PitchedQEvent( abjad.Offset(120000, 77), (abjad.NamedPitch("c'"),) ), abjadext.nauert.PitchedQEvent( abjad.Offset(180000, 77), (abjad.NamedPitch("c'"),) ), abjadext.nauert.SilentQEvent(abjad.Offset(240000, 77)), abjadext.nauert.PitchedQEvent( abjad.Offset(360000, 77), (abjad.NamedPitch("c'"),) ), abjadext.nauert.TerminalQEvent(abjad.Offset(60000, 11)), ) )
def voice_scale_degrees_in_open_position(self, scale_degrees): r'''Voices `scale_degrees` in open position. .. container:: example >>> scale = abjad.tonalanalysistools.Scale(('c', 'major')) >>> scale_degrees = [1, 3, 'b5', 7, '#9'] >>> segment = scale.voice_scale_degrees_in_open_position( ... scale_degrees) >>> segment PitchSegment("c' e' gf' b' ds''") Return pitch segment. ''' import abjad from abjad.tools import tonalanalysistools scale_degrees = [ tonalanalysistools.ScaleDegree(x) for x in scale_degrees ] pitch_classes = [ self.scale_degree_to_named_pitch_class(x) for x in scale_degrees ] pitches = [abjad.NamedPitch(pitch_classes[0])] for pitch_class in pitch_classes[1:]: pitch = abjad.NamedPitch(pitch_class) while pitch < pitches[-1]: pitch += 12 pitches.append(pitch) pitches = abjad.PitchSegment(pitches) return pitches
def _contains_pitch(self, pitch): import abjad if isinstance(pitch, numbers.Number): pitch = abjad.NamedPitch(pitch) elif isinstance(pitch, str): pitch = abjad.NamedPitch(pitch) if self.start_pitch is None and self.stop_pitch is None: return True elif self.start_pitch is None: if self.stop_pitch_is_included_in_range: return pitch <= self.stop_pitch else: return pitch < self.stop_pitch elif self.stop_pitch is None: if self.start_pitch_is_included_in_range: return self.start_pitch <= pitch else: return self.start_pitch < pitch else: if self.start_pitch_is_included_in_range: if self.stop_pitch_is_included_in_range: return self.start_pitch <= pitch <= self.stop_pitch else: return self.start_pitch <= pitch < self.stop_pitch else: if self.stop_pitch_is_included_in_range: return self.start_pitch < pitch <= self.stop_pitch else: return self.start_pitch < pitch < self.stop_pitch
def transpose(self, expr): r""" Transposes music specifier. .. container:: example >>> music_specifier = tsmakers.MusicSpecifier() >>> transposed_music_specifier = music_specifier.transpose('-M2') >>> print(abjad.storage(transposed_music_specifier)) tsmakers.MusicSpecifier() Returns new music specifier. """ if isinstance(expr, str): try: pitch = abjad.NamedPitch(expr) expr = abjad.NamedPitch("C4") - pitch except Exception: expr = abjad.NamedInterval(expr) pitch_handler = self.pitch_handler if pitch_handler is not None: pitch_handler = pitch_handler.transpose(expr) return abjad.new( self, pitch_handler=pitch_handler, )
def calc_anchor(self): durs = [self.leaf.written_duration, self.anchor_dur] container = abjad.Container() pre_mult = self.leaf.written_duration - self.anchor_dur mult = pre_mult / self.leaf.written_duration if isinstance(self.leaf, abjad.Chord): pitches = [ abjad.NamedPitch(_) for _ in abjad.get.pitches(self.leaf) ] elif isinstance(self.leaf, abjad.Note): pitches = [ abjad.NamedPitch(_) for _ in abjad.get.pitches(self.leaf) ] pitches = pitches[0] else: pass maker = abjad.LeafMaker() new_leaves = [list_ for list_ in maker([pitches], durs)] indicators = abjad.get.indicators(self.leaf) for indicator in indicators: abjad.attach(indicator, new_leaves[0][0]) self.leaf.multiplier = mult abjad.attach( abjad.LilyPondLiteral(r"""\abjad-invisible-music""", format_slot="before"), new_leaves[1], ) abjad.annotate(new_leaves[1], "type", "spanner anchor") container.extend(new_leaves) return container
def test_NamedInterval_01(pitch_a, pitch_b, name): pitch_a = abjad.NamedPitch(pitch_a) pitch_b = abjad.NamedPitch(pitch_b) interval = abjad.NamedInterval.from_pitch_carriers(pitch_a, pitch_b) assert str(interval) == name assert pitch_a.transpose(interval) == pitch_b assert pitch_b.transpose(-interval) == pitch_a
def __mul__(self, argument): """ Multiplies named interval by `argument`. .. container:: example >>> 3 * abjad.NamedInterval('+M9') NamedInterval('+A25') Returns new named interval. """ import abjad if not isinstance(argument, int): message = "must be integer: {!r}." message = message.format(argument) raise TypeError(message) dummy_pitch = abjad.NamedPitch(0) for i in range(abs(argument)): dummy_pitch += self result = NamedInterval.from_pitch_carriers(abjad.NamedPitch(0), dummy_pitch) if argument < 0: return -result return result
def create_named_pitch_set_in_pitch_range(self, pitch_range): r'''Creates named pitch-set in `pitch_range`. Returns pitch-set. ''' import abjad if not isinstance(pitch_range, abjad.PitchRange): pitch_range = abjad.PitchRange( float(abjad.NamedPitch(pitch_range[0])), float(abjad.NamedPitch(pitch_range[1]))) low = pitch_range.start_pitch.octave.number high = pitch_range.stop_pitch.octave.number pitches = [] octave = low while octave <= high: for x in self: pitch = abjad.NamedPitch((x.name, octave)) if (pitch_range.start_pitch <= pitch and pitch <= pitch_range.stop_pitch): pitches.append(pitch) octave += 1 return abjad.PitchSet( items=pitches, item_class=abjad.NamedPitch, )
def test_virtual_fundamental_08(): pitches = abjad.PitchSegment(r"c'' cs'' d'' ef'' e'' fs''") fundamental = auxjad.get.virtual_fundamental( pitches, min_fundamental=abjad.NamedPitch(r"c,,,"), ) assert fundamental == abjad.NamedPitch(r"d,,")
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) if self.displace_fifths: self.pitch = abjad.NamedPitch(self.pitch).transpose( self.displace_fifths * 7) if self.displace_octaves: self.pitch = abjad.NamedPitch(self.pitch).transpose( self.displace_octaves * 12)
def test_init(input_, expected_semitones): if isinstance(expected_semitones, type) and issubclass( expected_semitones, Exception): with pytest.raises(expected_semitones): abjad.NamedPitch(input_) return instance = abjad.NamedPitch(input_) assert float(instance) == expected_semitones
def test_quantizationtools_PitchedQEvent___init___01(): q_event = quantizationtools.PitchedQEvent(130, [0, 1, 4]) assert q_event.offset == abjad.Offset(130) assert q_event.pitches == (abjad.NamedPitch(0), abjad.NamedPitch(1), abjad.NamedPitch(4)) assert q_event.attachments == ()
def test_PitchedQEvent___init___01(): q_event = abjadext.nauert.PitchedQEvent(130, [0, 1, 4]) assert q_event.offset == abjad.Offset(130) assert q_event.pitches == ( abjad.NamedPitch(0), abjad.NamedPitch(1), abjad.NamedPitch(4), ) assert q_event.attachments == ()
def test_scoretools_Chord___init___04(): r'''Initialize chord with pitches. ''' pitches = [] pitches.append(abjad.NamedPitch('D#4')) pitches.append(abjad.NamedPitch('Eb4')) chord = abjad.Chord(pitches, (1, 4)) assert format(chord) == "<ds' ef'>4"
def test_Chord_written_pitches_05(): """ Set written pitches with both pitches and pitch numbers. """ chord = abjad.Chord([], (1, 4)) chord.written_pitches = [4, abjad.NamedPitch(3), abjad.NamedPitch(2)] assert format(chord) == "<d' ef' e'>4"
def test_quantizationtools_PitchedQEvent___init___02(): q_event = quantizationtools.PitchedQEvent( abjad.Offset(133, 5), [abjad.NamedPitch('fss')], attachments=['foo', 'bar', 'baz']) assert q_event.offset == abjad.Offset(133, 5) assert q_event.pitches == (abjad.NamedPitch('fss'), ) assert q_event.attachments == ('foo', 'bar', 'baz')
def test_PitchedQEvent___init___02(): q_event = abjadext.nauert.PitchedQEvent( abjad.Offset(133, 5), [abjad.NamedPitch("fss")], attachments=["foo", "bar", "baz"], ) assert q_event.offset == abjad.Offset(133, 5) assert q_event.pitches == (abjad.NamedPitch("fss"), ) assert q_event.attachments == ("foo", "bar", "baz")
def test_scoretools_NoteHeadList___contains___02(): chord = abjad.Chord("<ef' cs'' f''>4") assert not 18 in chord.note_heads assert not 18.0 in chord.note_heads assert not abjad.NamedPitch(18) in chord.note_heads assert not abjad.NamedPitch("fs''") in chord.note_heads assert not abjad.NoteHead(18) in chord.note_heads assert not abjad.NoteHead("fs''") in chord.note_heads
def find_pitches(self, abjad_pitch: abjad.NamedPitch) -> None: from mutools import lily basic_pitch = abjad.NamedPitch( lily.round_scale_index_to_12th_tone( float(abjad_pitch) - self.ground_interval)) harmonic_pitch = abjad.NamedPitch( lily.round_scale_index_to_12th_tone( float(basic_pitch) + self.harmonic_interval)) return abjad.PitchSegment([basic_pitch, harmonic_pitch])
def test_scoretools_NoteHeadList___contains___01(): chord = abjad.Chord("<ef' cs'' f''>4") assert 17 in chord.note_heads assert 17.0 in chord.note_heads assert abjad.NamedPitch(17) in chord.note_heads assert abjad.NamedPitch("f''") in chord.note_heads assert chord.note_heads[1] in chord.note_heads assert abjad.NoteHead("f''") in chord.note_heads
def test_Chord___init___04(): """ Initialize chord with pitches. """ pitches = [] pitches.append(abjad.NamedPitch("D#4")) pitches.append(abjad.NamedPitch("Eb4")) chord = abjad.Chord(pitches, (1, 4)) assert format(chord) == "<ds' ef'>4"
def _get_intervals_in_subrun(subrun_source): subrun_source = list(subrun_source) result = [0] for first, second in abjad.Sequence(subrun_source).nwise(): first_pitch = abjad.NamedPitch(first) second_pitch = abjad.NamedPitch(second) interval = (abjad.NumberedPitch(second_pitch).number - abjad.NumberedPitch(first_pitch).number) result.append(interval + result[-1]) result.pop(0) return result
def _is_equivalent_under_transposition(self, argument): import abjad if not isinstance(argument, type(self)): return False if not len(self) == len(argument): return False difference = -(abjad.NamedPitch(argument[0], 4) - abjad.NamedPitch(self[0], 4)) new_pitches = (x + difference for x in self) new_pitches = abjad.new(self, items=new_pitches) return argument == new_pitches
def assign_to_instruments(self, inst_names, inst_noten, round_=False): """Distribute analyzed pitches to different instruments. inst_noten: number of pitches assigned for each specified instrument (inst_names), for each chord analyzed. Save the result in a .json file. """ # inst_names = ["Bass Clarinet", "Piano"] # inst_noten = [4, 1] result = {} save_dict = {} for name in inst_names: result[name] = [] save_dict[name] = [] for chord in self.container: chord_ = [] str_chord = [] chord_notes = iter(chord.written_pitches) if round_ is True: num_pitches = [abjad.NamedPitch(_).number for _ in chord_notes] # NO MICROTONAL for item, i in zip(num_pitches, range(len(num_pitches))): if isinstance(item, float): item = item - 0.5 num_pitches[i] = item num_pitches = iter(num_pitches) for name, number in zip(inst_names, inst_noten): for n in range(number): note = next(num_pitches) chord_.append(note) str_chord.append(abjad.NamedPitch(note).name) result[name].append(chord_) save_dict[name].append(str_chord) else: for name, number in zip(inst_names, inst_noten): for n in range(number): note = next(chord_notes) chord_.append(note) str_chord.append(note.name) result[name].append(chord_) save_dict[name].append(str_chord) file_str = "" for item in result: file_str = file_str + item + "_" file_str = file_str + "pitches.json" a_file = open(file_str, "w") json.dump(save_dict, a_file) print("Saved in", file_str) a_file.close()
def test_scoretools_NoteHead_written_pitch_04(): r'''Set note-head pitch from another note or note-head. Make sure this does not cause reference problems. ''' n1 = abjad.Note(12, (1, 4)) n2 = abjad.Note(14, (1, 4)) n1.written_pitch = n2.written_pitch assert n1.written_pitch == abjad.NamedPitch(14) assert n2.written_pitch == abjad.NamedPitch(14) assert n1.written_pitch is not n2.written_pitch
def test_scoretools_Chord_written_pitches_06(): r'''Set written pitches with both pitches and pitch numbers. ''' chord = abjad.Chord([], (1, 4)) chord.written_pitches = [ 4, abjad.NamedPitch(3), abjad.NamedPitch(2), ] assert format(chord) == "<d' ef' e'>4"
def test_Chord_written_pitches_04(): """ Set written pitches with pitches. """ chord = abjad.Chord([], (1, 4)) chord.written_pitches = [ abjad.NamedPitch(4), abjad.NamedPitch(3), abjad.NamedPitch(2), ] assert format(chord) == "<d' ef' e'>4"