Merge pull request #49 from PedalPi/version-0.3.0

v0.3.0

Author: SrMouraSilva

.travis.yml

@@ -10,6 +10,7 @@ python:
 sudo: required
 
 install:
+  - sudo apt-get install -y portaudio19-dev python-all-dev --no-install-recommends
   - sudo apt-get install -y lilv-utils calf-plugins guitarix --no-install-recommends
   - pip3 install coveralls
 

CHANGES

@@ -1,3 +1,23 @@
+Version 0.3.0 - released 05/30/17
+=================================
+ - Issue #29 - Secure components close
+ - Issue #30 - Replace print log to logging
+ - **Breaking change**: Issues #39 and #5 - Change save method to pluginsmanager (v0.5.0) Autosaver
+   - Removed BanksDao -> Using now pluginsmanager Autosaver
+   - Removed Database -> Using now pluginsmanager Persistence
+   - BanksController, PedalboardController, EffectController, ParamController,
+     CurrentController changes your API
+ - Issue #41 - Allows current pedalboard is None
+ - Issue #40 - If current pedalboard index file is wrong, Application now starts
+   with the current pedalboard = None
+ - Issue #11 - Banks with same name not will be replaced when Application initialize
+ - Issue #17 - Fixes: Remove bank with current pedalboard will be crash (when reload Application)
+ - Issue #45 - Add plugins manager v0.5.0 support
+
+   - Removed BanksController, PedalboardController, EffectController, ParamController, NotificationController
+   - Implemented :meth:`.Application.register_observer`, :meth:`.Application.unregister_observer`
+
+
 Version 0.2.1 - released 04/14/17
 =================================
  - 21fdb32 Issue #30 - Fix move pedalboard notification

README.rst

