mpf 0.57.3.dev2__tar.gz → 0.57.4.dev1__tar.gz

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/.prospector.yaml

@@ -23,6 +23,7 @@ pylint:
   disable:
     - pointless-string-statement  # pointless statement, which is how our event docstrings are seen
     - too-few-public-methods
+    - too-many-positional-arguments  # many methods have many positional args
     - unsubscriptable-object    # broken on python 3.9
     # The following linter rules are disabled to make a refactor managable in chunks
     - consider-using-f-string  # temporarily disabling due to the 900+ instances to be replaced

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpf
-Version: 0.57.3.dev2
+Version: 0.57.4.dev1
 Summary: The Mission Pinball Framework (MPF)
 Author-email: The Mission Pinball Framework Team <brian@missionpinball.org>
 License: MIT

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/_version.py

@@ -10,7 +10,7 @@ PyPI.
 
 """
 
-__version__ = '0.57.3.dev2'  # Also consider whether MPF-MC pyproject.toml should be updated
+__version__ = '0.57.4.dev1'  # Also consider whether MPF-MC pyproject.toml should be updated
 '''The full version of MPF.'''
 
 __short_version__ = '0.57'

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/core/bcp/bcp_interface.py

@@ -101,10 +101,10 @@ class BcpInterface(MpfController):
         if not self.machine.bcp.transport.get_transports_for_handler(event):
             self.machine.events.remove_handler_by_event(event=event, handler=self.bcp_trigger)
 
-    async def _bcp_receive_set_machine_var(self, client, name, value):
+    async def _bcp_receive_set_machine_var(self, client, name, value, persist=False):
         """Set machine var via bcp."""
         del client
-        self.machine.variables.set_machine_var(name, value)
+        self.machine.variables.set_machine_var(name, value, persist)
         # document variables injected by MC
         '''machine_var: mc_version
 
@@ -458,8 +458,8 @@ class BcpInterface(MpfController):
             self.machine.register_monitor('machine_vars', self._machine_var_change)
 
         # Send initial machine variable values
-        for s in ("standard", "feature", "game", "coin"):
-            self._send_machine_vars(client, setting_type=s)
+        self._send_machine_vars(client)
+        self._send_machine_settings(client)
 
         # Establish handler for machine variable changes
         self.machine.bcp.transport.add_handler_to_transport("_machine_vars", client)
@@ -471,10 +471,14 @@ class BcpInterface(MpfController):
         if not self.machine.bcp.transport.get_transports_for_handler("_machine_vars"):
             self.machine.machine_var_monitor = False
 
-    def _send_machine_vars(self, client, setting_type=None):
-        self.machine.bcp.transport.send_to_client(
-            client, bcp_command='settings',
-            settings=Util.convert_to_simply_type(self.machine.settings.get_settings(setting_type)))
+    def _send_machine_settings(self, client, setting_type=None):
+        settings = [setting_type] if setting_type else ["standard", "feature", "game", "coin", "hw_volume"]
+        for s in settings:
+            self.machine.bcp.transport.send_to_client(
+                client, bcp_command='settings',
+                settings=Util.convert_to_simply_type(self.machine.settings.get_settings(s)))
+
+    def _send_machine_vars(self, client):
         for var_name, settings in self.machine.variables.machine_vars.items():
             self.machine.bcp.transport.send_to_client(client, bcp_command='machine_variable',
                                                       name=var_name,

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/core/crash_reporter.py

@@ -176,7 +176,7 @@ def analyze_traceback(tb, inspection_level=None, limit=None):
 
 
 def _send_crash_report(report, reporting_url):
-    r = requests.post(reporting_url, json=report)
+    r = requests.post(reporting_url, json=report, timeout=60)
     if r.status_code != 200:
         print("Failed to send report. Got response code {}. Error: {}", r.status_code, r.content)
     else:

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/core/device_manager.py

@@ -301,8 +301,7 @@ class DeviceCollection(dict):
         self.machine.log.warning("Iterating device collections directly is deprecated and will be removed. "
                                  "Access by value(): device_collections[%s] -> device_collections['%s'].values()",
                                  self.name, self.name)
-        for item in self.values():
-            yield item
+        yield from self.values()
 
     def items_tagged(self, tag) -> List["Device"]:
         """Return of list of device objects which have a certain tag.

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/core/logging.py

