mpf 0.81.0.dev4__tar.gz → 0.81.0.dev5__tar.gz

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpf
-Version: 0.81.0.dev4
+Version: 0.81.0.dev5
 Summary: The Mission Pinball Framework (MPF)
 Author-email: The Mission Pinball Framework Team <brian@missionpinball.org>
 License: MIT

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/mpf/_version.py

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

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/mpf/commands/__init__.py

@@ -1,9 +1,9 @@
 """MPF CLI commands."""
 import argparse
 from importlib import import_module
+import importlib.metadata
 import os
 import sys
-from pkg_resources import iter_entry_points
 
 
 import mpf.core
@@ -137,7 +137,8 @@ class CommandLineUtility(MpfCommandLineParser):
 
         This is used from mpf mc.
         """
-        for entry_point in iter_entry_points(group='mpf.command', name=None):
+        eps = importlib.metadata.entry_points(group='mpf.command')
+        for entry_point in eps:
             command, function_ref = entry_point.load()()
             self.external_commands[command] = function_ref
 

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/mpf/commands/game.py

@@ -31,13 +31,11 @@ class Command:
         self.machine = None
         self._sigint_count = 0
 
-        parser = argparse.ArgumentParser(
-            description='Starts the MPF game engine')
+        parser = argparse.ArgumentParser(description='Starts the MPF game engine')
 
         parser.add_argument("-a",
                             action="store_true", dest="no_load_cache",
-                            help="Forces the config to be loaded from files "
-                                 "and not cache")
+                            help="Forces the config to be loaded from files and not cache")
 
         parser.add_argument("-A",
                             action="store_false", dest="create_config_cache",
@@ -45,24 +43,24 @@ class Command:
 
         parser.add_argument("-b",
                             action="store_false", dest="bcp", default=True,
-                            help="Runs MPF without making a connection "
-                                 "attempt to a BCP Server")
+                            help="Runs MPF without making a connection attempt to a BCP Server")
 
         parser.add_argument("-c",
                             action="store", dest="configfile",
                             default="config.yaml", metavar='config_file',
-                            help="The name of a config file to load. Default "
-                                 "is "
-                                 "config.yaml. Multiple files can be used "
-                                 "via a comma-"
+                            help="The name of a config file to load. Default is "
+                                 "config.yaml. Multiple files can be used via a comma-"
                                  "separated list (no spaces between)")
 
+        parser.add_argument("-e",
+                            action="store_false", dest="echo_args", default=True,
+                            help="Stop logging the raw command line arguments on startup.")
+
         parser.add_argument("-f",
                             action="store_true", dest="force_assets_load",
                             default=False,
                             help="Load all assets upon startup.  Useful for "
-                            "ensuring all assets are set up properly "
-                            "during development.")
+                            "ensuring all assets are set up properly during development.")
 
         parser.add_argument("-pit", action="store", dest="platform_integration_test",
                             metavar='pit_file', default=False,
@@ -91,8 +89,8 @@ class Command:
 
         parser.add_argument("-P",
                             action="store_true", dest="production", default=False,
-                            help="Production mode. Will suppress errors, wait for hardware on start and "
-                                 "try to exit when startup fails. Run this inside a loop.")
+                            help="Production mode. Will suppress errors, wait for hardware on start "
+                                 "and try to exit when startup fails. Run this inside a loop.")
 
         parser.add_argument("-t",
                             action="store_false", dest='text_ui', default=True,
@@ -102,43 +100,35 @@ class Command:
                             action="store_const", dest="loglevel",
                             const=logging.DEBUG,
                             default=15,
-                            help="Enables verbose logging to the"
-                                 " log file")
+                            help="Enables verbose logging to the log file")
 
         parser.add_argument("-V",
                             action="store_const", dest="consoleloglevel",
                             const=logging.DEBUG,
                             default=logging.INFO,
                             help="Enables verbose logging to the console. DO "
-                                 "NOTE: you must also use -v for "
-                                 "this to work.")
+                                 "NOTE: you must also use -v for this to work.")
 
         parser.add_argument("-x",
                             action="store_const", dest="force_platform",
                             const='virtual',
-                            help="Forces the virtual platform to be "
-                                 "used for all devices")
+                            help="Forces the virtual platform to be used for all devices")
 
         parser.add_argument("--vpx",
                             action="store_const", dest="force_platform",
                             const='virtual_pinball',
-                            help="Forces the virtual_pinball platform to be "
-                                 "used for all devices")
+                            help="Forces the virtual_pinball platform to be used for all devices")
 
         parser.add_argument("--syslog_address",
                             action="store", dest="syslog_address",
-                            help="Log to the specified syslog address. This "
-                                 "can be a domain socket such as /dev/og on "
-                                 "Linux or /var/run/syslog on Mac. "
-                                 "Alternatively, you an specify host:port for "
-                                 "remote logging over UDP.")
+                            help="Log to the specified syslog address. This can be a domain socket "
+                                 "such as /dev/og on Linux or /var/run/syslog on Mac. Alternatively, "
+                                 "you an specify host:port for remote logging over UDP.")
 
         parser.add_argument("-X",
                             action="store_const", dest="force_platform",
                             const='smart_virtual',
-                            help="Forces the smart virtual platform to be "
-                                 "used for all"
-                                 " devices")
+                            help="Forces the smart virtual platform to be used for all devices")
 
         self.args = parser.parse_args(args)
         self.args.configfile = Util.string_to_event_list(self.args.configfile)
@@ -213,6 +203,10 @@ class Command:
 
         signal.signal(signal.SIGINT, self.sigint_handler)
 
+        if self.args.echo_args:
+            raw_cmd = " ".join(args) if args else "[None]"
+            logger.info("Raw command line: %s", raw_cmd)
+
         if not self.args.production:
             config_loader = YamlMultifileConfigLoader(machine_path, self.args.configfile,
                                                       not self.args.no_load_cache, self.args.create_config_cache)

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/mpf/config_spec.yaml

@@ -1446,6 +1446,7 @@ shots:
     switches: list|machine(switches)|None
     start_enabled: single|bool|None
     delay_switch: dict|machine(switches):ms|None
+    delay_event_list: dict|event_handler:ms|None
     persist_enable: single|bool|true
     playfield: single|machine(playfields)|playfield
     priority: single|int|0

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/mpf/core/config_spec_loader.py

@@ -1,7 +1,6 @@
 """Parse config_spec."""
 from typing import TYPE_CHECKING
-
-from pkg_resources import iter_entry_points
+import importlib.metadata
 
 from mpf.core.utility_functions import Util
 from mpf.file_interfaces.yaml_interface import YamlInterface
@@ -39,7 +38,8 @@ class ConfigSpecLoader:
     @staticmethod
     def load_external_platform_config_specs(config):
         """Load config spec for external platforms."""
-        for platform_entry in iter_entry_points(group='mpf.platforms'):
+        eps = importlib.metadata.entry_points(group='mpf.platforms')
+        for platform_entry in eps:
             config_spec = platform_entry.load().get_config_spec()
 
             if config_spec:

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/mpf/core/machine.py

@@ -1,6 +1,7 @@
 # pylint: disable-msg=too-many-lines
 """Contains the MachineController base class."""
 import asyncio
+import importlib.metadata
 import logging
 import subprocess
 import sys
@@ -8,7 +9,6 @@ import threading
 from typing import Any, Callable, Dict, List, Set, Optional, TYPE_CHECKING
 
 from packaging import version
-from pkg_resources import iter_entry_points
 
 from mpf._version import __version__
 from mpf.core.clock import ClockBase
@@ -399,25 +399,35 @@ class MachineController(LogMixin):
     def _register_system_events(self) -> None:
         """Register default event handlers."""
         self.events.add_handler('quit', self.stop)
-        self.events.add_handler('request_soft_shutdown', self.request_soft_shutdown)
-        self.events.add_handler(self.config['mpf']['switch_tag_event'].
-                                replace('%', 'quit'), self.stop)
+
+        self.events.add_handler(self.config['mpf']['switch_tag_event']. replace('%', 'quit'), self.stop)
+
+        self.events.add_handler('request_soft_shutdown', self._request_soft_shutdown)
+        '''Event: request_soft_shutdown
+        Desc: Trigger a soft shutdown request sequence.
+
+        This event is not itself the boolean event, instead it tells the
+        machine to start its machine_request_shutdown boolean event
+        sequence, which other code can hook onto to deny the request.
+
+        args:
+        reason: Optional, the reason for the shutdown request.
+        '''
 
     def _register_config_players(self) -> None:
         """Register config players."""
-        # todo move this to config_player module
+        # TODO move this to config_player module
         for name, module_class in self.config['mpf']['config_players'].items():
             config_player_class = Util.string_to_class(module_class)
-            setattr(self, '{}_player'.format(name),
-                    config_player_class(self))
+            setattr(self, '{}_player'.format(name), config_player_class(self))
 
         self._register_plugin_config_players()
 
     def _register_plugin_config_players(self):
         """Register plugin config players."""
         self.debug_log("Registering Plugin Config Players")
-        for entry_point in iter_entry_points(group='mpf.config_player',
-                                             name=None):
+        eps = importlib.metadata.entry_points(group='mpf.config_player')
+        for entry_point in eps:
             self.debug_log("Registering %s", entry_point)
             name, player = entry_point.load()(self)
             setattr(self, '{}_player'.format(name), player)
@@ -611,15 +621,14 @@ class MachineController(LogMixin):
 
             else:
                 # check entry points
-                entry_points = list(iter_entry_points(group='mpf.platforms', name=name))
-                if entry_points:
+                eps = list(importlib.metadata.entry_points(group='mpf.platforms', name=name))
+                if eps:
                     # load platform from entry point
                     self.debug_log("Loading platform %s from external entry_point", name)
-                    if len(entry_points) != 1:
-                        raise AssertionError("Got more than one entry point for platform {}: {}".format(name,
-                                                                                                        entry_points))
+                    if len(eps) != 1:
+                        raise AssertionError("Got multiple entry point for platform {}: {}".format(name, eps))
 
-                    hardware_platform = entry_points[0].load()
+                    hardware_platform = eps[0].load()
                 else:
                     raise AssertionError("Unknown platform {}".format(name))
 
@@ -816,10 +825,22 @@ class MachineController(LogMixin):
         except (subprocess.SubprocessError, OSError) as e:
             self.error_log("Failed to execute exit command: %s", e)
 
-    def request_soft_shutdown(self, **_kwargs) -> None:
+    def _request_soft_shutdown(self, reason=None, **_kwargs) -> None:
         """Attempt to soft shut down, allowing hooks to deny the request."""
-        self.warning_log("Attempting soft shutdown")
+        if not reason:
+            self.warning_log("Attempting soft shutdown.")
+        else:
+            self.warning_log("Attempting soft shutdown. Reason: {%s}", reason)
+
         self.events.post_boolean('machine_request_shutdown', callback=self._result_of_shutdown_request)
+        '''event: machine_request_shutdown
+        desc: This event is posted when to something has instructed the machine
+        to attempt to soft power down.
+
+        This is a boolean event. Any handler can return *False* and the
+        soft power down will not continue. Otherwise when this event is
+        done processing, the soft power down will proceed.
+        '''
 
     def _result_of_shutdown_request(self, ev_result=True):
         """Handle the result of the shutdown request.

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/mpf/devices/combo_switch.py

