def __init__(self, name='', file=None):
"""
Constructor arguments:
- *name* (*str*, default *empty string*) --
name of the Windows system sound to play. This argument is
effectively an alias for *file* on other platforms.
- *file* (*str*, default *None*) --
path of wave file to play when the action is executed.
If *name* and *file* are both *None*, then waveform playback
will be silenced on Windows when the action is executed. Nothing
will happen on other platforms.
"""
ActionBase.__init__(self)
self._flags = 0
if file is not None:
self._name = file
if os.name == 'nt':
self._flags = winsound.SND_FILENAME
else:
self._name = name
if os.name == 'nt':
self._flags = winsound.SND_ALIAS
# Expand ~ constructions and shell variables in the file path if
# necessary.
if file is not None or os.name != 'nt':
self._name = os.path.expanduser(os.path.expandvars(self._name))
self._str = str(self._name)
def __init__(self, *args, **kwargs):
"""
Constructor arguments:
- *args* (variable argument list of *str*'s) --
these strings are passed to subprocess.Popen()
to start the application as a child process
- *cwd* (*str*, default *None*) --
if not *None*, then start the application in this
directory
- *focus_after_start* (*bool*, default *False*) --
if *True*, then attempt to bring the window to the foreground
after starting the application.
A single *list* or *tuple* argument can be used instead of
variable arguments.
"""
ActionBase.__init__(self)
if len(args) == 1 and isinstance(args[0], (tuple, list)):
args = args[0] # use the sub-list instead
self._args = args
self._cwd = kwargs.pop("cwd", None)
self._focus_after_start = kwargs.pop("focus_after_start", False)
if kwargs:
raise ActionError("Invalid keyword arguments: %r" % kwargs)
# Expand any variables within path names.
self._args = [self._interpret(a) for a in self._args]
if self._cwd:
self._cwd = self._interpret(self._cwd)
self._str = str(", ".join(repr(a) for a in self._args))
def __init__(self, function, remap_data=None, **defaults):
"""
Constructor arguments:
- *function* (callable) --
the function to call when this action is executed
- *remap_data* (dict, default: None) --
optional dict of data keys to function keyword arguments
- defaults --
default keyword-values for the arguments with which
the function will be called
"""
ActionBase.__init__(self)
self._function = function
self._defaults = defaults
self._remap_data = remap_data or {}
self._str = function.__name__
# Get argument names and defaults. Use getfullargspec() in Python 3
# to avoid deprecation warnings.
if six.PY2:
# pylint: disable=deprecated-method
argspec = inspect.getargspec(self._function)
else:
argspec = inspect.getfullargspec(self._function)
args, varkw = argspec[0], argspec[2]
self._filter_keywords = not varkw
self._valid_keywords = set(args)
def __init__(self, default=None, actions=None):
'''
Constructor arguments:
- *default* (action object, default *do nothing*) -- the
default action to execute if there was no matching context in
*actions*.
- *actions* (iterable, default *empty list*) -- an iterable
object containing context-action pairs. The action of the
first matching context will be executed.
'''
if actions is None:
actions = []
# Validate default action.
# Use a new ActionBase action (to do nothing) if default is None.
if default is None:
self._log_init.debug("Using default action for ContextAction")
default = ActionBase()
# Otherwise check if default is an action.
elif not isinstance(default, ActionBase):
raise TypeError("Default action for ContextAction should be an "
"ActionBase or None, not %s." % default)
# Set the default action.
self.default = default
# Validate the actions list.
# Check if it can be converted to a dictionary. or convert it to a
# is one already (for consistent evaluation order).
if not isinstance(actions, dict):
dict(actions) # can raise a ValueError
# Convert dictionaries to lists instead for consistent evaluation
# order.
else:
actions = list(actions.items())
# Check the types of all keys and values.
for (context, action) in actions:
if not isinstance(context, Context):
raise TypeError("ContextAction actions list contains "
"unexpected object: %s, instead of a "
"Context." % context)
if not isinstance(action, ActionBase):
raise TypeError("ContextAction actions list contains "
"unexpected object: %s, instead of an "
"ActionBase." % action)
# Set the actions list.
self.actions = actions
ActionBase.__init__(self)
def __init__(self,
command=None,
process_command=None,
synchronous=False,
hide_window=True):
"""
Constructor arguments:
- *command* (str or list) -- the command to run when this
action is executed. It will be parsed by :meth:`shlex.split`
if it is a string and passed directly to ``subprocess.Popen``
if it is a list. Command arguments can be included.
- *process_command* (callable) -- optional callable to invoke
with the :class:`Popen` object after successfully starting
the subprocess. Using this argument overrides the
:meth:`process_command` method.
- *synchronous* (bool, default *False*) -- whether to wait
until :meth:`process_command` has finished executing before
continuing.
- *hide_window* (bool, default *True*) -- whether to hide the
application window. Set to *False* if using this action with
GUI programs. This argument only applies to Windows. It has
no effect on other platforms.
"""
ActionBase.__init__(self)
self._proc = None
# Complex handling of arguments because of clashing use of the names
# at the class level: property & class-value.
if command is not None:
self.command = command
command_types = (string_types, list)
if not (self.command and isinstance(self.command, command_types)):
raise TypeError("command must be a non-empty string or list, "
"not %s" % self.command)
if synchronous is not False:
self.synchronous = synchronous
if not (process_command is None or callable(process_command)):
raise TypeError("process_command must be a callable object or "
"None")
self._process_command = process_command
self._hide_window = hide_window
# Set the string used for representing actions.
if isinstance(self.command, list):
self._str = "'%s'" % " ".join(self.command)
else:
self._str = "'%s'" % self.command
def __init__(self, *words, **kwargs):
ActionBase.__init__(self)
self._words = tuple(words)
if "extra" in kwargs:
self._extra = kwargs.pop("extra")
else:
self._extra = None
# Set pretty printing string used by __str__ and __unicode__.
self._str = u", ".join(repr(w) for w in self._words)
# Make sure that all keyword arguments have been consumed.
if kwargs:
raise ActionError("Invalid arguments: %r"
% ", ".join(list(kwargs.keys())))
def __init__(self, series, speed=1):
"""
Constructor arguments:
- *series* (sequence of 2-tuples) --
the recognitions to playback. Each element must be a
2-tuple of the form *(["words", "two", "mimic"], interval)*,
where *interval* is a float giving the number of seconds to
pause after the given words are mimicked.
- *speed* (*float*) --
the factor by which to speed up playback. The intervals
after each mimic are divided by this number.
"""
ActionBase.__init__(self)
self._series = tuple(series)
self._speed = float(speed)
self._str = str([w for w, i in self._series])
def __init__(self, title=None, executable=None, timeout=15):
self._match_functions = []
string = []
if title is not None:
self._title = title.lower()
self._match_functions.append("_match_title")
string.append("title=%r" % self._title)
else:
self._title = None
if executable is not None:
self._executable = executable.lower()
self._match_functions.append("_match_executable")
string.append("executable=%r" % self._executable)
else:
self._executable = None
self._timeout = timeout
ActionBase.__init__(self)
self._str = ", ".join(string)
def __init__(self,
executable=None,
title=None,
index=None,
filter_func=None,
focus_only=False):
if executable: self.executable = executable.lower()
else: self.executable = None
if title: self.title = title.lower()
else: self.title = None
self.index = index
self.filter_func = filter_func
self.focus_only = focus_only
ActionBase.__init__(self)
arguments = []
if executable: arguments.append("executable=%r" % executable)
if title: arguments.append("title=%r" % title)
if index: arguments.append("index=%r" % index)
if filter_func: arguments.append("filter_func=%r" % filter_func)
if focus_only: arguments.append("focus_only=%r" % focus_only)
self._str = ", ".join(arguments)
def __init__(self, title=None, executable=None,
timeout=15):
self._match_functions = []
string = []
if title is not None:
self._title = title.lower()
self._match_functions.append("_match_title")
string.append("title=%r" % self._title)
else:
self._title = None
if executable is not None:
self._executable = executable.lower()
self._match_functions.append("_match_executable")
string.append("executable=%r" % self._executable)
else:
self._executable = None
self._timeout = timeout
ActionBase.__init__(self)
self._str = ", ".join(string)
def __init__(self, function, remap_data=None, **defaults):
"""
Constructor arguments:
- *function* (callable) --
the function to call when this action is executed
- *remap_data* (dict, default: None) --
optional dict of data keys to function keyword arguments
- defaults --
default keyword-values for the arguments with which
the function will be called
"""
ActionBase.__init__(self)
self._function = function
self._defaults = defaults
self._remap_data = remap_data or {}
self._str = function.__name__
# TODO Use inspect.signature instead; getargspec is deprecated.
(args, _, varkw, defaults) = getargspec(self._function)
if varkw: self._filter_keywords = False
else: self._filter_keywords = True
self._valid_keywords = set(args)
def __init__(self, function, remap_data=None, **defaults):
"""
Constructor arguments:
- *function* (callable) --
the function to call when this action is executed
- *remap_data* (dict, default: None) --
optional dict of data keys to function keyword arguments
- defaults --
default keyword-values for the arguments with which
the function will be called
"""
ActionBase.__init__(self)
self._function = function
self._defaults = defaults
self._remap_data = remap_data or {}
self._str = function.__name__
# TODO Use inspect.signature instead; getargspec is deprecated.
(args, varargs, varkw, defaults) = getargspec(self._function)
if varkw: self._filter_keywords = False
else: self._filter_keywords = True
self._valid_keywords = set(args)
def __init__(self, _):
ActionBase.__init__(self)
def __init__(self, *args, **kwargs):
ActionBase.__init__(self)
def __init__(self, _):
ActionBase.__init__(self)