mpf 0.57.5.dev3__py3-none-any.whl → 0.58.0.dev3__py3-none-any.whl

mpf/_version.py

@@ -10,10 +10,10 @@ PyPI.
 
 """
 
-__version__ = '0.57.5.dev3'  # Also consider whether MPF-MC pyproject.toml should be updated
+__version__ = '0.58.0.dev3'  # Also consider whether MPF-MC pyproject.toml should be updated
 '''The full version of MPF.'''
 
-__short_version__ = '0.57'
+__short_version__ = '0.58'
 '''The major.minor version of MPF.'''
 
 __bcp_version__ = '1.1'

mpf/config_spec.yaml

@@ -622,7 +622,7 @@ fast:
     __type__: config
     net: single|subconfig(fast_net)|None
     exp: single|subconfig(fast_exp)|None
-    exp_int: single|subconfig(fast_exp)|None    
+    exp_int: single|subconfig(fast_exp)|None
     aud: single|subconfig(fast_aud)|None
     seg: single|subconfig(fast_seg)|None
     dmd: single|subconfig(fast_dmd)|None
@@ -668,11 +668,11 @@ fast_exp_board:
 fast_breakout:
     port: single|enum(1,2,3)|
     model: single|str|
-    led_ports: list|subconfig(fast_led_port)|None
 fast_led_port:
-    port: single|str|
-    type: single|enum(ws2812,apa-102)|ws2812
-    leds: single|int|32
+    port: single|int|
+    type: single|enum(ws2812,apa-102,sk6812,mixed)|ws2812
+    count: single|int|32
+    rgbw_numbers: list|int|None  # only used with the "mixed" type
 fast_aud:
     port: list|str|auto
     baud: single|int|230400
@@ -944,7 +944,7 @@ neoseg_displays:
     number_template: single|str|None
     start_x: single|float|None
     start_y: single|float|None
-    size: single|enum(2digit,8digit)|8digit
+    size: single|enum(2digit,8digit,2digit-rg-swapped,8digit-rg-swapped)|8digit
     light_template: single|subconfig(lights,device)|
 lights:
     __valid_in__: machine
@@ -1573,7 +1573,7 @@ settings:
     label: single|str|
     sort: single|int|
     values: dict|str:str|
-    key_type: single|enum(str,float,int)|str
+    key_type: single|enum(str,float,int,bool)|str
     default: single|str|
     machine_var: single|str|None
     settingType: single|str|standard

mpf/core/device_manager.py

@@ -172,7 +172,20 @@ class DeviceManager(MpfController):
             for device_name in config:
                 futures.append(collection[device_name].device_added_system_wide())
 
-        await asyncio.wait([asyncio.create_task(futures) for futures in futures])
+        fs = [asyncio.create_task(future) for future in futures]
+        done, pending = await asyncio.wait(fs, return_when=asyncio.FIRST_EXCEPTION)
+
+        # Check if any of the futures returned an exception and throw it
+        for task in done:
+            if task.cancelled():
+                continue
+
+            exc = task.exception()
+            if exc is not None:
+                for pending_task in pending:
+                    pending_task.cancel()
+                await asyncio.gather(*pending, return_exceptions=True)
+                raise exc
 
     # pylint: disable-msg=too-many-nested-blocks
     def get_device_control_events(self, config) -> Generator[Tuple[str, Callable, int, "Device"], None, None]:

mpf/core/events.py

@@ -224,14 +224,15 @@ class EventManager(MpfController):
                                      'handler you passed?'.format(handler, event))
 
             sig = inspect.signature(handler)
-            if 'kwargs' not in sig.parameters:
-                raise AssertionError("Handler {} for event '{}' is missing **kwargs. Actual signature: {}".format(
-                    handler, event, sig))
-
-            if sig.parameters['kwargs'].kind != inspect.Parameter.VAR_KEYWORD:
-                raise AssertionError("Handler {} for event '{}' param kwargs is missing '**'. "
+            catchall_name = next((name for name in ('kwargs', '_kwargs') if name in sig.parameters), None)
+            if catchall_name is None:
+                raise AssertionError("Handler {} for event '{}' is missing **kwargs. "
                                      "Actual signature: {}".format(handler, event, sig))
 
+            if sig.parameters[catchall_name].kind != inspect.Parameter.VAR_KEYWORD:
+                raise AssertionError("Handler {} for event '{}' param {} is missing '**'. "
+                                     "Actual signature: {}".format(handler, event, catchall_name, sig))
+
         event, condition, additional_priority = self.get_event_and_condition_from_string(event)
         priority += additional_priority
 
@@ -457,6 +458,8 @@ class EventManager(MpfController):
                                                              _future=future,
                                                              _keys=keys,
                                                              event=event_name)))
+
+        future.add_done_callback(lambda f: [self.remove_handler_by_key(k) for k in keys])
         return future
 
     def _wait_handler(self, _future: asyncio.Future, _keys: List[EventHandlerKey], **kwargs):

mpf/core/placeholder_manager.py

@@ -4,7 +4,7 @@ import string
 import asyncio
 import operator as op
 import abc
-from functools import lru_cache
+from functools import lru_cache, partial
 
 import re
 from typing import Tuple, List, Any, Union
@@ -860,8 +860,28 @@ class BasePlaceholderManager(MpfController):
             subscriptions.append(self.machine.wait_for_stop())
             future = Util.any(subscriptions)
         future = asyncio.ensure_future(future)
+
+        future.add_done_callback(
+            partial(self._cleanup_placeholder_subscriptions, subscriptions=subscriptions)
+        )
         return value, future
 
+    def _cleanup_placeholder_subscriptions(self, future, subscriptions):
+        """Cancel child placeholder subscriptions when the parent template frame finishes."""
+        del future
+
+        for sub in subscriptions:
+            if isinstance(sub, asyncio.Future):
+                if not sub.done():
+                    # Cancel outstanding asyncio Future/Task instance
+                    sub.cancel()
+            elif asyncio.iscoroutine(sub):
+                try:
+                    # close raw coroutines (like sleep)
+                    sub.close()
+                except RuntimeWarning:
+                    pass
+
     @lru_cache(typed=True)
     def parse_conditional_template(self, template, default_number=None):
         """Parse a template for condition and number and return a dict."""

mpf/core/utility_functions.py

@@ -57,6 +57,8 @@ class Util:
             return float(value)
         if type_name == "str":
             return str(value)
+        if type_name == "bool":
+            return str(value).lower() in ['true', 't', 'yes', 'enable', 'on', '1']
 
         raise AssertionError("Unknown type {}".format(type_name))
 
@@ -586,13 +588,16 @@ class Util:
         if isinstance(time_string, (int, float)):
             return int(time_string)
 
-        time_string = str(time_string).upper()
+        time_string = str(time_string).upper().strip()
 
-        if time_string.endswith('MS') or time_string.endswith('MSEC'):
-            return int(time_string[:-2])
+        if time_string == 'NONE':
+            return 0
+
+        if time_string.endswith('MS'):
+            return int(float(time_string[:-2]))
 
         if time_string.endswith('MSEC'):
-            return int(time_string[:-4])
+            return int(float(time_string[:-4]))
 
         if time_string.endswith('D'):
             return int(float(time_string[:-1]) * 86400 * 1000)
@@ -609,7 +614,7 @@ class Util:
         if time_string.endswith('SEC'):
             return int(float(time_string[:-3]) * 1000)
 
-        return int(time_string)
+        return int(float(time_string))
 
     @staticmethod
     def string_to_secs(time_string: str) -> float:
@@ -847,4 +852,4 @@ class Util:
             bool: True if the bit is set, False otherwise
         """
         num = int(hex_string, 16)
