def __repr__(self, **k):
# type: (Any) -> str
output = "%s" % get_callable_repr(self.func)
if self.awaited_listener:
output += " (waiting for listener call %s)" % get_callable_repr(
self.awaited_listener)
return output
def __repr__(self):
# type: () -> str
if self._wrapped:
return str(self._wrapped)
else:
return "%s_%d_%s" % (get_callable_repr(
self._func), id(self), self.__class__.__name__)
def __init__(self, callback, tick_count, *a, **k):
# type: (Callable, int, Any, Any) -> None
super(SchedulerEvent, self).__init__(*a, **k)
self._executed = False
self._cancelled = False
self._callback = callback
self._tick_count = tick_count
self._ticks_left = tick_count
self.name = get_callable_repr(self._callback)
def execute(self, encoder_name, *a, **k):
# type: (str, Any, Any) -> Optional[Sequence]
"""
NB : Here lambda is just a way to act on the right objects at runtime
like this we can display the function name
"""
if self._is_executing:
self._is_executing = False
if self.cancel_action:
self.cancel_action.execute(encoder_name, *a, **k)
return None
raise DoubleEncoderActionExecution(self)
if self.song:
self.song.begin_undo_step()
if is_lambda(self.func):
func = self.func(
) # allows delaying property lookup until execution time
else:
func = self.func
if func is None:
return None # the action is sync and is already processed
assert callable(
func), "%s : action func should be callable, got %s" % (
encoder_name,
get_callable_repr(func),
)
if self.move_type != EncoderMoveEnum.SCROLL:
self.parent.log_notice("%s : executing %s" %
(encoder_name, get_callable_repr(func)))
else:
self.parent.log_notice("%s : scrolling %s" %
(encoder_name, get_callable_repr(func)))
self._is_executing = True
seq = Sequence()
with self.parent.component_guard():
seq.add(partial(func, *a, **k))
if self.song:
seq.add(self.song.end_undo_step)
seq.on_end(partial(setattr, self, "_is_executing", False))
return seq.done()
def __repr__(self, **k):
# type: (Any) -> str
output = self.name
if self.wait_for_system:
output += " (and wait for system)"
elif self._complete_on:
output += " (and wait for listener call : %s)" % get_callable_repr(
self._complete_on)
elif self._wait:
output += " (and wait %s)" % self._wait
elif self._wait_beats:
output += " (and wait_beats %.2f)" % self._wait_beats
return "[%s]" % output
def __init__(self, func, move_type, name, *a, **k):
# type: (Callable, EncoderMoveEnum, Optional[str], Any, Any) -> None
"""
base moves are listed in the enum. press is the default choice
"""
super(EncoderAction, self).__init__(*a, **k)
assert callable(
func
), "func action should be callable: %s" % get_callable_repr(func)
self.func = func
self.move_type = move_type
self.name = name
self._is_executing = False
self.cancel_action = None # type: Optional[EncoderAction]
def __init__(
self,
func, # type: Callable
sequence, # type: Sequence
name, # type: str
wait, # type: int
wait_beats, # type: float
wait_for_system, # type: bool
no_cancel, # type: bool
complete_on, # type: Optional[Union[Callable, CallableWithCallbacks]]
check_timeout, # type: int
*a, # type: Any
**k # type: Any
):
""" the tick is 100 ms """
super(SequenceStep, self).__init__(*a, **k)
if not name and func == nop:
name = "wait %s" % wait if wait else "pass"
self.name = "step %s" % (name or get_callable_repr(func))
self._sequence_name = sequence.name
self._callable = func
self._wait = wait
self._wait_beats = wait_beats or 0
self.wait_for_system = wait_for_system
self.no_cancel = no_cancel
self._complete_on = complete_on
self._check_timeout = check_timeout
self._callback_timeout = None # type: Optional[Callable]
self.res = None # type: Optional[Any]
if self.wait_for_system:
assert self._wait == 0 and self._wait_beats == 0 and self._complete_on is None, "waiting for system excludes other waiting options"
if self._complete_on:
assert self._wait == 0 and self._wait_beats == 0, "complete_on excludes wait and wait_beats"
if self._wait:
assert self._wait_beats == 0, "wait excludes wait_beats"
if self.no_cancel:
assert self.wait_for_system, "no cancel used without wait_for_system"
assert callable(
self._callable), "You passed a non callable (%s) to %s" % (
self._callable, self)
from protocol0.sequence.Sequence import Sequence
if Config.SEQUENCE_SLOW_MO:
self._wait = min(100, self._wait * 5)
self._check_timeout += 5
def __repr__(self, **k):
# type: (Any) -> str
return "%s : %s" % (self.name, get_callable_repr(self.func))
def __repr__(self):
# type: () -> str
return "cwc %s" % get_callable_repr(self._function)
def execute(self):
# type: () -> None
from protocol0 import Protocol0
Protocol0.SELF.log_debug("Api call, executing %s" % get_callable_repr(self.method))
self.method(**self.args)