mpf 0.57.3.dev3__tar.gz → 0.57.4.dev2__tar.gz

{mpf-0.57.3.dev3 → mpf-0.57.4.dev2}/.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.dev3 → mpf-0.57.4.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpf
-Version: 0.57.3.dev3
+Version: 0.57.4.dev2
 Summary: The Mission Pinball Framework (MPF)
 Author-email: The Mission Pinball Framework Team <brian@missionpinball.org>
 License: MIT
@@ -31,6 +31,7 @@ Requires-Dist: psutil==5.9.8
 Requires-Dist: pyserial==3.5
 Requires-Dist: pyserial-asyncio==0.6
 Requires-Dist: ruamel.yaml==0.18.6
+Requires-Dist: setuptools~=72.2.0
 Requires-Dist: sortedcontainers==2.4.0
 Requires-Dist: terminaltables==3.1.10
 Requires-Dist: Pillow==9.5.0

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

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

{mpf-0.57.3.dev3 → mpf-0.57.4.dev2}/mpf/config_spec.yaml

@@ -748,6 +748,9 @@ fast_servos:
     min_us: single|int|1000
     home_us: single|int|1500
     max_runtime: single|ms|2000  # 65535 max
+fast_stepper_settings:
+    __valid_in__: machine                 # todo add to validator
+    default_speed: single|int|600
 file_shows:
     __valid_in__: machine, mode                      # todo add to validator
     __type__: config_dict
@@ -1941,23 +1944,28 @@ spinners:
 steppers:
     __valid_in__: machine
     __type__: device
-    named_positions: dict|float:str|None
     home_events: event_handler|event_handler:ms|None
+    home_on_startup: single|bool|true
     homing_mode: single|enum(hardware,switch)|hardware
     homing_switch: single|machine(switches)|None
     homing_direction: single|enum(clockwise,counterclockwise)|clockwise
+    homing_speed: single|int|None
     pos_min: single|int|0
     pos_max: single|int|1000
     ball_search_min: single|int|0
     ball_search_max: single|int|1
     ball_search_wait: single|ms|5s
     include_in_ball_search: single|bool|true
-    relative_positions: dict|float:str|None
+    relative_positions: dict|float:subconfig(stepper_position_settings)|None
     reset_position: single|int|0
     reset_events: event_handler|event_handler:ms|machine_reset_phase_3, ball_starting, ball_will_end, service_mode_entered
+    named_positions: dict|float:subconfig(stepper_position_settings)|None
     number: single|str|
     platform: single|str|None
     platform_settings: single|dict|None
+stepper_position_settings:
+    event: single|str|
+    speed: single|int|None
 spike_stepper_settings:
     homing_speed: single|int|10
     speed: single|int|20

{mpf-0.57.3.dev3 → mpf-0.57.4.dev2}/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.dev3 → mpf-0.57.4.dev2}/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.dev3 → mpf-0.57.4.dev2}/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.dev3 → mpf-0.57.4.dev2}/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.dev3 → mpf-0.57.4.dev2}/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.dev3 → mpf-0.57.4.dev2}/mpf/core/text_ui.py

@@ -351,8 +351,11 @@ class TextUi(MpfController):
         self._machine_widgets.append(Label("MACHINE VARIABLES"))
         self._machine_widgets.append(Divider())
         machine_vars = self.machine.variables.machine_vars
-        # If config defines explict vars to show, only show those. Otherwise, all
-        names = self.config.get('machine_vars', machine_vars.keys())
+        # If config defines explict vars to show, only show those.
+        # Otherwise, filter out the unhelpful defaults
+        names = self.config.get('machine_vars', [n for n in machine_vars.keys() if not (
+            n.startswith("audits") or n.startswith("platform") or n.startswith("mpf"))
+        ])
         for name in names:
             self._machine_widgets.append(Label("{}: {}".format(name, machine_vars[name]['value'])))
         self._layout_change = True

{mpf-0.57.3.dev3 → mpf-0.57.4.dev2}/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.dev3 → mpf-0.57.4.dev2}/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.dev3 → mpf-0.57.4.dev2}/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.dev3 → mpf-0.57.4.dev2}/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.dev3 → mpf-0.57.4.dev2}/mpf/devices/multiball.py

@@ -120,14 +120,11 @@ class Multiball(EnableDisableMixin, SystemWideDevice, ModeDevice):
         # eject balls from locks
         for device in self.ball_locks:
             balls_to_release = max(min(device.available_balls, self.balls_added_live - balls_added), 0)
