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()