Пример #1
0
    def test_set_pedalboard(self):
        """Test only coverage"""
        manager = BanksManager()

        bank = Bank('Bank 1')
        manager.append(bank)

        mod_host = ModHost('localhost')
        mod_host.host = MagicMock()
        manager.register(mod_host)

        pedalboard = Pedalboard('test_set_pedalboard_1')
        bank.append(pedalboard)
        reverb = self.builder.build(
            'http://calf.sourceforge.net/plugins/Reverb')
        pedalboard.append(reverb)

        pedalboard2 = Pedalboard('test_set_pedalboard_2')
        reverb2 = self.builder.build(
            'http://calf.sourceforge.net/plugins/Reverb')
        bank.append(pedalboard)
        pedalboard2.append(reverb2)

        mod_host.pedalboard = pedalboard
        mod_host.pedalboard = pedalboard2
Пример #2
0
    def test_initial_banks(self):
        banks = [Bank('Bank 1'), Bank('Bank 1')]

        manager = BanksManager(banks)

        for original_bank, bank_managed in zip(banks, manager.banks):
            self.assertEqual(original_bank, bank_managed)
Пример #3
0
    def test_connection_not_current_pedalboard(self):
        """Test only coverage"""
        manager = BanksManager()

        bank = Bank('Bank 1')
        manager.append(bank)

        mod_host = ModHost('localhost')
        mod_host.host = MagicMock()
        manager.register(mod_host)

        pedalboard = Pedalboard('test_set_pedalboard_1')
        pedalboard.append(
            self.builder.build('http://calf.sourceforge.net/plugins/Reverb'))

        pedalboard2 = Pedalboard('test_set_pedalboard_2')
        pedalboard2.append(
            self.builder.build('http://calf.sourceforge.net/plugins/Reverb'))
        pedalboard2.append(
            self.builder.build('http://calf.sourceforge.net/plugins/Reverb'))

        bank.append(pedalboard)
        bank.append(pedalboard2)

        mod_host.pedalboard = pedalboard

        pedalboard2.connect(pedalboard2.effects[0].outputs[0],
                            pedalboard2.effects[1].inputs[0])
Пример #4
0
    def test_swap_banks(self):
        manager = BanksManager()

        bank1 = Bank('Bank 1')
        bank2 = Bank('Bank 2')
        bank3 = Bank('Bank 3')
        bank4 = Bank('Bank 4')

        manager.append(bank1)
        manager.append(bank2)
        manager.append(bank3)
        manager.append(bank4)

        observer = MagicMock()
        manager.register(observer)

        manager.banks[1], manager.banks[3] = manager.banks[3], manager.banks[1]

        calls = [
            call(bank4, UpdateType.UPDATED, index=1, origin=manager, old=bank2),
            call(bank2, UpdateType.UPDATED, index=3, origin=manager, old=bank4)
        ]

        self.assertListEqual(calls, observer.on_bank_updated.call_args_list)

        self.assertEqual(bank2.manager, manager)
        self.assertEqual(bank4.manager, manager)
Пример #5
0
    def test_unregister(self):
        observer = MagicMock()

        manager = BanksManager()
        manager.register(observer)

        self.assertIn(observer, manager.observers)
        manager.unregister(observer)
        self.assertNotIn(observer, manager.observers)
Пример #6
0
    def test_observers(self):
        observer1 = MagicMock()
        observer2 = MagicMock()

        manager = BanksManager()

        manager.register(observer1)
        manager.register(observer2)

        self.assertListEqual([observer1, observer2], manager.observers)