@@ -160,12 +160,13 @@ class LogMixin:
         if error_no:
             error_slug = "Log-{}-{}".format(self.log.name if self.log else "", error_no)
             error_url = log_url.format(error_slug)
-        if error_no and context:
-            return "{} Context: {} Log Code: {} ({})".format(msg, context, error_slug, error_url)
+
+            if context:
+                return "{} Context: {} Log Code: {} ({})".format(msg, context, error_slug, error_url)
+            return "{} Log Code: {} ({})".format(msg, error_slug, error_url)
+
         if context:
             return "{} Context: {} ".format(msg, context)
-        if error_no:
-            return "{} Log Code: {} ({})".format(msg, error_slug, error_url)
 
         return msg
 

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/core/machine_vars.py

@@ -93,6 +93,11 @@ class MachineVariables(LogMixin):
 
         desc: Architecture of your machine (32bit/64bit).
         '''
+        self.set_machine_var(name="log_file_path", value=self.machine.options.get('full_logfile_path', ""))
+        '''machine_var: log_file_path
+
+        desc: Absolute path of the file log for the current running game.
+        '''
 
     def __getitem__(self, key):
         """Allow the user to access a machine variable with []. This would be used is machine.variables["var_name"]."""
@@ -177,6 +182,9 @@ class MachineVariables(LogMixin):
         ----
             name: String name of the variable you're setting the value for.
             value: The value you're setting. This can be any Type.
+            persist: Whether to persist this machine var to disk. Only
+                applies to new/unconfigured vars; vars defined in the
+                machine_vars config will use their config setting.
         """
         if name not in self.machine_vars:
             self.configure_machine_var(name=name, persist=persist)

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/core/utility_functions.py

@@ -185,8 +185,7 @@ class Util:
         """Convert a list of nested lists and/or values into a single one-dimensional list."""
         for item in incoming_list:
             if isinstance(item, IterableCollection) and not isinstance(item, str):
-                for inner_item in Util.flatten_list(item):
-                    yield inner_item
+                yield from Util.flatten_list(item)
             else:
                 yield item
 

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/devices/ball_device/ball_count_handler.py

@@ -285,7 +285,8 @@ class BallCountHandler(BallDeviceStateHandler):
                 except asyncio.TimeoutError:
                     self.debug_log("BCH: Lost %s balls", missing_balls)
                     self._set_ball_count(new_balls)
-                    await self.ball_device.lost_idle_ball(missing_balls)
+                    for _ in range(missing_balls):
+                        await self.ball_device.lost_idle_ball()
                 else:
                     self._revalidate.set()
         else:

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/devices/ball_device/ball_device.py

@@ -138,15 +138,14 @@ class BallDevice(SystemWideDevice):
         eject.already_left = True
         self.outgoing_balls_handler.add_eject_to_queue(eject)
 
-    async def lost_idle_ball(self, balls=1):
+    async def lost_idle_ball(self):
         """Lost an ball while the device was idle."""
         # handle lost balls
-        self.info_log("Lost %s balls, will remove from count and add to ball_missing_target %s", balls, self.config['ball_missing_target'])
         if self.state == "idle":
             self.warning_log("Ball disappeared while idle. This should not normally happen.")
-        self.available_balls -= balls
-        self.config['ball_missing_target'].add_missing_balls(balls)
-        await self._balls_missing(balls)
+        self.available_balls -= 1
+        self.config['ball_missing_target'].add_missing_balls(1)
+        await self._balls_missing(1)
 
     async def lost_ejected_ball(self, target):
         """Handle an outgoing lost ball."""

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/devices/ball_device/outgoing_balls_handler.py

@@ -435,11 +435,12 @@ class OutgoingBallsHandler(BallDeviceStateHandler):
                 if new_balls < old_balls:
                     self.info_log("Found %s physical balls and %s expected balls", new_balls, old_balls)
                     # Post that the ball is lost
-                    await self.ball_device.lost_idle_ball(old_balls - new_balls)
+                    await self.ball_device.lost_idle_ball()
                     # Cancel the eject queue for the lost ball
-                    if not self._eject_queue.empty():
-                        self._eject_queue.get_nowait()
-                        self._eject_queue.task_done()
+                    for _ in range(0, old_balls - new_balls):
+                        if not self._eject_queue.empty():
+                            self._eject_queue.get_nowait()
+                            self._eject_queue.task_done()
                     self.info_log("Necessary queue requests are cancelled. Updating ball count to %s." % new_balls)
                     self.ball_device.ball_count_handler._set_ball_count(new_balls)  # pylint: disable=protected-access
 

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/devices/shot_group.py

@@ -47,7 +47,7 @@ class ShotGroup(ModeDevice):
         self.rotation_pattern = deque(self.profile.config['rotation_pattern'])
         self.rotation_enabled = not self.config['enable_rotation_events']
         for shot in self.config['shots']:
-            self.machine.events.add_handler("{}_hit".format(shot.name), self._hit)
+            self.machine.events.add_handler("{}_hit".format(shot.name), self._hit, shot=shot.name)
             self.machine.events.add_handler("player_shot_{}".format(shot.name), self._check_for_complete)
 
     def device_removed_from_mode(self, mode):
@@ -145,7 +145,7 @@ class ShotGroup(ModeDevice):
         for shot in self.config['shots']:
             shot.restart()
 
-    def _hit(self, advancing, **kwargs):
+    def _hit(self, advancing, shot, **kwargs):
         """One of the member shots in this shot group was hit.
 
         Args:
@@ -157,12 +157,12 @@ class ShotGroup(ModeDevice):
             }
         """
         del advancing
-        self.machine.events.post(self.name + '_hit')
+        self.machine.events.post(self.name + '_hit', shot=shot)
         '''event: (name)_hit
         desc: A member shots in the shot group called (name)
         has been hit.
         '''
-        self.machine.events.post("{}_{}_hit".format(self.name, kwargs['state']))
+        self.machine.events.post("{}_{}_hit".format(self.name, kwargs['state']), shot=shot)
         '''event: (name)_(state)_hit
         desc: A member shot with state (state) in the shot group (name)
         has been hit.

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/devices/timer.py