@@ -51,6 +51,8 @@ class ComboSwitch(SystemWideDevice, ModeDevice):
 
     def device_loaded_in_mode(self, mode: Mode, player: Player):
         """Add event handlers."""
+        # Start from scratch: switches already held when the mode starts do not count.
+        self._reset_state()
         self._add_switch_handlers()
 
     def _add_switch_handlers(self):
@@ -88,6 +90,15 @@ class ComboSwitch(SystemWideDevice, ModeDevice):
         self._remove_switch_handlers()
         self._kill_delays()
 
+        # Ensure reset to inactive state when mode ends, in case combo switch event triggers mode end,
+        # or the combo switch was partially engaged as mode ended.
+        self._reset_state()
+
+    def _reset_state(self):
+        self._state = 'inactive'
+        self._switches_1_active = False
+        self._switches_2_active = False
+
     def _register_switch_handlers(self):
         for switch in self.config['switches_1']:
             self._switch_handlers.append(switch.add_handler(self._switch_1_went_active, state=1, return_info=True))

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/mpf/devices/light.py

@@ -47,7 +47,7 @@ class LightStackEntry:
             self.key, self.start_color, self.start_time, self.dest_color, self.dest_time, self.priority)
 
 
-@DeviceMonitor(_color="color", _do_not_overwrite_setter=True)
+@DeviceMonitor(_color="color", address="address", _do_not_overwrite_setter=True)
 class Light(SystemWideDevice, DevicePositionMixin):
 
     """A light in a pinball machine."""
