mpf 0.81.0.dev2__py3-none-any.whl → 0.81.0.dev3__py3-none-any.whl

mpf/_version.py

@@ -10,7 +10,7 @@ PyPI.
 
 """
 
-__version__ = '0.81.0.dev2'
+__version__ = '0.81.0.dev3'
 '''The full version of MPF.'''
 
 __short_version__ = '0.81'

mpf/config_spec.yaml

@@ -544,7 +544,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
@@ -834,7 +834,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
@@ -1414,7 +1414,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_group.py

@@ -14,6 +14,21 @@ from mpf.core.system_wide_device import SystemWideDevice
 from mpf.devices.light import Light
 
 
+NEOSEG_8DIGIT_ORDER = [
+    95, 90, 93, 82, 85, 89, 86, 91, 88, 87, 81, 92, 83, 84, 94,
+    104, 76, 79, 96, 99, 103, 100, 77, 102, 101, 75, 78, 97, 98, 80,
+    110, 105, 108, 67, 70, 74, 71, 106, 73, 72, 66, 107, 68, 69, 109,
+    119, 61, 64, 111, 114, 118, 115, 62, 117, 116, 60, 63, 112, 113, 65,
+    5, 0, 3, 52, 55, 59, 56, 1, 58, 57, 51, 2, 53, 54, 4,
+    14, 46, 49, 6, 9, 13, 10, 47, 12, 11, 45, 48, 7, 8, 50,
+    20, 15, 18, 37, 40, 44, 41, 16, 43, 42, 36, 17, 38, 39, 19,
+    29, 31, 34, 21, 24, 28, 25, 32, 27, 26, 30, 33, 22, 23, 35]
+
+NEOSEG_2DIGIT_ORDER = [
+    5, 0, 3, 22, 25, 29, 26, 1, 28, 27, 21, 2, 23, 24, 4,
+    14, 16, 19, 6, 9, 13, 10, 17, 12, 11, 15, 18, 7, 8, 20]
+
+
 class LightGroup(SystemWideDevice):
 
     """An abstract group of lights."""
@@ -92,25 +107,41 @@ class LightGroup(SystemWideDevice):
         for light in self.lights:
             light.color(color, fade_ms, priority, key)
 
+    def _swap_grb_rgb_channel_offsets(self, offsets):
+        """Swap every first and second out of sets of three (GRB->RGB)."""
+        adjustments = {0: 1, 1: -1, 2: 0}
+        return [
+            x + adjustments[x % 3]
+            for x in offsets
+        ]
+
     def _reorder_lights(self):
         if self.config['size'] == '8digit':
             #Magic order for 8 digit NeoSeg displays from CobraPin
-            order = [95, 90, 93, 82, 85, 89, 86, 91, 88, 87, 81, 92, 83, 84, 94,
-                     104, 76, 79, 96, 99, 103, 100, 77, 102, 101, 75, 78, 97, 98, 80,
-                     110, 105, 108, 67, 70, 74, 71, 106, 73, 72, 66, 107, 68, 69, 109,
-                     119, 61, 64, 111, 114, 118, 115, 62, 117, 116, 60, 63, 112, 113, 65,
-                     5, 0, 3, 52, 55, 59, 56, 1, 58, 57, 51, 2, 53, 54, 4,
-                     14, 46, 49, 6, 9, 13, 10, 47, 12, 11, 45, 48, 7, 8, 50,
-                     20, 15, 18, 37, 40, 44, 41, 16, 43, 42, 36, 17, 38, 39, 19,
-                     29, 31, 34, 21, 24, 28, 25, 32, 27, 26, 30, 33, 22, 23, 35]
+            order = NEOSEG_8DIGIT_ORDER
+
         elif self.config['size'] == '2digit':
             #Magic order for 2 digit NeoSeg displays from CobraPin
-            order = [5, 0, 3, 22, 25, 29, 26, 1, 28, 27, 21, 2, 23, 24, 4,
-                     14, 16, 19, 6, 9, 13, 10, 17, 12, 11, 15, 18, 7, 8, 20]
+            order = NEOSEG_2DIGIT_ORDER
+
+        elif self.config['size'] == '8digit-rg-swapped':
+            #Magic order for 8 digit NeoSeg displays from CobraPin when platform numbering uses RGB channel order
+            order = self._swap_grb_rgb_channel_offsets(NEOSEG_8DIGIT_ORDER)
+
+        elif self.config['size'] == '2digit-rg-swapped':
+            #Magic order for 2 digit NeoSeg displays from CobraPin when platform numbering uses RGB channel order
+            order = self._swap_grb_rgb_channel_offsets(NEOSEG_2DIGIT_ORDER)
         else:
             order = range(0, len(self.lights))
 
-        self.lights = [self.lights[i] for i in order]
+        mapped_lights = []
+        try:
+            for i in order:
+                mapped_lights.append(self.lights[i])
+            self.lights = mapped_lights
+        except IndexError:
+            self.error_log("Attempted to use light index %s but source list only had %s items", i, len(self.lights))
+            raise
 
     def wait_for_loaded(self):
         """Return future."""
@@ -180,11 +211,12 @@ class NeoSegDisplay(LightGroup):
     __slots__ = []  # type: List[str]
 
     def _create_lights(self):
-        if self.config['size'] == '8digit':
+        if self.config['size'] in ('8digit', '8digit-rg-swapped'):
             count = 120
-        elif self.config['size'] == '2digit':
+        elif self.config['size'] in ('2digit', '2digit-rg-swapped'):
             count = 30
         else:
+            self.warning_log("NeoSegDisplay %s could not determine number of lights to create.", self.name)
             count = 0
 
         for index in range(self.config['number_start'], self.config['number_start'] + count):

mpf/platforms/fast/fast.py

@@ -593,10 +593,13 @@ class FastHardwarePlatform(ServoPlatform, LightsPlatform, RgbDmdPlatform,
             return FASTMatrixLight(number, self.serial_connections['net'], self.machine,
                                    int(1 / self.config['net']['lamp_hz'] * 1000), self)
         if not subtype or subtype == "led":
-            # make everything lowercase and strip trailing channel number
-            parts, channel = number.lower().rsplit('-', 1)
-            # split into board name, breakout, port, led
-            parts = parts.split('-')
+            try:
+                # make everything lowercase and strip trailing channel number
+                parts, channel = number.lower().rsplit('-', 1)
+                # split into board name, breakout, port, led
+                parts = parts.split('-')
+            except ValueError as e:
+                raise ValueError(f"Unable to parse FAST light '{config.name}' address {number}") from e
 
             if parts[0] in self.exp_boards_by_name:  # this is an expansion board LED in config file format
                 return self._add_exp_led_with_config_format(parts, channel, config.name)

mpf/platforms/fast/fast_led.py

@@ -40,7 +40,11 @@ class FASTRGBLED:
             channel = self.channels[index]
             if channel:
                 brightness, _, done = channel.get_fade_and_brightness(current_time)
-                result += f'{int(brightness * 255):02X}'
+                # Clamp to a single byte: an out-of-range brightness here would
+                # format to a 1- or 3-char hex channel and crash the downstream
+                # binascii unpacking with an "Odd-length string" error.
+                clamped_brightness = min(255, max(0, int(brightness * 255)))
+                result += f'{clamped_brightness:02X}'
                 if not done:
                     self.dirty = True
             else:
@@ -116,6 +120,12 @@ class FASTLEDChannel(LightPlatformInterface):
             fade_ms = max_fade_ms
             ratio = ((current_time + (fade_ms / 1000.0) - start_time) /
                      (target_time - start_time))
+            # A fade's start_time and the current_time passed in come from
+            # separate clock reads, so current_time can land a hair before
+            # start_time, making this ratio slightly out of [0, 1]. That would
+            # push brightness below 0 (fade up) or above 1 (fade down); clamp
+            # the ratio so the interpolation stays in range for both directions.
+            ratio = max(0.0, min(1.0, ratio))
             brightness = start_brightness + (target_brightness - start_brightness) * ratio
             done = False
         else:
@@ -125,15 +135,15 @@ class FASTLEDChannel(LightPlatformInterface):
             self._last_brightness = brightness
             done = True
 
-        # There is a bug that can sometimes cause the start_time to be ahead of the current_time,
-        # resulting in a negative brightness value. This may be a floating-point rounding error,
-        # or maybe something else. I can't figure it out, so just floor the value to be non-negative.
-        if brightness < 0:
-            brightness = 0
-            self.led.log.warning("Calculated a negative brightness (%s) for led %s channel %s. current_time: %s "
+        # Final guard in case start/target brightness themselves are ever out
+        # of [0, 1]: an out-of-range value would crash the hex formatter in
+        # current_color, so clamp both ends.
+        if brightness < 0 or brightness > 1:
+            self.led.log.warning("Calculated an out-of-range brightness (%s) for led %s channel %s. current_time: %s "
                                  "start_brightness: %s, start_time: %s, target_brightness: %s, target_time: %s",
                                  brightness, self.led, self.channel, current_time, start_brightness, start_time,
                                  target_brightness, target_time)
+            brightness = max(0.0, min(1.0, brightness))
 
         return brightness, fade_ms, done
 

mpf/platforms/virtual_pinball/virtual_pinball.py

@@ -160,7 +160,7 @@ class VirtualPinballPlatform(LightsPlatform, SwitchPlatform, DriverPlatform, Seg
 
     """VPX platform."""
 
-    __slots__ = ["_lights", "_switches", "_drivers", "_last_drivers", "_last_lights", 
+    __slots__ = ["_lights", "_switches", "_drivers", "_last_drivers", "_last_lights",
                  "_started", "rules", "_configured_segment_displays", "_last_segment_text"]
 
     def __init__(self, machine):

mpf/tests/machine_files/auditor/config/config.yaml

@@ -6,7 +6,7 @@ game:
 player_vars:
     score:
         initial_value: 0
-    my_var: 
+    my_var:
         initial_value: 0
 
 auditor:

mpf/tests/machine_files/custom_code/code/test_code.py

@@ -6,7 +6,11 @@ class TestCustomCode(CustomCode):
         self.log.debug("Loaded!")
 
         self.machine.events.add_handler('test_event', self._update)
+        self.machine.events.add_handler('test_event_2', self._alternative_kwargs)
 
     def _update(self, **kwargs):
         del kwargs
         self.machine.events.post("test_response")
+
+    def _alternative_kwargs(self, **_kwargs):
+        self.machine.events.post("test_response_2")

mpf/tests/machine_files/event_manager/config/test_event_manager.yaml

@@ -7,6 +7,12 @@ event_player:
     test_event_player_delayed:
         - test_event_player2|2s
         - test_event_player3:2s
+    "{machine.lifetime_earnings >= 500}": never_happens_machine
+    "{machine.switches.s_test_1.state == 1}": sometimes_happens_switch
+
+switches:
+    s_test_1:
+        number:
 
 random_event_player:
     test_random_event_player1:

mpf/tests/machine_files/event_manager/modes/game_mode/config/game_mode.yaml

@@ -3,6 +3,11 @@ mode:
   start_events: game_mode_start
   stop_events: game_mode_end
 
+event_player:
+    "{players[0].score>=99999999}": never_happens_players
+    "{current_player.score>=999999999}": never_happens_player
+    "{current_player.score<=current_player.score + 1 and current_player.score > -1}": always_happens_multiple_ast
+
 random_event_player:
     test_random_event_player_mode2:
         - out1

mpf/tests/machine_files/light/config/light_groups.yaml

@@ -50,3 +50,15 @@ neoseg_displays:
     light_template:
       type: w
       subtype: led
+  neoSeg_2:
+    start_channel: 0-1-0
+    size: 8digit-rg-swapped
+    light_template:
+      type: w
+      subtype: led
+  neoSeg_3:
+    start_channel: 0-1-120
+    size: 2digit-rg-swapped
+    light_template:
+      type: w
+      subtype: led

mpf/tests/machine_files/service_mode/config/config.yaml

@@ -67,7 +67,7 @@ lights:
 #   tracks:
 #     sfx: []
 #   enabled: true
-# 
+#
 # keyboard:
 #     right:
 #         switch: s_service_enter

mpf/tests/machine_files/settings/config/config.yaml

@@ -19,3 +19,30 @@ settings:
             zero: "Zero"
             one: "One"
             two: "Two"
+    custom_setting_float:
+        label: "Float Setting"
+        key_type: float
+        default: 0.1
+        sort: 3
+        values:
+            0: "Zero"
+            0.1: "Point One"
+            1.0: "One"
+            2.5: "Two Point Five"
+    custom_setting_bool_t:
+        label: "Boolean Setting Default True"
+        key_type: bool
+        default: true
+        sort: 4
+        values:
+            true: "yes"
+            false: "off"
+
+    custom_setting_bool_f:
+        label: "Boolean Setting Default False"
+        key_type: bool
+        default: false
+        sort: 5
+        values:
+            true: "on"
+            false: "no"

mpf/tests/test_CustomCode.py

@@ -15,3 +15,10 @@ class TestCustomCode(MpfTestCase):
         self.machine_run()
 
         self.assertEqual(1, self._events['test_response'])
+
+    def test_scoring_2(self):
+        self.mock_event("test_response_2")
+        self.post_event("test_event_2")
+        self.machine_run()
+
+        self.assertEqual(1, self._events['test_response_2'])

mpf/tests/test_DeviceManager.py

@@ -1,5 +1,8 @@
+import asyncio
 import inspect
 
+from unittest.mock import patch, AsyncMock, MagicMock
+
 from mpf.core.utility_functions import Util
 from mpf.tests.MpfTestCase import MpfTestCase
 
@@ -37,3 +40,63 @@ class TestDeviceManager(MpfTestCase):
                 self.assertTrue(hasattr(method, "relative_priority"),
                                 "Method {}.{} is missing a relative_priority. Did you apply the event_handler "
                                 "decorator?".format(device_type, method_name))
+
+    def test_initialize_devices_re_raises_first_exception(self):
+        """Test that initialize_devices re-raises exceptions from failed device initialization."""
+        async def test_exception_handling():
+            failing_task = asyncio.create_task(self._failing_coro())
+            slow_task = asyncio.create_task(self._slow_coro())
+
+            fs = [failing_task, slow_task]
+            done, pending = await asyncio.wait(fs, return_when=asyncio.FIRST_EXCEPTION)
+
+            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
+
+        with self.assertRaises(RuntimeError):
+            self.loop.run_until_complete(test_exception_handling())
+
+    def test_initialize_devices_completes_when_all_succeed(self):
+        """Test that initialize_devices completes normally when all devices succeed."""
+        async def test_success_handling():
+            success1 = asyncio.create_task(self._success_coro())
+            success2 = asyncio.create_task(self._success_coro())
+
+            fs = [success1, success2]
+            done, pending = await asyncio.wait(fs, return_when=asyncio.FIRST_EXCEPTION)
+
+            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
+
+            return "success"
+
+        result = self.loop.run_until_complete(test_success_handling())
+        self.assertEqual(result, "success")
+
+    async def _failing_coro(self):
+        """Async coroutine that fails."""
+        raise RuntimeError("Device initialization failed")
+
+    async def _slow_coro(self):
+        """Async coroutine that takes time."""
+        await asyncio.sleep(10)
+        return "done"
+
+    async def _success_coro(self):
+        """Async coroutine that succeeds."""
+        await asyncio.sleep(0)
+        return "success"

mpf/tests/test_EventManager.py

@@ -912,3 +912,48 @@ class TestEventManager(MpfFakeGameTestCase, MpfTestCase):
         # invalid space
         with self.assertRaises(ValueError):
             self.machine.events.add_handler("event_name {machine.variables.test}", self._handler)
+
+    def test_handler_cleanup_on_variable_change(self):
+        self.start_game()
+        self.machine.events.post('game_mode_start')
+        self.advance_time_and_run(0.01)
+
+        initial_count_pte = len(self.machine.events.registered_handlers['player_turn_ended'])
+        initial_count_player_added = len(self.machine.events.registered_handlers['player_added'])
+
+        for i in range(100):
+            self.machine.game.player.score += 100
+            self.advance_time_and_run(0.01)
+
+        final_count_pte = len(self.machine.events.registered_handlers['player_turn_ended'])
+        final_count_player_added = len(self.machine.events.registered_handlers['player_added'])
+        self.assertEqual(initial_count_pte, final_count_pte)
+        self.assertEqual(initial_count_player_added, final_count_player_added)
+
+    def test_handler_cleanup_on_machine_variable_change(self):
+        self.start_game()
+        self.advance_time_and_run(0.01)
+
+        event_name = 'machine_var_lifetime_earnings'
+        initial_count = len(self.machine.events.registered_handlers.get(event_name, []))
+
+        for i in range(100):
+            self.machine.variables.set_machine_var('lifetime_earnings', 10 + i)
+            self.advance_time_and_run(0.01)
+
+        final_count = len(self.machine.events.registered_handlers.get(event_name, []))
+        self.assertEqual(initial_count, final_count)
+
+    def test_handler_cleanup_on_switch_state_change(self):
+        self.start_game()
+        self.advance_time_and_run(0.01)
+
+        event_name = 'switch_s_test_1_active'
+        initial_count = len(self.machine.events.registered_handlers.get(event_name, []))
+
+        for _ in range(50):
+            self.hit_switch_and_run('s_test_1', 0.01)
+            self.release_switch_and_run('s_test_1', 0.01)
+
+        final_count = len(self.machine.events.registered_handlers.get(event_name, []))
+        self.assertEqual(initial_count, final_count)

mpf/tests/test_Fast_Led.py

@@ -0,0 +1,61 @@
+# mpf.tests.test_Fast_Led
+"""Unit tests for FAST LED fade/brightness math."""
+import unittest
+from unittest.mock import MagicMock
+
+from mpf.platforms.fast.fast_led import FASTLEDChannel
+
+
+class _FakeLed:
+    """Minimal stand-in for FASTRGBLED for unit-testing a single channel."""
+
+    def __init__(self, hardware_fade_ms=0):
+        self.number = '880'
+        self.hardware_fade_ms = hardware_fade_ms
+        self.dirty = False
+        self.log = MagicMock()
+
+
+class TestFastLed(unittest.TestCase):
+
+    def _channel(self, hardware_fade_ms=0):
+        return FASTLEDChannel(_FakeLed(hardware_fade_ms), 0)
+
+    def test_fade_interpolates_to_three_places(self):
+        # Half-way through a 0 -> 1 fade the brightness is 0.5.
+        ch = self._channel()
+        start = 1000.0
+        ch.set_fade(start_brightness=0.0, start_time=start,
+                    target_brightness=1.0, target_time=start + 1.0)
+
+        brightness, _, _ = ch.get_fade_and_brightness(start + 0.5)
+
+        self.assertAlmostEqual(brightness, 0.5, places=3)
+
+    def test_fade_up_when_current_time_precedes_start_time(self):
+        # When current_time reads as before the fade's start_time, a fade up
+        # must not calculate a brightness below 0.
+        ch = self._channel()
+        now = 1000.0
+        ch.set_fade(start_brightness=0.0, start_time=now + 0.01,
+                    target_brightness=1.0, target_time=now + 0.5)
+
+        brightness, _, _ = ch.get_fade_and_brightness(now)
+
+        self.assertGreaterEqual(brightness, 0.0)
+        self.assertLessEqual(brightness, 1.0)
+
+    def test_fade_down_when_current_time_precedes_start_time(self):
+        # The same out-of-order read while fading down must not calculate a
+        # brightness above 1, which would format to a 3-char hex channel and
+        # crash the downstream binascii unpacking.
+        ch = self._channel()
+        now = 1000.0
+        ch.set_fade(start_brightness=1.0, start_time=now + 0.01,
+                    target_brightness=0.0, target_time=now + 0.5)
+
+        brightness, _, _ = ch.get_fade_and_brightness(now)
+
+        self.assertGreaterEqual(brightness, 0.0)
+        self.assertLessEqual(brightness, 1.0)
+        self.assertEqual(2, len(f'{int(brightness * 255):02X}'))

mpf/tests/test_LightGroups.py

@@ -20,8 +20,7 @@ class TestLightGroups(MpfTestCase):
         self.assertLightColor("stripe1_light_3", "red")
         self.assertLightColor("stripe1_light_4", "red")
 
-    def test_config(self):
-        # stripe 1
+    def test_config_stripe_1(self):
         self.assertEqual("led-10-r", self.machine.lights["stripe1_light_0"].hw_drivers["red"][0].number)
         self.assertListEqual(["test", "stripe1"], self.machine.lights["stripe1_light_0"].config['tags'])
         self.assertEqual("led-11-r", self.machine.lights["stripe1_light_1"].hw_drivers["red"][0].number)
@@ -30,7 +29,7 @@ class TestLightGroups(MpfTestCase):
         self.assertEqual("led-14-r", self.machine.lights["stripe1_light_4"].hw_drivers["red"][0].number)
         self.assertListEqual(["test", "stripe1"], self.machine.lights["stripe1_light_4"].config['tags'])
 
-        # stripe 2
+    def test_config_stripe_2(self):
         self.assertEqual("led-7-200-r", self.machine.lights["stripe2_light_0"].hw_drivers["red"][0].number)
         self.assertEqual(10, self.machine.lights["stripe2_light_0"].config['x'])
         self.assertEqual(20, self.machine.lights["stripe2_light_0"].config['y'])
@@ -38,17 +37,14 @@ class TestLightGroups(MpfTestCase):
         self.assertEqual(15, self.machine.lights["stripe2_light_1"].config['x'])
         self.assertEqual(20, self.machine.lights["stripe2_light_1"].config['y'])
 
-        # stripe 3
+    def test_config_stripe_3(self):
         self.assertEqual("led-ABC-123", self.machine.lights["stripe3_light_0"].hw_drivers["red"][0].number)
         self.assertEqual("led-ABC-123+1", self.machine.lights["stripe3_light_0"].hw_drivers["green"][0].number)
-        self.assertEqual("led-ABC-123+2",
-                         self.machine.lights["stripe3_light_0"].hw_drivers["blue"][0].number)
-        self.assertEqual("led-ABC-123+3",
-                         self.machine.lights["stripe3_light_0"].hw_drivers["white"][0].number)
-        self.assertEqual("led-ABC-123+4",
-                         self.machine.lights["stripe3_light_1"].hw_drivers["red"][0].number)
-
-        # ring 1
+        self.assertEqual("led-ABC-123+2", self.machine.lights["stripe3_light_0"].hw_drivers["blue"][0].number)
+        self.assertEqual("led-ABC-123+3", self.machine.lights["stripe3_light_0"].hw_drivers["white"][0].number)
+        self.assertEqual("led-ABC-123+4", self.machine.lights["stripe3_light_1"].hw_drivers["red"][0].number)
+
+    def test_config_rings(self):
         self.assertEqual("led-20-r", self.machine.lights["ring1_light_0"].hw_drivers["red"][0].number)
         self.assertEqual("led-21-r", self.machine.lights["ring1_light_1"].hw_drivers["red"][0].number)
         self.assertEqual("led-22-r", self.machine.lights["ring1_light_2"].hw_drivers["red"][0].number)
@@ -67,13 +63,18 @@ class TestLightGroups(MpfTestCase):
         self.assertEqual(100, self.machine.lights["ring1_light_9"].config['x'])
         self.assertEqual(53, self.machine.lights["ring1_light_9"].config['y'])
 
-        # neoSeg_0
+    def test_config_neoSeg_0(self):  # 8 digit
         self.assertEqual("led-0-0-0", self.machine.lights["neoSeg_0_light_0"].hw_drivers["white"][0].number)
         self.assertEqual("led-0-0-0+1", self.machine.lights["neoSeg_0_light_1"].hw_drivers["white"][0].number)
         self.assertEqual("led-0-0-0+2", self.machine.lights["neoSeg_0_light_2"].hw_drivers["white"][0].number)
         self.assertEqual("neoSeg_0_light_119", self.machine.lights["neoSeg_0_light_119"].name)
-        # sanity check order...not 100%
+
         self.assertEqual(self.machine.neoseg_displays["neoSeg_0"].lights[0].name, self.machine.lights["neoSeg_0_light_95"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_0"].lights[1].name, self.machine.lights["neoSeg_0_light_90"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_0"].lights[2].name, self.machine.lights["neoSeg_0_light_93"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_0"].lights[3].name, self.machine.lights["neoSeg_0_light_82"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_0"].lights[4].name, self.machine.lights["neoSeg_0_light_85"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_0"].lights[5].name, self.machine.lights["neoSeg_0_light_89"].name)
         self.assertEqual(self.machine.neoseg_displays["neoSeg_0"].lights[20].name, self.machine.lights["neoSeg_0_light_103"].name)
         self.assertEqual(self.machine.neoseg_displays["neoSeg_0"].lights[40].name, self.machine.lights["neoSeg_0_light_66"].name)
         self.assertEqual(self.machine.neoseg_displays["neoSeg_0"].lights[60].name, self.machine.lights["neoSeg_0_light_5"].name)
@@ -81,12 +82,12 @@ class TestLightGroups(MpfTestCase):
         self.assertEqual(self.machine.neoseg_displays["neoSeg_0"].lights[100].name, self.machine.lights["neoSeg_0_light_36"].name)
         self.assertEqual(self.machine.neoseg_displays["neoSeg_0"].lights[119].name, self.machine.lights["neoSeg_0_light_35"].name)
 
-        # neoSeg_1
+    def test_config_neoSeg_1(self):  # 2 digit
         self.assertEqual("led-0-0-120", self.machine.lights["neoSeg_1_light_0"].hw_drivers["white"][0].number)
         self.assertEqual("led-0-0-120+1", self.machine.lights["neoSeg_1_light_1"].hw_drivers["white"][0].number)
         self.assertEqual("led-0-0-120+2", self.machine.lights["neoSeg_1_light_2"].hw_drivers["white"][0].number)
         self.assertEqual("neoSeg_1_light_29", self.machine.lights["neoSeg_1_light_29"].name)
-        # sanity check order...not 100%
+
         self.assertEqual(self.machine.neoseg_displays["neoSeg_1"].lights[0].name, self.machine.lights["neoSeg_1_light_5"].name)
         self.assertEqual(self.machine.neoseg_displays["neoSeg_1"].lights[5].name, self.machine.lights["neoSeg_1_light_29"].name)
         self.assertEqual(self.machine.neoseg_displays["neoSeg_1"].lights[10].name, self.machine.lights["neoSeg_1_light_21"].name)
@@ -94,3 +95,34 @@ class TestLightGroups(MpfTestCase):
         self.assertEqual(self.machine.neoseg_displays["neoSeg_1"].lights[20].name, self.machine.lights["neoSeg_1_light_13"].name)
         self.assertEqual(self.machine.neoseg_displays["neoSeg_1"].lights[25].name, self.machine.lights["neoSeg_1_light_15"].name)
         self.assertEqual(self.machine.neoseg_displays["neoSeg_1"].lights[29].name, self.machine.lights["neoSeg_1_light_20"].name)
+
+    def test_config_neoSeg_2(self):  # 8 digit on rgb-ordered channels
+        self.assertEqual("led-0-1-0", self.machine.lights["neoSeg_2_light_0"].hw_drivers["white"][0].number)
+        self.assertEqual("led-0-1-0+1", self.machine.lights["neoSeg_2_light_1"].hw_drivers["white"][0].number)
+        self.assertEqual("neoSeg_2_light_119", self.machine.lights["neoSeg_2_light_119"].name)
+
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_2"].lights[0].name, self.machine.lights["neoSeg_2_light_95"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_2"].lights[1].name, self.machine.lights["neoSeg_2_light_91"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_2"].lights[2].name, self.machine.lights["neoSeg_2_light_94"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_2"].lights[3].name, self.machine.lights["neoSeg_2_light_81"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_2"].lights[4].name, self.machine.lights["neoSeg_2_light_84"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_2"].lights[5].name, self.machine.lights["neoSeg_2_light_89"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_2"].lights[20].name, self.machine.lights["neoSeg_2_light_102"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_2"].lights[40].name, self.machine.lights["neoSeg_2_light_67"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_2"].lights[60].name, self.machine.lights["neoSeg_2_light_5"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_2"].lights[80].name, self.machine.lights["neoSeg_2_light_12"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_2"].lights[100].name, self.machine.lights["neoSeg_2_light_37"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_2"].lights[119].name, self.machine.lights["neoSeg_2_light_35"].name)
+
+    def test_config_neoSeg_3(self):  # 2 digit on rgb-ordered channels
+        self.assertEqual("led-0-1-120", self.machine.lights["neoSeg_3_light_0"].hw_drivers["white"][0].number)
+        self.assertEqual("led-0-1-120+1", self.machine.lights["neoSeg_3_light_1"].hw_drivers["white"][0].number)
+        self.assertEqual("neoSeg_3_light_29", self.machine.lights["neoSeg_3_light_29"].name)
+
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_3"].lights[0].name, self.machine.lights["neoSeg_3_light_5"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_3"].lights[5].name, self.machine.lights["neoSeg_3_light_29"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_3"].lights[10].name, self.machine.lights["neoSeg_3_light_22"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_3"].lights[15].name, self.machine.lights["neoSeg_3_light_14"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_3"].lights[20].name, self.machine.lights["neoSeg_3_light_12"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_3"].lights[25].name, self.machine.lights["neoSeg_3_light_16"].name)
+        self.assertEqual(self.machine.neoseg_displays["neoSeg_3"].lights[29].name, self.machine.lights["neoSeg_3_light_20"].name)

mpf/tests/test_LightNumbering.py

@@ -14,8 +14,7 @@ class TestLightNumbering(MpfTestCase):
         led1 = self.machine.lights["first"]
         led2 = self.machine.lights["second"]
         led3 = self.machine.lights["third"]
-        led4 = self.machine.lights["fourth"]       
-
+        led4 = self.machine.lights["fourth"]
 
         self.assertEqual(led1.hw_drivers["green"][0].number,"led-0-0-0")
         self.assertEqual(led1.hw_drivers["red"][0].number,"led-0-0-0+1")
@@ -35,4 +34,4 @@ class TestLightNumbering(MpfTestCase):
         self.assertEqual(led4.hw_drivers["green"][0].number,"led-0-0-0+12")
         self.assertEqual(led4.hw_drivers["red"][0].number,"led-0-0-0+13")
         self.assertEqual(led4.hw_drivers["blue"][0].number,"led-0-0-0+14")
-        self.assertEqual(led4.hw_drivers["white"][0].number,"led-0-0-0+15")
+        self.assertEqual(led4.hw_drivers["white"][0].number,"led-0-0-0+15")

mpf/tests/test_RandomEventPlayer.py

@@ -100,17 +100,17 @@ class TestRandomEventPlayerBase():
             self.runner.advance_time_and_run()
             self.runner.assertNotEqual(self.prevEvent, self.lastEvent)
             self.runner.assertEqual(self.lastEvent, self.events[expectedIdx])
-    
+
     def _test_conditional_random(self):
         self._reset()
-        
+
         # Only one event is true
         results = list()
         for x in range(RANDOM_RUNS):
             self.runner.post_event("test_{}_conditional_random".format(self.scope))
             self.runner.advance_time_and_run()
             self.assertEqual(RANDOM_RUNS, results.count('event1'))
-        
+
         # Conditional event kwarg is true
         results = list()
         for x in range(RANDOM_RUNS):
@@ -126,4 +126,4 @@ class TestRandomEventPlayerBase():
             self.runner.post_event("test_{}_conditional_random".format(self.scope))
             self.runner.advance_time_and_run()
             self.assertAlmostEqual(RANDOM_RUNS / 2, results.count('event1'), delta=3)
-            self.assertAlmostEqual(RANDOM_RUNS / 2, results.count('event4'), delta=3)
+            self.assertAlmostEqual(RANDOM_RUNS / 2, results.count('event4'), delta=3)

mpf/tests/test_Settings.py

@@ -24,3 +24,19 @@ class TestSettings(MpfTestCase):
         self.assertEqual("one", self.machine.settings.custom_setting_str)
         self.machine.settings.set_setting_value("custom_setting_str", "zero")
         self.assertEqual("zero", self.machine.settings.custom_setting_str)
+
+        self.assertEqual(0.1, self.machine.settings.custom_setting_float)
+        self.machine.settings.set_setting_value("custom_setting_float", 2.5)
+        self.assertEqual(2.5, self.machine.settings.custom_setting_float)
+        self.machine.settings.set_setting_value("custom_setting_float", 0)
+        self.assertEqual(0, self.machine.settings.custom_setting_float)
+
+        self.assertEqual(True, self.machine.settings.custom_setting_bool_t)
+        self.machine.settings.set_setting_value("custom_setting_bool_t", False)
+        self.assertEqual(False, self.machine.settings.custom_setting_bool_t)
+        self.machine.settings.set_setting_value("custom_setting_bool_t", True)
+        self.assertEqual(True, self.machine.settings.custom_setting_bool_t)
+
+        self.assertEqual(False, self.machine.settings.custom_setting_bool_f)
+        self.machine.settings.set_setting_value("custom_setting_bool_f", True)
+        self.assertEqual(True, self.machine.settings.custom_setting_bool_f)

mpf/tests/test_Utility_Functions.py

@@ -5,13 +5,60 @@ from mpf.core.utility_functions import Util
 class TestUtil(unittest.TestCase):
 
     def test_string_to_ms(self):
-        self.assertEqual(86400000, Util.string_to_ms('1d'))
-        self.assertEqual(3600000, Util.string_to_ms('1h'))
-        self.assertEqual(60000, Util.string_to_ms('1m'))
-        self.assertEqual(1000, Util.string_to_ms('1s'))
-        self.assertEqual(1, Util.string_to_ms('1ms'))
-        self.assertEqual(0, Util.string_to_ms(None))
-        self.assertEqual(0, Util.string_to_ms(False))
+        # Base Units
+        self.assertEqual(Util.string_to_ms('1d'), 86400000)
+        self.assertEqual(Util.string_to_ms('1h'), 3600000)
+        self.assertEqual(Util.string_to_ms('1m'), 60000)
+        self.assertEqual(Util.string_to_ms('1s'), 1000)
+        self.assertEqual(Util.string_to_ms('1ms'), 1)
+
+        # Quirky Units
+        self.assertEqual(Util.string_to_ms('200msec'), 200)
+        self.assertEqual(Util.string_to_ms('200Msec'), 200)
+        self.assertEqual(Util.string_to_ms('2sec'), 2000)
+        self.assertEqual(Util.string_to_ms('2Sec'), 2000)
+        self.assertEqual(Util.string_to_ms('1.5S'), 1500)
+        self.assertEqual(Util.string_to_ms('100.0ms'), 100)
+
+        # Unitless int/floats as strings
+        self.assertEqual(Util.string_to_ms('200'), 200)
+        self.assertEqual(Util.string_to_ms('100.0'), 100)
+
+        # Actual int/float
+        self.assertEqual(Util.string_to_ms(500), 500)
+        self.assertEqual(Util.string_to_ms(1.5), 1)
+
+        # Strings implying zero
+        self.assertEqual(Util.string_to_ms('None'), 0)
+        self.assertEqual(Util.string_to_ms('NONE'), 0)
+
+        # T/F/N native behavior
+        self.assertEqual(Util.string_to_ms(True), 1)
+        self.assertEqual(Util.string_to_ms(False), 0)
+        self.assertEqual(Util.string_to_ms(None), 0)
+
+        # Whitespace handling
+        self.assertEqual(Util.string_to_ms('  500ms  '), 500)
+        self.assertEqual(Util.string_to_ms('2s '), 2000)
+
+    def test_string_to_ms_unhandled(self):
+        with self.assertRaises(ValueError):
+            Util.string_to_ms('')
+
+        with self.assertRaises(ValueError):
+            Util.string_to_ms('no')
+
+        with self.assertRaises(ValueError):
+            Util.string_to_ms('pinball')
+
+        with self.assertRaises(ValueError):
+            Util.string_to_ms('True')
+
+        with self.assertRaises(ValueError):
+            Util.string_to_ms('200mss')
+
+        with self.assertRaises(ValueError):
+            Util.string_to_ms('2s 1s')
 
     def test_keys_to_lower(self):
         inner_dict = dict(key1=1, Key2=2)

{mpf-0.81.0.dev2.dist-info → mpf-0.81.0.dev3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpf
-Version: 0.81.0.dev2
+Version: 0.81.0.dev3
 Summary: The Mission Pinball Framework (MPF)
 Author-email: The Mission Pinball Framework Team <brian@missionpinball.org>
 License: MIT
@@ -85,7 +85,7 @@ What is Mission Pinball Framework?
 Mission Pinball Framework (MPF) is open source, cross-platform software for powering real pinball
 machines. MPF is a community-developed project released under the MIT license. It's supported by volunteers in their spare time.
 
-[![Coverage Status](https://coveralls.io/repos/missionpinball/mpf/badge.svg?branch=dev&service=github)](https://coveralls.io/github/missionpinball/mpf?branch=dev)
+[![Coverage Status](https://coveralls.io/repos/github/missionpinball/mpf/badge.svg?branch=dev)](https://coveralls.io/github/missionpinball/mpf?branch=dev)
 [![Test Status](https://github.com/missionpinball/mpf/actions/workflows/run_tests.yml/badge.svg)](https://github.com/missionpinball/mpf/actions/workflows/run_tests.yml)
 [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/1687/badge)](https://bestpractices.coreinfrastructure.org/projects/1687)
 

{mpf-0.81.0.dev2.dist-info → mpf-0.81.0.dev3.dist-info}/RECORD

@@ -1,7 +1,7 @@
 mpf/__init__.py,sha256=ycmoyzDc1kSASShp-FwsBhnBrCuVw3uXr58b_MbffIE,73
 mpf/__main__.py,sha256=8eo0swsTb94xUqTnjo7uE0oyz9ita3Pqpk85t2BYs1w,294
-mpf/_version.py,sha256=CAKFLv09Zhe0fQyDEtdpGrU_YowPM5AZeELmCD1TKWg,1789
-mpf/config_spec.yaml,sha256=GP85RWa4CPLr0AjOmMWvcUQ_Yy5t5pyxnjffy9hFMoE,71037
+mpf/_version.py,sha256=YJAG6WLo_IBHGOBCSPa4MjktqgHH2JlWbH9I6E165JU,1789
+mpf/config_spec.yaml,sha256=j2nIb18HQAzE2ePjjKvNx7wwfAkJ1vh3IGi7l74xqUU,71074
 mpf/mpfconfig.yaml,sha256=JZ_X-Uvm1JaXOy6_fxLauzBuCu99aClAQTs4J9I20XA,14757
 mpf/assets/__init__.py,sha256=AhIAlZFZRmGQzlTDD7nfOfrjF1pE82FNhWVnuTb8MFA,58
 mpf/assets/show.py,sha256=lHKhCGmsF1PN52lQ_XnMMCPYNq7On5J9YXm_05P4fQY,31350
@@ -72,10 +72,10 @@ mpf/core/custom_code.py,sha256=Zoxo8u5l0vwLjbe8D5SoHzcDIPi5mdx4mXbSTK_EojE,891
 mpf/core/data_manager.py,sha256=GeeuRpDRL-pEkCBz_2YZOihNZCE0Kv1-2I4ymYnz1kc,4775
 mpf/core/delays.py,sha256=iv9Hyj28897mdGVLv0c6oTRDpupI4PGkuWhC1JDncfg,6709
 mpf/core/device.py,sha256=jnUiuTmTdKryS_rwptipWvEVJ7_OSOPL0Jau1bMMthg,4924
-mpf/core/device_manager.py,sha256=UQ4IaQnNN6YwIa_vb83p1qyAxrfp9jzonNoDJBUW3fU,13191
+mpf/core/device_manager.py,sha256=Nt0DnRO3qmYmxVCs-NlpyIXQ5-fnGxqnCL60-pYtuE4,13668
 mpf/core/device_monitor.py,sha256=EbscdXm0DK7PPwWkJFdCkIWHoIEHOrM3c5aBMIPIojU,4399
 mpf/core/enable_disable_mixin.py,sha256=twqqbA0U1W2ipNmMdDPu4vSeEU47Op3m5Z2HL-xqP-0,5621
-mpf/core/events.py,sha256=tUNXwSZXvBsczm19u_z9aQen1OpAP_-VNK85HoVuglU,42036
+mpf/core/events.py,sha256=jIpaiDKe2imqiPYC9qLnZdxd3kQk3kVG4ThGZPMwFXg,42260
 mpf/core/file_interface.py,sha256=vGon_Mrj5z6rFohXJJT-smRE9X1iE21nxIfwTeZgJAU,1644
 mpf/core/file_manager.py,sha256=0wP2bE_zI9w1Z9o2tklyjmPt5mDGrPu7sN4Sv_gQon8,4087
 mpf/core/light_controller.py,sha256=vFvKSY3fq6VbgRHpFP1eeCsU0zVvUQ5kf1kNtj7jc_k,4752
@@ -86,7 +86,7 @@ mpf/core/mode.py,sha256=YlGj7VczEUwD1ESDStkZhKaqxNYctqR5MmFICdSAYDM,23375
 mpf/core/mode_controller.py,sha256=7eaK2-LxcVlOX0QK2oefDMNQbNLNSunCwOtPwMAbeGU,14053
 mpf/core/mode_device.py,sha256=C9E9eiKPX9R9RgBDpuwUwuObeYvkkgM7Qs62gONlS2o,2589
 mpf/core/mpf_controller.py,sha256=R_kfMHKD6xYzGEpnIJgxY0GCtqBlxK7dE7ysyE5BxDg,1170
-mpf/core/placeholder_manager.py,sha256=CGoM-suQytxvUJsANdI64A6BAK4YneAve83N5RiOCrY,31679
+mpf/core/placeholder_manager.py,sha256=YmHiZeOp7baPrRhmc8r69SUMO1KKOLbhiCkIJKTThTs,32447
 mpf/core/platform.py,sha256=_9eh9ybl2ep6JNgOaOqpsXjslCorf18NQH1_hwFCEk4,27086
 mpf/core/platform_batch_light_system.py,sha256=YQXNmXJkdP41Gw7PgVk92gnu1eaMn3YdHjDSUAqLoew,7892
 mpf/core/platform_controller.py,sha256=oniy9CgK3ki9ENsMJJqvTF6NA5IxaJWPca2Fj5OLJoc,23725
@@ -102,7 +102,7 @@ mpf/core/show_controller.py,sha256=C9wtABHGZZ78vyHuFtS0gj6qFaXl_YTiLaGMf2iMMZg,6
 mpf/core/switch_controller.py,sha256=xwY7uc0UuixfeYtraUbh-XfpFitNzU3W2E6w-9bsyGc,30662
 mpf/core/system_wide_device.py,sha256=5e_nB3zYZSTjq_wTcbckSw7vxLtW7idIGk44Yby-cXE,431
 mpf/core/text_ui.py,sha256=sQNIqzTpkBS1gtjsQ3qDO_YcyzCuz0X6ViHgLhaH2jY,19088
-mpf/core/utility_functions.py,sha256=lY_EeksSDiooVgwfMATlFhOCYn3Z5IELaDOT3KqWoCU,30245
+mpf/core/utility_functions.py,sha256=XILkH65fVA4g0ikCEHoYeTyIT2pNw6WN89HCaE17_G0,30414
 mpf/core/bcp/__init__.py,sha256=MdDZJevywlYvFsmDNEOveGV-IiYMlR11c8bcIflo3zw,47
 mpf/core/bcp/bcp.py,sha256=CVJSVqDhDghJAQcL_hG6eiG9ukzEhGqF7OIq-nvYx0Y,4750
 mpf/core/bcp/bcp_client.py,sha256=o9sCF34Er-_c8aS5llok1bUoN9zk94lEZn8yTvGUpAI,1085
@@ -135,7 +135,7 @@ mpf/devices/flipper.py,sha256=QZIy0Zvkxhs3wlmp-uTd59awGF46_XuLYhyyTEOGMbg,12209
 mpf/devices/hardware_sound_system.py,sha256=XFq8LtyxwlDyCtZYvk-JSOms-CTAnTK4KXGOjeV60MQ,2406
 mpf/devices/kickback.py,sha256=ZkXvGDojfCF0w3Y4-QE6qX963tDDAN6zQ-XZ1bckG3g,748
 mpf/devices/light.py,sha256=pPBMlx0GM9OYiJfXxMmUV0IDUscPYidqEv7BGAnVE-g,36608
-mpf/devices/light_group.py,sha256=h9e5tBYI_kCva491P84LX71AVcweCaXFh72vZ2jwgG8,6768
+mpf/devices/light_group.py,sha256=PcujFBLSL1fCSOI7kQSQ-bu87n8ordvGBLbctGwpe4Y,7912
 mpf/devices/logic_blocks.py,sha256=paZV6FOuqSOEq2o4-bKNxKNJCUzbO0SNLDIbp9mnKPQ,24340
 mpf/devices/magnet.py,sha256=GsTTg4Te4OHRz-ZQJxIr8vTj86_VVg2xBXdx6iK88o0,5420
 mpf/devices/motor.py,sha256=014xbRpO6Je-glD1jz9hz7MuafBw_q2aKm2yrPHxZ5E,9728
@@ -266,7 +266,7 @@ mpf/platforms/virtual.py,sha256=NfyI80ZEnnAspDmy92K7AMjjisQ4KaCmzD7SuplzoWo,2608
 mpf/platforms/zedmd.py,sha256=hx0PXXbxJa35vufUgHByDLdpwMbkQaOmrcCz76YvFk4,4139
 mpf/platforms/fast/TODO.md,sha256=WzddBMV7jfNwzkzkYovpmYGX_NMGMQhTL0R7fkKLmIY,3087
 mpf/platforms/fast/__init__.py,sha256=79CsU79usuvjebPggPmvlZg5DrzdQ_nCTHGow-2T_V4,30
-mpf/platforms/fast/fast.py,sha256=HlQimgIlu9FoIpk-gKch25Sxhmj9aLtAwCErSFl-3_0,43380
+mpf/platforms/fast/fast.py,sha256=9fD00hzeRpd274TYDoUVIYKpZWA9NCdOM41pIeaIJe0,43553
 mpf/platforms/fast/fast_audio.py,sha256=OpSJZ1bU3qyLP_xWDPOfsGZYkmQHYhOOvcs4V5Ee17c,10281
 mpf/platforms/fast/fast_defines.py,sha256=tDHaJzF4i3PmQDf3Ymn06xC17irDkFsVcmXrrPaADTA,7300
 mpf/platforms/fast/fast_dmd.py,sha256=2wmbj95htWMRQWK2T83E9KCcRT2Q4sfJ5BkKOZQHy2M,662
@@ -274,7 +274,7 @@ mpf/platforms/fast/fast_driver.py,sha256=7mnn4_6WNjI8auWgIQXCfu7nUV3cA_umfQtH-n3
 mpf/platforms/fast/fast_exp_board.py,sha256=SC0h_SYkOsuwYLhOwIlt9U3P1Evy_6kKFr33-RjxTiQ,14904
 mpf/platforms/fast/fast_gi.py,sha256=daV7B7X1ApGkjzbd4YGxJ1AoRgoIC1Fx0UcBRquTzqU,1630
 mpf/platforms/fast/fast_io_board.py,sha256=psNIrZ3GooNejhfXy1Z7_KXtv6jdw6j4vzsj81CjSx0,1275
-mpf/platforms/fast/fast_led.py,sha256=gZ334LnVpaI0CSxs1JBfjvUrTXJcZ4r6XUTDrdVUhsI,6911
+mpf/platforms/fast/fast_led.py,sha256=HdgmqOAkGRR4v1bN2WFR8UO608kMDPZ2m5u7EiRmFcc,7605
 mpf/platforms/fast/fast_light.py,sha256=UeUdeRHgfrRpdZDd1KtNlmClkk3C0oRBQJahQHoMZSE,1905
 mpf/platforms/fast/fast_port_detector.py,sha256=jt8L3aIey1HZXiLUnnSSlg3aze2mzp8Cjb7ci_a-QQw,5022
 mpf/platforms/fast/fast_segment_display.py,sha256=DOrzzAWF0ztJHYK2yl2kLx_MUghBEbMVzungeOxSoyo,1739
@@ -350,7 +350,7 @@ mpf/platforms/trinamics/README,sha256=en6fywA6uVtkVWtnSh99qA7lIGBqtg-57xudNqRG1O
 mpf/platforms/trinamics/TMCL.py,sha256=yKzBBHqbFFw8_quIldt2oh1iVtSkX-xChLLlgRa3f2A,30543
 mpf/platforms/trinamics/__init__.py,sha256=w8UfkzSsOjidkOajJVAkRw1AXeFRN77jHPCyVh7YK18,30
 mpf/platforms/virtual_pinball/__init__.py,sha256=YBWkKGkc5GItvkPUFb6LMn5VYDoKH6uAPaQ0CDmNHU4,27
-mpf/platforms/virtual_pinball/virtual_pinball.py,sha256=QaXkCidsdDJEQhasW7zf5D0zhPhZUY7GmRxPgRoUdHU,19164
+mpf/platforms/virtual_pinball/virtual_pinball.py,sha256=TK5Zse36u98mGXBUebXZLouqZrJLFgg-oTBSPWyTgTI,19163
 mpf/platforms/visual_pinball_engine/__init__.py,sha256=8nICCe2NaXpfTUSTIA8VEVzuYxQaR9U232_9VoHTGNI,27
 mpf/platforms/visual_pinball_engine/generate.py,sha256=2xofapyggJEstxbOsCfdFvVsM7QZxeEgEuAeJAH0qwQ,588
 mpf/platforms/visual_pinball_engine/platform_pb2.py,sha256=5pPiv7pKibQ0GuPCv-CPZubwJUroKqcfXqCST1ofZvg,8781
@@ -450,7 +450,7 @@ mpf/tests/test_ConfigOldVersion.py,sha256=l1Uf-ZAxHGTbfIwJZRPggearqyD075MzKa7VTd
 mpf/tests/test_ConfigPlayers.py,sha256=hiNYK0puN0IE_hPfhVMrYQ5MSryUdI0xNY8ah86afSg,4919
 mpf/tests/test_ConfigProcessor.py,sha256=xzZ-kSooPX-AewZoDwU3sTXSFOPZ_QR5032igowoh3U,2497
 mpf/tests/test_CreditsMode.py,sha256=fR4kCC2HTTA9-bcZ2SNsM925mT9xAPJzA85NN8sHjHQ,17788
-mpf/tests/test_CustomCode.py,sha256=rMRgfM1AwYecEDnzVzNWlteGFP0xKo29vn10sCt8dz8,445
+mpf/tests/test_CustomCode.py,sha256=xPsQ6Ijs-kKbu05kWBRYm20olNXF8EuLdI21tWeYFrY,648
 mpf/tests/test_DataManager.py,sha256=WOC_AwrtXt5mzBBCqZ4Z2UWyZiP6fjn6I-iURwfYRJA,5350
 mpf/tests/test_Delay.py,sha256=r-ijAjNm4QQ5YRj8iA5ACQ14M2drU-nqir6fqFrBTos,4931
 mpf/tests/test_DeviceCollection.py,sha256=twCg7qAY6CYMw9F3rwxI0NP64gMHe9WhOlhsAgckvXE,1770
@@ -458,7 +458,7 @@ mpf/tests/test_DeviceDriver.py,sha256=Un6fAW_-wjmjX-GiiwdhuDXz8kTgW5r6jjASh-gdYe
 mpf/tests/test_DeviceFlasher.py,sha256=DbBULJDCL2KBsAepLtKXEUwP38Zb0aJVA42ncgNfNog,2201
 mpf/tests/test_DeviceGI.py,sha256=8IlcdwJPf1rMaofHYPBX8m82fwUgystmPyDjBbGicqw,1358
 mpf/tests/test_DeviceLight.py,sha256=LW2XoIBCh8O2U3eSE1eRvYcQD7n2_Fqf7v7fApa1M5c,22534
-mpf/tests/test_DeviceManager.py,sha256=fvINpL51HaiQHdzyCSzNM7Ur-L8kaOX-WF1TPg_dPcM,1741
+mpf/tests/test_DeviceManager.py,sha256=6BnNBgdNywipOwaRDzuqNwCbu_vPgjBGr9JSmTfA9pg,4153
 mpf/tests/test_DeviceMatrixLight.py,sha256=siJaDyaickqj9Vv1Qr5oD9Yf0YrZl-OIZPk1sOfdGiQ,2513
 mpf/tests/test_DigitalOutput.py,sha256=INYIhtJW0OVDsoUdq--4Fb-iHiqcKUfpbXbzV8cEzFQ,1256
 mpf/tests/test_DigitalScoreReels.py,sha256=BrCj_VovVvFi84ewPaFPKL6AO-p9Nnu6LBTkmCZJbLI,1905
@@ -466,7 +466,7 @@ mpf/tests/test_Diverter.py,sha256=12BHmcDmZz2yEuz4O6RvhHKdWO_SnZ0MdfJHZTuSKhE,26
 mpf/tests/test_Dmd.py,sha256=3caBAYOPNynnLzNZzjTvwxJApoiRRzdQlWoStIyEZRo,1332
 mpf/tests/test_DropTargets.py,sha256=BjowOQFA5fTkLR15StArXD_FBZxkrq86dtZ_GHsPNSc,18671
 mpf/tests/test_DualWoundCoil.py,sha256=rBfL56OOnY1ZzBxlZlPUeGsLtf9UlkyAdQRiGd2W28U,1883
-mpf/tests/test_EventManager.py,sha256=VEUHITtxApA3vHP0yN9CtaCUw7ybZJjAbbnNYY1JCK4,35867
+mpf/tests/test_EventManager.py,sha256=9KLT-zC9MBzhLhCAdKBQfv834ZyPHpEd_utPiOlK8po,37799
 mpf/tests/test_EventPlayer.py,sha256=rV1HK2C6iPvace-aD1zlLkdsUfYCvbBh1eNeVnY0G9M,10354
 mpf/tests/test_ExtraBall.py,sha256=xAt2s8IP4Eh7fAi2kPbKrw7pchpXsfVrLKEaPbcZiCQ,16388
 mpf/tests/test_Fadecandy.py,sha256=y7ZQkdGYmG6WXoi6kKMTxdRYymPhOc9SqHzbrkK9V60,8133
@@ -474,6 +474,7 @@ mpf/tests/test_Fast.py,sha256=6bbS_z3Dv6KP9GDirL7IhEnzCZ_2JfEkQNGPWDTCUGc,10711
 mpf/tests/test_Fast_Audio.py,sha256=50O_tWU350s1WXrre5X0TY9wmwgKRsyKph1Wvikr8Fg,6008
 mpf/tests/test_Fast_Dmd.py,sha256=0htPLOemtTi1EZa7LKVkANaP5RH_HpmknFKBKvePhFI,800
 mpf/tests/test_Fast_Exp.py,sha256=sxUe48fvFdzwqE_C4L7A9G1J5T96HuMWFkA4tzYdd7U,11324
+mpf/tests/test_Fast_Led.py,sha256=c26fRdwODDlsC1M6sue9CHCDyq0pdhr9d4wrUc7QTbs,2240
 mpf/tests/test_Fast_Nano.py,sha256=OcxiGiche1BfTulxchyePdbmJat6tTxVWyugNnAnBzw,33999
 mpf/tests/test_Fast_Neuron.py,sha256=c038-jFbv3f3TF_fPnNhRm-PY55jF_5uXOWwNz2QViA,40225
 mpf/tests/test_Fast_Retro.py,sha256=N-xiiNnMdY-KwB2zFyXhd1u9L0yMAGoPqS-i76bNAeA,19814
@@ -489,8 +490,8 @@ mpf/tests/test_HighScoreModeWithVars.py,sha256=zGrpvxJbxUteanOttPwmCLqUhPBPmQ-Xc
 mpf/tests/test_I2cServoController.py,sha256=osRF2mqK5BcYikb5iHTQVfkFCxN5T5vPlukSOR93lJ8,2493
 mpf/tests/test_InfoLights.py,sha256=ahslOuYGEDKwIyZ4lWU-4iwInHimfN0TnYwTxjqerpA,3370
 mpf/tests/test_Kickback.py,sha256=VQXMmVnfVNgfuKf9UnSjfJKOxcQfzznDqKBDykZIuY0,2119
-mpf/tests/test_LightGroups.py,sha256=bEN-7cPFwsR59JO-qOj5c0HrT6PRTw-GJT2fus3hyHg,6741
-mpf/tests/test_LightNumbering.py,sha256=mdJGj-HHsCGroNRp6_JPKExYPFzumVnanMN-qYG3IXA,1708
+mpf/tests/test_LightGroups.py,sha256=jIGBCrL63Mi6Oplq8P6pS3qw_WvXWARJ_2VnaXA5LU0,10570
+mpf/tests/test_LightNumbering.py,sha256=Hpgv0e5YbszlZJF_ZNEtcI3_FxssJJTsXdRqPaHZyC8,1701
 mpf/tests/test_LightPlayer.py,sha256=KieLKDzYtNF6XMHnHu1ez3f7AtjnuSh3EeB40buyRNo,15265
 mpf/tests/test_LightPositions.py,sha256=zAbifSeIqEQmNU5gZS3ImXuJY5PtrVW_qhrKjxhmQE0,834
 mpf/tests/test_LightSegmentDisplays.py,sha256=vvTIZQGQhzFOilWcKa_GwIulYyJS1pOHHdVV7dgRWKI,8866
@@ -523,7 +524,7 @@ mpf/tests/test_PololuMaestro.py,sha256=guKXqbW92Yu-FodrjRyr8Y1dBw6Y8lJvE48LMxpy5
 mpf/tests/test_PololuTic.py,sha256=WaKHMazooOok5PcQjaSurScO9FgUjc7aALd8DebQmi4,5033
 mpf/tests/test_QueueEventPlayer.py,sha256=hWX0sScrDgTVPr5q9vwH6lpe5lif6rhjTlc_kv9qGqM,4786
 mpf/tests/test_RGBColor.py,sha256=upiXfSN0rtDpgwFjPCC1jutuRwVcPfgWjYBgT8X7IKM,6517
-mpf/tests/test_RandomEventPlayer.py,sha256=iFi2CYKgFJSiA19--CO3yFH1KscmcKhpdoBzqXt0vZ0,4972
+mpf/tests/test_RandomEventPlayer.py,sha256=7L46cleZtx-Ka2mu0DaYOKweOl3iv267jmymfUI0mO0,4953
 mpf/tests/test_Randomizer.py,sha256=-LuhPfvDHyX0jkC3LZdZBUO7Dg1iKYSlpfsJwAzsj9o,11692
 mpf/tests/test_Rpi.py,sha256=QhHuLo7SsUtLfU8mNl_3HktGHn0pKLNG5VoT2-jWN0E,5703
 mpf/tests/test_RpiDmd.py,sha256=khG8rV34wZJ0mNSW0CCqNolXonGaBFojk5AUKLDeaT0,1584
@@ -535,7 +536,7 @@ mpf/tests/test_SequenceShot.py,sha256=cjgz717-fpfzyjr1nKueJncRqgfqXV9KIu5pp0UqbM
 mpf/tests/test_ServiceCli.py,sha256=vC5ph_zFMxRx5Jnet7ZY4LRSwACusbYUpie1S4AyxzM,5184
 mpf/tests/test_ServiceMode.py,sha256=Ohh6kcPBaha5xUL3ilay2YO-ZHJQOLdU2HDlJcMimL0,17058
 mpf/tests/test_Servo.py,sha256=Ge5qjUCFUkUgz2LeeN2XiHiD2A4jZnCB-UmlPWuYKCE,2927
-mpf/tests/test_Settings.py,sha256=ZuDgdb1h5Ui0atT2Q3Quosgr1xINfk9W-8Apwhd3yag,844
+mpf/tests/test_Settings.py,sha256=3MbSiIZnXelcaxqbHRXCP0_8worAWL-BFdKLjNQmkYY,1839
 mpf/tests/test_ShotGroups.py,sha256=mwSa8z2wcg02IeecQCrROZRutsGyb9Y1bjuoP0dzESE,18353
 mpf/tests/test_Shots.py,sha256=tftWsVXkiCXhNJ0EcUd92pDd5f8KHvBxYRnuor7xyRs,37943
 mpf/tests/test_ShowPools.py,sha256=kPdZLW0bqLeji60_kInCFA4ZWY8YyhewH38tZDoP5Mg,2485
@@ -561,7 +562,7 @@ mpf/tests/test_TooLongExitCountDelay.py,sha256=2qpMlq1lif4xmPn-VXj3vQG5QDufhJz2G
 mpf/tests/test_TrinamicsStepRocker.py,sha256=KWUD1JVf4R81f5Du1xyX2oQYOonxyInoItO5QzafscM,3289
 mpf/tests/test_TroughEntranceSwitch.py,sha256=PRCTPxtJ2D4j0zZhY9SXO7SFUkJcUF1zHgE_uRKPsgc,1654
 mpf/tests/test_TwitchClient.py,sha256=2XJNcaNkgsfyZCk0BaVFsJCRus5nSg4hHE6-uHaGil0,6993
-mpf/tests/test_Utility_Functions.py,sha256=s3SAf5nQF0qCS24zGdCTO6H2LE_F-tooscFIvvuVhqY,8621
+mpf/tests/test_Utility_Functions.py,sha256=_JTtApKS6_hvmEEKm9vpuzMeTORQCDdfZkZ2PzPvsJo,10230
 mpf/tests/test_VPX.py,sha256=-RhGgzWHCFfv0meRY4jMXDaltmSs5J4b5ba8qkzrtU0,7802
 mpf/tests/test_VariablePlayer.py,sha256=Pe2TihiarrjsL1knzViv52gu5jo5BlurNH8GCczPXvc,10282
 mpf/tests/test_Virtual.py,sha256=hiiUjIVY3bmFZvRKgBTOhVmlV2ASzfML4o8pRhsz3CI,612
@@ -592,7 +593,7 @@ mpf/tests/machine_files/asset_manager/shows/custom1/show13.yaml,sha256=_P-fejT-l
 mpf/tests/machine_files/asset_manager/shows/on_demand/show5.yaml,sha256=_P-fejT-lM_Ri5FA0GP9tAY7ILw9h6oaW4nbt-kbIjw,527
 mpf/tests/machine_files/asset_manager/shows/preload/show4.yaml,sha256=_P-fejT-lM_Ri5FA0GP9tAY7ILw9h6oaW4nbt-kbIjw,527
 mpf/tests/machine_files/asset_manager/shows/preload/subfolder/show4b.yaml,sha256=_P-fejT-lM_Ri5FA0GP9tAY7ILw9h6oaW4nbt-kbIjw,527
-mpf/tests/machine_files/auditor/config/config.yaml,sha256=57a420Y5BCJcirw57pxx6SovwyXdEv7gxjYo9WW8L54,388
+mpf/tests/machine_files/auditor/config/config.yaml,sha256=Ao7PrPMiBrRXk0WEdp3-0TsSKZ4_PtVnsE_4vsqtD0s,387
 mpf/tests/machine_files/auditor/modes/base/config/base.yaml,sha256=HcnCQGbaVT6i9NJwUNL5fWj36Jhcnl7zykghnPGrY6A,261
 mpf/tests/machine_files/autofire/config/config.yaml,sha256=7LL4RB24kSi7eQICGRdWbRxFmLIWKJZ7DSEHuZYyAFs,1487
 mpf/tests/machine_files/ball_controller/config/config.yaml,sha256=a6DMjD4_Xts1KJ3UBDDtDgbybYKdDaEHjOHN6feYdyE,1068
@@ -697,7 +698,7 @@ mpf/tests/machine_files/credits/config/config_freeplay.yaml,sha256=6JMbjmjsS8yK8
 mpf/tests/machine_files/credits/config/config_inhibit.yaml,sha256=MYAjgeSHE6iV6rh1YV4a3-WEI_5qv-3QrYYn_35YOkY,367
 mpf/tests/machine_files/credits/modes/credits/config/config.yaml,sha256=N9dGGiwQH67CsEhAtWE31OwumVGyoztTVzaGkRXs9zY,107
 mpf/tests/machine_files/custom_code/code/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mpf/tests/machine_files/custom_code/code/test_code.py,sha256=mzIpK_mAg0c_DsJ43zAb_8ekRoLr89cwc34F3AfpvCI,309
+mpf/tests/machine_files/custom_code/code/test_code.py,sha256=KHrkCVTVhvoW_uCmhA2JoI6XcTXneLCKLSVxg90Dk_E,490
 mpf/tests/machine_files/custom_code/config/config.yaml,sha256=roJzS_8FhnvK1UzWG9DyqPpG0N1NMmZm7PtbQSR4az8,380
 mpf/tests/machine_files/data_manager/config/config.yaml,sha256=I0aiEhNSdlLMRlJKtcbAgPV_48725L7lDWr3wbqjx70,164
 mpf/tests/machine_files/device/config/coils.yaml,sha256=HlzikHgj_AGzGp0oll3IITEkRONMEkKN8gZP8cq67zQ,533
@@ -726,8 +727,8 @@ mpf/tests/machine_files/dmd/config/testRgbDmd.yaml,sha256=3bgVH7UjPRHLZbYw1q_n43
 mpf/tests/machine_files/drop_targets/config/test_drop_targets.yaml,sha256=58vBTtYMhdwkjW9TpJDWQQWFdjkRcYUyKlK3BXQeXFE,1710
 mpf/tests/machine_files/drop_targets/config/test_multiple_drop_resets_on_startup.yaml,sha256=ht-FfB-8ZjujnGSWcW9DN4F9zKIcp82AQaj90ElYNSU,337
 mpf/tests/machine_files/drop_targets/modes/mode1/config/mode1.yaml,sha256=znSa7PmrvBTspwQ34o7fSlCl3n5NtvLWizI-3_0Su4Q,186
-mpf/tests/machine_files/event_manager/config/test_event_manager.yaml,sha256=F6ZBH8l6teXjiFJnB8h_dDbx4X6dJNX_1uPyEwNJqeY,406
-mpf/tests/machine_files/event_manager/modes/game_mode/config/game_mode.yaml,sha256=TI77DsAmpqUBxmpchBEqdRO7t6m7XJ3Rn6RMi5HBnOE,172
+mpf/tests/machine_files/event_manager/config/test_event_manager.yaml,sha256=r0bFMKucXaxG68fqCThIGBCPXSUWHRNaktlnx0RpX88,582
+mpf/tests/machine_files/event_manager/modes/game_mode/config/game_mode.yaml,sha256=Wcvh7mSDILzKTrv7Lh3IPjtlCAnFgs7AsC2TGu9lBr4,421
 mpf/tests/machine_files/event_manager/modes/test_mode/config/test_mode.yaml,sha256=8_LOBAMFabPcT1u-fncfQ0NsPW0UatSsUxquU4FOgVA,552
 mpf/tests/machine_files/event_players/config/test_event_player.yaml,sha256=oxWJElrLOfctXEXz_cDyabFYpJgfyh9qCNM3lYHGCYY,2092
 mpf/tests/machine_files/event_players/config/test_queue_event_player.yaml,sha256=-guARDhqONBsw__GRqBKwxwAufnehQrBz7YK0sQYWwg,414
@@ -763,7 +764,7 @@ mpf/tests/machine_files/kickback/config/config.yaml,sha256=VTfx491DKfYxcDdCnB2th
 mpf/tests/machine_files/light/config/light.yaml,sha256=4NjJ-yL1O9o_jNYO6NGy6DTt2BGzDMs86usnrBDVJ0o,964
 mpf/tests/machine_files/light/config/light_autonumber.yaml,sha256=ZAwGXze2wlk0FFBKgTAxz_beRFpItKSNRrwabX5dr4I,213
 mpf/tests/machine_files/light/config/light_default_color_correction.yaml,sha256=h7ZSv7uSJRG57hpxUqy7SMX4VqWftBk0b12YjuZ4fu0,309
-mpf/tests/machine_files/light/config/light_groups.yaml,sha256=TVZZrh58gCUVl3PCK6LOpwCJpMreMNGqZnM2h9RPwHw,833
+mpf/tests/machine_files/light/config/light_groups.yaml,sha256=GEwMtLaa3OXUlkOMh4oCssYnBXz2q9-CZgahZJE6rvY,1071
 mpf/tests/machine_files/light/config/lights_on_drivers.yaml,sha256=Wc6GPnlAdL8D9H58SZQtjDY9Pc4c0Bz7ASMvafAwrPo,215
 mpf/tests/machine_files/light/config/matrix_lights.yaml,sha256=ntmFDNeNg8XLopCeyWwD3quh1qm7cxyylrK8zrFDBgs,178
 mpf/tests/machine_files/light_player/config/light_player.yaml,sha256=HhgenUx6hk65xibQwjXb08LGulu5fi_b25otcYU50DY,1177
@@ -881,9 +882,9 @@ mpf/tests/machine_files/segment_display/config/game.yaml,sha256=xCGQxOFaqm1mSl-K
 mpf/tests/machine_files/segment_display/modes/mode1/config/mode1.yaml,sha256=30Xo3grYQG3zypICRnb1mbz8mY78BDweMcajpINhkC0,173
 mpf/tests/machine_files/sequence_shot/config/config.yaml,sha256=ate99LsEy9czRLDJSyC1PFxxvxC15TsdlQ1xr-ZIiNA,2028
 mpf/tests/machine_files/sequence_shot/modes/mode1/config/mode1.yaml,sha256=jufw8bwnOoPtAwyGpouWNnmcpqvWxflb9zWYGWZcKxg,489
-mpf/tests/machine_files/service_mode/config/config.yaml,sha256=qvqf77vl8Sbqg5hm8b4TDjKD4seCu1MvGd8-TM_-Ss0,1417
+mpf/tests/machine_files/service_mode/config/config.yaml,sha256=3tLwdjr6YR_vezJywbEAZvRj9hWF4F3glzl-vQlSYCw,1416
 mpf/tests/machine_files/servo/config/config.yaml,sha256=iJXZsC5xVrQnRkwF9adAxsuiBGiVBqGA4gSpFlKAFIQ,481
-mpf/tests/machine_files/settings/config/config.yaml,sha256=CERk0G2viSxZoIgdV79DPKg_jWFqxY6haFDbRfOh8Ec,423
+mpf/tests/machine_files/settings/config/config.yaml,sha256=wqNkyp6lIGb5ds9OFKbTOl2yLJmnxIEo9J4Cm5Pbq-w,1064
 mpf/tests/machine_files/shots/config/test_shot_group_rotate_with_exclude.yaml,sha256=rDXihcEySJErepBjUEewpaPDm4xoVGPZ1pcZv3SYin8,209
 mpf/tests/machine_files/shots/config/test_shot_groups.yaml,sha256=pT808F42hPuEquQxRfpiClVZU336ZKYIU9GKCoP1wjQ,1678
 mpf/tests/machine_files/shots/config/test_shots.yaml,sha256=7nXSIgBmq75TumSfXAWlul5EzIxwCg_d-oYtA8Zbkjs,2461
@@ -960,10 +961,10 @@ mpf/tests/regression_tests/shots_with_token_in_profile_and_shot.yaml,sha256=uyRp
 mpf/tests/regression_tests/show_player_subscriptions.yaml,sha256=JJJ72Kmc6p4dQB9NA78DcR8JEbHTpurclYUCpTX8Cug,2206
 mpf/wire/base.py,sha256=6AsVN7gxAdSP40T1SIABplUbiYRqOp37x-2w_CE8fcQ,11581
 mpf/wire/fast.py,sha256=XmqBuwM1CZ102LQXNy26SqTy75HuOuCmfkQA9Xc2MiM,20521
-mpf-0.81.0.dev2.dist-info/licenses/AUTHORS.md,sha256=izUqN5WUC6FV2pUURPUiD308hYo_JREH_ENeTsEstLg,1445
-mpf-0.81.0.dev2.dist-info/licenses/LICENSE.md,sha256=dMfwSWLbBdRZPIahHwQoMq_dxiZxOxVRLiTZ6GE_5wo,1119
-mpf-0.81.0.dev2.dist-info/METADATA,sha256=X45Xqy8f28EQN3Geo9B25Dpu8qZTt70JsdIK6jG8TVY,6021
-mpf-0.81.0.dev2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-mpf-0.81.0.dev2.dist-info/entry_points.txt,sha256=FMGV1EnYmb_MOBOb2nMg-kpgMbqk5HItDSA1rkkjnAM,59
-mpf-0.81.0.dev2.dist-info/top_level.txt,sha256=K6To2MlFIMFjYIQIVaql2hOPCpu_yzao6_OotT3n5pw,4
-mpf-0.81.0.dev2.dist-info/RECORD,,
+mpf-0.81.0.dev3.dist-info/licenses/AUTHORS.md,sha256=izUqN5WUC6FV2pUURPUiD308hYo_JREH_ENeTsEstLg,1445
+mpf-0.81.0.dev3.dist-info/licenses/LICENSE.md,sha256=dMfwSWLbBdRZPIahHwQoMq_dxiZxOxVRLiTZ6GE_5wo,1119
+mpf-0.81.0.dev3.dist-info/METADATA,sha256=haS2MRSNrSOH-fSfOUwTQQHGzpnACGP6VeUiWETzw_0,6013
+mpf-0.81.0.dev3.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+mpf-0.81.0.dev3.dist-info/entry_points.txt,sha256=FMGV1EnYmb_MOBOb2nMg-kpgMbqk5HItDSA1rkkjnAM,59
+mpf-0.81.0.dev3.dist-info/top_level.txt,sha256=K6To2MlFIMFjYIQIVaql2hOPCpu_yzao6_OotT3n5pw,4
+mpf-0.81.0.dev3.dist-info/RECORD,,

{mpf-0.81.0.dev2.dist-info → mpf-0.81.0.dev3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (83.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any