Пример #7
0
    def test_observers(self):
        mock = MagicMock()
        observer = Autosaver('data/test/')
        observer.save = mock
        observer.delete = mock

        manager = BanksManager()
        manager.register(observer)

        bank = Bank('Bank 1')
        manager.append(bank)
        observer.save.assert_called_with(bank)

        pedalboard = Pedalboard('Rocksmith')
        bank.append(pedalboard)
        observer.save.assert_called_with(bank)

        builder = Lv2EffectBuilder()
        reverb = builder.build('http://calf.sourceforge.net/plugins/Reverb')
        filter = builder.build('http://calf.sourceforge.net/plugins/Filter')
        reverb2 = builder.build('http://calf.sourceforge.net/plugins/Reverb')

        pedalboard.append(reverb)
        observer.save.assert_called_with(bank)
        pedalboard.append(filter)
        observer.save.assert_called_with(bank)
        pedalboard.append(reverb2)
        observer.save.assert_called_with(bank)

        reverb.outputs[0].connect(filter.inputs[0])
        observer.save.assert_called_with(bank)
        reverb.outputs[1].connect(filter.inputs[0])
        observer.save.assert_called_with(bank)
        filter.outputs[0].connect(reverb2.inputs[0])
        observer.save.assert_called_with(bank)
        reverb.outputs[0].connect(reverb2.inputs[0])
        observer.save.assert_called_with(bank)

        filter.toggle()
        observer.save.assert_called_with(bank)

        filter.params[0].value = (filter.params[0].maximum -
                                  filter.params[0].minimum) / 2
        observer.save.assert_called_with(bank)

        del bank.pedalboards[0]
        observer.save.assert_called_with(bank)

        bank2 = Bank('Bank 2')
        manager.banks[0] = bank2
        observer.delete.assert_called_with(bank2)
        observer.save.assert_called_with(bank2)

        manager.banks.remove(bank2)
        observer.delete.assert_called_with(bank2)
Пример #8
0
    def test_observers_mock(self):
        """Test only coverage"""
        sys_effect = SystemEffect('system', ('capture_1', 'capture_2'),
                                  ('playback_1', 'playback_2'))
        manager = BanksManager()

        bank = Bank('Bank 1')
        manager.append(bank)

        mod_host = ModHost('localhost')
        mod_host.host = MagicMock()
        manager.register(mod_host)

        pedalboard = Pedalboard('Rocksmith')

        mod_host.pedalboard = pedalboard

        bank.append(pedalboard)

        reverb = self.builder.build(
            'http://calf.sourceforge.net/plugins/Reverb')
        filter = self.builder.build(
            'http://calf.sourceforge.net/plugins/Filter')
        reverb2 = self.builder.build(
            'http://calf.sourceforge.net/plugins/Reverb')

        pedalboard.append(reverb)
        pedalboard.append(filter)
        pedalboard.append(reverb2)

        pedalboard.connect(reverb.outputs[0], filter.inputs[0])
        pedalboard.connect(reverb.outputs[1], filter.inputs[0])
        pedalboard.connect(filter.outputs[0], reverb2.inputs[0])
        pedalboard.connect(reverb.outputs[0], reverb2.inputs[0])

        filter.toggle()
        filter.params[0].value = (filter.params[0].maximum -
                                  filter.params[0].minimum) / 2

        pedalboard.disconnect(filter.outputs[0], reverb2.inputs[0])
        filter.toggle()

        pedalboard.effects.remove(filter)

        pedalboard.connections.append(
            Connection(sys_effect.outputs[0], reverb.inputs[0]))
        pedalboard.connections.append(
            Connection(reverb2.outputs[0], sys_effect.inputs[0]))

        for connection in list(pedalboard.connections):
            pedalboard.connections.remove(connection)

        for effect in list(pedalboard.effects):
            pedalboard.effects.remove(effect)
    def test_notification_scope(self):
        observer = MockObserver()

        manager = BanksManager()
        components_observer = ComponentsObserver(manager)

        manager.register(components_observer)
        components_observer.register(observer)

        bank = self.generate_bank('test_notification')
        with observer:
            manager.append(bank)

        observer.on_bank_updated.assert_not_called()
