mpf 0.57.5.dev3__tar.gz → 0.80.0__tar.gz

{mpf-0.57.5.dev3 → mpf-0.80.0}/.github/workflows/run_tests.yml

@@ -18,10 +18,6 @@ jobs:
       fail-fast: false
       matrix:
         include:
-        - os: windows-latest
-          python-version: 3.8
-        - os: windows-latest
-          python-version: 3.9
         - os: windows-latest
           python-version: "3.10"
         - os: windows-latest
@@ -32,10 +28,7 @@ jobs:
           python-version: 3.13
         - os: windows-latest
           python-version: 3.14
-        - os: ubuntu-latest
-          python-version: 3.8
-        - os: ubuntu-latest
-          python-version: 3.9
+
         - os: ubuntu-latest
           python-version: "3.10"
         - os: ubuntu-latest
@@ -46,10 +39,7 @@ jobs:
           python-version: 3.13
         - os: ubuntu-latest
           python-version: 3.14
-        - os: macos-latest
-          python-version: 3.8
-        - os: macos-latest
-          python-version: 3.9
+
         - os: macos-latest
           python-version: "3.10"
         - os: macos-latest

{mpf-0.57.5.dev3 → mpf-0.80.0}/.gitignore

@@ -25,7 +25,8 @@ venv/
 #  Usually these files are written by a python script from a template
 #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 *.manifest
-*.spec
+# AVW: Going to include the spec at least for reference
+.spec
 
 # Installer logs
 pip-log.txt

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpf
-Version: 0.57.5.dev3
+Version: 0.80.0
 Summary: The Mission Pinball Framework (MPF)
 Author-email: The Mission Pinball Framework Team <brian@missionpinball.org>
 License: MIT
@@ -10,8 +10,6 @@ Keywords: pinball
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
-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
@@ -23,7 +21,7 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Topic :: Artistic Software
 Classifier: Topic :: Games/Entertainment :: Arcade
-Requires-Python: <3.15,>=3.8
+Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 License-File: AUTHORS.md
@@ -37,7 +35,7 @@ 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>=10.4.0
+Requires-Dist: Pillow>=11.3.0
 Provides-Extra: crash-reporter
 Requires-Dist: requests==2.28.2; extra == "crash-reporter"
 Provides-Extra: irc
@@ -61,7 +59,7 @@ Requires-Dist: protobuf==5.29.3; 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.57.5.dev3 → mpf-0.80.0}/mpf/_version.py