-            self.debug_log("Releasing %s balls from source device %s", balls_to_release, device)
             self.source_playfield.add_ball(balls=balls_to_release, source_device=device)
             balls_added += balls_to_release
 
         # request remaining balls
         if self.balls_added_live - balls_added > 0:
-            self.debug_log("Requesting %s additional balls from source playfield",
-                           self.balls_added_live - balls_added)
             self.source_playfield.add_ball(balls=self.balls_added_live - balls_added)
 
         shoot_again_ms = self.config['shoot_again'].evaluate([])

{mpf-0.57.3.dev3 → mpf-0.57.4.dev2}/mpf/devices/multiball_lock.py

@@ -357,11 +357,7 @@ class MultiballLock(EnableDisableMixin, ModeDevice):
         balls_added = 0
         for device in self._source_devices:
             balls_to_add = max(min(device.available_balls, balls - balls_added), 0)
-            self.debug_log("Requesting %s new balls from source device %s", balls_to_add, device)
             device.eject(balls=balls_to_add, target=self.source_playfield)
             balls_added += balls_to_add
 
-        remaining_balls = max(balls - balls_added, 0)
-        if remaining_balls:
-            self.debug_log("Requesting %s remaining balls from source playfield", remaining_balls)
-            self.source_playfield.add_ball(balls=remaining_balls)
+        self.source_playfield.add_ball(balls=max(balls - balls_added, 0))

{mpf-0.57.3.dev3 → mpf-0.57.4.dev2}/mpf/devices/playfield.py

@@ -108,8 +108,6 @@ class Playfield(SystemWideDevice):
         # TODO: add incoming ball only and wait for confirm or timeout
         self.available_balls += balls
         self.balls += balls
-        self.debug_log("Added %s missing balls. Current balls now %s, available balls %s.",
-                       balls, self.balls, self.available_balls)
 
     @property
     def balls(self):