Пример #10
0
    def __init__(self):
        self._log = logging.getLogger('musicbox.MusicBox')

        # Internal attributes
        self._selected_stompbox = 1  # 0 = global parameters, 1-8 = actual stompboxes
        self._current_mode = Mode.PRESET
        self._last_slider_update_time = 0

        # OSC inputs (footpedal)
        try:
            self._midi_to_osc = MidiToOsc(
                'Arduino Micro')  # works via callbacks, so not blocking
        except ValueError as e:
            self._log.error('Failed to start Midi Footpedal: ' + str(e))

        # OSC server (receives inputs)
        self._osc_server = FootpedalOscServer(self.cb_mode, self.cb_preset,
                                              self.cb_stomp, self.cb_looper,
                                              self.cb_metronome,
                                              self.cb_slider)

        # mod-host LV2 host (output)
        self._banks_manager = BanksManager()
        self._banks_manager.append(
            Bank('Bank 1'))  # TODO: load banks from stored files
        self._modhost = ModHost('localhost')
        self._modhost.connect()
        self._banks_manager.register(self._modhost)
        self._pedalboard = None
        self._log.info("STARTED mod-host client")

        # Metronome output (using klick)
        self._metronome = Metronome()
        self._log.info("STARTED Metronome")

        # Looper object (using sooperlooper)
        self._looper = Looper()
        self._log.info("STARTED Looper")

        # Notifiers
        self._notifier = TcpNotifier()
        self._log.info("STARTED TcpNotifier")

        # Initialize: set mode PRESET and load preset1
        time.sleep(2)
        self._set_mode(Mode.PRESET)
        for preset_id in range(4):
            self._load_preset('preset{:02d}.yaml'.format(preset_id))
    def test_notification(self):
        observer = MockObserver()

        manager = BanksManager()
        components_observer = ComponentsObserver(manager)

        manager.register(components_observer)
        components_observer.register(observer)

        bank = self.generate_bank('test_notification')
        manager.append(bank)

        observer.on_bank_updated.assert_called_with(bank,
                                                    UpdateType.CREATED,
                                                    index=bank.index,
                                                    origin=manager)
Пример #12
0
    def test_replace_bank(self):
        observer = Autosaver('../data/test/')

        manager = BanksManager()
        manager.register(observer)

        bank1 = Bank('Bank 1')
        pedalboard = Pedalboard('Rocksmith')
        bank1.append(pedalboard)

        manager.append(bank1)

        manager.banks[0] = Bank('Bank 2')

        self.validate_persisted(manager)

        while manager.banks:
            del manager.banks[0]
Пример #13
0
    def test_swap_bank(self):
        observer = Autosaver('../data/test/')

        manager = BanksManager()
        manager.register(observer)

        bank1 = Bank('Bank 1')
        bank2 = Bank('Bank 2')

        manager.banks.append(bank1)
        manager.banks.append(bank2)

        manager.banks[0], manager.banks[1] = manager.banks[1], manager.banks[0]

        self.validate_persisted(manager)

        while manager.banks:
            del manager.banks[0]
Пример #14
0
    def load(self, system_effect):
        """
        Return a :class:`.BanksManager` instance contains the banks present in
        :attr:`~pluginsmanager.observer.autosaver.autosaver.Autosaver.data_path`

        :param SystemEffect system_effect: SystemEffect used in pedalboards
        :return BanksManager: :class:`.BanksManager` with banks persisted in
                :attr:`~pluginsmanager.observer.autosaver.autosaver.Autosaver.data_path`
        """
        banks = self.banks_files.load(system_effect)
        banks_ordered = self.index_file.load(banks)

        manager = BanksManager()
        manager.register(self)

        for bank in banks_ordered:
            manager.append(bank)
            bank.manager = manager

        return manager
Пример #15
0
    def test_notify(self):
        observer1 = Observer()
        observer1.on_bank_updated = MagicMock()
        observer2 = Observer()
        observer2.on_bank_updated = MagicMock()
        observer3 = Observer()
        observer3.on_bank_updated = MagicMock()

        manager = BanksManager()
        manager.register(observer1)
        manager.register(observer2)
        manager.register(observer3)

        bank = Bank('Bank 1')
        with observer1:
            manager.banks.append(bank)

        observer1.on_bank_updated.assert_not_called()
        observer2.on_bank_updated.assert_called_with(bank, UpdateType.CREATED, index=0, origin=manager)
        observer3.on_bank_updated.assert_called_with(bank, UpdateType.CREATED, index=0, origin=manager)