@@ -57,12 +57,13 @@ class Light(SystemWideDevice, DevicePositionMixin):
     class_label = 'light'
 
     __slots__ = ["hw_drivers", "platforms", "delay", "default_fade_ms", "_color_correction_profile", "stack",
-                 "_off_color", "_drivers_loaded", "_last_fade_target", "_rbgw_style"]
+                 "_off_color", "_drivers_loaded", "_last_fade_target", "_rbgw_style", "address"]
 
     def __init__(self, machine, name):
         """Initialize light."""
         self.hw_drivers = {}        # type: Dict[str, List[LightPlatformInterface]]
         self.platforms = set()      # type: Set[LightsPlatform]
+        self.address = None
         super().__init__(machine, name)
         self.machine.light_controller.initialize_light_subsystem()
         self.delay = DelayManager(self.machine)
@@ -127,16 +128,24 @@ class Light(SystemWideDevice, DevicePositionMixin):
     @staticmethod
     def _check_duplicate_light_numbers(machine: MachineController, **kwargs):
         del kwargs
-        check_set = set()
+        driver_registry = {}
+
         for light in machine.lights.values():
             for drivers in light.hw_drivers.values():
                 for driver in drivers:
                     key = (light.config['platform'], driver.number, type(driver))
-                    if key in check_set:
-                        raise ConfigFileError(f"Duplicate number {type(driver)} {driver.number} for light {light}",
-                                              10, "light", key, "light")
 