@@ -66,7 +66,10 @@ Create the script file that contains the code to run the application (as example
     application.start()
 
     from signal import pause
-    pause()
+    try:
+        pause()
+    except KeyboardInterrupt:
+        application.stop()
 
 Download, compile and install `mod-host`_. Mod-host is a *LV2 host for Jack controllable via socket or command line*.
 It is developed by `Mod Devices`_, a company that also develops professional equipment for musicians.
@@ -132,6 +135,14 @@ To add a component in your configuration file, download it and register it befor
     # Start application
     application.start()
 
+    # Don't stop application
+    from signal import pause
+    try:
+        pause()
+    except KeyboardInterrupt:
+        # Stop components with safety
+        application.stop()
+
 Each component needs a configuration to work.
 Pay attention to your documentation for details on how to set it up and use it.
 

application/application.py

@@ -12,24 +12,24 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import time
+import atexit
+import logging
 import os
-from shutil import copytree
+import sys
 from pathlib import Path
+from shutil import copytree
+from unittest.mock import MagicMock
 
-from application.controller.banks_controller import BanksController
-from application.controller.current_controller import CurrentController
+from application.component.components_observer import ComponentsObserver
+from application.component.current_pedalboard_observer import CurrentPedalboardObserver
 from application.controller.component_data_controller import ComponentDataController
+from application.controller.current_controller import CurrentController
 from application.controller.device_controller import DeviceController
-from application.controller.effect_controller import EffectController
-from application.controller.notification_controller import NotificationController
-from application.controller.param_controller import ParamController
-from application.controller.pedalboard_controller import PedalboardController
 from application.controller.plugins_controller import PluginsController
+from pluginsmanager.observer.autosaver.autosaver import Autosaver
+from pluginsmanager.observer.mod_host.mod_host import ModHost
 
-from pluginsmanager.mod_host.mod_host import ModHost
-
-from unittest.mock import MagicMock
+logging.basicConfig(format='[%(asctime)s] %(levelname)s - %(message)s', stream=sys.stdout, level=logging.DEBUG)
 
 
 class Application(object):
@@ -43,16 +43,16 @@ class Application(object):
     for control::
 
         >>> from application.application import Application
-        >>> from application.controller.CurrentController import CurrentController
+        >>> from application.controller.current_controller import CurrentController
 
         >>> application = Application()
         >>> current_controller = application.controller(CurrentController)
 
-        >>> print(current_controller.current_pedalboard)
+        >>> print(current_controller.pedalboard)
         <Pedalboard object as Shows with 2 effects at 0x7fa3bcb49be0>
 
         >>> current_controller.to_next_pedalboard()
-        >>> current_controller.current_pedalboard
+        >>> current_controller.pedalboard
         <Pedalboard object as Shows 2 with 1 effects at 0x7fa3bbcdecf8>
 
     For more details see the Controllers extended classes.
@@ -67,12 +67,25 @@ class Application(object):
     def __init__(self, path_data="data/", address="localhost", test=False):
         self.mod_host = self._initialize(address, test)
 
+        # Data
+        path_data = Path(path_data)
         self.path_data = self._initialize_data(path_data)
+        self.autosaver = Autosaver(str(path_data / Path('banks')))
+        self.manager = self.autosaver.load(DeviceController.sys_effect)
+
+        # Controllers
         self.components = []
         self.controllers = self._load_controllers()
 
         self._configure_controllers(self.controllers)
 
+        # Observers
+        self.components_observer = ComponentsObserver(self.manager)
+        current_pedalboard_observer = CurrentPedalboardObserver(self.controller(CurrentController))
+
+        self.manager.register(self.components_observer)
+        self.manager.register(current_pedalboard_observer)
+
     def _initialize(self, address, test=False):
         mod_host = ModHost(address)
         if test:
@@ -83,34 +96,25 @@ def _initialize(self, address, test=False):
         return mod_host
 
     def _initialize_data(self, path):
-        if not os.path.exists(path):
+        str_path = str(path)
+        if not os.path.exists(str_path):
             default_path_data = os.path.dirname(os.path.abspath(__file__)) / Path('data')
 
             ignore_files = lambda d, files: [f for f in files if (Path(d) / Path(f)).is_file() and f.endswith('.py')]
-            copytree(str(default_path_data), str(os.path.abspath(path)), ignore=ignore_files)
+            copytree(str(default_path_data), str(os.path.abspath(str_path)), ignore=ignore_files)
 
             self.log('Data - Create initial data')
 
-        self.log('Data - Loads', os.path.abspath(path))
+        self.log('Data - Loads {}', os.path.abspath(str_path))
         return path
 
-    def _teste(self, d, files):
-        for f in files:
-            print(f)
-        return
-
     def _load_controllers(self):
         controllers = {}
 
         list_controllers = [
-            BanksController,
             ComponentDataController,
             CurrentController,
             DeviceController,
-            EffectController,
-            NotificationController,
-            ParamController,
-            PedalboardController,
             PluginsController,
         ]
 
@@ -122,28 +126,69 @@ def _load_controllers(self):
     def _configure_controllers(self, controllers):
         for controller in list(controllers.values()):
             controller.configure()
-            self.log('Load controller -', controller.__class__.__name__)
+            self.log('Load controller - {}', controller.__class__.__name__)
 
     def register(self, component):
         """
-        Register a :class:`Component` extended class into Application.
+        Register a :class:`.Component` extended class into Application.
         The components will be loaded when application is loaded (after `start` method is called).
 
         :param Component component: A module to be loaded when the Application is loaded
         """
         self.components.append(component)
 
+    def register_observer(self, observer):
+        """
+        Register a :class:`.ApplicationObserver` specialization into Application.
+        The observer will receive calls when changes occurs in system, like
+        banks creation, current pedalboard changes.
+
+        :param ApplicationObserver observer: The observer who will receive the changes notifications
+        """
+        self.components_observer.register(observer)
+
+    def unregister_observer(self, observer):
+        """
+        Unregister an observer in :class:`.Application`.
+        The observer not will be more notified of the changes requested in the application API.
+
+        :param ApplicationObserver observer: The observer who will not receive further changes notification
+        """
+        self.components_observer.unregister(observer)
+
     def start(self):
         """
-        Start this API, initializing the components.
+        Start the application, initializing your components.
         """
-        current_pedalboard = self.controller(CurrentController).current_pedalboard
-        self.log('Load current pedalboard -', '"' + current_pedalboard.name + '"')
+        current_pedalboard = self.controller(CurrentController).pedalboard
+        if current_pedalboard is None:
+            self.log('Not exists any current pedalboard.')
+            self.log('Use CurrentController to set the current pedalboard')
+        else:
+            self.log('Load current pedalboard - "{}"', current_pedalboard.name)
+
         self.mod_host.pedalboard = current_pedalboard
 
         for component in self.components:
             component.init()
-            self.log('Load component -', component.__class__.__name__)
+            self.log('Load component - {}', component.__class__.__name__)
+
+        self.log('Components loaded')
+        atexit.register(self.stop)
+
+    def stop(self):
+        """
+        Stop the application, closing your components.
+        """
+        for component in self.components:
+            component.close()
+            self.log('Stopping component - {}', component.__class__.__name__)
+
+        for controller in self.controllers.values():
+            controller.close()
+            self.log('Stopping controller - {}', controller.__class__.__name__)
+
+        atexit.unregister(self.stop)
 
     def controller(self, controller):
         """
@@ -163,5 +208,5 @@ def dao(self, dao):
         """
         return dao(self.path_data)
 
-    def log(self, *args, **kwargs):
-        print('[' + time.strftime('%Y-%m-%d %H:%M:%S') + ']', *args, **kwargs)
+    def log(self, message, *args, **kwargs):
+        logging.info(message.format(*args, **kwargs))

application/component/application_observer.py

@@ -13,44 +13,25 @@
 # limitations under the License.
 
 from abc import ABCMeta, abstractmethod
-from pluginsmanager.model.updates_observer import UpdatesObserver
+from pluginsmanager.observer.updates_observer import UpdatesObserver
 
 
 class ApplicationObserver(UpdatesObserver, metaclass=ABCMeta):
     """
-    The :class:`ApplicationObserver` extends :class:`UpdatesObserver`.
+    The :class:`.ApplicationObserver` extends :class:`.UpdatesObserver`.
     It is an abstract class definition for treatment of changes in some class model.
     Your methods are called when occurs any change in Bank, Pedalboard, Effect, etc.
 
-    To do this, it is necessary that the :class:`ApplicationObserver` objects
-    be registered in some manager, so that it reports the changes. An
-    example of a manager is :class:`NotificationController`.
-
-    :class:`NotificationController`, comparing with, :class:`UpdatesObserver`
-    add TOKEN. Each observer should have a unique token. This token will differentiate who
-    is making requests so the manager does not notify you back.
-
-    For example, if a component requires the manager to have an effect change its
-    state (`effect.active = not effect.active`), it is not necessary for the manager
-    to inform the component of the change. If the component was informed, it might not know
-    that it was the one that requested the change and possibly would update its interface
-    erroneously.
+    To do this, it is necessary that the :class:`.ApplicationObserver` objects
+    be registered in application (using :meth:`.Application.register_observer`
+    or :meth:`.Component.register_observer`), so that it reports the changes.
     """
 
-    def __init__(self):
-        super(ApplicationObserver, self).__init__()
-
-    @property
     @abstractmethod
-    def token(self):
+    def on_current_pedalboard_changed(self, pedalboard, **kwargs):
         """
-        Observer token identifier.
-        :return: string for token identifier
-                 or None if is not necessary identify the observer
-                 (it will receive all notification)
-        """
-        return None
+        Called when the current pedalboard is changed
 
-    @abstractmethod
-    def on_current_pedalboard_changed(self, pedalboard, token=None):
+        :param Pedalboard pedalboard: New current pedalboard
+        """
         pass

application/component/component.py

@@ -14,8 +14,6 @@
 
 from abc import ABCMeta, abstractmethod
 
-from application.controller.notification_controller import NotificationController
-
 
 class Component(metaclass=ABCMeta):
 
@@ -29,26 +27,29 @@ def init(self):
         """
         pass
 
+    def close(self):
+        """
+        Method called when the application is requested to quit.
+        Classes components must implement to safely finish their
+        activities.
+        """
+        pass
+
     def controller(self, controller):
         return self.application.controller(controller)
 
     def register_observer(self, observer):
         """
-        Register an observer in :class:`Application` by :class:`NotificationController`.
-        Observers will be notified of the changes requested in the application API.
-
-        Obs: If a observer contains a _token_ and the request informs the same _token_
-        the observer not will be notified.
+        Calls :meth:`.Application.register_observer`.
 
-        :param UpdatesObserver observer:
+        :param ApplicationObserver observer: The observer who will receive the changes notifications
         """
-        self.controller(NotificationController).register(observer)
+        self.application.register_observer(observer)
 
     def unregister_observer(self, observer):
         """
-        Unregister an observer in :class:`Application` by :class:`NotificationController`.
-        The observer not will be more notified of the changes requested in the application API.
+        Calls :meth:`.Application.unregister_observer`.
 
-        :param UpdatesObserver observer:
+        :param ApplicationObserver observer: The observer who will not receive further changes notification
         """
-        self.controller(NotificationController).unregister(observer)
+        self.application.unregister_observer(observer)