@@ -310,10 +308,9 @@ class Playfield(SystemWideDevice):
         '''
 
     def _ball_removed_handler2(self, balls):
+        self.debug_log("%s ball(s) removed from the playfield", balls)
         self.balls -= balls
         self.available_balls -= balls
-        self.debug_log("%s ball(s) removed from the playfield. Current balls now %s, available balls %s.",
-                       balls, self.balls, self.available_balls)
         for _ in range(balls):
             self.machine.ball_controller.add_captured_ball(self)
 

{mpf-0.57.3.dev3 → mpf-0.57.4.dev2}/mpf/devices/servo.py

@@ -80,8 +80,10 @@ class Servo(SystemWideDevice):
 
         This should either home the servo or disable the output.
         """
-        self.debug_log("Stopping servo")
-        self.hw_servo.stop()
+        # A crash may occur during startup before hw_servo is instantiated
+        if self.hw_servo:
+            self.debug_log("Stopping servo")
+            self.hw_servo.stop()
 
     @event_handler(5)
     def _position_event(self, position, **kwargs):

{mpf-0.57.3.dev3 → mpf-0.57.4.dev2}/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.dev3 → mpf-0.57.4.dev2}/mpf/devices/stepper.py

@@ -26,7 +26,8 @@ class Stepper(SystemWideDevice):
     class_label = 'stepper'
 
     __slots__ = ["hw_stepper", "_target_position", "_current_position", "_ball_search_started",
-                 "_ball_search_old_target", "_is_homed", "_is_moving", "_move_task", "delay"]
+                 "_ball_search_old_target", "_is_homed", "_is_moving", "_move_task", "delay",
+                 "_target_speed"]
 
     def __init__(self, machine, name):
         """Initialize stepper."""
@@ -34,6 +35,7 @@ class Stepper(SystemWideDevice):
         self.platform = None            # type: Optional[Stepper]
         self._target_position = 0       # in user units
         self._current_position = 0      # in user units
+        self._target_speed = None       # in steps per second
         self._ball_search_started = False
         self._ball_search_old_target = 0
         self._is_homed = False
@@ -51,14 +53,16 @@ class Stepper(SystemWideDevice):
         self._target_position = self.config['reset_position']
 
         for position in self.config['named_positions']:
-            self.machine.events.add_handler(self.config['named_positions'][position],
+            self.machine.events.add_handler(self.config['named_positions'][position]['event'],
                                             self.event_move_to_position,
-                                            position=position)
+                                            position=position,
+                                            speed=self.config['named_positions'][position]['speed'])
 
         for position in self.config['relative_positions']:
-            self.machine.events.add_handler(self.config['relative_positions'][position],
+            self.machine.events.add_handler(self.config['relative_positions'][position]['event'],
                                             self.event_move_to_position,
                                             position=position,
+                                            speed=self.config['relative_positions'][position]['speed'],
                                             is_relative=True)
 
         if not self.platform.features['allow_empty_numbers'] and self.config['number'] is None:
@@ -82,6 +86,13 @@ class Stepper(SystemWideDevice):
 
     def validate_and_parse_config(self, config, is_mode_config, debug_prefix: str = None):
         """Validate stepper config."""
+        # If positions are just strings, expand them into strings and speeds
+        # TODO: Figure out how to use express_config() to map this
+        for cfg in ('named_positions', 'relative_positions'):
+            if cfg in config:
+                for pos, value in config[cfg].items():
+                    if isinstance(value, str):
+                        config[cfg][pos] = {'event': value}
         config = super().validate_and_parse_config(config, is_mode_config, debug_prefix)
         platform = self.machine.get_platform_sections(
             'stepper_controllers', getattr(config, "platform", None))
@@ -94,9 +105,13 @@ class Stepper(SystemWideDevice):
         # wait for switches to be initialized
         await self.machine.events.wait_for_event("init_phase_3")
 
-        # first home the stepper
-        self.info_log("Initializing stepper and homing.")
-        await self._home()
+        if self.config['home_on_startup']:
+            # first home the stepper
+            self.info_log("Initializing stepper and homing.")
+            await self._home()
+        else:
+            self.info_log("Initializing stepper but will not home.")
+            self._is_homed = True
 
         # run the loop at least once
         self._is_moving.set()
@@ -119,7 +134,10 @@ class Stepper(SystemWideDevice):
                 self.info_log("Stepper moving relative %s to hit target %s from %s",
                               delta, target_position, self._current_position)
                 # move stepper
-                self.hw_stepper.move_rel_pos(delta)
+                self.hw_stepper.move_rel_pos(delta, self._target_speed)
+                # Clear the speed override here, in case a subsequent move wants
+                # to set one before this one finishes.
+                self._target_speed = None
                 # wait for the move to complete
                 await self.hw_stepper.wait_for_move_completed()
             else:
@@ -130,12 +148,13 @@ class Stepper(SystemWideDevice):
             # post ready event
             self._post_ready_event()
 
-    def _move_to_absolute_position(self, position):
+    def _move_to_absolute_position(self, position, speed=None):
         """Move stepper to position."""
         self.info_log("Moving to absolute position %s. Current position: %s",
-                      self.hw_stepper, position, self._current_position)
+                      position, self._current_position)
         if self.config['pos_min'] <= position <= self.config['pos_max']:
             self._target_position = position
+            self._target_speed = speed
             self._is_moving.set()
         else:
             raise ValueError("_move_to_absolute_position: position argument beyond limits")
@@ -176,7 +195,9 @@ class Stepper(SystemWideDevice):
 
     def stop_device(self):
         """Stop motor."""
-        self.hw_stepper.stop()
+        # A crash during startup may not have initialized the hw_stepper yet
+        if self.hw_stepper:
+            self.hw_stepper.stop()
         self._is_moving.clear()
         if self._move_task:
             self._move_task.cancel()
@@ -201,22 +222,22 @@ class Stepper(SystemWideDevice):
         self._move_to_absolute_position(self.config['reset_position'])
 
     @event_handler(5)
-    def event_move_to_position(self, position=None, is_relative=False, **kwargs):
+    def event_move_to_position(self, position=None, speed=None, is_relative=False, **kwargs):
         """Event handler for move_to_position event."""
         del kwargs
         if position is None:
             raise AssertionError("move_to_position event is missing a position.")
 
-        self.move_to_position(position, is_relative)
+        self.move_to_position(position, speed, is_relative)
 
-    def move_to_position(self, position, is_relative=False):
+    def move_to_position(self, position, speed=None, is_relative=False):
         """Move stepper to a position."""
         self.info_log("Stepper at %s moving to %s position %s", self._current_position,
                       "relative" if is_relative else "absolute", position)
         self._target_position = (self._current_position + position) if is_relative else position
         if self._ball_search_started:
             return
-        self._move_to_absolute_position(self._target_position)
+        self._move_to_absolute_position(self._target_position, speed)
 
     def _ball_search_start(self, **kwargs):
         del kwargs

{mpf-0.57.3.dev3 → mpf-0.57.4.dev2}/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.dev3 → mpf-0.57.4.dev2}/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.dev3 → mpf-0.57.4.dev2}/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.dev3 → mpf-0.57.4.dev2}/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.dev3 → mpf-0.57.4.dev2}/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.dev3 → mpf-0.57.4.dev2}/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