mpf 0.57.0.dev35__tar.gz → 0.57.0.dev36__tar.gz

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/PKG-INFO

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

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/_version.py

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

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/assets/show.py

@@ -604,7 +604,7 @@ class RunningShow:
         Updates the values of a show while it runs. Currently supports only speed
         and manual_advance properties.
         """
-        updated_values = {k: v for k, v in kwargs.items() if v is not None and v != getattr(self.show_config, k)}
+        updated_values = {k: v for k, v in kwargs.items() if v is not None}
         if updated_values:
             self.show_config = self.show_config._replace(**updated_values)
 

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/config_players/show_player.py

@@ -197,10 +197,9 @@ class ShowPlayer(DeviceConfigPlayer):
         del show
         del queue
         del start_time
-        del placeholder_args
         if key in instance_dict:
             instance_dict[key].update(
-                speed=show_settings.get('speed'),
+                speed=show_settings['speed'].evaluate(placeholder_args),
                 manual_advance=show_settings.get('manual_advance')
             )
 

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/config_spec.yaml

@@ -92,10 +92,16 @@ assets:
 auditor:
     __valid_in__: machine
     __type__: config
+    enable_events: list|event_handler|game_starting
+    disable_events: list|event_handler|game_ended
     save_events: event_handler|event_handler:ms|ball_ended
     audit: list|str|None
+    autosave: single|bool|true
+    autosave_events: single|bool|true
     events: list|event_handler|None
     player: list|str|None
+    audit_shots: single|bool|true
+    missing_switch_min_games: single|int|10
     num_player_top_records: single|int|1
     reset_audit_events: list|event_handler|auditor_reset,factory_reset
 autofire_coils:
@@ -180,7 +186,7 @@ ball_device_counter_entrance_switches:
 ball_device_ejector_event:
     class: ignore
     events_when_eject_try: list|event_posted|None
-    events_when_reoder_balls: list|event_posted|None
+    events_when_reorder_balls: list|event_posted|None
     events_when_ball_search: list|event_posted|None
 ball_device_ejector_pulse:
     class: ignore
@@ -313,6 +319,7 @@ coils:
     disable_events: event_handler|event_handler:ms|None
     enable_events: event_handler|event_handler:ms|None
     pulse_events: event_handler|event_handler:ms|None
+    timed_enable_events: event_handler|event_handler:ms|None
     platform_settings: single|dict|None
     psu: single|machine(psus)|default
     platform: single|str|None
@@ -1136,6 +1143,7 @@ multiball_locks:
     __type__: device
     balls_to_lock: single|int|
     balls_to_replace: single|int|-1
+    ball_lost_action: single|str|None
     blocking_facility: single|str|None
     lock_devices: list|machine(ball_devices)|
     source_devices: list|machine(ball_devices)|None
@@ -1787,6 +1795,7 @@ sound_player:
     delay: single|secs|None
     track: single|str|None
     volume: single|gain|None
+    ducking: single|subconfig(sound_ducking)|None
     pan: single|float_or_token|None
     loops: single|int_or_token|None
     priority: single|int_or_token|None

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/core/ball_search.py

@@ -104,8 +104,7 @@ class BallSearch(MpfController):
             restore_callback: optional callback to restore state of the device
                 after ball search ended
         """
-        self.debug_log("Registering callback: {} (priority: {})".format(
-            name, priority))
+        self.debug_log("Registering callback: %s (priority: %s)", name, priority)
         self.callbacks.append(BallSearchCallback(priority, callback, name, restore_callback))
         # sort by priority
         self.callbacks = sorted(self.callbacks, key=lambda entry: entry.priority)
@@ -279,8 +278,8 @@ class BallSearch(MpfController):
                     'ball_search_wait_after_iteration']
 
             # if a callback returns True we wait for the next one
-            self.debug_log("Ball search: {} (phase: {}  iteration: {})".format(
-                element.name, self.phase, self.iteration))
+            self.debug_log("Ball search: %s (phase: %s  iteration: %s)",
+                element.name, self.phase, self.iteration)
             if element.callback(self.phase, self.iteration):
                 self.delay.add(name='run', callback=self._run, ms=timeout)
                 return

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/core/bcp/bcp_interface.py