@@ -144,8 +144,8 @@ class Timer(ModeDevice):
     def _setup_control_events(self, event_list):
         self.debug_log("Setting up control events")
 
-        kwargs = {}
         for entry in event_list:
+            kwargs = {}
             if entry['action'] in ('add', 'subtract', 'jump', 'pause', 'set_tick_interval'):
                 handler = getattr(self, entry['action'])
                 kwargs = {'timer_value': entry['value']}

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/modes/attract/code/attract.py

@@ -1,9 +1,9 @@
 """Contains the Attract class which is the attract mode in a pinball machine."""
 
-from mpf.core.mode import Mode
+from mpf.modes.carousel.code.carousel import Carousel
 
 
-class Attract(Mode):
+class Attract(Carousel):
 
     """Default mode running in a machine when a game is not in progress.
 
@@ -22,6 +22,13 @@ class Attract(Mode):
         self.start_hold_time = 0.0
         self.start_buttons_held = list()
 
+    def mode_init(self):
+        """Initialize the mode and handle missing carousel items."""
+        try:
+            super().mode_init()
+        except AssertionError:
+            pass
+
     def mode_start(self, **kwargs):
         """Start the attract mode."""
         # register switch handlers for the start button press so we can
@@ -50,6 +57,10 @@ class Attract(Mode):
                 playfield.ball_search.enable()
                 playfield.ball_search.start()
 
+        # Check for carousel items
+        if self._all_items:
+            super().mode_start(**kwargs)
+
     def start_button_pressed(self):
         """Handle start button press.
 

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/modes/bonus/code/bonus.py

@@ -91,11 +91,10 @@ class Bonus(Mode):
             self._subtotal()
             return
 