-        return bool(num & (1 << bit))
+        return bool(num & (1 << bit))

mpf/devices/light.py

@@ -138,47 +138,21 @@ class Light(SystemWideDevice, DevicePositionMixin):
 
                     check_set.add(key)
 
-    def _map_channels_to_colors(self, channel_list) -> dict:
-        if self.config['type']:
-            color_channels = self.config['type']
-        else:
-            if len(channel_list) == 1:
-                # for one channel default to a white channel
-                color_channels = "w"
-            elif len(channel_list) == 3:
-                # for three channels default to RGB
-                color_channels = "rgb"
-            else:
-                self.raise_config_error("Please provide a type for light {}. No default for channels {}.".
-                                        format(self.name, channel_list), 11)
+    def _color_letter_to_name(self, letter):
+        if letter == 'r':
+            return 'red'
 
-        if len(channel_list) != len(color_channels):
-            self.raise_config_error("Type {} does not match channels {} for light {}".format(
-                color_channels, channel_list, self.name), 12)
+        if letter == 'g':
+            return 'green'
 
-        channels = {}   # type: Dict[str, List[Any]]
-        for color_name in color_channels:
-            # red channel
-            if color_name == 'r':
-                full_color_name = "red"
-            # green channel
-            elif color_name == 'g':
-                full_color_name = "green"
-            # blue channel
-            elif color_name == 'b':
-                full_color_name = "blue"
-            # simple white channel
-            elif color_name == 'w':
-                full_color_name = "white"
-            else:
-                self.raise_config_error("Invalid element {} in type {} of light {}".format(
-                    color_name, self.config['type'], self.name), 13)
+        if letter == 'b':
+            return 'blue'
 
