Return the :class:`Variable` or :class:`List` to watch.

        Returns ``None`` if it's a block watcher.
13027
def value(self):
        
        if self.kind == 'variable':
            return self.target.variables[self.block.args[0]]
        elif self.kind == 'list':
            return self.target.lists[self.block.args[0]]
541106
def _rule_block(self):
        

        name = self._get_token(self.RE_NAME)
        self._expect_token('{')

        # consume additional options if available
        options = []
        while self._lookahead_token() != '}':
            options.append(self._rule_option())

        self._expect_token('}')
        return [name, options]
1327199
def get(self, path, watch=None):
        """"""
        _log.debug(
            "ZK: Getting {path}".format(path=path),
        )
        return self.zk.get(path, watch)
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()
964754
async def _watch(self):
        

        file_name = os.path.basename(self._file_path)
        logger.info(
            'Watching %s "%s"',
            self.THING,
            self._file_path,
        )

        while self._running:
            evt = await self._watcher.get_event()

            if evt.name == file_name:
                await self._load()
                logger.info(
                    'Reloading changed %s from "%s"',
                    self.THING,
                    self._file_path
                )
393337
def get_variable_definitions(self, block_addr):
        

        if block_addr in self._outstates:
            return self._outstates[block_addr].variables
        return set()
577440
function getWatcherByPath(path) {
        var rlt = undefined;

        watchers.forEach(function(watcher) {
            if (watcher.path == path)
                rlt = watcher;
        });

        return rlt;
    }
863216
def get_block(self, block_identifier: BlockSpecification) -> Dict:
        """"""
        return self.web3.eth.getBlock(block_identifier)
1129645
def getVariable(self, name):
        
        return lock_and_call(
            lambda: Variable(self._impl.getVariable(name)),
            self._lock
        )
1359666
def start_watching(self):
        
        if not self.is_sync:
            return

        self._stop = False
        while not self._stop:
            self.reactor.doIteration(0)
767309
def unwatch(self):
        """"""
        if self.watchers is not None:
            unwatched = []
            for watcher in self.watchers:
                watcher.inst.param.unwatch(watcher)
                unwatched.append(watcher)
            self.watchers = [w for w in self.watchers if w not in unwatched]
1010732
function watchPath(path, ignored) {
    if (_watcherMap.hasOwnProperty(path)) {
        return;
    }
    return _watcherImpl.watchPath(path, ignored, _watcherMap, _domainManager);
}
1310637
def ack_watch(self, watch_id, action_id=None, params=None):
        
        if watch_id in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'watch_id'.")
        return self.transport.perform_request(
            "PUT",
            _make_path("_watcher", "watch", watch_id, "_ack", action_id),
            params=params,
        )
1190166
def execute(self):
        
        try:
            for key, value in self._watched_keys.items():
                if self.mock_redis.redis.get(self.mock_redis._encode(key)) != value:
                    raise WatchError("Watched variable changed.")
            return [command() for command in self.commands]
        finally:
            self._reset()
1343026
def kind(self):
        
        if self.block.type.has_command('readVariable'):
            return 'variable'
        elif self.block.type.has_command('contentsOfList:'):
            return 'list'
        else:
            return 'block'
369492
def goto_block(self, block):
        
        old_block = self.basic_block
        term = block.terminator
        if term is not None:
            self.position_before(term)
        else:
            self.position_at_end(block)
        try:
            yield
        finally:
            self.position_at_end(old_block)
1105410
def _pfp__watch(self, watcher):
        
        if self._pfp__parent is not None and isinstance(self._pfp__parent, Union):
            self._pfp__parent._pfp__watch(watcher)
        else:
            self._pfp__watchers.append(watcher)