-                    check_set.add(key)
+                    if key in driver_registry:
+                        existing_light = driver_registry[key]
+
+                        new_light_name = getattr(light, 'name', light)
+                        old_light_name = getattr(existing_light, 'name', existing_light)
+                        raise ConfigFileError(
+                            f"Hardware address conflict! Driver number '{driver.number}' "
+                            f"is assigned to light '{new_light_name}', but it is already "
+                            f"claimed by light '{old_light_name}'.", 10, "light", key, "light")
+
+                    driver_registry[key] = light
 
     def _color_letter_to_name(self, letter):
         if letter == 'r':
@@ -171,13 +180,16 @@ class Light(SystemWideDevice, DevicePositionMixin):
 
     async def _initialize(self):
         await super()._initialize()
+        self.address = None
         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.address = f'prev: {start_channel}'
                 self._load_hw_driver_sequentially(start_channel)
             elif self.config['start_channel']:
+                self.address = f'channel: {self.config["start_channel"]}'
                 self._load_hw_driver_sequentially(self.config['start_channel'])
             else:
                 self._load_hw_drivers()
@@ -274,6 +286,7 @@ class Light(SystemWideDevice, DevicePositionMixin):
             self.raise_config_error("Light {} cannot contain platform/platform_settings/number and channels".
                                     format(self.name), 5)
         channels = self.config['channels']
+        self.address = f'channels: {channels}'
 
         # ensure that each color's channels are a list, not single value
         for channel in channels:
@@ -289,6 +302,7 @@ class Light(SystemWideDevice, DevicePositionMixin):
 
         try:
             channel_list = platform.parse_light_number_to_channels(self.config['number'], self.config['subtype'])
+            self.address = f'number: {self.config["number"]}'
         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)

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/mpf/devices/shot.py

@@ -55,8 +55,7 @@ class Shot(EnableDisableMixin, ModeDevice):
 
         for switch in self.config['switches'] + list(self.config['delay_switch'].keys()):
             # mark the playfield active no matter what
-            switch.add_handler(self._mark_active,
-                               callback_kwargs={'playfield': switch.config['playfield']})
+            switch.add_handler(self._mark_active, callback_kwargs={'playfield': switch.config['playfield']})
 
     def _mark_active(self, playfield, **kwargs):
         """Mark playfield active."""
@@ -85,17 +84,27 @@ class Shot(EnableDisableMixin, ModeDevice):
 
     def _register_switch_handlers(self):
         self._handlers = []
+        priority = self.mode.priority + self.config['priority']
         for switch in self.config['switches']:
             self._handlers.append(self.machine.events.add_handler("{}_active".format(switch.name),
                                                                   self.event_hit,
-                                                                  priority=self.mode.priority + self.config['priority'],
+                                                                  priority=priority,
                                                                   blocking_facility="shot"))
 
