:meth:`.WSignalSourceProto.watch` implementation

		:rtype: watcher: WSignalSource.Watcher
486740
def watch(self, signal_name):
		
		watcher = WSignalSource.Watcher(
			self.__queues[signal_name], lambda x: self.__watchers_callbacks[signal_name].remove(x)
		)
		self.__watchers_callbacks[signal_name].add(watcher)
		return watcher
731204
def set_watchpoint(self, addr, size, type):
        
        return self.dwt.set_watchpoint(addr, size, type)
1135380
public void startWatching() {
        try {
            final List<MonitorLine> lines = getSource().getLastLine(getInitialCount());
            actual = null;
            updateLines(lines);
        } catch (Exception e) {
            notifyObservers(e);
        }
    }
288829
def watch(self, path, action, *args, **kwargs):
        
        if action is None:
            action = _set_changed
        event_handler = _WatchdogHandler(self, action)
        self._observer.schedule(event_handler, path=path, recursive=True)
865477
def stop_watch(self):
        

        if self.greenlet_watch:
            self.greenlet_watch.kill(block=False)
            self.greenlet_watch = None
1166108
async def _watch(self, node, conn, names):
        ""
        for name in names:
            slot = self._determine_slot('WATCH', name)
            dist_node = self.connection_pool.get_node_by_slot(slot)
            if node.get('name') != dist_node['name']:
                # raise error if commands in a transaction can not hash to same node
                if len(node) > 0:
                    raise ClusterTransactionError("Keys in request don't hash to the same node")
        if self.explicit_transaction:
            raise RedisError('Cannot issue a WATCH after a MULTI')
        await conn.send_command('WATCH', *names)
        return await conn.read_response()
1144398
def register_press_watcher(self, watcher_name, press_keys, *condition_list):
        
        def unicode_to_list(a_unicode):
            a_list = list()
            comma_count = a_unicode.count(',')
            for count in range(comma_count + 1):
                comma_position = a_unicode.find(',')
                if comma_position == -1:
                    a_list.append(str(a_unicode))
                else:
                    a_list.append(a_unicode[0:comma_position])
                    a_unicode = a_unicode[comma_position + 1:]
            return a_list

        watcher = self.device.watcher(watcher_name)
        for condition in condition_list:
            watcher.when(**self.__unicode_to_dict(condition))
        watcher.press(*unicode_to_list(press_keys))
        self.device.watchers.run()
1198480
def watch_project(self, path):
    
    # TODO(kwlzn): Add a client.query(timeout=X) param to the upstream pywatchman project.
    try:
      return self.client.query('watch-project', os.path.realpath(path))
    finally:
      self._attempt_set_timeout(self._timeout)
311050
def _connected(self, watcher, events):
        """"""
        self.connected = True
        self._finish()
        self.deferred.callback(self.sock)
699890
def add_watcher(self, issue, watcher):
        
        url = self._get_url('issue/' + str(issue) + '/watchers')
        self._session.post(
            url, data=json.dumps(watcher))
762884
def _watch_callback(obj_weakref, method_name, *args, **kwargs):
    
    obj = obj_weakref()
    if obj is None:
        return
    getattr(obj, method_name)(*args, **kwargs)
145546
def watch_async(self, limit=None, timeout=None):
        """"""
        return self.watch(limit=limit, timeout=timeout)
1091500
def initialize_watcher(samples):
    
    work_dir = dd.get_in_samples(samples, dd.get_work_dir)
    ww = WorldWatcher(work_dir,
                      is_on=any([dd.get_cwl_reporting(d[0]) for d in samples]))
    ww.initialize(samples)
    return ww
983171
def get_watchers(self):
        
        return github.PaginatedList.PaginatedList(
            github.NamedUser.NamedUser,
            self._requester,
            self.url + "/watchers",
            None
        )
1023860
function watcher (specs, options) {
  const err = fileOptions.validate(specs)
  if (err) {
    return Promise.reject(err)
  }
  const w = new Watcher(fileOptions.normalize(specs), options || {})
  return w._promise.then(() => w)
}
31
def monitor(self):
        
        if self._monitor is None:
            from twilio.rest.monitor import Monitor
            self._monitor = Monitor(self)
        return self._monitor
1146423
def fetch_watch_info(self):
        
        self._watch_info = self.send_and_read(WatchVersion(data=WatchVersionRequest()), WatchVersion).data