-            if full_color_name not in channels:
-                channels[full_color_name] = []
-            channels[full_color_name].append(channel_list.pop(0))
+        if letter == 'w':
+            return 'white'
 
-        return channels
+        self.raise_config_error("Invalid element {} in type {} of light {}".format(
+                                letter, self.config['type'], self.name), 14)
 
     def wait_for_loaded(self):
         """Return future."""
@@ -195,29 +169,64 @@ class Light(SystemWideDevice, DevicePositionMixin):
         sorted_channels = sorted(all_drivers)
         return sorted_channels[-1].get_successor_number()
 
-    def _load_hw_driver_sequentially(self, next_channel):
-        if self.config['number'] or self.config['channels']:
-            self.raise_config_error("Cannot use start_channel/previous and number or channels.", 3)
+    async def _initialize(self):
+        await super()._initialize()
+        try:
+            if self.config['previous']:
+                self._detect_previous_reference_loop()
+                await self.config['previous'].wait_for_loaded()
+                start_channel = self.config['previous'].get_successor_number()
+                self._load_hw_driver_sequentially(start_channel)
+            elif self.config['start_channel']:
+                self._load_hw_driver_sequentially(self.config['start_channel'])
+            else:
+                self._load_hw_drivers()
+
+            self._drivers_loaded.set_result(True)
+            self.config['default_on_color'] = RGBColor(self.config['default_on_color'])
+
+            self._apply_color_correction_profile(self.config['color_correction_profile'])
+            self._apply_fade(self.config['fade_ms'])
+            self._apply_rgbw_style()
+
+            self.debug_log("Initializing Light. CC Profile: %s, Default fade: %sms",
+                           self._color_correction_profile,
+                           self.default_fade_ms)
+        except Exception:
+            self._drivers_loaded.cancel()
+            raise
+
+    def _detect_previous_reference_loop(self):
+        if self.config['previous'].name == self.name:
+            self.raise_config_error(
+                "Failed to configure light {} in platform. 'previous' value cannot refer to itself.".
+                format(self.name), 8)
+
+        # If we are in development mode, do a robust tree traversal to catch infinite light loops
+        if not self.machine.options['production']:
+            tree = [self.name]
+            prev = self.config['previous']
+            while prev:
+                tree.append(prev.name)
+                prev = prev.config.get('previous')
+                if prev is not None and prev.name in tree:
+                    tree.append(prev.name)
+                    self.raise_config_error("Cyclical light chain found: {}".format(" -> ".join(tree)), 9)
+
+    def _load_hw_driver_sequentially(self, first_channel):
+        if self.config['number']:
+            self.raise_config_error("Cannot use number with start_channel/previous.", 15)
+
+        if self.config['channels']:
+            self.raise_config_error("Cannot use channels list with start_channel/previous.", 16)
+
         if not self.config['type']:
             self.raise_config_error("Cannot use previous or start_channel without type. "
                                     "Add a type setting to your light.", 2)
 
