mpf 0.80.0.dev1__tar.gz → 0.80.0.dev3__tar.gz

{mpf-0.80.0.dev1 → mpf-0.80.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpf
-Version: 0.80.0.dev1
+Version: 0.80.0.dev3
 Summary: The Mission Pinball Framework (MPF)
 Author-email: The Mission Pinball Framework Team <brian@missionpinball.org>
 License: MIT
@@ -14,6 +14,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Natural Language :: English
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
@@ -55,7 +56,7 @@ Requires-Dist: protobuf==3.14.0; extra == "vpe"
 Provides-Extra: all
 Requires-Dist: prompt_toolkit==3.0.43; extra == "all"
 Requires-Dist: asciimatics==1.15.0; extra == "all"
-Requires-Dist: terminaltables==3.1.0; extra == "all"
+Requires-Dist: terminaltables==3.1.10; extra == "all"
 Requires-Dist: requests==2.28.2; extra == "all"
 Requires-Dist: irc==19.0.1; extra == "all"
 Requires-Dist: smbus2_asyncio==0.0.5; extra == "all"

{mpf-0.80.0.dev1 → mpf-0.80.0.dev3}/mpf/_version.py

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

{mpf-0.80.0.dev1 → mpf-0.80.0.dev3}/mpf/assets/show.py

@@ -521,6 +521,7 @@ class RunningShow:
     def _start_play(self):
         if self._stopped:
             return
+        self.machine.show_controller.info_log("Starting show %s", self.show.name)
 
         self._total_steps = len(self.show_steps)
 
@@ -560,6 +561,7 @@ class RunningShow:
         """Stop show."""
         if self._stopped:
             return
+        self.machine.show_controller.info_log("Stopping show %s", self.show.name)
 
         self._stopped = True
 
@@ -589,12 +591,14 @@ class RunningShow:
 
     def pause(self):
         """Pause show."""
+        self.machine.show_controller.info_log("Pausing show %s", self.show.name)
         self._remove_delay_handler()
         if self.show_config.events_when_paused:
             self._post_events(self.show_config.events_when_paused)
 
     def resume(self):
         """Resume paused show."""
+        self.machine.show_controller.info_log("Resuming show %s", self.show.name)
         self.next_step_time = self.machine.clock.get_time()
         self._run_next_step(post_events=self.show_config.events_when_resumed)
 

mpf-0.80.0.dev3/mpf/config_players/bus_player.py

@@ -0,0 +1,36 @@
+"""Bus player plugin for MPF to support GMC."""
+
+from functools import partial
+from mpf.config_players.plugin_player import PluginPlayer
+
+
+class BusPlayer(PluginPlayer):
+
+    """Base class for part of the bus player which runs as part of MPF.
+
+    Note: This class is loaded by MPF and everything in it is in the context of
+    MPF, not the mc.
+    """
+
+    config_file_section = 'bus_player'
+    show_section = 'buses'
+
+    def _validate_config_item(self, device, device_settings):
+        # device is bus name, device_settings is configuration
+
+        device_settings = self.machine.config_validator.validate_config(
+            'bus_player', device_settings)
+
+        return_dict = dict()
+        return_dict[device] = device_settings
+
+        return return_dict
+
+    def _register_trigger(self, event, **kwargs):
+        """Register trigger via BCP for MC."""
+        del kwargs
+        client = self.machine.bcp.transport.get_named_client("local_display")
+        if client:
+            self.machine.bcp.interface.add_registered_trigger_event_for_client(client, event)
+        else:
+            self.machine.events.add_handler("bcp_clients_connected", partial(self._register_trigger, event))

{mpf-0.80.0.dev1 → mpf-0.80.0.dev3}/mpf/config_spec.yaml

@@ -115,7 +115,7 @@ autofire_coils:
     coil_overwrite: single|subconfig(coil_overwrites)|None
     switch_overwrite: dict|str:str|None
     ball_search_order: single|int|100
-    playfield: single|machine(playfields)|playfield
+    playfield: single|machine(playfields)|None
     timeout_watch_time: single|ms|0
     timeout_max_hits: single|int|0
     timeout_disable_time: single|ms|0
@@ -302,6 +302,11 @@ bonus_entries:
     player_score_entry: single|str|None
     skip_if_zero: single|bool|true
     skip_if_negative: single|bool|false
+bus_player:
+    __valid_in__: machine, mode, show
+    __type__: config_player
+    action: single|enum(pause,stop,unpause)|
+    fade: single|secs|0.1sec
 coils:
     __valid_in__: machine
     __type__: device
@@ -494,11 +499,12 @@ drop_targets:
     reset_coil_max_wait_ms: single|ms|100ms
     knockdown_coil_max_wait_ms: single|ms|100ms
     ignore_switch_ms: single|ms|500ms
-    playfield: single|machine(playfields)|playfield
+    playfield: single|machine(playfields)|None
 drop_target_banks:
     __valid_in__: machine, mode
     __type__: device
     drop_targets: list|machine(drop_targets)|
+    ball_search_order: single|int|100
     max_reset_attempts: single|int|None
     reset_on_complete: single|ms|None
     reset_coil: single|machine(coils)|None
@@ -506,6 +512,7 @@ drop_target_banks:
     reset_coil_max_wait_ms: single|ms|100ms
     reset_events: event_handler|event_handler:ms|machine_reset_phase_3, ball_starting
     ignore_switch_ms: single|ms|500ms
+    playfield: single|machine(playfields)|playfield
 effects:
     common:
         type: single|str|
@@ -1075,7 +1082,7 @@ magnets:
     release_time: single|ms|500ms
     fling_drop_time: single|ms|250ms
     fling_regrab_time: single|ms|50ms
-    playfield: single|machine(playfields)|playfield
+    playfield: single|machine(playfields)|None
     enable_events: event_handler|event_handler:ms|ball_started
     disable_events: event_handler|event_handler:ms|ball_will_end, service_mode_entered
     reset_events: event_handler|event_handler:ms|machine_reset_phase_3, ball_starting
@@ -1301,7 +1308,7 @@ player_vars:
 playfields:
     __valid_in__: machine
     __type__: device
-    enable_ball_search: single|bool|None
+    enable_ball_search: single|template_bool|None
     ball_search_timeout: single|ms|15s
     ball_search_interval: single|ms|150ms
     ball_search_phase_1_searches: single|int|3
@@ -1700,8 +1707,12 @@ sound_player:
     events_when_looping: list|event_posted|None
     events_when_about_to_finish: list|event_posted|None
     key: single|str|None
+sound_pools:
+    __valid_in__: machine, mode                      # todo add to validator
+    __type__: config_dict
+    __allow_others__:
 sound_ducking:
-    bus: single|str|None
+    bus: single|str|
     attack: single|secs|
     attenuation: single|float|
     delay: single|secs|0.0
@@ -1763,6 +1774,7 @@ spinners:
     labels: list|str|None
     active_ms: single|ms|1000ms
     idle_ms: single|ms|None
+    max_events_per_second: single|int|-1
     playfield: single|machine(playfields)|playfield
     reset_when_inactive: single|bool|true
     enable_events: event_handler|event_handler:ms|None
@@ -1819,7 +1831,7 @@ sequence_shots:
     delay_switch_list: dict|machine(switches):ms|None
     delay_event_list: event_handler|event_handler:ms|None
     sequence_timeout: single|ms|0
-    playfield: single|machine(playfields)|playfield
+    playfield: single|machine(playfields)|None
 switches:
     __valid_in__: machine
     __type__: device
@@ -1827,10 +1839,12 @@ switches:
     type: single|enum(NC,NO)|NO
     debounce: single|enum(auto,quick,normal)|auto
     ignore_window_ms: single|ms|0
+    ignore_during_ball_search: single|bool|false
     events_when_activated: list|event_posted|None
     events_when_deactivated: list|event_posted|None
     platform: single|str|None
     platform_settings: single|dict|None
+    playfield: single|machine(playfields)|playfield
     x: single|float|None
     y: single|float|None
     z: single|float|None

{mpf-0.80.0.dev1 → mpf-0.80.0.dev3}/mpf/core/ball_search.py

@@ -121,13 +121,16 @@ class BallSearch(MpfController):
             return
 
         del kwargs
-        if self.playfield.config['enable_ball_search'] is False or (
-            not self.playfield.config['enable_ball_search'] and
+        is_ball_search_enabled = self.playfield.config['enable_ball_search'].evaluate({}) if \
+            self.playfield.config['enable_ball_search'] else None
+        if is_ball_search_enabled is False or (
+            is_ball_search_enabled is None and
                 not self.machine.config['mpf']['default_ball_search']):
             return
 
         if not self.callbacks:
-            raise AssertionError("No callbacks registered")
+            raise AssertionError(f"Cannot run ball search on playfield '{self.playfield.name}', no callbacks "
+                                 "registered. Do you have any shots/devices defined in this playfield?")
 
         self.debug_log("Enabling Ball Search")
 
@@ -255,14 +258,6 @@ class BallSearch(MpfController):
                 element = next(self.iterator)
             except StopIteration:
                 self.iteration += 1
-                self.machine.events.post('ball_search_phase_{}'.format(self.phase),
-                                         iteration=self.iteration)
-                '''event: ball_search_phase_(num)
-
-                desc: The ball search phase (num) has started.
-                args:
-                    iteration: Current iteration of phase (num)
-                '''
                 # give up at some point
                 if self.iteration > self.playfield.config[
                         'ball_search_phase_{}_searches'.format(self.phase)]:
@@ -272,6 +267,15 @@ class BallSearch(MpfController):
                         self.give_up()
                         return
 
+                self.machine.events.post('ball_search_phase_{}'.format(self.phase),
+                                         iteration=self.iteration)
+                '''event: ball_search_phase_(num)
+
+                desc: The ball search phase (num) has started.
+                args:
+                    iteration: Current iteration of phase (num)
+                '''
+
                 self.iterator = iter(self.callbacks)
                 element = next(self.iterator)
                 timeout = self.playfield.config[

{mpf-0.80.0.dev1 → mpf-0.80.0.dev3}/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
 
@@ -472,7 +472,7 @@ class BcpInterface(MpfController):
             self.machine.machine_var_monitor = False
 
     def _send_machine_settings(self, client, setting_type=None):
-        settings = [setting_type] if setting_type else ["standard", "feature", "game", "coin"]
+        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',

{mpf-0.80.0.dev1 → mpf-0.80.0.dev3}/mpf/core/config_processor.py

@@ -150,19 +150,23 @@ class ConfigProcessor:
         if not isinstance(config, dict):
             raise ConfigFileError("Config should be a dict: {}".format(config), 1, self.log.name, filename)
 
-        deprecated_080 = ["playlists", "playlist_player", "slides", "sounds", "sound_pools", "sound_loop_player",
-                          "sound_loop_sets", "sound_system", "track_player", "widgets"]
+        deprecated_080 = ["sound_pools"]
+        invalid_080 = ["playlists", "playlist_player", "slides", "sounds", "sound_loop_player",
+                       "sound_loop_sets", "sound_system", "track_player", "widgets"]
         for k in config.keys():
             if k in config_spec:
+                if k in deprecated_080:
+                    self.log.warning("Config section '%s' is deprecated in MPF 0.80 and will be unsupported "
+                                     "in future versions. Please migrate this config to GMC.", k)
                 if config_type not in config_spec[k]['__valid_in__']:
                     raise ConfigFileError('Found a "{}:" section in config file {}, '
                                           'but that section is not valid in {} config '
                                           'files (only in {}).'.format(k, filename, config_type,
                                                                        config_spec[k]['__valid_in__']),
                                           2, self.log.name, filename)
-            elif k in deprecated_080:
+            elif k in invalid_080:
                 # MPF 0.80 DEPRECATION
-                self.log.warning("Config section '%s' is deprecated in MPF 0.80 and will be ignored.", k)
+                self.log.error("Config section '%s' is removed in MPF 0.80 and will be ignored.", k)
             elif not ignore_unknown_sections:
                 suggestion = self._find_similar_key(k, config_spec, config_type)
 

{mpf-0.80.0.dev1 → mpf-0.80.0.dev3}/mpf/core/config_validator.py

@@ -353,7 +353,10 @@ class ConfigValidator:
                     validation_failure_info.parent.item, config), 3, self.log.name)
 
     def _validate_type_subconfig(self, item, param, validation_failure_info):
-        if item is None:
+        # The inclusion of sound_pools causes a nested ducking subconfig that
+        # fails due to missing required properties. Check for an empty dict
+        # as subconfig and ignore it.
+        if item is None or (item is Dict and len(item) == 0):
             return {}
         try:
             attribute, base_spec_str = param.split(",", 1)

{mpf-0.80.0.dev1 → mpf-0.80.0.dev3}/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.80.0.dev1 → mpf-0.80.0.dev3}/mpf/core/machine_vars.py