-        # Calling player.vars.get() instead of player.get() bypasses the
-        # auto-fill zero and will throw if there is no player variable.
-        # The fallback value of 1 is used for bonus entries that don't use
-        # a player score, which are multiplied by one to get the bonus.
-        hits = self.player.vars.get(entry['player_score_entry'], 1)
+        # If a player_score_entry is provided, use player getattr to get a
+        # fallback value of zero if the variable is not set. Otherwise
+        # use 1 as the multiplier for non-player-score bonuses.
+        hits = self.player[entry['player_score_entry']] if entry['player_score_entry'] else 1
         score = entry['score'].evaluate([]) * hits
 
         if (not score and entry['skip_if_zero']) or (score < 0 and entry['skip_if_negative']):

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/modes/high_score/code/high_score.py

@@ -196,7 +196,8 @@ class HighScore(AsyncMode):
                     # ask player for initials if we do not know them
                     if not player.initials:
                         try:
-                            player.initials = await self._ask_player_for_initials(player, award_names[i], value, category_name)
+                            player.initials = await self._ask_player_for_initials(player, award_names[i],
+                                                                                  value, category_name)
                         except asyncio.TimeoutError:
                             del new_list[i]
                             # no entry when the player missed the timeout
@@ -270,6 +271,7 @@ class HighScore(AsyncMode):
             input_initials = choice(unused_initials)
         return input_initials
 
+    # pylint: disable-msg=too-many-arguments
     async def _show_award_slide(self, player_num, player_name: str, category_name: str, award: str, value: int) -> None:
         if not self.high_score_config['award_slide_display_time']:
             return

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/modes/service/code/service.py

@@ -508,6 +508,7 @@ sort_devices_by_number: single|bool|True
         for board, l in items:
             numbers = l.get_hw_numbers()
             chain_2 = None
+            addr_2 = None
             # Just choose the first one as representative?
             number = numbers[0]
             if "-" in number:
@@ -557,9 +558,10 @@ sort_devices_by_number: single|bool|True
                 items.append(LightChainMap(platform_name, chain_name, chain))
         # do not crash if no lights are configured
         if not items:   # pragma: no cover
-            return
+            return []
 
         items.sort(key=lambda x: x.chain)
+        return items
 
     async def _volume_menu(self, platform=None):
         position = 0

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/platforms/fast/communicators/base.py

@@ -448,9 +448,9 @@ class FastSerialCommunicator(LogMixin):
                 if self.pause_sending_flag.is_set():
                     await self.pause_sending_flag.wait()
 
+            # TODO better way to catch shutting down?
             except SerialException as e:
                 self.log.error(e)
-                return  # TODO better way to catch shutting down?
 
     def write_to_port(self, msg, log_msg=None):
         """Send a message as is, without encoding or adding a <CR> character."""
@@ -464,4 +464,3 @@ class FastSerialCommunicator(LogMixin):
             self.writer.write(msg)
         except AttributeError:
             self.log.warning("Serial connection is not open. Cannot send message: %s", msg)
-            return

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/platforms/fast/communicators/net_neuron.py