-        for color_name in self.config['type']:
-            # red channel
-            if color_name == 'r':
-                full_color_name = "red"
-            # green channel
-            elif color_name == 'g':
-                full_color_name = "green"
-            # blue channel
-            elif color_name == 'b':
-                full_color_name = "blue"
-            # simple white channel
-            elif color_name == 'w':
-                full_color_name = "white"
-            else:
-                self.raise_config_error("Invalid element {} in type {} of light {}".format(
-                    color_name, self.config['type'], self.name), 14)
+        next_channel = first_channel
+        for color_letter in self.config['type']:
+            full_color_name = self._color_letter_to_name(color_letter)
 
             if full_color_name not in self.hw_drivers:
                 self.hw_drivers[full_color_name] = []
@@ -225,37 +234,14 @@ class Light(SystemWideDevice, DevicePositionMixin):
                        'platform_settings': self.config['platform_settings'], 'number': next_channel}
             channel = self.machine.config_validator.validate_config("light_channels", channel)
             driver = self._load_hw_driver(channel, full_color_name)
-            next_channel = driver.get_successor_number()
+            next_channel = driver.get_successor_number()  # increment for the next loop
             self.hw_drivers[full_color_name].append(driver)
 
     def _load_hw_drivers(self):
         if not self.config['channels']:
-            # get channels from number + platform
-            platform = self.machine.get_platform_sections('lights', self.config['platform'])
-            platform.assert_has_feature("lights")
-            try:
-                channel_list = platform.parse_light_number_to_channels(self.config['number'], self.config['subtype'])
-            except AssertionError as e:
-                self.raise_config_error("Failed to parse light number {} in platform. See error above".
-                                        format(self.name), 4, source_exception=e)
-
-            # copy platform and platform_settings to all channels
-            for channel, _ in enumerate(channel_list):
-                channel_list[channel]['subtype'] = self.config['subtype']
-                channel_list[channel]['platform'] = self.config['platform']
-                channel_list[channel]['platform_settings'] = self.config['platform_settings']
-            # map channels to colors
-            channels = self._map_channels_to_colors(channel_list)
+            channels = self._derive_platform_channels()
         else:
-            if self.config['number'] or self.config['platform'] or self.config['platform_settings']:
-                self.raise_config_error("Light {} cannot contain platform/platform_settings/number and channels".
-                                        format(self.name), 5)
-            # alternatively use channels from config
-            channels = self.config['channels']
-            # ensure that we got lists
-            for channel in channels:
-                if not isinstance(channels[channel], list):
-                    channels[channel] = [channels[channel]]
+            channels = self._prepare_config_channels()
 
         if not channels:
             self.raise_config_error("Light {} has no channels.".format(self.name), 6)
@@ -275,10 +261,7 @@ class Light(SystemWideDevice, DevicePositionMixin):
         if not platform.features['allow_empty_numbers'] and channel['number'] is None:
             self.raise_config_error("Light must have a number.", 1)
 
-        config = LightConfig(
-            name=self.name,
-            color=LightConfigColors[color.upper()]
-        )
+        config = LightConfig(name=self.name, color=LightConfigColors[color.upper()])
 
         try:
             return platform.configure_light(channel['number'], channel['subtype'], config, channel['platform_settings'])
@@ -286,74 +269,93 @@ class Light(SystemWideDevice, DevicePositionMixin):
             self.raise_config_error("Failed to configure light {} in platform. See error above".format(self.name), 7,
                                     source_exception=e)
 
-    async def _initialize(self):
-        await super()._initialize()
+    def _prepare_config_channels(self):
+        if self.config['number'] or self.config['platform'] or self.config['platform_settings']:
+            self.raise_config_error("Light {} cannot contain platform/platform_settings/number and channels".
+                                    format(self.name), 5)
+        channels = self.config['channels']
+
+        # ensure that each color's channels are a list, not single value
+        for channel in channels:
+            if not isinstance(channels[channel], list):
+                channels[channel] = [channels[channel]]
+
+        return channels
+
+    def _derive_platform_channels(self):
+        # get channels from number + platform
+        platform = self.machine.get_platform_sections('lights', self.config['platform'])
+        platform.assert_has_feature("lights")
+
         try:
-            if self.config['previous']:
-                if self.config['previous'].name == self.name:
-                    self.raise_config_error(
-                        "Failed to configure light {} in platform. 'previous' value cannot refer to itself.".
-                        format(self.name), 8)
-
-                # If we are in development mode, do a robust tree traversal to catch infinite light loops
-                if not self.machine.options['production']:
-                    tree = [self.name]
-                    prev = self.config['previous']
-                    while prev:
-                        tree.append(prev.name)
-                        prev = prev.config.get('previous')
-                        if prev is not None and prev.name in tree:
-                            tree.append(prev.name)
-                            self.raise_config_error("Cyclical light chain found: {}".format(" -> ".join(tree)), 9)
+            channel_list = platform.parse_light_number_to_channels(self.config['number'], self.config['subtype'])
+        except AssertionError as e:
+            self.raise_config_error("Failed to parse light number {} in platform. See error above".
+                                    format(self.name), 4, source_exception=e)
 
-                await self.config['previous'].wait_for_loaded()
-                start_channel = self.config['previous'].get_successor_number()
-                self._load_hw_driver_sequentially(start_channel)
-            elif self.config['start_channel']:
-                self._load_hw_driver_sequentially(self.config['start_channel'])
-            else:
-                self._load_hw_drivers()
-            self._drivers_loaded.set_result(True)
+        # copy platform and platform_settings to all channels
+        for channel, _ in enumerate(channel_list):
+            channel_list[channel]['subtype'] = self.config['subtype']
+            channel_list[channel]['platform'] = self.config['platform']
+            channel_list[channel]['platform_settings'] = self.config['platform_settings']
 
-            self.config['default_on_color'] = RGBColor(self.config['default_on_color'])
+        # map channels to colors
+        if self.config['type']:
+            color_channels = self.config['type']
+        else:
+            if len(channel_list) == 1:
+                # for one channel default to a white channel
+                color_channels = "w"
+            elif len(channel_list) == 3:
+                # TODO this seems like a bug waiting to happen -- what if the channel list ISNT R G B ordered?
+                # -- the blind .pop(0) down below combined with the "for letter in 'rgb'" seems risky
+                # and the channel list order is up to the platform to provide, which doesnt seem clear in the
+                # parse_light_number_to_channels interface definition at all
 
-            if self.config['color_correction_profile'] is not None:
-                profile_name = self.config['color_correction_profile']
-            elif 'light_settings' in self.machine.config and \
-                    self.machine.config['light_settings']['default_color_correction_profile'] is not None:
-                profile_name = self.machine.config['light_settings']['default_color_correction_profile']
-            else:
-                profile_name = None
-
-            if profile_name:
-                if profile_name in self.machine.light_controller.light_color_correction_profiles:
-                    profile = self.machine.light_controller.light_color_correction_profiles[profile_name]
-
-                    if profile is not None:
-                        self._set_color_correction_profile(profile)
-                else:   # pragma: no cover
-                    error = "Color correction profile '{}' was specified for light '{}'"\
-                            " but the color correction profile does not exist."\
-                            .format(profile_name, self.name)
-                    self.error_log(error)
-                    raise ValueError(error)
-
-            if self.config['fade_ms'] is not None:
-                self.default_fade_ms = self.config['fade_ms']
+                # for three channels default to RGB
+                color_channels = "rgb"
             else:
-                self.default_fade_ms = (self.machine.config['light_settings']
-                                        ['default_fade_ms'])
+                self.raise_config_error("Please provide a type for light {}. No default for channels {}.".
+                                        format(self.name, channel_list), 11)
 
-            if len(self.hw_drivers) == 4 and all(channel in self.hw_drivers
-                                                 for channel in ['red', 'green', 'blue', 'white']):
-                self._rbgw_style = self.machine.config['mpf']['rgbw_white_behavior']
+        if len(channel_list) != len(color_channels):
+            self.raise_config_error("Type {} does not match channels {} for light {}".format(
+                color_channels, channel_list, self.name), 12)
 