@@ -458,7 +458,8 @@ class BcpInterface(MpfController):
             self.machine.register_monitor('machine_vars', self._machine_var_change)
 
         # Send initial machine variable values
-        self._send_machine_vars(client)
+        for s in ("standard", "feature", "game", "coin"):
+            self._send_machine_vars(client, setting_type=s)
 
         # Establish handler for machine variable changes
         self.machine.bcp.transport.add_handler_to_transport("_machine_vars", client)
@@ -470,9 +471,10 @@ 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):
+    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()))
+            client, bcp_command='settings',
+            settings=Util.convert_to_simply_type(self.machine.settings.get_settings(setting_type)))
         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.0.dev35 → mpf-0.57.0.dev36}/mpf/core/config_player.py

@@ -161,7 +161,7 @@ class ConfigPlayer(LogMixin, metaclass=abc.ABCMeta):
         try:
             return self.instances[context][self.config_file_section]
         except KeyError:
-            self.warning_log("Config player {} is missing context {}".format(self.config_file_section, context))
+            self.warning_log("Config player %s is missing context %s", self.config_file_section, context)
             return {}
 
     def _reset_instance_dict(self, context):

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/core/machine.py

@@ -499,7 +499,7 @@ class MachineController(LogMixin):
 
             for custom_code in Util.string_to_event_list(self.config['custom_code']):
 
-                self.debug_log(f"Loading {custom_code} custom code")
+                self.debug_log("Loading %s custom code", custom_code)
 
                 custom_code_obj = Util.string_to_class(custom_code)(
                     machine=self,
@@ -656,7 +656,7 @@ class MachineController(LogMixin):
                                                           timeout=timeout))
         except asyncio.TimeoutError:
             self._crash_shutdown()
-            self.error_log("MPF needed more than {}s for initialization. Aborting!".format(timeout))
+            self.error_log("MPF needed more than %ss for initialization. Aborting!", timeout)
             return False
         except RuntimeError as e:
             self._crash_shutdown()

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/core/mpf_controller.py

@@ -34,4 +34,4 @@ class MpfController(LogMixin, metaclass=abc.ABCMeta):
             self.machine.config['logging']['console'][self.config_name],
             self.machine.config['logging']['file'][self.config_name])
 
-        self.debug_log("Loading the {}".format(self.module_name))
+        self.debug_log("Loading the %s", self.module_name)

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/core/placeholder_manager.py

@@ -907,8 +907,8 @@ class BasePlaceholderManager(MpfController):
                     match_dict['number'] = type(default_number)(match_dict['number'])
                 # Gracefully fall back if the number can't be parsed
                 except ValueError:
-                    self.warning_log("Condition '{}' has invalid number value '{}'".format(
-                                     template, match_dict['number']))
+                    self.warning_log("Condition '%s' has invalid number value '%s'",
+                                     template, match_dict['number'])
                     match_dict['number'] = default_number
         return ConditionalEvent(match_dict["name"], match_dict["condition"], match_dict["number"])
 

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/core/settings_controller.py

@@ -85,18 +85,17 @@ class SettingsController(MpfController):
             value = self.machine.variables.get_machine_var(self._settings[setting_name].machine_var)
 
         if value not in self._settings[setting_name].values:
-            self.warning_log("Setting {} contained an invalid value {}. Falling back to default: {}".format(
-                setting_name, value, self._settings[setting_name].default
-            ))
+            self.warning_log("Setting %s contained an invalid value %s. Falling back to default: %s",
+                             setting_name, value, self._settings[setting_name].default)
             value = self._settings[setting_name].default
 
-        self.debug_log("Retrieving value: {}={}".format(setting_name, value))
+        self.debug_log("Retrieving value: %s=%s", setting_name, value)
 
         return value
 
     def set_setting_value(self, setting_name, value):
         """Set the value of a setting."""
-        self.debug_log("New value: {}={}".format(setting_name, value))
+        self.debug_log("New value: %s=%s", setting_name, value)
 
         if setting_name not in self._settings:
             raise AssertionError("Invalid setting {}".format(setting_name))

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/core/show_controller.py

@@ -48,7 +48,7 @@ class ShowController(MpfController):
         del kwargs
         show_names = self.machine.mpf_config.get_shows()
         for show_name in show_names:
-            self.log.debug(f"Loading show: {show_name}")
+            self.log.debug("Loading show: %s", show_name)
             show_config = self.machine.mpf_config.get_show_config(show_name)
             self.machine.shows[show_name].load(show_config)
 
@@ -68,7 +68,7 @@ class ShowController(MpfController):
                              "there's already a show with that name. Shows are"
                              " shared machine-wide".format(name))
 
-        self.debug_log("Registering show: {}".format(name))
+        self.debug_log("Registering show: %s", name)
         self.machine.shows[name] = Show(self.machine,
                                         name=name)
 

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/core/text_ui.py

@@ -80,7 +80,7 @@ class TextUi(MpfController):
         self.screen = None
 
         if not machine.options['text_ui'] or not Scene:
-            self.log.debug(f"Text UI is disabled. TUI option setting: {machine.options['text_ui']}, Asciimatics loaded: {Scene}")
+            self.log.debug("Text UI is disabled. TUI option setting: %s, Asciimatics loaded: %s", machine.options['text_ui'], Scene)
             return
 
         # hack to add themes until https://github.com/peterbrittain/asciimatics/issues/207 is implemented

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/devices/ball_device/ball_device.py

@@ -141,7 +141,8 @@ class BallDevice(SystemWideDevice):
     async def lost_idle_ball(self):
         """Lost an ball while the device was idle."""
         # handle lost balls
-        self.warning_log("Ball disappeared while idle. This should not normally happen.")
+        if self.state == "idle":
+            self.warning_log("Ball disappeared while idle. This should not normally happen.")
         self.available_balls -= 1
         self.config['ball_missing_target'].add_missing_balls(1)
         await self._balls_missing(1)

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/devices/ball_device/event_ejector.py

@@ -22,7 +22,7 @@ class EventEjector(BallDeviceEjector):
 
     async def reorder_balls(self):
         """Reorder balls when jammed."""
-        for event in self.config["events_when_reoder_balls"]:
+        for event in self.config["events_when_reorder_balls"]:
             self.machine.events.post(event)
 
     def ball_search(self, phase, iteration):

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/devices/ball_device/outgoing_balls_handler.py

@@ -424,6 +424,26 @@ class OutgoingBallsHandler(BallDeviceStateHandler):
             result = await self._handle_confirm(eject_request, ball_eject_process, incoming_ball_at_target,
                                                 eject_try)
             await self.ball_device.ball_count_handler.end_eject(ball_eject_process, result)
+
+            # Check if more balls left than expected, meaning the ejector kicked out multiple
+            # balls. If so, tag those missing balls as lost (except for mechanical ejects, which
+            # may be expected, and troughs, which may jam)
+            if "trough" not in self.ball_device.tags and not self.ball_device.config['mechanical_eject']:
+                new_balls = await self.ball_device.ball_count_handler.counter.count_balls()
+                old_balls = self.ball_device.counted_balls
+
+                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()
+                    # Cancel the eject queue for the lost ball
+                    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)
+
             return result
         except asyncio.CancelledError:
             ball_eject_process.cancel()

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/devices/ball_hold.py

@@ -220,12 +220,16 @@ class BallHold(EnableDisableMixin, SystemWideDevice, ModeDevice):
         # register on ball_enter of hold_devices
         for device in self.hold_devices:
             self.machine.events.add_handler(
-                'balldevice_' + device.name + '_ball_enter',
+                f'balldevice_{device.name}_ball_enter',
                 self._hold_ball, device=device, priority=priority)
+            self.machine.events.add_handler(
+                f'balldevice_{device.name}_ball_missing',
+                self._lost_ball, device=device, priority=priority)
 
     def _unregister_handlers(self):
         # unregister ball_enter handlers
         self.machine.events.remove_handler(self._hold_ball)
+        self.machine.events.remove_handler(self._lost_ball)
 
     def is_full(self):
         """Return true if hold is full."""
@@ -238,6 +242,16 @@ class BallHold(EnableDisableMixin, SystemWideDevice, ModeDevice):
             balls = 0
         return balls
 