@@ -10,15 +10,18 @@ PyPI.
 
 """
 
-__version__ = '0.57.5.dev3'  # Also consider whether MPF-MC pyproject.toml should be updated
+__version__ = '0.80.0'
 '''The full version of MPF.'''
 
-__short_version__ = '0.57'
+__short_version__ = '0.80'
 '''The major.minor version of MPF.'''
 
 __bcp_version__ = '1.1'
 '''The version of BCP this build of MPF uses.'''
 
+__gmc_version__ = '1.0.0'
+'''The version of GMC this build of MPF requires.'''
+
 __config_version__ = '6'
 '''The config file version this build of MPF uses.'''
 

mpf-0.80.0/mpf/commands/both.py

@@ -0,0 +1,87 @@
+"""Command which launches both the MPF core engine and MPF-MC."""
+
+from importlib import import_module
+import argparse
+import configparser
+import shutil
+import subprocess
+import os
+import re
+
+
+def _start_mpf(mpf_path, machine_path, args):
+    module = import_module('mpf.commands.game')
+    module.Command(mpf_path, machine_path, args)
+
+
+def _spawn_gmc(gmc_args, mpf_args):
+    full_godot_exec_path = shutil.which(gmc_args.godot_exec_path)
+
+    # Verify that the godot executable exists
+    if not full_godot_exec_path:
+        raise FileNotFoundError("Unable to find Godot executable at '%s'. Please check this file, "
+                                "your PATH, or specify an executable with the -G argument." % gmc_args.godot_exec_path)
+
+    full_gmc_project_path = os.path.join(gmc_args.gmc_project_path, "project.godot")
+    try:
+        os.stat(full_gmc_project_path)
+    except FileNotFoundError:
+        raise FileNotFoundError("Unable to find GMC project.godot file in '%s'. Please check this folder "
+                                "or specify a project directory with the -g argument." % gmc_args.gmc_project_path)
+
+    # Some args for MPF we'll borrow as well
+    transferred_args = []
+    # TODO: Refactor the ArgParse to use subparsers
+    # and parent parsers to simplify the whole affair.
+    verbose_regex = r'-[\w]*[vV]'
+    if re.match(verbose_regex, " ".join(mpf_args)):
+        transferred_args.append("-v")
+
+    #pylint: disable-msg=consider-using-with
+    subprocess.Popen(
+        [full_godot_exec_path, *transferred_args],
+        cwd=gmc_args.gmc_project_path
+    )
+
+
+class Command:
+
+    """Command which runs game and gmc."""
+
+    def __init__(self, mpf_path, machine_path, args):
+        """Run game and gmc."""
+        # First load a config file for possible default values
+        config = configparser.ConfigParser(strict=False, allow_no_value=True)
+        try:
+            # It feels cleaner to use the same config file as GMC, even though the
+            # name is misleading
+            config_path = os.path.join(machine_path, "gmc.cfg")
+            os.stat(config_path)
+            config.read(config_path)
+        except FileNotFoundError:
+            pass
+
+        parser = argparse.ArgumentParser(description='Starts MPF and GMC concurrently')
+
+        parser.add_argument("-g",
+                            action="store", dest="gmc_project_path",
+                            default=config.get("cli", "gmc_project_path", fallback=machine_path).strip('\'"'),
+                            help="Path to the GMC project folder, if not current directory.")
+
+        parser.add_argument("-G",
+                            action="store", dest="godot_exec_path",
+                            default=config.get("cli", "godot_exec_path", fallback="godot").strip('\'"'),
+                            help="Path to the Godot executable")
+
+        parser.add_argument("-L",
+                            action="store", dest="gmc_log_file",
+                            metavar='gmc_log_file',
+                            default=config.get("cli", "gmc_log_file", fallback=None),
+                            help=argparse.SUPPRESS)
+
+        # Parse the GMC-specific args and pass the leftovers to MPF
+        gmc_args, mpf_args = parser.parse_known_args(args)
+
+        _spawn_gmc(gmc_args, mpf_args)
+
+        _start_mpf(mpf_path, machine_path, mpf_args)

{mpf-0.57.5.dev3 → mpf-0.80.0}/mpf/commands/game.py

@@ -140,17 +140,6 @@ class Command:
                                  "used for all"
                                  " devices")
 
-        # The following are just included for full compatibility with mc
-        # which is needed when using "mpf both".
-
-        parser.add_argument("-L",
-                            action="store", dest="mc_file_name",
-                            metavar='mc_file_name',
-                            default=None, help=argparse.SUPPRESS)
-
-        parser.add_argument("--no-sound",
-                            action="store_true", dest="no_sound", default=False)
-
         self.args = parser.parse_args(args)
         self.args.configfile = Util.string_to_event_list(self.args.configfile)
 
@@ -160,10 +149,10 @@ class Command:
             if exception.errno != errno.EEXIST:
                 raise
 
-        full_logfile_path = os.path.join(machine_path, self.args.logfile)
+        self.args.full_logfile_path = os.path.join(machine_path, self.args.logfile)
 
         try:
-            os.remove(full_logfile_path)
+            os.remove(self.args.full_logfile_path)
         except OSError:
             pass
 
@@ -188,7 +177,7 @@ class Command:
         self.console_queue_listener.start()
 
         # initialize file log
-        file_log = logging.FileHandler(full_logfile_path)
+        file_log = logging.FileHandler(self.args.full_logfile_path)
         if self.args.jsonlogging:
             formatter = JSONFormatter()
         else:
@@ -273,8 +262,12 @@ class Command:
             logging.exception(exception)
 
         logging.shutdown()
-        self.console_queue_listener.stop()
-        self.file_queue_listener.stop()
+        if self.console_queue_listener:
+            self.console_queue_listener.stop()
+            self.console_queue_listener = None
+        if self.file_queue_listener:
+            self.file_queue_listener.stop()
+            self.file_queue_listener = None
 
         if self.args.pause:
             input('Press ENTER to continue...')     # nosec

mpf-0.80.0/mpf/commands/init.py

@@ -0,0 +1,70 @@
+"""Command to initialize an MPF project folder."""
+
+import os
+import pathlib
+import shutil
+
+SUBCOMMAND = True
+INITIAL_MODES = ("attract", "base")
+
+
+class Command:
+
+    """Initializes an MPF project folder."""
+
+    __slots__ = ("path", )
+
+    def __init__(self, argv, path):
+        """Generate config and mode folders."""
+        # If a path is provided, use it
+        if len(argv) > 1:
+            path = os.path.join(path, argv[1])
+        self.path = path
+
+        print(f"Initializing MPF project at path {self.path}")
+
+        try:
+            os.stat(self.path)
+        except FileNotFoundError:
+            os.makedirs(self.path)
+
+        self.generate_config_file()
+        self.generate_mode_folder()
+
+        print("MPF project initialization complete!")
+
+    def generate_config_file(self):
+        """Create a config folder and default config.yaml file."""
+        config_dir = os.path.join(self.path, "config")
+        try:
+            os.stat(config_dir)
+        except FileNotFoundError:
+            os.mkdir(config_dir)
+
+        config_file = os.path.join(config_dir, "config.yaml")
+        try:
+            os.stat(config_file)
+        except FileNotFoundError:
+            base_config_file = os.path.join(pathlib.Path(__file__).parent.absolute(), "templates/config.yaml")
+            shutil.copy2(base_config_file, config_file)
+
+    def generate_mode_folder(self):
+        """Create mode folder and default mode subfolders."""
+        mode_dir = os.path.join(self.path, "modes")
+        try:
+            os.stat(mode_dir)
+        except FileNotFoundError:
+            os.mkdir(mode_dir)
+
+        for mode in INITIAL_MODES:
+            mode_path = os.path.join(mode_dir, mode, "config")
+            try:
+                os.stat(mode_path)
+            except FileNotFoundError:
+                os.makedirs(mode_path)
+            mode_config = os.path.join(mode_path, f"{mode}.yaml")
+            try:
+                os.stat(mode_config)
+            except FileNotFoundError:
+                mode_config_template = os.path.join(pathlib.Path(__file__).parent.absolute(), f"templates/{mode}.yaml")
+                shutil.copy2(mode_config_template, mode_config)

mpf-0.80.0/mpf/commands/templates/attract.yaml

@@ -0,0 +1,7 @@
+#config_version=6
+
+# Attract mode that starts when the machine boots up, stops
+# whenever a game is started, and re-starts after the game ends.
+
+slide_player:
+  mode_attract_started: attract

mpf-0.80.0/mpf/commands/templates/base.yaml

@@ -0,0 +1,9 @@
+#config_version=6
+
+# Base mode that starts at the beginning of each ball
+# and stops at the end of each ball.
+
+mode:
+  start_events: ball_starting
+  stop_events: ball_will_end
+  priority: 100

mpf-0.80.0/mpf/commands/templates/config.yaml

@@ -0,0 +1,12 @@
+#config_version=6
+
+## MPF Main Machine Config File
+#
+# This file defines your system-wide properties like switches,
+# drivers, ball devices, hardware platforms, and more. You can
+# include everything here, or create sub-config files to be
+# imported and merged with this one.
+
+modes:
+  - attract
+  - base

mpf-0.80.0/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.57.5.dev3 → mpf-0.80.0}/mpf/config_players/plugin_player.py

@@ -1,5 +1,6 @@
 """Plugin config player."""
 from mpf.config_players.device_config_player import DeviceConfigPlayer
+from mpf.core.placeholder_manager import BaseTemplate, NativeTypeTemplate
 
 
 class PluginPlayer(DeviceConfigPlayer):
@@ -80,9 +81,24 @@ class PluginPlayer(DeviceConfigPlayer):
 
     def play(self, settings, context, calling_context, priority=0, **kwargs):
         """Trigger remote player via BCP."""
+        # The triggering event's kwargs are passed through, and the triggering
+        # event may have come from BCP. Explicitly set _from_bcp=False so that
+        # this play event won't be swallowed.
+        if '_from_bcp' in kwargs:
+            del kwargs['_from_bcp']
+        # If any templates need evaluating, do so *before* sending via BCP
+        eval_settings = {}
+        for s, settings_dict in settings.items():
+            for key, value in settings_dict.items():
+                if isinstance(value, (BaseTemplate, NativeTypeTemplate)):
+                    if s not in eval_settings:
+                        eval_settings[s] = settings_dict.copy()
+                    eval_settings[s][key] = value.evaluate(kwargs)
+
         self.machine.bcp.interface.bcp_trigger(
             name='{}_play'.format(self.show_section),
-            settings=settings, context=context, calling_context=calling_context,
+            settings={**settings, **eval_settings},
+            context=context, calling_context=calling_context,
             priority=priority, **kwargs)
 
     def clear_context(self, context):

mpf-0.80.0/mpf/config_players/slide_player.py

@@ -0,0 +1,36 @@
+"""Slide player for MPF to support GMC."""
+from functools import partial
+
+from mpf.config_players.plugin_player import PluginPlayer
+
+
+class SlidePlayer(PluginPlayer):
+
+    """Base class for part of the slide 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 = 'slide_player'
+    show_section = 'slides'
+
+    def _validate_config_item(self, device, device_settings):
+        # device is slide name, device_settings is configuration
+
+        device_settings = self.machine.config_validator.validate_config(
+            'slide_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/mpf/config_players/sound_player.py

@@ -0,0 +1,39 @@
+"""Sound player plugin for MPF to support GMC."""
+from functools import partial
+from mpf.config_players.plugin_player import PluginPlayer
+
+
+class SoundPlayer(PluginPlayer):
+
+    """Base class for part of the sound 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 mpf-mc. MPF finds this instance because the mpf-mc setup.py
+    has the following entry_point configured:
+
+        sound_player=mpfmc.config_players.sound_player:register_with_mpf
+
+    """
+
+    config_file_section = 'sound_player'
+    show_section = 'sounds'
+
+    def _validate_config_item(self, device, device_settings):
+        # device is slide name, device_settings is configuration
+
+        device_settings = self.machine.config_validator.validate_config(
+            'sound_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/mpf/config_players/widget_player.py

@@ -0,0 +1,34 @@
+"""Widget player plugin for MPF to support GMC."""
+from functools import partial
+from mpf.config_players.plugin_player import PluginPlayer
+
+
+class WidgetPlayer(PluginPlayer):
+
+    """Widget Player in MPF.
+
+    Note: This class is loaded by MPF and everything in it is in the context of MPF.
+    """
+
+    config_file_section = 'widget_player'
+    show_section = 'widgets'
+
+    def _validate_config_item(self, device, device_settings):
+        # device is slide name, device_settings is configuration
+
+        device_settings = self.machine.config_validator.validate_config(
+            'widget_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))