-            self.debug_log("Initializing Light. CC Profile: %s, "
-                           "Default fade: %sms", self._color_correction_profile,
-                           self.default_fade_ms)
-        except Exception:
-            self._drivers_loaded.cancel()
-            raise
+        channels = {}   # type: Dict[str, List[Any]]
+        for color_letter in color_channels:
+            full_color_name = self._color_letter_to_name(color_letter)
+            if full_color_name not in channels:
+                channels[full_color_name] = []
+
+            channels[full_color_name].append(channel_list.pop(0))
+
+        return channels
+
+    def _apply_color_correction_profile(self, profile_value):
+        profile_name = self._determine_color_correction_profile(profile_value)
+        if profile_name:
+            if profile_name in self.machine.light_controller.light_color_correction_profiles:
+                profile = self.machine.light_controller.light_color_correction_profiles[profile_name]
+
+                if profile is not None:
+                    self._set_color_correction_profile(profile)
+            else:  # pragma: no cover
+                error = "Color correction profile '{}' was specified for light '{}'"\
+                        " but the color correction profile does not exist."\
+                        .format(profile_name, self.name)
+                self.error_log(error)
+                raise ValueError(error)
+
+    def _determine_color_correction_profile(self, profile_value):
+        if profile_value is not None:
+            return profile_value
+
+        if 'light_settings' in self.machine.config and \
+                self.machine.config['light_settings']['default_color_correction_profile'] is not None:
+            return self.machine.config['light_settings']['default_color_correction_profile']
+
+        return None
 
     def _set_color_correction_profile(self, profile):
         """Apply a color correction profile to this light.
@@ -365,6 +367,19 @@ class Light(SystemWideDevice, DevicePositionMixin):
         """
         self._color_correction_profile = profile
 
+    def _apply_fade(self, fade_value):
+        if fade_value is not None:
+            self.default_fade_ms = fade_value
+        else:
+            self.default_fade_ms = self.machine.config['light_settings']['default_fade_ms']
+
+    def _apply_rgbw_style(self):
+        rgbw_all_present = all(channel in self.hw_drivers
+                               for channel in ['red', 'green', 'blue', 'white'])
+
+        if len(self.hw_drivers) == 4 and rgbw_all_present:
+            self._rbgw_style = self.machine.config['mpf']['rgbw_white_behavior']
+
     # pylint: disable-msg=too-many-arguments
     def color(self, color, fade_ms=None, priority=0, key=None, start_time=None):
         """Add or update a color entry in this light's stack.
@@ -392,8 +407,7 @@ class Light(SystemWideDevice, DevicePositionMixin):
         """
         if self._debug:
             self.debug_log("Received color() command. color: %s, fade_ms: %s "
-                           "priority: %s, key: %s", color, fade_ms, priority,
-                           key)
+                           "priority: %s, key: %s", color, fade_ms, priority, key)
 
         if isinstance(color, str) and color == "on":
             color = self.config['default_on_color']
@@ -440,8 +454,7 @@ class Light(SystemWideDevice, DevicePositionMixin):
             fade_ms: duration of fade
         """
         del kwargs
-        self.color(color=self._off_color, fade_ms=fade_ms, priority=priority,
-                   key=key)
+        self.color(color=self._off_color, fade_ms=fade_ms, priority=priority, key=key)
 
     # pylint: disable-msg=too-many-arguments
     def _add_to_stack(self, color, fade_ms, priority, key, start_time):
@@ -473,12 +486,7 @@ class Light(SystemWideDevice, DevicePositionMixin):
         if self.stack:
             self._remove_from_stack_by_key(key)
 
-        self.stack.append(LightStackEntry(priority,
-                                          key,
-                                          start_time,
-                                          color_below,
-                                          dest_time,
-                                          color))
+        self.stack.append(LightStackEntry(priority, key, start_time, color_below, dest_time, color))
 
         if len(self.stack) > 1:
             self.stack.sort(reverse=True)