opening quite already consumed
432693
String parseObjectKey() throws IOException {
        if (cachedObjectKey != null) {
            String key = cachedObjectKey;
            cachedObjectKey = null;
            return key;
        }
        String str = parseString();
        acceptEvent(JsonEvent.COLON);
        return str;
    }
735327
def open(self):
        """"""
        self._id = str(uuid.uuid4())
        self._client.open_connection(self._id, info=self._connection_args)
758910
def open(self, path, mode='r', *args, **kwargs):
        """"""
        return open(os.path.join(os.path.dirname(self.path), path),
                    mode=mode, *args, **kwargs)
235961
public void consumeUntilGreedy(Parser recognizer, IntervalSet follow, CSSLexerState.RecoveryMode mode, CSSLexerState ls) {
        consumeUntil(recognizer, follow, mode, ls);
        recognizer.getInputStream().consume();
    }
271719
def open(self, path, binary=False):
        """"""
        if binary:
            return open(path, "rb")
        return open(path, encoding="utf-8")
933856
def _Open(self):
    """"""
    self._connection = sqlite3.connect(
        self._path, detect_types=sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES)
    self._cursor = self._connection.cursor()
336928
def open(self):
        
        self.clearException()
        try:
            if self._isOpen:
                logger.warn("Resources already open. Closing them first before opening.")
                self._closeResources()
                self._isOpen = False

            assert not self._isOpen, "Sanity check failed: _isOpen should be false"
            logger.debug("Opening {}".format(self))
            self._openResources()
            self._isOpen = True

            if self.model:
                self.model.sigItemChanged.emit(self)
            else:
                logger.warning("Model not set yet: {}".format(self))

        except Exception as ex:
            if DEBUGGING:
                raise
            logger.exception("Error during tree item open: {}".format(ex))
            self.setException(ex)
565408
async def open(self, wait_for_completion=True):
        
        await self.set_position(
            position=Position(position_percent=0),
            wait_for_completion=wait_for_completion)
250194
def open(self):
        """"""
        self._window = Window(
            caption=self.caption,
            height=self.height,
            width=self.width,
            vsync=False,
            resizable=True,
        )
1221684
def _really_load(self, f, filename, ignore_discard, ignore_expires):
        ''''''
        data = json.load(f) or []
        now = time.time()
        for cookie in map(go_to_py_cookie, data):
            if not ignore_expires and cookie.is_expired(now):
                continue
            self.set_cookie(cookie)
1081377
def open(self, path):
        
        self.current.append(self.create(path))
        return self.current[-1]
356103
def open_fast(self):
        """"""
        open_command = StandardSend(self._address,
                                    COMMAND_LIGHT_ON_FAST_0X12_NONE, cmd2=0xff)
        self._send_method(open_command, self._open_message_received)
1105291
def check_and_consume(self):
        

        if self._count < 1.0:
            self._fill()

        consumable = self._count >= 1.0
        if consumable:
            self._count -= 1.0
            self.throttle_count = 0
        else:
            self.throttle_count += 1

        return consumable
966881
def open(self, new=False):
        '''
        
        '''
        self._db.new() if new else self._db.open()  # pylint: disable=W0106
        self._run_init_queries()
178378
def reopen(self):
        
        assignee = self.assignee.login if self.assignee else ''
        number = self.milestone.number if self.milestone else None
        labels = [str(l) for l in self.labels]
        return self.edit(self.title, self.body, assignee, 'open',
                         number, labels)
925898
def open(self):
        
        try:
            self.graph.open(self.cache_uri, create=False)
            self._add_namespaces(self.graph)
            self.is_open = True
        except Exception:
            raise InvalidCacheException('The cache is invalid or not created')
620257
def consume(self):  # pragma: no cover
        
        print(' [*] Waiting for logs. To exit press CTRL+C')
        self.channel.basic_consume(self.queue_name, self.callback)
        self.channel.start_consuming()