Пример #16
0
    def test_observers_calls(self):
        observer = MagicMock()

        manager = BanksManager()
        manager.register(observer)

        bank = Bank('Bank 1')
        manager.append(bank)
        observer.on_bank_updated.assert_called_with(bank, UpdateType.CREATED, index=0, origin=manager)

        pedalboard = Pedalboard('Rocksmith')
        bank.append(pedalboard)
        observer.on_pedalboard_updated.assert_called_with(pedalboard, UpdateType.CREATED, index=0, origin=bank)

        builder = Lv2EffectBuilder()
        reverb = builder.build('http://calf.sourceforge.net/plugins/Reverb')
        filter = builder.build('http://calf.sourceforge.net/plugins/Filter')
        reverb2 = builder.build('http://calf.sourceforge.net/plugins/Reverb')

        pedalboard.append(reverb)
        observer.on_effect_updated.assert_called_with(reverb, UpdateType.CREATED, index=reverb.index, origin=pedalboard)
        pedalboard.append(filter)
        observer.on_effect_updated.assert_called_with(filter, UpdateType.CREATED, index=filter.index, origin=pedalboard)
        pedalboard.append(reverb2)
        observer.on_effect_updated.assert_called_with(reverb2, UpdateType.CREATED, index=reverb2.index, origin=pedalboard)

        pedalboard.connect(reverb.outputs[0], filter.inputs[0])
        observer.on_connection_updated.assert_called_with(
            Connection(reverb.outputs[0], filter.inputs[0]),
            UpdateType.CREATED,
            pedalboard=pedalboard
        )
        pedalboard.connect(reverb.outputs[1], filter.inputs[0])
        observer.on_connection_updated.assert_called_with(
            Connection(reverb.outputs[1], filter.inputs[0]),
            UpdateType.CREATED,
            pedalboard=pedalboard
        )
        pedalboard.connect(filter.outputs[0], reverb2.inputs[0])
        observer.on_connection_updated.assert_called_with(
            Connection(filter.outputs[0], reverb2.inputs[0]),
            UpdateType.CREATED,
            pedalboard=pedalboard
        )
        pedalboard.connect(reverb.outputs[0], reverb2.inputs[0])
        observer.on_connection_updated.assert_called_with(
            Connection(reverb.outputs[0], reverb2.inputs[0]),
            UpdateType.CREATED,
            pedalboard=pedalboard
        )

        filter.toggle()
        observer.on_effect_status_toggled.assert_called_with(filter)

        filter.params[0].value = (filter.params[0].maximum - filter.params[0].minimum) / 2
        observer.on_param_value_changed.assert_called_with(filter.params[0])

        del bank.pedalboards[0]
        observer.on_pedalboard_updated.assert_called_with(pedalboard, UpdateType.DELETED, index=0, origin=bank)

        bank2 = Bank('Bank 2')
        old_bank = manager.banks[0]
        manager.banks[0] = bank2
        observer.on_bank_updated.assert_called_with(bank2, UpdateType.UPDATED, index=0, origin=manager, old=old_bank)

        manager.banks.remove(bank2)
        observer.on_bank_updated.assert_called_with(bank2, UpdateType.DELETED, index=0, origin=manager)
Пример #17
0
# See the License for the specific language governing permissions and
# limitations under the License.

from pluginsmanager.banks_manager import BanksManager
from pluginsmanager.mod_host.mod_host import ModHost

from pluginsmanager.model.bank import Bank
from pluginsmanager.model.pedalboard import Pedalboard
from pluginsmanager.model.connection import Connection

from pluginsmanager.model.lv2.lv2_effect_builder import Lv2EffectBuilder

from pluginsmanager.model.system.system_effect import SystemEffect

if __name__ == '__main__':
    manager = BanksManager()

    bank = Bank('Bank 1')
    manager.append(bank)

    mod_host = ModHost('raspberrypi.local')
    mod_host.connect()
    manager.register(mod_host)

    pedalboard = Pedalboard('Rocksmith')
    bank.append(pedalboard)

    mod_host.pedalboard = pedalboard

    builder = Lv2EffectBuilder()