fix #1382 and refactor enable attribue

mpf/core/device_monitor.py

@@ -16,7 +16,7 @@ def __init__(self, *attributes_to_monitor, **aliased_attributes_to_monitor):
         self._attributes_to_monitor = attributes_to_monitor
         self._aliased_attributes_to_monitor = aliased_attributes_to_monitor
 
-    def __call__(self, cls):
+    def __call__(self, cls):    # noqa
         """Decorate class."""
         _sentinel = object()
 
@@ -28,6 +28,7 @@ def __init__(self_inner, *args, **kwargs):  # noqa
             self_inner.machine.device_manager.register_monitorable_device(self_inner)
 
         old_setattr = getattr(cls, '__setattr__', None)
+        super_get_placeholder_value = getattr(cls, "get_placeholder_value", None)
 
         # pylint: disable-msg=
         def __setattr__(self_inner, name, value):   # noqa
@@ -84,6 +85,9 @@ def get_placeholder_value(self_inner, item):
                 if name == item:
                     return Util.convert_to_simply_type(getattr(self_inner, attribute))
 
+            if super_get_placeholder_value:
+                return super_get_placeholder_value(self_inner, item)
+
             raise ValueError("Attribute {} does not exist.".format(item))
 
         cls.__init__ = __init__

mpf/core/enable_disable_mixin.py

@@ -2,6 +2,8 @@
 import abc
 import asyncio
 
+from mpf.core.device_monitor import DeviceMonitor
+
 from mpf.core.events import event_handler
 
 from mpf.core.mode_device import ModeDevice
@@ -12,6 +14,7 @@
     from mpf.core.mode import Mode
 
 
+@DeviceMonitor("enabled")
 class EnableDisableMixin(ModeDevice, metaclass=abc.ABCMeta):
 
     """Implements enable and disable_events."""
@@ -44,6 +47,7 @@ def enable(self) -> None:
         if self.enabled is True:
             return
         self.enabled = True
+        self.notify_virtual_change("enabled", False, True)
         self._enable()
 
     def add_control_events_in_mode(self, mode) -> None:
@@ -61,6 +65,7 @@ def disable(self):
         if self.enabled is False:
             return
         self.enabled = False
+        self.notify_virtual_change("enabled", True, False)
         self._disable()
 
     def _load_enable_based_on_config_default(self) -> None:

mpf/devices/ball_hold.py

@@ -10,7 +10,7 @@
 from mpf.core.system_wide_device import SystemWideDevice
 
 
-@DeviceMonitor("balls_held", _enabled="enabled")
+@DeviceMonitor("balls_held")
 class BallHold(EnableDisableMixin, SystemWideDevice, ModeDevice):
 
     """Ball hold device which can be used to keep balls in ball devices and control their eject later on."""

mpf/devices/ball_routing.py

@@ -15,7 +15,7 @@
 from mpf.core.mode_device import ModeDevice
 
 
-@DeviceMonitor("balls_routing", enabled="_enabled")
+@DeviceMonitor("balls_routing")
 class BallRouting(EnableDisableMixin, ModeDevice):
 
     """Route balls from one device to another when captured."""

mpf/devices/multiball.py

@@ -11,7 +11,7 @@
 from mpf.core.system_wide_device import SystemWideDevice
 
 
-@DeviceMonitor("shoot_again", "balls_added_live", "balls_live_target", _enabled="enabled")
+@DeviceMonitor("shoot_again", "balls_added_live", "balls_live_target")
 class Multiball(EnableDisableMixin, SystemWideDevice, ModeDevice):
 
     """Multiball device for MPF."""

mpf/devices/multiball_lock.py

@@ -12,7 +12,7 @@
     from mpf.devices.ball_device.ball_device import BallDevice
 
 
-@DeviceMonitor("locked_balls", _enabled="enabled")
+@DeviceMonitor("locked_balls")
 class MultiballLock(EnableDisableMixin, ModeDevice):
 
     """Ball lock device which locks balls for a multiball."""

mpf/devices/shot_group.py

@@ -12,7 +12,7 @@
 from mpf.core.utility_functions import Util
 
 
-@DeviceMonitor("common_state")
+@DeviceMonitor("common_state", "rotation_enabled")
 class ShotGroup(ModeDevice):
 
     """Represents a group of shots in a pinball machine by grouping together multiple `Shot` class devices.

mpf/tests/test_MultiballLock.py

@@ -28,7 +28,7 @@ def test_filling_two(self):
         self.assertEqual(1, lock_device.balls)
         self.assertEqual(1, mb_lock.locked_balls)
         self.assertEventCalled("multiball_lock_lock_default_locked_ball")
-        self.assertEqual({'total_balls_locked': 1}, 
+        self.assertEqual({'total_balls_locked': 1},
                          self._last_event_kwargs["multiball_lock_lock_default_locked_ball"])
         self.assertEventNotCalled("multiball_lock_lock_default_full")
 
@@ -94,12 +94,14 @@ def test_placeholder_events(self):
         lock = self.machine.multiball_locks["lock_default"]
 
         self.assertTrue(lock.enabled)
+        self.assertPlaceholderEvaluates(True, "device.multiball_locks.lock_default.enabled")
         self.post_event("test_event_when_enabled")
         self.assertEventCalled("should_post_when_enabled")
         self.assertEventNotCalled("should_not_post_when_enabled")
 
         lock.disable()
         self.assertFalse(lock.enabled)
+        self.assertPlaceholderEvaluates(False, "device.multiball_locks.lock_default.enabled")
         self.post_event("test_event_when_disabled")
         self.assertEventCalled("should_post_when_disabled")
         self.assertEventNotCalled("should_not_post_when_disabled")

mpf/tests/test_ShotGroups.py

@@ -180,6 +180,7 @@ def test_control_events(self):
         self.assertLightColor("led_32", 'red')
         self.assertLightColor("led_33", 'off')
         self.assertFalse(group32.rotation_enabled)
+        self.assertPlaceholderEvaluates(False, "device.shot_groups.shot_group_32.rotation_enabled")
 
         self.machine.events.post('group32_rotate')
         self.advance_time_and_run()
@@ -192,6 +193,7 @@ def test_control_events(self):
         self.machine.events.post('group32_enable_rotation')
         self.advance_time_and_run()
         self.assertTrue(group32.rotation_enabled)
+        self.assertPlaceholderEvaluates(True, "device.shot_groups.shot_group_32.rotation_enabled")
 
         # test that rotate works now
         self.machine.events.post('group32_rotate_left')

mpf/tests/test_Shots.py

@@ -480,6 +480,7 @@ def test_enable_persist(self):
         self.start_mode("mode1")
         self.assertFalse(self.machine.shots.mode1_shot_17.enabled)
         self.assertTrue(self.machine.shots.mode1_shot_1.enabled)
+        self.assertPlaceholderEvaluates(True, "device.shots.mode1_shot_1.enabled")
 
         self.stop_mode("mode1")
         self.start_mode("mode1")
@@ -490,6 +491,7 @@ def test_enable_persist(self):
         self.assertTrue(self.machine.shots.mode1_shot_17.enabled)
         self.post_event("custom_disable_1")
         self.assertFalse(self.machine.shots.mode1_shot_1.enabled)
+        self.assertPlaceholderEvaluates(False, "device.shots.mode1_shot_1.enabled")
 
         self.stop_mode("mode1")
         self.assertFalse(self.machine.shots.mode1_shot_17.enabled)