Method to call in order to invoke the user callback.

        :param args: list of signal-dependent arguments
        :return:
171744
def signal_handler(self, *args):
        
        self.user_callback(self.signal, self.user_arg, *args)
461246
def call_command_handler(command, pymux, arguments):
    
    assert isinstance(arguments, list)

    # Resolve aliases.
    command = ALIASES.get(command, command)

    try:
        handler = COMMANDS_TO_HANDLERS[command]
    except KeyError:
        pymux.show_message('Invalid command: %s' % (command,))
    else:
        try:
            handler(pymux, arguments)
        except CommandException as e:
            pymux.show_message(e.message)
1263550
def run_command(self, args):
        
        parsed_args = self.parser.parse_args(args)
        if hasattr(parsed_args, 'func'):
            parsed_args.func(parsed_args)
        else:
            self.parser.print_help()
169500
def invoke(*args)
      task_args = TaskArguments.new(arg_names, args)
      invoke_with_call_chain(task_args, InvocationChain::EMPTY)
    end
334501
def notify_to(observers, *args)
      if block_given? && !args.empty?
        raise ArgumentError.new 'cannot give arguments and a block'
      end
      observers.each do |observer, function|
        args = yield if block_given?
        observer.send(function, *args)
      end
    end
1309881
def invoke(self, ctx):
        
        _maybe_show_deprecated_notice(self)
        if self.callback is not None:
            return ctx.invoke(self.callback, **ctx.params)
89997
def signal_callback(id, signal, data)
      data = Weechat::Utilities.apply_transformation(signal, data, SignalCallbackTransformations)
      Weechat::Hooks::Signal.find_by_id(id).call(signal, data)
    end
792296
def __watchers_callbacks_exec(self, signal_name):
		
		def callback_fn():
			for watcher in self.__watchers_callbacks[signal_name]:
				if watcher is not None:
					watcher.notify()
		return callback_fn
470743
def emit(self, signalName, *args, **kwargs):
        
        assert signalName in self, "%s is not a registered signal" % signalName
        self[signalName].emit(*args, **kwargs)
273744
function(signal, arg) {
            var slot = this._slots[signal];
            if (slot) {
                slot.call(this, arg, signal);
                return true;
            }
            return false;
        }
856776
def send(self, signal, **kwargs):
        
        return self.__app.signals.send(signal, plugin=self._plugin, **kwargs)
1083748
def on_command_call(receiver, dot, method, args)
      if is_ident?(method) &&
              (constant = resolve_constant_ref(receiver))
        method_call(method, [constant])
      end
      keep_walking(receiver, args)
    end
994416
def sighandler(signals):
    
    def wrap(function):
        set_signal_handlers(signals, function)

        @wraps(function)
        def wrapper(*args, **kwargs):
            return function(*args, **kwargs)

        return wrapper

    return wrap
160296
def do_server(self, arg):
        
        if arg['on']:
            self.server_on()
        elif arg['off']:
            self.server_off()
        elif arg['restart']:
            self.server_restart()
        elif arg['log']:
            self.server_log()
        else:
            self.help_server()
1211381
def call(method, *args, **kwargs):
    '''
    
    '''
    kwargs = clean_kwargs(**kwargs)
    if not netmiko_device['always_alive']:
        connection = ConnectHandler(**netmiko_device['args'])
        ret = getattr(connection, method)(*args, **kwargs)
        connection.disconnect()
        return ret
    return getattr(netmiko_device['connection'], method)(*args, **kwargs)
697012
def add_callback(self, callback: callable):
        
        def internal_callback(*args):
            try:
                callback()
            except TypeError:
                callback(self.get())

        self._var.trace('w', internal_callback)
1343891
def main_callback(self, *args, **kwargs):
        
        if not self.callback:
            raise NotImplementedError('Entrypoints must declare `callback`')
        if not self.settings:
            raise NotImplementedError('Entrypoints must declare `settings`')

        self.callback.im_self.db = None

        #1. Start all the middlewares
        with self.debug(*args, **kwargs):
            with self.database():
                #2. `Real` callback
                result = self.callback(*args, **kwargs)#pylint: disable=not-callable
        return result