-        for switch in list(self.config['delay_switch'].keys()):
+        for switch, ms in list(self.config['delay_switch'].items()):
             self._handlers.append(self.machine.events.add_handler("{}_active".format(switch.name),
                                                                   self._delay_switch_hit,
-                                                                  switch_name=switch.name,
-                                                                  priority=self.mode.priority + self.config['priority'],
+                                                                  name=switch.name,
+                                                                  ms=ms,
+                                                                  priority=priority,
+                                                                  blocking_facility="shot"))
+
+        for event, ms in list(self.config['delay_event_list'].items()):
+            self._handlers.append(self.machine.events.add_handler(event,
+                                                                  self._delay_switch_hit,
+                                                                  name=event,
+                                                                  ms=ms,
+                                                                  priority=priority,
                                                                   blocking_facility="shot"))
 
     def _remove_switch_handlers(self):
@@ -406,18 +415,17 @@ class Shot(EnableDisableMixin, ModeDevice):
                 callback(name=self.name, profile=profile, state=state)
 
     @event_handler(4)
-    def _delay_switch_hit(self, switch_name, **kwargs):
+    def _delay_switch_hit(self, name, ms, **kwargs):
         del kwargs
         if not self.enabled:
             return
 
-        self.delay.reset(name=switch_name + '_delay_timer',
-                         ms=self.config['delay_switch']
-                                       [self.machine.switches[switch_name]],
+        self.delay.reset(name=name + '_delay_timer',
+                         ms=ms,
                          callback=self._release_delay,
-                         switch=switch_name)
+                         switch=name)
 
-        self.active_delays.add(switch_name)
+        self.active_delays.add(name)
 
     def _release_delay(self, switch):
         self.active_delays.remove(switch)

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/mpf/devices/switch.py

@@ -17,7 +17,7 @@ if TYPE_CHECKING:
     from mpf.core.platform import SwitchPlatform    # pylint: disable-msg=cyclic-import,unused-import
 
 
-@DeviceMonitor("state", "recycle_jitter_count")
+@DeviceMonitor("state", "recycle_jitter_count", "number")
 class Switch(SystemWideDevice, DevicePositionMixin):
 
     """A switch in a pinball machine."""
@@ -27,12 +27,13 @@ class Switch(SystemWideDevice, DevicePositionMixin):
     class_label = 'switch'
 
     __slots__ = ["hw_switch", "state", "hw_state", "invert", "recycle_secs", "recycle_clear_time",
-                 "recycle_jitter_count",  "last_change", "_events_to_post", "_mutes"]
+                 "recycle_jitter_count",  "last_change", "_events_to_post", "_mutes", "number"]
 
     def __init__(self, machine: MachineController, name: str) -> None:
         """Initialize switch."""
         self.hw_switch = None   # type: Optional[SwitchPlatformInterface]
         self.platform = None    # type: Optional[SwitchPlatform]
+        self.number = None
         super().__init__(machine, name)
 
         self.state = 0
@@ -134,6 +135,8 @@ class Switch(SystemWideDevice, DevicePositionMixin):
         self.platform = self.machine.get_platform_sections(
             'switches', self.config['platform'])
 
+        self.number = self.config.get('number', None)
+
         if self.config['type'].upper() == 'NC':
             self.invert = 1
 

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/mpf/platforms/fast/fast.py