@@ -293,7 +293,7 @@ class FastNetNeuronCommunicator(FastSerialCommunicator):
         This will silently sync the switch.hw_state. If the logical state changes,
         it will process it like any switch change.
         """
-        for switch in self.machine.switches.values():
+        for switch in [sw for sw in self.machine.switches.values() if sw.platform == self.platform]:
             hw_state = self.platform.hw_switch_data[switch.hw_switch.number]
 
             if hw_state != switch.hw_state:

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/platforms/fast/fast_audio.py

@@ -2,6 +2,10 @@
 
 from math import ceil
 from mpf.core.logging import LogMixin
+from mpf.core.settings_controller import SettingEntry
+
+VARIABLE_NAME = "fast_audio_%s_volume"
+SETTING_TYPE = "hw_volume"
 
 
 class FASTAudioInterface(LogMixin):
@@ -17,9 +21,9 @@ class FASTAudioInterface(LogMixin):
         self.machine = platform.machine
         self.communicator = communicator
         self.amps = {
-            'main': {'name': 'fast_audio_main', 'label': "Speakers"},
-            'sub': {'name': 'fast_audio_sub', 'label': "Subwoofer"},
-            'headphones': {'name': 'fast_audio_headphones', 'label': "Headphones"}
+            'main': {'name': 'fast_audio_main', 'label': "Speakers", 'sort': 0},
+            'sub': {'name': 'fast_audio_sub', 'label': "Subwoofer", 'sort': 1},
+            'headphones': {'name': 'fast_audio_headphones', 'label': "Headphones", 'sort': 2}
         }
         self.control_pin_pulse_times = list()
 
@@ -35,30 +39,41 @@ class FASTAudioInterface(LogMixin):
         self._register_event_handlers()
 
     def _configure_machine_vars(self):
-        for amp_name in self.amps:
-            var_name = f'fast_audio_{amp_name}_volume'
-
-            # Is there a race condition on first boot if the linked amp
-            # comes in the iteration before 'main' is written?
-            if amp_name != 'main' and self.communicator.config[f'link_{amp_name}_to_main']:
-                self.machine.variables.set_machine_var(
-                    name=var_name,
-                    value=self.machine.variables.get_machine_var('fast_audio_main_volume'),
-                    persist=self.communicator.config['persist_volume_settings']
-                )
-            elif not self.machine.variables.is_machine_var(var_name):
-                self.machine.variables.set_machine_var(
-                    name=var_name,
-                    value=self.communicator.config[f'default_{amp_name}_volume'],
-                    persist=self.communicator.config['persist_volume_settings']
-                )
+        # See if main volume has been defined yet, otherwise use default
+        main_volume = self.machine.variables.get_machine_var('fast_audio_main_volume')
+        if main_volume is None:
+            main_volume = self.communicator.config['default_main_volume']
+
+        for amp_name, settings in self.amps.items():
+
+            default_value = self.communicator.config[f'default_{amp_name}_volume']
+            if self.communicator.config.get(f'link_{amp_name}_to_main', False):
+                machine_var_name = VARIABLE_NAME % "main"
+            else:
+                machine_var_name = VARIABLE_NAME % amp_name
+
+                # Create a machine variable if one doesn't exist
+                if not self.machine.variables.is_machine_var(machine_var_name):
+                    self.machine.variables.set_machine_var(machine_var_name, default_value,
+                                                           self.communicator.config['persist_volume_settings'])
+
+            # Identify the machine var for this amp
+            settings["machine_var"] = machine_var_name
+            self.machine.settings.add_setting(SettingEntry(
+                settings['name'],
+                settings['label'],
+                settings['sort'],
+                machine_var_name,
+                default_value,
+                None,
+                SETTING_TYPE
+            ))
 
     def _init_amps(self):
         for amp_name, amp in self.amps.items():
             amp['steps'] = self.communicator.config[f'{amp_name}_steps']
             amp['max_volume'] = self.communicator.config[f'max_hw_volume_{amp_name}']
             amp['levels_list'] = self.communicator.config[f'{amp_name}_levels_list']
-            amp['link_to_main'] = self.communicator.config[f'link_{amp_name}_to_main']
 
             # Just set everything here. The communicator will send the
             # config as part of its init process later
@@ -71,7 +86,8 @@ class FASTAudioInterface(LogMixin):
                 # if we have a levels list in the config, make sure the steps num is right
                 amp['steps'] = len(amp['levels_list']) - 1
 
-            if amp['link_to_main'] and len(amp['levels_list']) != len(self.amps['main']['levels_list']):
+            if self.communicator.config[f'link_{amp_name}_to_main'] and \
+                    len(amp['levels_list']) != len(self.amps['main']['levels_list']):
                 raise AssertionError(f"Cannot link {amp_name} to main. The number of volume steps must be the same. "
                                      f"Main has {len(self.amps['main']['levels_list'])} steps, "
                                      f"but {amp_name} has {len(amp['levels_list'])} steps.")
@@ -135,7 +151,6 @@ class FASTAudioInterface(LogMixin):
             for each_amp_name in self.amps:
                 self.send_volume_to_hw(each_amp_name, send_now)
             return
-
         self.communicator.set_volume(amp_name, self.get_volume(amp_name), send_now)
 
     def _set_volume(self, amp_name, value=0, **kwargs):
@@ -155,19 +170,13 @@ class FASTAudioInterface(LogMixin):
         #self.platform.debug_log("Writing FAST amp volume %s to %s (decimal)", amp_name, value)
         self.send_volume_to_hw(amp_name)
 
-        if amp_name == 'main':
-            for other_amp_name, other_amp in self.amps.items():
-                if other_amp_name != amp_name and other_amp['link_to_main']:
-                    # Update the machine var, which will be caught and handled
-                    self._set_machine_var_volume(other_amp_name, value)
-
     def get_volume(self, amp_name, **kwargs):
         """Return the current volume of the specified amp."""
         del kwargs
-        return self.machine.variables.get_machine_var(f'fast_audio_{amp_name}_volume')
+        return self.machine.variables.get_machine_var(self.amps[amp_name]["machine_var"]) or 0
 
     def _set_machine_var_volume(self, amp_name, value):
-        self.machine.variables.set_machine_var(f'fast_audio_{amp_name}_volume', value)
+        self.machine.variables.set_machine_var(self.amps[amp_name]["machine_var"], value)
 
     def temp_volume(self, amp_name, change=1, **kwargs):
         """Temporarily change the volume by the specified number of units, up or down.

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/platforms/fast/fast_driver.py

