`<http://www.elastic.co/guide/en/elasticsearch/reference/current/watcher-api-execute-watch.html>`_

        :arg id: Watch ID
        :arg body: Execution control
        :arg debug: indicates whether the watch should execute in debug mode
972850
def execute_watch(self, id=None, body=None, params=None):
        
        return self.transport.perform_request(
            "PUT",
            _make_path("_watcher", "watch", id, "_execute"),
            params=params,
            body=body,
        )
445287
def register_click_watcher(self, watcher_name, selectors, *condition_list):
        
        watcher = self.device.watcher(watcher_name)
        for condition in condition_list:
            watcher.when(**self.__unicode_to_dict(condition))
        watcher.click(**self.__unicode_to_dict(selectors))
        self.device.watchers.run()
980951
async def debug(self, conn_id, name, cmd_args):
        

        adapter_id = self._get_property(conn_id, 'adapter')
        return await self.adapters[adapter_id].debug(conn_id, name, cmd_args)
439850
def __add_watch(self, path, mask, proc_fun, auto_add, exclude_filter):
        
        path = self.__format_path(path)
        if auto_add and not mask & IN_CREATE:
            mask |= IN_CREATE
        wd = self._inotify_wrapper.inotify_add_watch(self._fd, path, mask)
        if wd < 0:
            return wd
        watch = Watch(wd=wd, path=path, mask=mask, proc_fun=proc_fun,
                      auto_add=auto_add, exclude_filter=exclude_filter)
        # wd are _always_ indexed with their original unicode paths in wmd.
        self._wmd[wd] = watch
        log.debug('New %s', watch)
        return wd
1080394
def watcher_delegate(proxy_var)
      %w{attach attached? detach enable disable}.each do |method|
        module_eval <<-EOD
          def #{method}(*args)
            if defined? #{proxy_var} and #{proxy_var}
              #{proxy_var}.#{method}(*args)
              return self
            end

            super
          end
        EOD
      end
    end
1037438
def watch(args):
    "  "
    assert op.isdir(args.source), "Watch mode allowed only for directories."
    print 'Zeta-library v. %s watch mode' % VERSION
    print '================================'
    print 'Ctrl+C for exit\n'
    observer = Observer()
    handler = ZetaTrick(args=args)
    observer.schedule(handler, args.source, recursive=True)
    observer.start()
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
        print "\nWatch mode stoped."
    observer.join()
908960
async def debug(self, conn_id, name, cmd_args):
        

        progress_callback = functools.partial(_on_progress, self, 'debug', conn_id)

        resp = await self._execute(self._adapter.debug_sync, conn_id, name, cmd_args, progress_callback)
        _raise_error(conn_id, 'send_rpc', resp)

        return resp.get('return_value')
861470
def watch(*what, level=logging.DEBUG):
    
    if not what:
        what = ALL

    for watcher_name in what:
        watcher = globals()[watcher_name]
        watcher.setLevel(level)
834617
async function Execute(command, args, watch) {
    let full = args.filter(s => s === "--full").length > 0;
    switch (command) {
        case "wp":
            let wp = `webpack --config ./config/webpack.${args[0]}.ts`;
            if (watch) wp += " --watch";
            await run(wp);
            break;
        case "deploy":
            await run("node script wp dist");
            break;
        case "publish":
            await run(`npm run deploy`);
            await run(`git add .`); 
            await run(`git commit -m "Preparing for next ${args[0]} version`); 
            await run(`npm version ${args[0]}`);
            await run(`npm publish`);
            break;
        default:
            console.log("Unknown command!");
            process.exit(1);
    }

}
930686
def do_bp(self, arg):
        
        pid = self.get_process_id_from_prefix()
        if not self.debug.is_debugee(pid):
            raise CmdError("target process is not being debugged")
        process     = self.get_process(pid)
        token_list  = self.split_tokens(arg, 1, 1)
        try:
            address = self.input_address(token_list[0], pid)
            deferred = False
        except Exception:
            address = token_list[0]
            deferred = True
        if not address:
            address = token_list[0]
            deferred = True
        self.debug.break_at(pid, address)
        if deferred:
            print("Deferred breakpoint set at %s" % address)
        else:
            print("Breakpoint set at %s" % address)
259784
def monitor(args, watch):
    
    watch = watch if isinstance(watch, (list, tuple)) else [watch]
    watch = [Path(entry).expand().abspath() for entry in watch]
    event_handler = RunScriptChangeHandler(args)
    observer = Observer()
    for entry in watch:
        if entry.isfile():
            entry = entry.parent
        click.secho('watch recursive: {0}'.format(entry), fg='blue')
        observer.schedule(event_handler, entry, recursive=True)
    event_handler.run()  # run always once
    observer.start()

    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()
236387
@Override
  public void watch(@Service DatabaseWatch watch, String sql, 
                    Result<Cancel> result,
                    Object ...args)
  {
    _kraken.query(sql, 
                        result.then((x,r)->{ x.watch(watch, r, args); }));
  }
1103474
function unwatch(id) {
    let type = typeof id;
    let index = watchers.findIndex(function _matchWatcher(watcher) {
      return watcher && (type === 'string' ? watcher.id === id : watcher.callback === id);
    });

    if (index !== -1) {
      // We can't delete the last watcher...
      if (watchers.length === 1) {
        unwatchAll();
      } else {
        delete watchers[index];
      }
    }
  }
1201173
function watchOpts(src) {
    if ((src._pkg && !opts.watchPkgs) || ('watch' in src && !src.watch)) return false;
    return (typeof src.watch === 'object') ? src.watch : {};
  }
961532
def _call_watcher(self_, watcher, event):
        
        if self_.self_or_cls.param._TRIGGER:
            pass
        elif watcher.onlychanged and (not self_._changed(event)):
            return

        if self_.self_or_cls.param._BATCH_WATCH:
            self_._events.append(event)
            if watcher not in self_._watchers:
                self_._watchers.append(watcher)
        elif watcher.mode == 'args':
            with batch_watch(self_.self_or_cls, run=False):
                watcher.fn(self_._update_event_type(watcher, event, self_.self_or_cls.param._TRIGGER))
        else:
            with batch_watch(self_.self_or_cls, run=False):
                event = self_._update_event_type(watcher, event, self_.self_or_cls.param._TRIGGER)
                watcher.fn(**{event.name: event.new})
657090
def trigger(self_, *param_names):
        
        events = self_.self_or_cls.param._events
        watchers = self_.self_or_cls.param._watchers
        self_.self_or_cls.param._events  = []
        self_.self_or_cls.param._watchers = []
        param_values = dict(self_.get_param_values())
        params = {name: param_values[name] for name in param_names}
        self_.self_or_cls.param._TRIGGER = True
        self_.set_param(**params)
        self_.self_or_cls.param._TRIGGER = False
        self_.self_or_cls.param._events = events
        self_.self_or_cls.param._watchers = watchers
978628
def cmd_watch(args):
    ''''''
    if len(args) == 0:
        mpstate.status.watch = None
        return
    mpstate.status.watch = args
    print("Watching %s" % mpstate.status.watch)