mpf 0.57.0.dev33__tar.gz → 0.57.0.dev34__tar.gz

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/PKG-INFO

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

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf/_version.py

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

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf/commands/game.py

@@ -168,7 +168,10 @@ class Command:
             console_log.setLevel(logging.ERROR)
         else:
             console_log = logging.StreamHandler()
-            console_log.setLevel(self.args.consoleloglevel)
+            if self.args.production:
+                console_log.setLevel(logging.ERROR)
+            else:
+                console_log.setLevel(self.args.consoleloglevel)
 
         console_log.setFormatter(logging.Formatter(
             '%(asctime)s.%(msecs)03d : %(levelname)s [%(name)s] %(message)s', "%H:%M:%S"))

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf/config_spec.yaml

@@ -286,6 +286,8 @@ bonus_mode_settings:
     end_bonus_event: single|event_handler|None
     keep_multiplier: single|template_bool|False
     bonus_entries: list|subconfig(bonus_entries)|
+    rounding_value: single|int|None
+    rounding_direction: single|str|up
 bonus_entries:
     event: single|event_posted|
     score: single|template_int|
@@ -1561,6 +1563,7 @@ shots:
     delay_switch: dict|machine(switches):ms|None
     persist_enable: single|bool|true
     playfield: single|machine(playfields)|playfield
+    priority: single|int|0
     mark_playfield_active: single|bool|true
     enable_events: event_handler|event_handler:ms|None
     disable_events: event_handler|event_handler:ms|None
@@ -1923,6 +1926,7 @@ steppers:
     __valid_in__: machine
     __type__: device
     named_positions: dict|float:str|None
+    home_events: event_handler|event_handler:ms|None
     homing_mode: single|enum(hardware,switch)|hardware
     homing_switch: single|machine(switches)|None
     homing_direction: single|enum(clockwise,counterclockwise)|clockwise
@@ -1932,6 +1936,7 @@ steppers:
     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
     reset_position: single|int|0
     reset_events: event_handler|event_handler:ms|machine_reset_phase_3, ball_starting, ball_will_end, service_mode_entered
     number: single|str|
@@ -2192,6 +2197,7 @@ widgets:
         timing: single|enum(after_previous,with_previous)|after_previous
         repeat: single|bool_or_token|false
         easing: single|str|linear
+        step: single|float|0.0
     bezier:
         points: list|num_or_token|
         thickness: single|float_or_token|1.0
@@ -2319,6 +2325,7 @@ widgets:
         force_complete_event: single|event_handler|None
         block_events: list|event_handler|None
         release_events: list|event_handler|None
+        bitmap_font: single|bool_or_token|false
         bold: single|bool_or_token|false
         italic: single|bool_or_token|false
         number_grouping: single|bool_or_token|false

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf/core/assets.py

@@ -575,7 +575,7 @@ class BaseAssetManager(MpfController, LogMixin):
 
         if not remaining:
             if self._start_time:
-                self.log.info("Asset loading took: %s", time.time() - self._start_time)
+                self.info_log("Asset loading took: %s", time.time() - self._start_time)
             self._last_asset_event_time = None
             self.machine.events.post('asset_loading_complete')
             '''event: asset_loading_complete
@@ -833,6 +833,9 @@ class AssetPool:
 
     def _get_random_force_all_asset(self) -> Optional[AssetClass]:
         conditional_assets = self._get_conditional_assets()  # Store to variable to avoid calling twice
+        # Different players may have different conditions, so remove any unapplicable ones
+        # Otherwise a previous player may "use up" all the assets of the next player
+        self._assets_sent = set(a for a in self._assets_sent if a in conditional_assets)
         if len(self._assets_sent) == len(conditional_assets):
             self._assets_sent = set()
 

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf/core/data_manager.py

@@ -116,19 +116,29 @@ class DataManager(MpfController):
 
     def _writing_thread(self):  # pragma: no cover
         # prevent early writes at start-up
+        data = None
         time.sleep(self.min_wait_secs)
         while not self.machine.thread_stopper.is_set():
             if not self._dirty.wait(1):
                 continue
+            while FileManager.is_busy:
+                time.sleep(0.2)
             self._dirty.clear()
 
             data = copy.deepcopy(self.data)
-            self.debug_log("Writing %s to: %s", self.name, self.filename)
             # save data
-            FileManager.save(self.filename, data)
+            try:
+                FileManager.save(self.filename, data)
+            except Exception as e:
+                # If the file writer has an exception handle it here. Otherwise
+                # this thread will die and all subsequent write attempts will no-op.
+                self.info_log("ERROR writing file %s: %s", self.filename, e)
+            data = None
             # prevent too many writes
             time.sleep(self.min_wait_secs)
 
         # if dirty write data one last time during shutdown
-        if self._dirty.is_set():
+        if data and self._dirty.is_set():
+            while FileManager.is_busy:
+                time.sleep(0.2)
             FileManager.save(self.filename, data)

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf/core/file_manager.py

@@ -20,6 +20,7 @@ class FileManager:
     log = logging.getLogger('FileManager')
     file_interfaces = dict()    # type: Dict[str, YamlInterface]
     initialized = False
+    is_busy = False
 
     @classmethod
     def init(cls):
@@ -109,6 +110,12 @@ class FileManager:
         if not FileManager.initialized:
             FileManager.init()
 
+        # FileManager is a singleton and many threads may attempt to write
+        # concurrently. Ruamel has a known issue where concurrent writes
+        # on a YamlInterface will throw. Set a flag to prevent multiple
+        # data writes concurrently.
+        # TODO: Create FileManager instances for each DataManager instance.
+        FileManager.is_busy = True
         ext = os.path.splitext(filename)[1]
 
         # save to temp file and move afterwards. prevents broken files
@@ -121,3 +128,4 @@ class FileManager:
 
         # move temp file
         os.replace(temp_file, filename)
+        FileManager.is_busy = False

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf/core/mode.py

@@ -105,6 +105,11 @@ class Mode(LogMixin):
         """Return *True* if this mode is active."""
         return self._active
 
+    @property
+    def starting(self) -> bool:
+        """Return *True* if this mode is starting."""
+        return self._starting
+
     @active.setter
     def active(self, new_active: bool):
         """Setter for _active."""

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf/devices/shot.py

@@ -80,14 +80,15 @@ class Shot(EnableDisableMixin, ModeDevice):
         self._handlers = []
         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.event_hit,
+                                                                  priority=self.mode.priority + self.config['priority'],
                                                                   blocking_facility="shot"))
 
         for switch in list(self.config['delay_switch'].keys()):
             self._handlers.append(self.machine.events.add_handler("{}_active".format(switch.name),
                                                                   self._delay_switch_hit,
                                                                   switch_name=switch.name,
-                                                                  priority=self.mode.priority,
+                                                                  priority=self.mode.priority + self.config['priority'],
                                                                   blocking_facility="shot"))
 
     def _remove_switch_handlers(self):
@@ -281,7 +282,8 @@ class Shot(EnableDisableMixin, ModeDevice):
         if self.profile.config['block']:
             min_priority = kwargs.get("_min_priority", {"all": 0})
             min_shots = min_priority.get("shot", 0)
-            min_priority["shot"] = self.mode.priority if self.mode.priority > min_shots else min_shots
+            shot_priority = self.mode.priority + self.config["priority"]
+            min_priority["shot"] = shot_priority if shot_priority > min_shots else min_shots
             return {"_min_priority": min_priority}
 
         return None

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf/devices/stepper.py

@@ -1,4 +1,4 @@
-"""Implements a servo in MPF."""
+"""Implements a stepper in MPF."""
 import asyncio
 
 from typing import Optional
@@ -55,6 +55,12 @@ class Stepper(SystemWideDevice):
                                             self.event_move_to_position,
                                             position=position)
 
+        for position in self.config['relative_positions']:
+            self.machine.events.add_handler(self.config['relative_positions'][position],
+                                            self.event_move_to_position,
+                                            position=position,
+                                            is_relative=True)
+
         if not self.platform.features['allow_empty_numbers'] and self.config['number'] is None:
             self.raise_config_error("Stepper must have a number.", 2)
 
@@ -97,11 +103,18 @@ class Stepper(SystemWideDevice):
 
         while True:
             # wait until we should be moving
+            self.debug_log("Waiting for stepper to move...")
             await self._is_moving.wait()
+            if not self._is_homed:
+                await self._home()
+                self._post_ready_event()
+                continue
+            self.debug_log("Moving the stepper!")
             self._is_moving.clear()
             # store target position in local variable since it may change in the meantime
             target_position = self._target_position
             delta = target_position - self._current_position
+            self.debug_log("Stepper moving relative %s to hit target %s from %s", delta, target_position, self._current_position)
             if delta != 0:
                 self.debug_log("Got move command. Current position: %s Target position: %s Delta: %s",
                                self._current_position, target_position, delta)
@@ -118,8 +131,8 @@ class Stepper(SystemWideDevice):
             self.debug_log("Move completed")
 
     def _move_to_absolute_position(self, position):
-        """Move servo to position."""
-        self.debug_log("Moving to position %s", position)
+        """Move stepper to position."""
+        self.debug_log("Moving stepper %s to absolute position %s", self.hw_stepper, position)
         if self.config['pos_min'] <= position <= self.config['pos_max']:
             self._target_position = position
             self._is_moving.set()
@@ -168,6 +181,14 @@ class Stepper(SystemWideDevice):
             self._move_task.cancel()
             self._move_task = None
 
+    @event_handler(1)
+    def event_home(self, **kwargs):
+        """Event handler for home event."""
+        del kwargs
+        self._target_position = 0
+        self._is_homed = False
+        self._is_moving.set()
+
     @event_handler(1)
     def event_reset(self, **kwargs):
         """Event handler for reset event."""
@@ -179,20 +200,21 @@ class Stepper(SystemWideDevice):
         self._move_to_absolute_position(self.config['reset_position'])
 
     @event_handler(5)
-    def event_move_to_position(self, position=None, **kwargs):
+    def event_move_to_position(self, position=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)
+        self.move_to_position(position, is_relative)
 
-    def move_to_position(self, position):
+    def move_to_position(self, position, is_relative=False):
         """Move stepper to a position."""
-        self._target_position = position
+        self.debug_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(position)
+        self._move_to_absolute_position(self._target_position)
 
     def _ball_search_start(self, **kwargs):
         del kwargs

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf/modes/bonus/code/bonus.py

@@ -100,6 +100,13 @@ class Bonus(Mode):
             self._bonus_next_item()
             return
 
+        if self.settings["rounding_value"] and (r := (score % self.settings["rounding_value"])):
+            self.debug_log("rounding bonus score %s remainder of %s", score, r)
+            if self.settings["rounding_direction"] == "down":
+                score -= r
+            else:
+                score += self.settings["rounding_value"] - r
+
         self.debug_log("Bonus Entry '{}': score: {} player_score_entry: {}={}".
                        format(entry['event'], score,
                               entry['player_score_entry'], hits))

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf/tests/machine_files/asset_manager/config/test_asset_loading.yaml

@@ -86,3 +86,9 @@ show_pools:
       - show2
       - show3{mode.mode1.stopping}
     type: sequence
+  group9:
+    shows:
+      - show1{mode.mode1.priority>1}
+      - show2{mode.mode1.priority>1}
+      - show3
+    type: random_force_all

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf/tests/machine_files/shots/config/test_shots.yaml

@@ -5,6 +5,7 @@ modes:
   - base3
   - mode1
   - mode2
+  - mode3
 
 switches:
   switch_1:

mpf-0.57.0.dev34/mpf/tests/machine_files/shots/modes/mode3/config/mode3.yaml

@@ -0,0 +1,21 @@
+#config_version=6
+
+mode:
+  priority: 100
+
+shots:
+  mode3_shot_3_1:
+    switch: switch_3
+  mode3_shot_3_2:
+    switch: switch_3
+    priority: 10
+
+variable_player:
+  mode3_shot_3_1_hit:
+    foo:
+      action: set
+      int: 100
+  mode3_shot_3_2_hit:
+    foo:
+      action: set
+      int: 50

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf/tests/machine_files/stepper/config/config.yaml

@@ -5,6 +5,7 @@ steppers:
         number: 1
         pos_min:   -5 #user units (negative is behind home flag)
         pos_max: 1000 #user units
+        home_events: test_home
         homing_direction: clockwise
         homing_mode: hardware
         reset_position: 0
@@ -14,6 +15,10 @@ steppers:
             -5: test_00
             999: test_01
             500: test_10
+        relative_positions:
+            -2: test_rel_00
+            25: test_rel_01
+            100: test_rel_02
 
 
 # this is needed to test ball search

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf/tests/test_AssetManager.py

@@ -222,6 +222,31 @@ class TestAssets(MpfTestCase):
         # play a group
         self.machine.shows['group7'].play()
 
+    def _test_conditional_random_with_multiplayer_conditions(self):
+        # When the number of valid conditional assets goes *down* on
+        # a random_force_all, a situation could occur that all the remaining
+        # conditional assets are used up. This test validates that the
+        # pool will reset the availability in that case.
+        self.machine.modes["mode1"].start()
+        self.advance_time_and_run()
+        self.assertIn('group8', self.machine.shows)
+
+        # Set a condition so all three events are valid
+        self.machine.modes["mode1"].priority = 2
+        # Pull two assets, including the future only-valid one
+        res = list()
+        while self.machine.shows['show3'] not in res:
+            res = [
+                self.machine.shows['group9'].asset,
+                self.machine.shows['group9'].asset
+            ]
+        # Change the condition so only one show is valid, but already used
+        self.machine.modes["mode1"].priority = 0
+        self.assertIs(self.machine.shows['group9'].asset, self.machine.shows['show3'])
+        self.assertIs(self.machine.shows['group9'].asset, self.machine.shows['show3'])
+        self.assertIs(self.machine.shows['group9'].asset, self.machine.shows['show3'])
+        self.assertIs(self.machine.shows['group9'].asset, self.machine.shows['show3'])
+
     def _test_conditional_sequence_asset_group(self):
         # These tests are not independent, and mode1 is still running/stopping from the above test :(
         self.advance_time_and_run()
@@ -262,4 +287,3 @@ class TestAssets(MpfTestCase):
         self.assertIs(self.machine.shows['group8'].asset, self.machine.shows['show1'])
         self.assertIs(self.machine.shows['group8'].asset, self.machine.shows['show2'])
         self.assertIs(self.machine.shows['group8'].asset, self.machine.shows['show3'])
-

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf/tests/test_Shots.py

@@ -119,6 +119,16 @@ class TestShots(MpfTestCase):
         # check if color returns to mode1_shot_2 color
         self.assertLightColor("light_2", "antiquewhite")
 
+    def test_switch_priorities(self):
+        self.start_game()
+        self.start_mode("mode3")
+
+        self.assertEqual(self.machine.game.player['foo'], 0)
+        self.hit_and_release_switch('switch_3')
+        self.advance_time_and_run()
+
+        self.assertEqual(self.machine.game.player['foo'], 100)
+
     def test_hits(self):
         self.assertFalse(self.machine.shots["mode1_shot_1"].enabled)
 

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf/tests/test_Stepper.py

@@ -96,24 +96,49 @@ class TestStepper(MpfTestCase):
         # should go to reset position
         self.assertEqual(0.0, stepper._current_position)
 
-        # post another defined event
+        # post a named_position defined event
         event_future = self.machine.events.wait_for_event("stepper_linearAxis_stepper_ready")
         self.post_event("test_00")
         self.machine.clock.loop.run_until_complete(event_future)
         self.assertEqual(-5.0, stepper._current_position, 0)
 
-        # post another defined event
+        # post a named_position defined event
         event_future = self.machine.events.wait_for_event("stepper_linearAxis_stepper_ready")
         self.post_event("test_01")
         self.machine.clock.loop.run_until_complete(event_future)
         self.assertEqual(999.0, stepper._current_position, 0)
 
-        # post another defined event
+        # post a named_position defined event
         event_future = self.machine.events.wait_for_event("stepper_linearAxis_stepper_ready")
         self.post_event("test_10")
         self.machine.clock.loop.run_until_complete(event_future)
         self.assertEqual(500.0, stepper._current_position, 0)
 
+        # post a home event
+        event_future = self.machine.events.wait_for_event("stepper_linearAxis_stepper_ready")
+        self.post_event("test_home")
+        self.machine.clock.loop.run_until_complete(event_future)
+        # should go to reset position
+        self.assertEqual(0.0, stepper._current_position)
+
+        # post a relative_position defined event
+        event_future = self.machine.events.wait_for_event("stepper_linearAxis_stepper_ready")
+        self.post_event("test_rel_00")
+        self.machine.clock.loop.run_until_complete(event_future)
+        self.assertEqual(-2.0, stepper._current_position, 0)
+
+        # post a relative_position defined event
+        event_future = self.machine.events.wait_for_event("stepper_linearAxis_stepper_ready")
+        self.post_event("test_rel_01")
+        self.machine.clock.loop.run_until_complete(event_future)
+        self.assertEqual(23.0, stepper._current_position, 0)
+
+        # post a relative_position defined event
+        event_future = self.machine.events.wait_for_event("stepper_linearAxis_stepper_ready")
+        self.post_event("test_rel_02")
+        self.machine.clock.loop.run_until_complete(event_future)
+        self.assertEqual(123.0, stepper._current_position, 0)
+
     def test_ball_search(self):
         stepper = self.machine.steppers["linearAxis_stepper"]
 

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf.egg-info/PKG-INFO

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

{mpf-0.57.0.dev33 → mpf-0.57.0.dev34}/mpf.egg-info/SOURCES.txt

@@ -973,6 +973,7 @@ mpf/tests/machine_files/shots/modes/base2/config/base2.yaml
 mpf/tests/machine_files/shots/modes/base3/config/base3.yaml
 mpf/tests/machine_files/shots/modes/mode1/config/mode1.yaml
 mpf/tests/machine_files/shots/modes/mode2/config/mode2.yaml
+mpf/tests/machine_files/shots/modes/mode3/config/mode3.yaml
 mpf/tests/machine_files/shots/modes/rotate_with_exclude/config/rotate_with_exclude.yaml
 mpf/tests/machine_files/shows/config/test_show_player_queue.yaml
 mpf/tests/machine_files/shows/config/test_show_pools.yaml