@@ -503,6 +503,9 @@ class FASTDriver:
             reconfigured = True
 
         if hold_settings is not None:
+            hold_power = Util.float_to_pwm8_hex_string(hold_settings.power)
+            hold_ms = "00"
+
             if hold_settings.duration > 25500:
                 raise AssertionError("FAST platform does not support hold durations > 25500ms")
             if 25500 >= hold_settings.duration > 255:
@@ -512,8 +515,6 @@ class FASTDriver:
                 hold_ms = Util.int_to_hex_string(hold_settings.duration)
                 mode = '10'
 
-            hold_power = Util.float_to_pwm8_hex_string(hold_settings.power)
-
         else:
             hold_ms = self.current_driver_config.param3
             hold_power = self.current_driver_config.param4

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/platforms/fast/fast_exp_board.py

@@ -2,6 +2,7 @@
 
 import asyncio
 from base64 import b16decode
+from binascii import Error as binasciiError
 from importlib import import_module
 
 from packaging import version
@@ -176,7 +177,7 @@ class FastExpansionBoard:
 
                 try:
                     self.communicator.send_bytes(b16decode(f'{msg_header}{msg}'), log_msg)
-                except Exception as e:
+                except binasciiError as e:
                     self.log.error(
                         f"Error decoding the following message for board {breakout_address} : {msg_header}{msg}")
                     self.log.info("Attempted update that caused this error: %s", dirty_leds)

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/platforms/light_segment_displays.py

@@ -2,7 +2,7 @@
 import logging
 
 from mpf.devices.segment_display.segment_display_text import ColoredSegmentDisplayText
-from mpf.core.segment_mappings import SEVEN_SEGMENTS, BCD_SEGMENTS, FOURTEEN_SEGMENTS, SIXTEEN_SEGMENTS,\
+from mpf.core.segment_mappings import SEVEN_SEGMENTS, BCD_SEGMENTS, FOURTEEN_SEGMENTS, SIXTEEN_SEGMENTS, \
     EIGHT_SEGMENTS, TextToSegmentMapper
 from mpf.platforms.interfaces.segment_display_platform_interface import SegmentDisplaySoftwareFlashPlatformInterface
 from mpf.core.platform import SegmentDisplaySoftwareFlashPlatform

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/platforms/opp/opp.py

@@ -890,7 +890,6 @@ class OppHardwarePlatform(LightsPlatform, SwitchPlatform, DriverPlatform, ServoP
             ]
 
         self.raise_config_error("Unknown subtype {}".format(subtype), 8)
-        return []
 
     def configure_light(self, number, subtype, config, platform_settings):
         """Configure a led or matrix light."""