+    def _lost_ball(self, device, balls, **kwargs):
+        """Handle the ball hold devices losing a ball."""
+        if self.balls_held:
+            self.balls_held -= balls
+            self.info_log("Ball device %s lost %s balls, hold now has %s balls held", device, balls, self.balls_held)
+        else:
+            self.info_log("Ball device %s lost %s balls but hold is not holding. Doing nothing.", device, balls)
+        # Do not claim this ball
+        return { 'balls': balls }
+
     def _hold_ball(self, device, new_balls, unclaimed_balls, **kwargs):
         """Handle result of _ball_enter event of hold_devices."""
         del new_balls

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/devices/ball_save.py

@@ -78,10 +78,10 @@ class BallSave(SystemWideDevice, ModeDevice):
         self.enabled = True
         self.state = 'enabled'
         self.active_time = self.config['active_time'].evaluate([])
-        self.debug_log("Enabling. Auto launch: {}, Balls to save: {}, Active time: {}s".format(
+        self.debug_log("Enabling. Auto launch: %s, Balls to save: %s, Active time: %ss",
                        self.config['auto_launch'],
                        self.config['balls_to_save'],
-                       self.active_time))
+                       self.active_time)
 
         # Enable shoot again
         self.machine.events.add_handler('ball_drain',

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/devices/blinkenlight.py

@@ -56,7 +56,7 @@ class Blinkenlight(SystemWideDevice):
         # check if this key already exists. If it does, replace it with the incoming color/priority
         self._colors = [x for x in self._colors if x[1] != key]
         self._colors.append((color, key, priority))
-        self.info_log('Color {} with key {} added'.format(color, key))
+        self.info_log('Color %s with key %s added', color, key)
         self._update_light()
 
     def remove_all_colors(self):
@@ -70,7 +70,7 @@ class Blinkenlight(SystemWideDevice):
         old_len = len(self._colors)
         self._colors = [x for x in self._colors if x[1] != key]
         if len(self._colors) != old_len:
-            self.info_log('Color removed with key {}'.format(key))
+            self.info_log('Color removed with key %s', key)
             self._update_light()
 
     def _update_light(self):

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/devices/flipper.py

@@ -125,7 +125,7 @@ class Flipper(SystemWideDevice):
 
         To prevent multiple rules at the same time we prioritize disable > enable.
         """
-        self.debug_log(f"Disabling via event callback. kwargs: {kwargs}")
+        self.debug_log("Disabling via event callback. kwargs: %s", kwargs)
         self.disable()
 
     def disable(self):

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/devices/multiball.py

@@ -78,7 +78,7 @@ class Multiball(EnableDisableMixin, SystemWideDevice, ModeDevice):
     def _handle_balls_in_play_and_balls_live(self):
         ball_count = self.config['ball_count'].evaluate([])
         balls_to_replace = self.machine.game.balls_in_play if self.config['replace_balls_in_play'] else 0
-        self.debug_log("Going to add an additional {} balls for replace_balls_in_play".format(balls_to_replace))
+        self.debug_log("Going to add an additional %s balls for replace_balls_in_play", balls_to_replace)
 
         if self.config['ball_count_type'] == "total":
             # policy: total balls

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/devices/multiball_lock.py

@@ -54,6 +54,10 @@ class MultiballLock(EnableDisableMixin, ModeDevice):
         self.machine.events.add_handler("player_turn_starting", self._player_turn_starting)
         self.machine.events.add_handler("ball_ending", self._ball_ending)
 
+        for device in self.lock_devices:
+            self.machine.events.add_handler(f'balldevice_{device.name}_ball_missing',
+                                            self._lost_ball, device=device)
+
     def _enable(self):
         """Enable the lock.
 
@@ -315,18 +319,29 @@ class MultiballLock(EnableDisableMixin, ModeDevice):
         '''
 
         # schedule eject of new balls for all physically locked balls
-        if self.config['balls_to_replace'] == -1 or self.locked_balls <= self.config['balls_to_replace']:
-            self.debug_log("{} locked balls and {} to replace, requesting {} new balls"
-                           .format(self.locked_balls, self.config['balls_to_replace'], balls_to_lock_physically))
+        if self.config['balls_to_replace'] == -1 or new_locked_balls <= self.config['balls_to_replace']:
+            self.info_log("%s locked balls and %s to replace, requesting %s new balls",
+                          new_locked_balls, self.config['balls_to_replace'], balls_to_lock_physically)
             self._request_new_balls(balls_to_lock_physically)
         else:
-            self.debug_log("{} locked balls exceeds {} to replace, not requesting any balls"
-                           .format(self.locked_balls, self.config['balls_to_replace']))
+            self.info_log("%s locked balls exceeds %s to replace, not requesting any balls",
+                          new_locked_balls, self.config['balls_to_replace'])
 
-        self.debug_log("Locked %s balls virtually and %s balls physically", balls_to_lock, balls_to_lock_physically)
+        self.info_log("Locked %s balls virtually and %s balls physically", balls_to_lock, balls_to_lock_physically)
 
         return {'unclaimed_balls': unclaimed_balls - balls_to_lock_physically}
 
+    def _lost_ball(self, device, balls, **kwargs):
+        del kwargs
+        self.info_log("Ball device %s lost %s balls, %s has %s locked balls and action %s",
+                      device.name, balls, self.name, self.locked_balls,
+                      self.config['ball_lost_action'] )
+        if self.locked_balls and self.config['ball_lost_action'] == "add_to_play":
+            self.info_log("Ball device %s lost %s balls, adding to balls_in_play", device.name, balls)
+            self.machine.game.balls_in_play += balls
+        # Do not claim the ball
+        return {'balls': balls}
+
     def _post_events(self, device, **kwargs):
         """Post events on callback from _ball_entered handler.
 

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/devices/playfield.py

@@ -315,6 +315,7 @@ class Playfield(SystemWideDevice):
             self.machine.ball_controller.add_captured_ball(self)
 
     def _source_device_ball_lost(self, target, **kwargs):
+        self.debug_log("Ball lost from source device %s with target %s", target.name, self.name)
         del kwargs
         if target == self:
             self.available_balls -= 1

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/devices/shot.py

@@ -242,9 +242,9 @@ class Shot(EnableDisableMixin, ModeDevice):
 
         priority = settings['priority'] + self.mode.priority
         if not start_step:
-            start_step = settings['start_step']
+            start_step = show_tokens.get('start_step') or settings['start_step']
 
-        self.debug_log("Playing show: %s. %s", show_name, settings)
+        self.debug_log("Playing show: %s (starting at step %s). %s", show_name, start_step, settings)
 
         show_config = self.machine.show_controller.create_show_config(
             show_name, priority=priority, speed=settings.get("speed"),

{mpf-0.57.0.dev35 → mpf-0.57.0.dev36}/mpf/devices/timer.py

@@ -185,15 +185,12 @@ class Timer(ModeDevice):
 
         Args:
         ----
-            **kwargs: Not used in this method. Only exists since this method is
-                often registered as an event handler which may contain
-                additional keyword arguments.
+            **kwargs: Optional kwargs that may affect the evaluation of the
+                timer value placeholder template.
         """
-        del kwargs
-
         self.debug_log("Resetting timer. New value: %s", self.start_value)
 
-        self.jump(self.start_value)
+        self.jump(self.start_value, **kwargs)
 
     def start(self, **kwargs):
         """Start this timer based on the starting value that's already been configured.
@@ -246,12 +243,10 @@ class Timer(ModeDevice):
 
         Args:
         ----
-            **kwargs: Not used in this method. Only exists since this method is
-                often registered as an event handler which may contain
-                additional keyword arguments.
+            **kwargs: Optional kwargs that may affect the evaluation of the
+                timer value placeholder template.
         """
-        del kwargs
-        self.reset()
+        self.reset(**kwargs)
         # If the timer is not running, start it
         if not self.running:
             self.start()
@@ -300,16 +295,13 @@ class Timer(ModeDevice):
             timer_value: How many seconds you want to pause the timer for. Note
                 that this pause time is real-world seconds and does not take
                 into consideration this timer's tick interval.
-            **kwargs: Not used in this method. Only exists since this method is
-                often registered as an event handler which may contain
-                additional keyword arguments.
+            **kwargs: Optional kwargs that may affect the evaluation of the
+                timer value placeholder template.
         """
-        del kwargs
-
         if not timer_value:
             pause_ms = 0  # make sure it's not None, etc.
         else:
-            pause_ms = self._get_timer_value(timer_value) * 1000  # delays happen in ms
+            pause_ms = self._get_timer_value(timer_value, in_ms=True, **kwargs)  # delays happen in ms
 
         self.info_log("Pausing Timer for %s ms", pause_ms)
 
@@ -417,13 +409,10 @@ class Timer(ModeDevice):
         ----
             timer_value: The number of ticks you want to add to this timer's
                 current value.
-            kwargs: Not used in this method. Only exists since this method is
-                often registered as an event handler which may contain
-                additional keyword arguments.
+            **kwargs: Optional kwargs that may affect the evaluation of the
+                timer value placeholder template.
         """
-        del kwargs
-
-        timer_value = self._get_timer_value(timer_value)
+        timer_value = self._get_timer_value(timer_value, **kwargs)
         ticks_added = timer_value
 
         new_value = self.ticks + ticks_added
@@ -457,13 +446,10 @@ class Timer(ModeDevice):
         ----
             timer_value: The number of ticks you want to subtract from this
                 timer's current value.
-            **kwargs: Not used in this method. Only exists since this method is
-                often registered as an event handler which may contain
-                additional keyword arguments.
+            **kwargs: Optional kwargs that may affect the evaluation of the
+                timer value placeholder template.
         """
-        del kwargs
-
-        ticks_subtracted = self._get_timer_value(timer_value)
+        ticks_subtracted = self._get_timer_value(timer_value, **kwargs)
 
         self.ticks -= ticks_subtracted
 
@@ -526,10 +512,19 @@ class Timer(ModeDevice):
             self.timer = None
 
     @staticmethod
-    def _get_timer_value(timer_value):
+    def _get_timer_value(timer_value, in_ms=False, **kwargs):
+        """Return an int value for the number of ticks on the timer."""
+        if hasattr(timer_value, "evaluate"):
+            # Convert to int for ticks; config_spec must be float for change_tick_interval
+            return int(timer_value.evaluate(kwargs) * (1000 if in_ms else 1))
+        return timer_value
+
+    @staticmethod
+    def _get_timer_tick_secs(timer_value, **kwargs):
+        """Return a float value for the number of seconds between each tick."""
         if hasattr(timer_value, "evaluate"):
             # Convert to int for ticks; config_spec must be float for change_tick_interval
-            return int(timer_value.evaluate([]))
+            return timer_value.evaluate(kwargs)
         return timer_value
 
     def change_tick_interval(self, change=0.0, **kwargs):
@@ -541,14 +536,10 @@ class Timer(ModeDevice):
                 tick rate. Note this value is multiplied by the current tick
                 interval: >1 will increase the tick interval (slow the timer) and
                 <1 will decrease the tick interval (accelerate the timer).
-                To set an absolute value, use the set_tick_interval() method.
-            **kwargs: Not used in this method. Only exists since this method is
-                often registered as an event handler which may contain
-                additional keyword arguments.
+            **kwargs: Optional kwargs that may affect the evaluation of the
+                timer value placeholder template.
         """
-        del kwargs
-
-        self.tick_secs *= change.evaluate([])
+        self.tick_secs *= change.evaluate(kwargs)
         self._create_system_timer()
 
     def set_tick_interval(self, timer_value, **kwargs):
@@ -561,11 +552,10 @@ class Timer(ModeDevice):
         ----
             timer_value: The new number of seconds between each tick of this
                 timer. This value should always be positive.
-            **kwargs: Not used in this method. Only exists since this method is
-                often registered as an event handler which may contain
-                additional keyword arguments.
+            **kwargs: Optional kwargs that may affect the evaluation of the
+                timer value placeholder template.
         """
-        self.tick_secs = abs(self._get_timer_value(timer_value.evaluate(kwargs)))
+        self.tick_secs = abs(self._get_timer_tick_secs(timer_value, **kwargs))
         self._create_system_timer()
 
     def jump(self, timer_value, **kwargs):
@@ -577,13 +567,10 @@ class Timer(ModeDevice):
         Args:
         ----
             timer_value: Integer of the current value you want this timer to be.
-            **kwargs: Not used in this method. Only exists since this method is
-                often registered as an event handler which may contain
-                additional keyword arguments.
+            **kwargs: Optional kwargs that may affect the evaluation of the
+                timer value placeholder template.
         """
-        del kwargs
-
-        self.ticks = self._get_timer_value(timer_value)
+        self.ticks = self._get_timer_value(timer_value, **kwargs)
 
         if self.max_value and self.ticks > self.max_value:
             self.ticks = self.max_value