@@ -182,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.80.0.dev1 → mpf-0.80.0.dev3}/mpf/core/switch_controller.py

@@ -367,14 +367,18 @@ class SwitchController(MpfController):
         obj.state = state
         obj.last_change = timestamp
 
+        muted_state = "(muted) " if obj.is_muted else ""
         if state:
-            self.info_log("<<<<<<< '%s' active >>>>>>>", obj.name)
+            self.info_log("<<<<<<< '%s' active %s>>>>>>>", obj.name, muted_state)
         else:
-            self.info_log("<<<<<<< '%s' inactive >>>>>>>", obj.name)
+            self.info_log("<<<<<<< '%s' inactive %s>>>>>>>", obj.name, muted_state)
 
         self._cancel_timed_handlers(obj)
 
-        self._call_handlers(obj, state)
+        # Don't call switch callbacks during initialization, or devices may try and
+        # flag playfields active and mess up the ball counts.
+        if self._initialized and not obj.is_muted:
+            self._call_handlers(obj, state)
 
         for monitor in self.monitors:
             monitor(MonitoredSwitchChange(name=obj.name, label=obj.label, platform=obj.platform,

{mpf-0.80.0.dev1 → mpf-0.80.0.dev3}/mpf/devices/autofire.py

@@ -34,7 +34,8 @@ class AutofireCoil(SystemWideDevice):
     collection = 'autofire_coils'
     class_label = 'autofire'
 
-    __slots__ = ["_enabled", "_rule", "delay", "_ball_search_in_progress", "_timeout_watch_time", "_timeout_max_hits",
+    __slots__ = ["_enabled", "_rule", "delay", "_ball_search_in_progress", "playfield",
+                 "_timeout_watch_time", "_timeout_max_hits",
                  "_timeout_disable_time", "_timeout_hits"]
 
     def __init__(self, machine: "MachineController", name: str) -> None:
@@ -44,6 +45,7 @@ class AutofireCoil(SystemWideDevice):
         super().__init__(machine, name)
         self.delay = DelayManager(self.machine)
         self._ball_search_in_progress = False
+        self.playfield = None
         self._timeout_watch_time = None
         self._timeout_max_hits = None
         self._timeout_disable_time = None
@@ -51,8 +53,9 @@ class AutofireCoil(SystemWideDevice):
 
     async def _initialize(self):
         await super()._initialize()
+        self.playfield = self.config['playfield'] or self.config['switch'].playfield
         if self.config['ball_search_order']:
-            self.config['playfield'].ball_search.register(
+            self.playfield.ball_search.register(
                 self.config['ball_search_order'], self._ball_search, self.name)
         # pulse is handled via rule but add a handler so that we take notice anyway
         self.config['switch'].add_handler(self._hit)
@@ -61,13 +64,13 @@ class AutofireCoil(SystemWideDevice):
             self._timeout_max_hits = self.config['timeout_max_hits']
             self._timeout_disable_time = self.config['timeout_disable_time']
 
-        if f"{self.config['playfield'].name}_active" in self.config['switch'].tags:
+        if f"{self.playfield.name}_active" in self.config['switch'].tags:
             self.raise_config_error(
                 "Autofire device '{}' uses switch '{}' which has a "
                 "'{}_active' tag. This is handled internally by the device. Remove the "
                 "redundant '{}_active' tag from that switch.".format(
-                    self.name, self.config['switch'].name, self.config['playfield'].name,
-                    self.config['playfield'].name), 1)
+                    self.name, self.config['switch'].name, self.playfield.name,
+                    self.playfield.name), 1)
 
     @event_handler(1)
     def event_enable(self, **kwargs):
@@ -169,7 +172,7 @@ class AutofireCoil(SystemWideDevice):
         if not self._enabled:
             return
         if not self._ball_search_in_progress:
-            self.config['playfield'].mark_playfield_active_from_device_action()
+            self.playfield.mark_playfield_active_from_device_action(self.name)
         if self._timeout_watch_time:
             current_time = self.machine.clock.get_time()
             self._timeout_hits = [t for t in self._timeout_hits if t > current_time - self._timeout_watch_time / 1000.0]

{mpf-0.80.0.dev1 → mpf-0.80.0.dev3}/mpf/devices/diverter.py

@@ -379,15 +379,15 @@ class Diverter(SystemWideDevice):
         del phase
         del iteration
         if self.active:
-            self.info_log("Temporarily deactivating diverter to search ball for %sms",
-                          self.config['ball_search_hold_time'])
+            self.debug_log("Temporarily deactivating diverter to search ball for %sms",
+                           self.config['ball_search_hold_time'])
             self._coil_deactivate()
             self.machine.delay.add(self.config['ball_search_hold_time'],
                                    self._coil_activate,
                                    'diverter_{}_ball_search'.format(self.name))
         else:
-            self.info_log("Temporarily activating diverter to search ball for %sms",
-                          self.config['ball_search_hold_time'])
+            self.debug_log("Temporarily activating diverter to search ball for %sms",
+                           self.config['ball_search_hold_time'])
             self._coil_activate()
             self.machine.delay.add(self.config['ball_search_hold_time'],
                                    self._coil_deactivate,