@@ -949,7 +948,6 @@ class OppHardwarePlatform(LightsPlatform, SwitchPlatform, DriverPlatform, ServoP
             return self.opp_incands[index].configure_software_fade_incand(light_num)
 
         self.raise_config_error("Unknown subtype {}".format(subtype), 12)
-        return None
 
     async def _poll_sender(self, chain_serial):
         """Poll switches."""
@@ -1148,6 +1146,7 @@ class OppHardwarePlatform(LightsPlatform, SwitchPlatform, DriverPlatform, ServoP
         """Generate an OPPServo class with the given number."""
         del config
         chain_serial, _, pin_number = number.split('-')  # Unused value is 'card'
+        possible_inputs = None
 
         if self.min_version[chain_serial] < 0x02020002:
             self.raise_config_error("Servos not supported on this OPP FW version: {}.".format(
@@ -1157,7 +1156,7 @@ class OppHardwarePlatform(LightsPlatform, SwitchPlatform, DriverPlatform, ServoP
             if inputs.chain_serial == chain_serial:
                 possible_inputs = self._get_numbers(inputs.mask)
 
-        if 8 <= int(pin_number) < 16 and int(pin_number) in possible_inputs:
+        if 8 <= int(pin_number) < 16 and possible_inputs and int(pin_number) in possible_inputs:
             servo_number = int(pin_number) - 8
         else:
             self.raise_config_error("Servo unavailable at this number: {}.".format(number), 24)

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/platforms/virtual.py

@@ -107,7 +107,7 @@ class VirtualHardwarePlatform(AccelerometerPlatform, I2cPlatform, ServoPlatform,
                 initial_active_switches = []
                 for switch_name in Util.string_to_list(self.machine.config['virtual_platform_start_active_switches']):
                     if switch_name not in self.machine.switches.keys():
-                        if " " in switch:
+                        if " " in switch_name:
                             self.raise_config_error("MPF no longer supports lists separated by space in "
                                                     "virtual_platform_start_active_switches. Please separate "
                                                     "switches by comma: {}.".format(switch_name), 1)

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/plugins/auditor.py

@@ -78,7 +78,7 @@ class Auditor(MpfPlugin):
 
         self.switchnames_to_audit = {
             # Don't audit tagged switches, or credit switches during free play
-            x.name for x in self.machine.switches.values() if \
+            x.name for x in self.machine.switches.values() if
             ('no_audit' not in x.tags) and ('no_audit_free' not in x.tags or not is_free_play)
         }
 

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/plugins/platform_integration_test_runner.py

@@ -227,7 +227,7 @@ class MpfPlatformIntegrationTestRunner(MpfPlugin):
         drain_switches = self.machine.ball_devices.items_tagged('drain')[0].config.get('ball_switches')
         self.info_log("Found drain switches: %s of type %s", drain_switches, type(drain_switches))
         # If there's only one drain switch it might be a single value, rather than a list
-        drain_switch = drain_switches if type(drain_switches) is str else drain_switches[-1]
+        drain_switch = drain_switches if isinstance(drain_switches, str) else drain_switches[-1]
         self.info_log("Setting drain switch '%s' to zero", drain_switch)
         self.set_switch_sync(drain_switch, 0)
         await asyncio.sleep(0.25)

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/tests/machine_files/bonus/modes/bonus/config/bonus.yaml

@@ -12,3 +12,9 @@ mode_settings:
         score: 5000
         player_score_entry: modes
         reset_player_score_entry: False
+      - event: bonus_undefined_var
+        score: 5000
+        skip_if_zero: false
+        player_score_entry: undefined_var
+      - event: bonus_static
+        score: 2000

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/tests/machine_files/fast/config/audio.yaml

@@ -22,6 +22,14 @@ fast:
     power_pulse_time: 98
     reset_pulse_time: 97
 
+machine_vars:
+  fast_audio_sub_volume:
+    initial_value: 9
+  fast_audio_main_volume:
+    initial_value: 8
+  fast_audio_headphones_volume:
+    initial_value: 10
+
 variable_player:
   increase_main_volume:
     fast_audio_main_volume:

{mpf-0.57.3.dev2 → mpf-0.57.4.dev1}/mpf/tests/machine_files/fast/config/audio2.yaml

@@ -27,6 +27,7 @@ fast:
       - 14
       - 15
     headphones_level: line
+    link_sub_to_main: true
 
 machine_vars:
   fast_audio_main_volume: