def test_sequence_cancel():
# type: () -> None
test_res = []
def inner_seq():
# type: () -> Sequence
seq = Sequence()
return seq.done()
def inner_seq_cancel():
# type: () -> Sequence
seq = Sequence()
seq.add(seq.cancel)
return seq.done()
seq = Sequence()
seq.add(inner_seq_cancel)
seq.add(lambda: test_res.append(True))
seq.done()
assert test_res == []
seq = Sequence()
seq.add(inner_seq)
seq.add(lambda: test_res.append(True))
seq.done()
assert test_res == [True]
def _added_track_init(self):
# type: () -> Sequence
self.has_monitor_in = True
self.input_routing_type = InputRoutingTypeEnum.NO_INPUT
seq = Sequence()
seq.add(super(SimpleDummyTrack, self)._added_track_init)
# creating automation
seq = Sequence()
seq.add(self._select_parameters)
seq.add(self._insert_device)
seq.add(wait=5)
seq.add(self._insert_dummy_clip)
seq.add(self._create_dummy_automation)
return seq.done()
def test_sanity_checks():
# type: () -> None
seq = Sequence()
seq.add([])
seq.done()
assert seq.terminated
with pytest.raises(Exception):
seq.add(wait=1)
with pytest.raises(Exception):
Sequence().add(wait=1, complete_on=lambda: True).done()
with pytest.raises(Exception):
Sequence().add(wait_for_system=True, wait=1).done()
def test_async_callback_execution_order():
# type: () -> None
test_res = []
# noinspection PyClassHasNoInit
class Example:
@has_callback_queue()
def listener(self):
# type: () -> Sequence
# noinspection PyShadowingNames
seq = Sequence()
seq.add(lambda: test_res.append(0), name="append 0")
seq.add(wait=1)
seq.add(lambda: test_res.append(1), name="append 1")
return seq.done()
obj = Example()
seq = Sequence()
seq.add(nop, complete_on=obj.listener, name="waiting for obj.listener")
seq.add(lambda: test_res.append(2), name="append 2")
seq.add(nop, name="after listener step")
def check_res():
# type: () -> None
assert test_res == [0, 1, 2]
seq.add(check_res)
seq.done()
obj.listener()
def crop_clip(self):
# type: () -> Sequence
seq = Sequence()
seq.add(partial(self.system.right_click, 1202, 809))
seq.add(partial(self.system.click, 1262, 413))
seq.add(wait=2)
return seq.done()
def activate_plugin_window(self,
select_instrument_track=False,
force_activate=False):
# type: (bool, bool) -> Optional[Sequence]
seq = Sequence()
if force_activate or not self.activated:
seq.add(self.device.track.select)
seq.add(
partial(self.parent.deviceManager.make_plugin_window_showable,
self.device))
seq.add(lambda: setattr(self, "activated", True),
name="mark instrument as activated")
if force_activate or self.needs_exclusive_activation:
seq.add(self.device.track.select)
seq.add(self.exclusive_activate)
if force_activate or not self.activated:
seq.add(self.post_activate)
if not force_activate and not select_instrument_track:
seq.add(wait=2)
seq.add(self.system.hide_plugins)
return seq.done()
def load_preset(self, preset):
# type: (AbstractInstrument, InstrumentPreset) -> Optional[Sequence]
""" Overridden default is send program change """
seq = Sequence()
seq.add(self.track.abstract_track.arm)
seq.add(partial(self.parent.midiManager.send_program_change, preset.index + self.PROGRAM_CHANGE_OFFSET))
return seq.done()
def exclusive_activate(self):
# type: () -> Optional[Sequence]
InstrumentProphet.ACTIVE_INSTANCE = self
seq = Sequence()
seq.add(wait=5)
seq.add(self.system.activate_rev2_editor, wait=5)
return seq.done()
def bounce_session_to_arrangement(self):
# type: () -> Optional[Sequence]
if SessionToArrangementManager.IS_BOUNCING:
self.song.session_end_listener()
self.parent.defer(self.parent.navigationManager.show_session)
return None
from protocol0.lom.Scene import Scene
Scene.LOOPING_SCENE = None
SessionToArrangementManager.IS_BOUNCING = True
SessionToArrangementManager.LAST_SCENE_FIRED = None
self.song.unfocus_all_tracks()
self.song.normal_tempo = self.song.tempo
self.song.tempo = 999
self.parent.navigationManager.show_arrangement()
seq = Sequence()
seq.add(self.system.clear_arrangement)
seq.add(wait=20)
seq.add(self.parent.navigationManager.show_session)
seq.add(self.song.reset)
# make recording start at 1.1.1
seq.add(self.song.scenes[0].pre_fire)
seq.add(partial(setattr, self.song, "record_mode", True))
seq.add(complete_on=self.song.session_end_listener, no_timeout=True)
seq.add(self.song.reset)
seq.add(self.song.activate_arrangement)
seq.add(partial(setattr, SessionToArrangementManager, "IS_BOUNCING", False))
seq.add(partial(setattr, SessionToArrangementManager, "LAST_SCENE_FIRED", None))
return seq.done()
def launch(self):
# type: () -> Sequence
self.song.stop_playing()
# self.track.stop(immediate=True)
seq = Sequence()
seq.add(wait=40) # mini count in
return seq.done()
def delete_unnecessary_devices(self, full_scan=False):
# type: (bool) -> None
devices_to_delete = list(
self.get_deletable_devices(full_scan=full_scan))
if len(devices_to_delete) == 0:
if full_scan is False:
self.delete_unnecessary_devices(full_scan=True)
else:
self.parent.show_message("No devices to delete")
return
devices_by_name = {} # type: Dict[str, List[Device]]
for device in devices_to_delete:
name = device.name or device.class_name
if name not in devices_by_name:
devices_by_name[name] = []
devices_by_name[name].append(device)
info = "\n".join(("%s %s" % (len(devices), cls)
for cls, devices in devices_by_name.items()))
seq = Sequence()
seq.prompt("%s devices to delete,\n\n%s\n\nproceed ?" %
(len(devices_to_delete), info))
seq.add([device.delete for device in devices_to_delete])
seq.add(lambda: self.parent.show_message("Devices deleted"))
seq.add(self.delete_unnecessary_devices
) # now delete enclosing racks if empty
seq.done()
def select_device(self, device):
# type: (Song, Device) -> Sequence
seq = Sequence()
seq.add(device.track.select)
seq.add(partial(self._view.select_device, device._device))
seq.add(self.parent.navigationManager.focus_detail)
return seq.done()
def duplicate_scene(self, index):
# type: (Song, int) -> Sequence
seq = Sequence()
# seq.add(partial(self._song.duplicate_scene, index))
seq.add(partial(self._song.duplicate_scene, index),
complete_on=self.parent.songScenesManager.scenes_listener)
return seq.done()
def fire_and_move_position(self):
# type: (Scene) -> Sequence
self.song.stop_playing()
seq = Sequence()
from protocol0.lom.Scene import Scene
if Scene.LAST_MANUALLY_STARTED_SCENE_BAR_POSITION >= self.bar_length:
Scene.LAST_MANUALLY_STARTED_SCENE_BAR_POSITION = 0
# removing click when changing position
master_volume = self.song.master_track.volume
self.song.master_track.volume = 0
seq.add(wait=1)
# leveraging throttle to disable the next update (that would be 1 / *)
seq.add(
partial(
self.scene_name.update,
bar_position=Scene.LAST_MANUALLY_STARTED_SCENE_BAR_POSITION))
seq.add(self.fire)
seq.add(
partial(self.jump_to_bar,
Scene.LAST_MANUALLY_STARTED_SCENE_BAR_POSITION))
seq.add(self.song.stop_playing)
seq.add(
partial(setattr, self.song.master_track, "volume", master_volume))
seq.add(wait=1)
seq.add(self.song.continue_playing)
return seq.done()
def _propagate_new_audio_clip(self):
# type: () -> Optional[Sequence]
audio_clip_slot = self.track.audio_track.clip_slots[self.recording_scene_index]
source_midi_clip = self.track.midi_track.clip_slots[audio_clip_slot.index].clip
source_audio_clip = self.track.audio_track.clip_slots[audio_clip_slot.index].clip
if source_midi_clip is None or source_audio_clip is None:
return None
source_cs = source_audio_clip.clip_slot
duplicate_audio_clip_slots = list(self._get_duplicate_audio_clip_slots(source_midi_clip, source_audio_clip))
if len(duplicate_audio_clip_slots) == 0:
return None
seq = Sequence()
seq.prompt("Propagate to %s audio clips in track ?" % len(duplicate_audio_clip_slots))
seq.add([partial(source_cs.duplicate_clip_to, clip) for clip in duplicate_audio_clip_slots])
duplicate_midi_clips = [self.track.midi_track.clip_slots[cs.index].clip for cs in duplicate_audio_clip_slots]
seq.add([partial(clip.clip_name.update, base_name=source_audio_clip.clip_name.base_name) for clip in
duplicate_midi_clips])
if self.track.audio_tail_track:
source_tail_cs = self.track.audio_tail_track.clip_slots[source_cs.index]
duplicate_audio_tail_clip_slots = [self.track.audio_tail_track.clip_slots[cs.index] for cs in
duplicate_audio_clip_slots]
seq.add([partial(source_tail_cs.duplicate_clip_to, cs) for cs in duplicate_audio_tail_clip_slots])
seq.add(lambda: self.parent.show_message("%s audio clips duplicated" % len(duplicate_audio_clip_slots)))
return seq.done()
def test_audio_latency(self):
# type: () -> Optional[Sequence]
if self.song.usamo_track is None:
self.parent.show_message("Missing usamo track")
return None
ext_synth_track = self.song.current_track
if not isinstance(ext_synth_track, ExternalSynthTrack):
ext_synth_track = next(self.song.prophet_tracks, None)
if ext_synth_track is None:
self.parent.show_message("Please select an ExternalSynthTrack")
return None
tempo = self.song.tempo
self.song.tempo = 120 # easier to see jitter
seq = Sequence()
seq.add(ext_synth_track.duplicate)
seq.add(self._set_up_track_for_record)
seq.add(self._create_audio_test_clip)
seq.add(self._record_test_clip)
seq.add(self._analyze_jitter)
seq.add(partial(setattr, self.song, "tempo", tempo))
return seq.done()
def test_p0_subject_slot_sequence():
# type: () -> None
class Example(AbstractObject):
__subject_events__ = ("test", )
def __init__(self, val, test_res, *a, **k):
# type: (int, List[int], Any, Any) -> None
super(Example, self).__init__(*a, **k)
self.val = val
self.test_res = test_res
self.subject_slot_listener.subject = self
@p0_subject_slot("test")
def subject_slot_listener(self):
# type: () -> None
return None
test_res_callbacks = [] # type: List[int]
example = Example(0, test_res_callbacks)
seq = Sequence()
seq.add(complete_on=example.subject_slot_listener)
seq.add(lambda: test_res_callbacks.append(1))
seq.done()
example.subject_slot_listener()
def check_res():
# type: () -> None
assert test_res_callbacks == [1]
p0.wait(3, check_res)
def pre_fire(self):
# type: (Scene) -> Sequence
self.fire()
self.song.stop_playing()
seq = Sequence()
seq.add(wait=2)
return seq.done()
def delete_clip(self):
# type: () -> Sequence
seq = Sequence()
if self._clip_slot and self.clip:
seq.add(self._clip_slot.delete_clip,
complete_on=self.has_clip_listener)
return seq.done()
def fix(self):
# type: () -> Sequence
self._track.has_monitor_in = True
seq = Sequence()
seq.add(super(ExternalSynthTrackValidator, self).fix)
seq.add(self._track.midi_track.select)
return seq.done()
def test_has_callback_queue_result():
# type: () -> None
class Example(AbstractObject):
__subject_events__ = ("test", )
def __init__(self):
# type: () -> None
super(Example, self).__init__()
self.listener_normal.subject = self
self.listener_sequence.subject = self
self.callback_called = False
def test(self):
# type: () -> None
from protocol0 import Protocol0
# noinspection PyUnresolvedReferences
Protocol0.SELF.defer(self.notify_test)
@p0_subject_slot("test")
def listener_normal(self):
# type: () -> None
pass
@p0_subject_slot("test")
def listener_sequence(self):
# type: () -> Sequence
return Sequence().done()
# 'normal' listener
obj = Example()
seq = Sequence()
seq.add(obj.test, complete_on=obj.listener_normal)
seq.add(lambda: setattr(obj, "callback_called", True))
def check_called():
# type: () -> None
assert obj.callback_called
seq.add(check_called)
seq.done()
# listener returning sequence
seq = Sequence()
seq.add(obj.test, complete_on=obj.listener_sequence)
seq.add(lambda: setattr(obj, "callback_called", True))
seq.add(check_called)
seq.done()
def listener(self):
# type: () -> Sequence
# noinspection PyShadowingNames
seq = Sequence()
seq.add(lambda: test_res.append(0), name="append 0")
seq.add(wait=1)
seq.add(lambda: test_res.append(1), name="append 1")
return seq.done()
def scroll_presets_or_samples(self, go_next):
# type: (AbstractInstrument, bool) -> Sequence
self.parent.navigationManager.show_device_view()
seq = Sequence()
seq.add(partial(self._preset_list.scroll, go_next=go_next))
seq.add(partial(self._sync_selected_preset))
return seq.done()
def _create_audio_test_clip(self):
# type: () -> Sequence
current_track = cast(ExternalSynthTrack, self.song.current_track)
# switching to test preset
seq = Sequence()
seq.add(current_track.midi_track.clip_slots[0].create_clip)
seq.add(self._generate_test_notes)
return seq.done()
def decorate(*a, **k):
# type: (Any, Any) -> None
from protocol0.sequence.Sequence import Sequence
seq = Sequence()
seq.prompt(question)
seq.add(partial(func, *a, **k))
seq.done()
def _disable_protected_mode(self):
# type: (ExternalSynthTrack) -> Sequence
seq = Sequence()
seq.prompt("Disable protected mode ?")
seq.add(partial(setattr, self, "protected_mode_active", False))
seq.add(
partial(self.parent.show_message, "track protected mode disabled"))
return seq.done()
def activate_editor_automation(self):
# type: () -> Sequence
seq = Sequence()
if self and self.device and InstrumentProphet.EDITOR_DEVICE_ON is False:
self.device.device_on = True
seq.add(wait=15)
seq.add(partial(setattr, self.device, "device_on", False))
return seq.done()
def _focus_main_clip(self):
# type: () -> Sequence
seq = Sequence()
main_clip_slot = self._main_recording_track.clip_slots[
self.recording_scene_index]
if not main_clip_slot.clip:
seq.add(complete_on=main_clip_slot.has_clip_listener)
seq.add(lambda: main_clip_slot.clip.select())
return seq.done()
def _added_track_init(self):
# type: () -> Optional[Sequence]
self.refresh_appearance()
if self.KEEP_CLIPS_ON_ADDED:
return None
seq = Sequence()
seq.add([clip.delete for clip in self.clips])
return seq.done()
def _sync_selected_preset(self):
# type: (AbstractInstrument) -> Sequence
seq = Sequence()
if self.selected_preset:
if isinstance(self.device, PluginDevice):
self.device.selected_preset_index = self.selected_preset.index
seq.add(partial(self.load_preset, self.selected_preset))
seq.add(partial(self.track.abstract_track.track_name.update, self.selected_preset.name))
return seq.done()