def test_quantizationtools_QGrid___eq___02():
a = quantizationtools.QGrid(
root_node=quantizationtools.QGridContainer(
preprolated_duration=1,
children=[
quantizationtools.QGridLeaf(
preprolated_duration=1,
q_event_proxies=[
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent(100),
0.5,
),
],
),
],
),
next_downbeat=quantizationtools.QGridLeaf(
preprolated_duration=1,
q_event_proxies=[
quantizationtools.QEventProxy(
quantizationtools.TerminalQEvent(200),
0.9,
),
],
),
)
b = quantizationtools.QGrid(
root_node=quantizationtools.QGridContainer(
preprolated_duration=1,
children=[
quantizationtools.QGridLeaf(
preprolated_duration=1,
q_event_proxies=[
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent(100),
0.5,
),
],
),
],
),
next_downbeat=quantizationtools.QGridLeaf(
preprolated_duration=1,
q_event_proxies=[
quantizationtools.QEventProxy(
quantizationtools.TerminalQEvent(200),
0.9,
),
],
),
)
assert format(a) == format(b)
assert a != b
def test_quantizationtools_QGrid___eq___03():
a = quantizationtools.QGrid()
b = quantizationtools.QGrid(root_node=quantizationtools.QGridContainer(
preprolated_duration=1,
children=[
quantizationtools.QGridLeaf(
preprolated_duration=1,
q_event_proxies=[
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent(100), 0.5)
],
),
],
), )
c = quantizationtools.QGrid(next_downbeat=quantizationtools.QGridLeaf(
preprolated_duration=1,
q_event_proxies=[
quantizationtools.QEventProxy(
quantizationtools.TerminalQEvent(200), 0.9),
],
), )
d = quantizationtools.QGrid(
root_node=quantizationtools.QGridContainer(
preprolated_duration=1,
children=[
quantizationtools.QGridLeaf(
preprolated_duration=1,
q_event_proxies=[
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent(100), 0.5),
],
),
],
),
next_downbeat=quantizationtools.QGridLeaf(
preprolated_duration=1,
q_event_proxies=[
quantizationtools.QEventProxy(
quantizationtools.TerminalQEvent(200),
0.9,
),
],
),
),
assert a != b
assert a != c
assert a != d
assert b != c
assert b != d
assert c != d
def from_tempo_scaled_durations(class_, durations, tempo=None):
r'''Convert ``durations``, scaled by ``tempo``
into a ``QEventSequence``:
>>> tempo = abjad.MetronomeMark((1, 4), 174)
>>> durations = [(1, 4), (-3, 16), (1, 16), (-1, 2)]
>>> sequence = \
... abjad.quantizationtools.QEventSequence.from_tempo_scaled_durations(
... durations, tempo=tempo)
>>> for q_event in sequence:
... print(format(q_event, 'storage'))
...
abjad.quantizationtools.PitchedQEvent(
offset=abjad.Offset(0, 1),
pitches=(
abjad.NamedPitch("c'"),
),
)
abjad.quantizationtools.SilentQEvent(
offset=abjad.Offset(10000, 29),
)
abjad.quantizationtools.PitchedQEvent(
offset=abjad.Offset(17500, 29),
pitches=(
abjad.NamedPitch("c'"),
),
)
abjad.quantizationtools.SilentQEvent(
offset=abjad.Offset(20000, 29),
)
abjad.quantizationtools.TerminalQEvent(
offset=abjad.Offset(40000, 29),
)
Returns ``QEventSequence`` instance.
'''
import abjad
from abjad.tools import quantizationtools
durations = [abjad.Duration(x) for x in durations]
assert isinstance(tempo, indicatortools.MetronomeMark)
durations = [
x for x in abjad.sequence(durations).sum_by_sign(sign=[-1]) if x
]
durations = [tempo.duration_to_milliseconds(_) for _ in durations]
offsets = mathtools.cumulative_sums([abs(_) for _ in durations])
q_events = []
for pair in zip(offsets, durations):
offset = abjad.Offset(pair[0])
duration = pair[1]
# negative duration indicates silence
if duration < 0:
q_event = quantizationtools.SilentQEvent(offset)
# otherwise use middle C
else:
q_event = quantizationtools.PitchedQEvent(offset, [0])
q_events.append(q_event)
# insert terminating silence QEvent
q_events.append(quantizationtools.TerminalQEvent(offsets[-1]))
return class_(q_events)
def test_quantizationtools_QGrid_pickle_01():
q_grid = quantizationtools.QGrid(
root_node=quantizationtools.QGridContainer(
preprolated_duration=1,
children=[
quantizationtools.QGridLeaf(
preprolated_duration=1,
q_event_proxies=[
quantizationtools.QEventProxy(
quantizationtools.SilentQEvent(100),
0.5,
),
],
),
],
),
next_downbeat=quantizationtools.QGridLeaf(
preprolated_duration=1,
q_event_proxies=[
quantizationtools.QEventProxy(
quantizationtools.TerminalQEvent(200),
0.9,
),
],
),
)
pickled = pickle.loads(pickle.dumps(q_grid))
assert format(pickled) == format(q_grid)
assert pickled is not q_grid
assert pickled != q_grid, \
systemtools.TestManager.diff(pickled, q_grid, 'Diff:')
def from_millisecond_offsets(cls, offsets):
r'''Convert millisecond offsets ``offsets`` into a ``QEventSequence``:
::
>>> offsets = [0, 250, 750, 1750, 3000, 4000]
::
>>> sequence = \
... quantizationtools.QEventSequence.from_millisecond_offsets(
... offsets)
::
>>> for q_event in sequence:
... print(format(q_event, 'storage'))
...
quantizationtools.PitchedQEvent(
offset=durationtools.Offset(0, 1),
pitches=(
pitchtools.NamedPitch("c'"),
),
)
quantizationtools.PitchedQEvent(
offset=durationtools.Offset(250, 1),
pitches=(
pitchtools.NamedPitch("c'"),
),
)
quantizationtools.PitchedQEvent(
offset=durationtools.Offset(750, 1),
pitches=(
pitchtools.NamedPitch("c'"),
),
)
quantizationtools.PitchedQEvent(
offset=durationtools.Offset(1750, 1),
pitches=(
pitchtools.NamedPitch("c'"),
),
)
quantizationtools.PitchedQEvent(
offset=durationtools.Offset(3000, 1),
pitches=(
pitchtools.NamedPitch("c'"),
),
)
quantizationtools.TerminalQEvent(
offset=durationtools.Offset(4000, 1),
)
Returns ``QEventSequence`` instance.
'''
from abjad.tools import quantizationtools
q_events = [
quantizationtools.PitchedQEvent(x, [0]) for x in offsets[:-1]
]
q_events.append(quantizationtools.TerminalQEvent(offsets[-1]))
return cls(q_events)
def test_quantizationtools_PitchedQEvent___eq___03():
a = quantizationtools.TerminalQEvent(100)
b = quantizationtools.PitchedQEvent(100, [0])
c = quantizationtools.SilentQEvent(100)
assert a != b
assert a != c
def test_quantizationtools_QEventSequence_from_tempo_scaled_leaves_02():
staff = abjad.Staff([])
staff.append(abjad.Note(0, (1, 4)))
staff.append(abjad.Rest((1, 4)))
staff.append(abjad.Rest((1, 8)))
staff.append(abjad.Note(1, (1, 8)))
staff.append(abjad.Note(1, (1, 8)))
staff.append(abjad.Note(2, (1, 8)))
staff.append(abjad.Note(2, (1, 8)))
staff.append(abjad.Note(3, (1, 8)))
staff.append(abjad.Skip((1, 4)))
staff.append(abjad.Rest((1, 4)))
staff.append(abjad.Note(3, (1, 8)))
staff.append(abjad.Chord([0, 1, 4], (1, 4)))
tie = abjad.Tie()
abjad.attach(tie, staff[3:5])
tie = abjad.Tie()
abjad.attach(tie, staff[5:7])
tempo = abjad.MetronomeMark((1, 4), 58)
abjad.attach(tempo, staff[0], context='Staff')
tempo = abjad.MetronomeMark((1, 4), 77)
abjad.attach(tempo, staff[9], context='Staff')
leaves = abjad.select(staff).leaves()
q_events = quantizationtools.QEventSequence.from_tempo_scaled_leaves(
leaves)
assert q_events == quantizationtools.QEventSequence(
(quantizationtools.PitchedQEvent(abjad.Offset(0, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.SilentQEvent(abjad.Offset(30000, 29)),
quantizationtools.PitchedQEvent(abjad.Offset(75000, 29),
(abjad.NamedPitch("cs'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(105000, 29),
(abjad.NamedPitch("d'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(135000, 29),
(abjad.NamedPitch("ef'"), )),
quantizationtools.SilentQEvent(abjad.Offset(150000, 29)),
quantizationtools.PitchedQEvent(abjad.Offset(15600000, 2233),
(abjad.NamedPitch("ef'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(16470000, 2233), (
abjad.NamedPitch("c'"),
abjad.NamedPitch("cs'"),
abjad.NamedPitch("e'"),
)), quantizationtools.TerminalQEvent(abjad.Offset(18210000, 2233))))
def test_quantizationtools_QEventSequence_from_tempo_scaled_leaves_01():
staff = abjad.Staff([])
staff.append(abjad.Note(0, (1, 4)))
staff.append(abjad.Rest((1, 4)))
staff.append(abjad.Rest((1, 8)))
staff.append(abjad.Note(1, (1, 8)))
staff.append(abjad.Note(1, (1, 8)))
staff.append(abjad.Note(2, (1, 8)))
staff.append(abjad.Note(2, (1, 8)))
staff.append(abjad.Note(3, (1, 8)))
staff.append(abjad.Skip((1, 4)))
staff.append(abjad.Rest((1, 4)))
staff.append(abjad.Note(3, (1, 8)))
staff.append(abjad.Chord([0, 1, 4], (1, 4)))
tie = abjad.Tie()
abjad.attach(tie, staff[3:5])
tie = abjad.Tie()
abjad.attach(tie, staff[5:7])
tempo = abjad.MetronomeMark((1, 4), 55)
leaves = abjad.select(staff).leaves()
q_events = quantizationtools.QEventSequence.from_tempo_scaled_leaves(
leaves, tempo)
assert q_events == quantizationtools.QEventSequence(
(quantizationtools.PitchedQEvent(abjad.Offset(0, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.SilentQEvent(abjad.Offset(12000, 11)),
quantizationtools.PitchedQEvent(abjad.Offset(30000, 11),
(abjad.NamedPitch("cs'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(42000, 11),
(abjad.NamedPitch("d'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(54000, 11),
(abjad.NamedPitch("ef'"), )),
quantizationtools.SilentQEvent(abjad.Offset(60000, 11)),
quantizationtools.PitchedQEvent(abjad.Offset(84000, 11),
(abjad.NamedPitch("ef'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(90000, 11), (
abjad.NamedPitch("c'"),
abjad.NamedPitch("cs'"),
abjad.NamedPitch("e'"),
)), quantizationtools.TerminalQEvent(abjad.Offset(102000, 11))))
def test_quantizationtools_QEventSequence_from_millisecond_durations_03():
r'''Silences are fused.
'''
durations = [100, -100, 100, -100, -100, 100]
q_events = quantizationtools.QEventSequence.from_millisecond_durations(
durations, fuse_silences=True)
assert q_events == quantizationtools.QEventSequence(
(quantizationtools.PitchedQEvent(abjad.Offset(0),
(abjad.NamedPitch("c'"), )),
quantizationtools.SilentQEvent(abjad.Offset(100)),
quantizationtools.PitchedQEvent(abjad.Offset(200),
(abjad.NamedPitch("c'"), )),
quantizationtools.SilentQEvent(abjad.Offset(300)),
quantizationtools.PitchedQEvent(abjad.Offset(500),
(abjad.NamedPitch("c'"), )),
quantizationtools.TerminalQEvent(abjad.Offset(600))))
def test_quantizationtools_QEventSequence_from_millisecond_pitch_pairs_01():
durations = [100, 200, 100, 300, 350, 400, 600]
pitches = [0, None, None, [1, 4], None, 5, 7]
pairs = tuple(zip(durations, pitches))
q_events = quantizationtools.QEventSequence.from_millisecond_pitch_pairs(
pairs)
assert q_events == quantizationtools.QEventSequence((
quantizationtools.PitchedQEvent(
abjad.Offset(0),
(abjad.NamedPitch("c'"),)
),
quantizationtools.SilentQEvent(
abjad.Offset(100, 1)
),
quantizationtools.PitchedQEvent(
abjad.Offset(400, 1),
(
abjad.NamedPitch("cs'"),
abjad.NamedPitch("e'")
)
),
quantizationtools.SilentQEvent(
abjad.Offset(700, 1)
),
quantizationtools.PitchedQEvent(
abjad.Offset(1050, 1),
(abjad.NamedPitch("f'"),)
),
quantizationtools.PitchedQEvent(
abjad.Offset(1450, 1),
(abjad.NamedPitch("g'"),)
),
quantizationtools.TerminalQEvent(
abjad.Offset(2050, 1),
)
))
def test_quantizationtools_QEventSequence_from_tempo_scaled_durations_01():
r'''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 = quantizationtools.QEventSequence.from_tempo_scaled_durations(
durations, tempo)
assert q_events == quantizationtools.QEventSequence(
(quantizationtools.PitchedQEvent(abjad.Offset(0, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(12000, 11),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(28000, 11),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(244000, 77),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(34400, 7),
(abjad.NamedPitch("c'"), )),
quantizationtools.TerminalQEvent(abjad.Offset(630400, 77))))
def test_quantizationtools_QEventSequence_from_tempo_scaled_durations_02():
r'''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 = quantizationtools.QEventSequence.from_tempo_scaled_durations(
durations, tempo)
assert q_events == quantizationtools.QEventSequence(
(quantizationtools.PitchedQEvent(abjad.Offset(0, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.SilentQEvent(abjad.Offset(60000, 77)),
quantizationtools.PitchedQEvent(abjad.Offset(120000, 77),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(180000, 77),
(abjad.NamedPitch("c'"), )),
quantizationtools.SilentQEvent(abjad.Offset(240000, 77)),
quantizationtools.PitchedQEvent(abjad.Offset(360000, 77),
(abjad.NamedPitch("c'"), )),
quantizationtools.TerminalQEvent(abjad.Offset(60000, 11))))
def from_tempo_scaled_durations(cls, durations, tempo=None):
r'''Convert ``durations``, scaled by ``tempo``
into a ``QEventSequence``:
::
>>> tempo = Tempo((1, 4), 174)
>>> durations = [(1, 4), (-3, 16), (1, 16), (-1, 2)]
::
>>> sequence = \
... quantizationtools.QEventSequence.from_tempo_scaled_durations(
... durations, tempo=tempo)
::
>>> for q_event in sequence:
... print(format(q_event, 'storage'))
...
quantizationtools.PitchedQEvent(
offset=durationtools.Offset(0, 1),
pitches=(
pitchtools.NamedPitch("c'"),
),
)
quantizationtools.SilentQEvent(
offset=durationtools.Offset(10000, 29),
)
quantizationtools.PitchedQEvent(
offset=durationtools.Offset(17500, 29),
pitches=(
pitchtools.NamedPitch("c'"),
),
)
quantizationtools.SilentQEvent(
offset=durationtools.Offset(20000, 29),
)
quantizationtools.TerminalQEvent(
offset=durationtools.Offset(40000, 29),
)
Returns ``QEventSequence`` instance.
'''
from abjad.tools import quantizationtools
durations = [durationtools.Duration(x) for x in durations]
assert isinstance(tempo, indicatortools.Tempo)
durations = [
x for x in sequencetools.sum_consecutive_elements_by_sign(
durations,
sign=[-1],
) if x
]
durations = [tempo.duration_to_milliseconds(x) for x in durations]
offsets = mathtools.cumulative_sums(abs(x) for x in durations)
q_events = []
for pair in zip(offsets, durations):
offset = durationtools.Offset(pair[0])
duration = pair[1]
if duration < 0: # negative duration indicates silence
q_event = quantizationtools.SilentQEvent(offset)
else: # otherwise, use middle-C
q_event = quantizationtools.PitchedQEvent(offset, [0])
q_events.append(q_event)
# insert terminating silence QEvent
q_events.append(quantizationtools.TerminalQEvent(offsets[-1]))
return cls(q_events)
def from_millisecond_pitch_pairs(cls, pairs):
r'''Convert millisecond-duration:pitch pairs ``pairs`` into a
``QEventSequence``:
::
>>> durations = [250, 500, 1000, 1250, 1000]
>>> pitches = [(0,), None, (2, 3), None, (1,)]
>>> pairs = tuple(zip(durations, pitches))
::
>>> sequence = \
... quantizationtools.QEventSequence.from_millisecond_pitch_pairs(
... pairs)
::
>>> for q_event in sequence:
... print(format(q_event, 'storage'))
...
quantizationtools.PitchedQEvent(
offset=durationtools.Offset(0, 1),
pitches=(
pitchtools.NamedPitch("c'"),
),
)
quantizationtools.SilentQEvent(
offset=durationtools.Offset(250, 1),
)
quantizationtools.PitchedQEvent(
offset=durationtools.Offset(750, 1),
pitches=(
pitchtools.NamedPitch("d'"),
pitchtools.NamedPitch("ef'"),
),
)
quantizationtools.SilentQEvent(
offset=durationtools.Offset(1750, 1),
)
quantizationtools.PitchedQEvent(
offset=durationtools.Offset(3000, 1),
pitches=(
pitchtools.NamedPitch("cs'"),
),
)
quantizationtools.TerminalQEvent(
offset=durationtools.Offset(4000, 1),
)
Returns ``QEventSequence`` instance.
'''
from abjad.tools import quantizationtools
assert isinstance(pairs, collections.Iterable)
assert all(isinstance(x, collections.Iterable) for x in pairs)
assert all(len(x) == 2 for x in pairs)
assert all(0 < x[0] for x in pairs)
for pair in pairs:
assert isinstance(
pair[1], (numbers.Number, type(None), collections.Iterable))
if isinstance(pair[1], collections.Iterable):
assert 0 < len(pair[1])
assert all(isinstance(x, numbers.Number) for x in pair[1])
# fuse silences
g = itertools.groupby(pairs, lambda x: x[1] is not None)
groups = []
for value, group in g:
if value:
groups.extend(list(group))
else:
duration = sum(x[0] for x in group)
groups.append((duration, None))
# find offsets
offsets = mathtools.cumulative_sums([abs(x[0]) for x in groups])
# build QEvents
q_events = []
for pair in zip(offsets, groups):
offset = durationtools.Offset(pair[0])
pitches = pair[1][1]
if isinstance(pitches, collections.Iterable):
assert all(isinstance(x, numbers.Number) for x in pitches)
q_events.append(
quantizationtools.PitchedQEvent(offset, pitches))
elif isinstance(pitches, type(None)):
q_events.append(quantizationtools.SilentQEvent(offset))
elif isinstance(pitches, numbers.Number):
q_events.append(
quantizationtools.PitchedQEvent(offset, [pitches]))
q_events.append(
quantizationtools.TerminalQEvent(durationtools.Offset(
offsets[-1])))
return cls(q_events)
def from_millisecond_durations(cls, milliseconds, fuse_silences=False):
r'''Convert a sequence of millisecond durations ``durations`` into
a ``QEventSequence``:
::
>>> durations = [-250, 500, -1000, 1250, -1000]
::
>>> sequence = \
... quantizationtools.QEventSequence.from_millisecond_durations(
... durations)
::
>>> for q_event in sequence:
... print(format(q_event, 'storage'))
...
quantizationtools.SilentQEvent(
offset=durationtools.Offset(0, 1),
)
quantizationtools.PitchedQEvent(
offset=durationtools.Offset(250, 1),
pitches=(
pitchtools.NamedPitch("c'"),
),
)
quantizationtools.SilentQEvent(
offset=durationtools.Offset(750, 1),
)
quantizationtools.PitchedQEvent(
offset=durationtools.Offset(1750, 1),
pitches=(
pitchtools.NamedPitch("c'"),
),
)
quantizationtools.SilentQEvent(
offset=durationtools.Offset(3000, 1),
)
quantizationtools.TerminalQEvent(
offset=durationtools.Offset(4000, 1),
)
Returns ``QEventSequence`` instance.
'''
from abjad.tools import quantizationtools
if fuse_silences:
durations = [x for x in \
sequencetools.sum_consecutive_elements_by_sign(
milliseconds, sign=[-1]) if x]
else:
durations = milliseconds
offsets = mathtools.cumulative_sums([abs(x) for x in durations])
q_events = []
for pair in zip(offsets, durations):
offset = durationtools.Offset(pair[0])
duration = pair[1]
if duration < 0: # negative duration indicates silence
q_event = quantizationtools.SilentQEvent(offset)
else:
q_event = quantizationtools.PitchedQEvent(offset, [0])
q_events.append(q_event)
q_events.append(
quantizationtools.TerminalQEvent(durationtools.Offset(
offsets[-1])))
return cls(q_events)
def test_quantizationtools_TerminalQEvent___eq___01():
a = quantizationtools.TerminalQEvent(1000)
b = quantizationtools.TerminalQEvent(1000)
assert a == b
def test_quantizationtools_QEventSequence_from_millisecond_durations_01():
r'''Test basic functionality.
'''
durations = abjad.mathtools.difference_series(
[x[0] for x in test_time_segments])
q_events = quantizationtools.QEventSequence.from_millisecond_durations(
durations)
assert q_events == quantizationtools.QEventSequence(
(quantizationtools.PitchedQEvent(abjad.Offset(0, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(163, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(511, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(627, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(1208, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(1417, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(1997, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(3204, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(3297, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(4087, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(4296, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(4830, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(6362, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(6595, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(6687, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(7013, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(7245, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(7872, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(8197, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(8359, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(8638, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(8731, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(8917, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(9288, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(9404, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(10240, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(10356, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(10496, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(10890, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(11169, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(11285, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(11424, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(12307, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(12957, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(13073, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(13653, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(13979, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(14234, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(15256, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(15883, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(16022, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(16649, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(16927, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(17044, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(17276, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.TerminalQEvent(abjad.Offset(18483, 1))))
def test_quantizationtools_TerminalQEvent___init___01():
q_event = quantizationtools.TerminalQEvent(154)
assert q_event.offset == abjad.Offset(154)