@@ -121,9 +121,16 @@ class FastHardwarePlatform(ServoPlatform, LightsPlatform, RgbDmdPlatform,
             info_string += f"{port.upper()}: {self.serial_connections[port].remote_model} " + \
                 f"v{self.serial_connections[port].remote_firmware}\n"
 
-        info_string += "\nI/O Boards:\n"
-        for board in self.io_boards.values():
-            info_string += board.get_description_string() + "\n"
+        if self.io_boards.values():
+            info_string += "\nI/O Boards:\n"
+            for board in self.io_boards.values():
+                info_string += board.get_description_string() + "\n"
+
+        if self.exp_boards_by_name.values():
+            info_string += "\nEXP Boards:\n"
+            for board in self.exp_boards_by_name.values():
+                info_string += board.get_description_string() + "\n"
+
         return info_string
 
     async def initialize(self):
@@ -1018,5 +1025,4 @@ class FastHardwarePlatform(ServoPlatform, LightsPlatform, RgbDmdPlatform,
 
     def report_soft_power_down_request(self):
         """Neuron soft power requesting shutdown."""
-        self.warning_log("Neuron soft power down requested.")
-        self.machine.request_soft_shutdown()
+        self.machine.events.post("request_soft_shutdown", reason="FAST Neuron soft power down button")

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/mpf/platforms/fast/fast_exp_board.py

@@ -87,7 +87,7 @@ class FastExpansionBoard:
     def get_description_string(self) -> str:
         """Return description string."""
         # TODO add breakout boards
-        return f"Expansion Board Model: {self.model_string},  Firmware: {self.firmware_version}"
+        return f"EXP Board: {self.name} - {self.model},  Firmware: {self.firmware_version}, Address: {self.address}"
 
     def verify_hardware(self, id_string: str, active_board: str) -> None:
         """Verifies an EXP or breakout board firmware versions.

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/mpf/platforms/smart_virtual.py

@@ -291,6 +291,10 @@ class SmartVirtualHardwarePlatform(VirtualPlatform):
         self._initialize_drop_target_banks()
         self._initialize_score_reels()
 
+    def get_info_string(self) -> str:
+        """Provide info on virtual devices."""
+        return 'Smart Virtual Platform'
+
     def _initialize_score_reels(self):
         for device in self.machine.score_reels.values():
             if device.config['coil_inc'] and isinstance(device.config['coil_inc'].hw_driver, VirtualDriver):

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/mpf/platforms/virtual.py

@@ -343,6 +343,10 @@ class VirtualHardwarePlatform(AccelerometerPlatform, I2cPlatform, ServoPlatform,
         del number
         return {}
 
+    def get_info_string(self) -> str:
+        """Provide info on virtual devices."""
+        return 'Virtual Platform'
+
 
 class VirtualI2cDevice(I2cPlatformInterface):
 

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/mpf/tests/machine_files/shots/config/test_shots.yaml

@@ -60,6 +60,8 @@ switches:
     number:
   switch_28:
     number:
+  switch_29:
+    number:
 
 lights:
   light_1:

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/mpf/tests/machine_files/shots/modes/base2/config/base2.yaml

@@ -36,6 +36,10 @@ shots:
     switch: switch_15
     delay_switch:
       switch_15: 2s
+  shot_delay_event:
+    switch: switch_29
+    delay_event_list:
+      my_delay_event: 2s
   default_show_light:
     switch: switch_5
     show_tokens:

{mpf-0.81.0.dev4 → mpf-0.81.0.dev5}/mpf/tests/test_BcpInterface.py

@@ -89,22 +89,22 @@ class TestBcpInterface(MpfBcpTestCase):
         self.assertIn(
             ("device", {"type": "switch",
                         "name": "s_test",
-                        "state": {'state': 1, 'recycle_jitter_count': 0},
+                        "state": {'state': 1, 'recycle_jitter_count': 0, 'number': '1000'},
                         "changes": False}), queue)
         self.assertNotIn(
             ("device", {"type": "switch",
                         "name": "s_test",
-                        "state": {'state': 0, 'recycle_jitter_count': 0},
+                        "state": {'state': 0, 'recycle_jitter_count': 0, 'number': '1000'},
                         "changes": False}), queue)
         self.assertIn(
             ("device", {"type": "switch",
                         "name": "s_test2",
-                        "state": {'state': 0, 'recycle_jitter_count': 0},
+                        "state": {'state': 0, 'recycle_jitter_count': 0, 'number': '1001'},
                         "changes": False}), queue)
         self.assertNotIn(
             ("device", {"type": "switch",
                         "name": "s_test2",
-                        "state": {'state': 1, 'recycle_jitter_count': 0},
+                        "state": {'state': 1, 'recycle_jitter_count': 0, 'number': '1001'},
                         "changes": False}), queue)
 
         # change switch
@@ -113,7 +113,7 @@ class TestBcpInterface(MpfBcpTestCase):
         self.assertIn(
             ("device", {"type": "switch",
                         "name": "s_test",
-                        "state": {'state': 0, 'recycle_jitter_count': 0},
+                        "state": {'state': 0, 'recycle_jitter_count': 0, 'number': '1000'},
                         "changes": ('state', 1, 0)}),
             queue)
 
@@ -128,7 +128,7 @@ class TestBcpInterface(MpfBcpTestCase):
         self.assertIn(
             ("device", {"type": "switch",
                         "name": "s_test",
-                        "state": {'state': 1, 'recycle_jitter_count': 0},
+                        "state": {'state': 1, 'recycle_jitter_count': 0, 'number': '1000'},
                         "changes": ('state', 0, 1)}),
             queue)