Open reader handle and return current object.

        :return: current object
481263
async def open(self) -> 'Tails':
        

        LOGGER.debug('Tails.open >>>')

        self._reader_handle = await blob_storage.open_reader('default', self._tails_config_json)

        LOGGER.debug('Tails.open <<<')
        return self
1298707
async def get_reader(self, source=FFMPEG_STDOUT) -> asyncio.StreamReader:
        """"""
        reader = asyncio.StreamReader(loop=self._loop)
        reader_protocol = asyncio.StreamReaderProtocol(reader)

        # Attach stream
        if source == FFMPEG_STDOUT:
            await self._loop.connect_read_pipe(
                lambda: reader_protocol, self._proc.stdout
            )
        else:
            await self._loop.connect_read_pipe(
                lambda: reader_protocol, self._proc.stderr
            )

        # Start reader
        return reader
1241108
def current_window_handle(self):
        
        if self.w3c:
            return self.execute(Command.W3C_GET_CURRENT_WINDOW_HANDLE)['value']
        else:
            return self.execute(Command.GET_CURRENT_WINDOW_HANDLE)['value']
1081377
def open(self, path):
        
        self.current.append(self.create(path))
        return self.current[-1]
1010435
def read
      handle  = File.open(@path, 'r')
      content = handle.read

      handle.close

      content
    end
585788
def currentItem( self ):
        
        model = self.navigationModel()
        if ( not model ):
            return None
        
        return model.itemByPath(self.text())
399507
def dump(self):
        

        reading = self.reading
        if reading is not None:
            reading = reading.asdict()

        return {
            u'selector': str(self.selector),
            u'reading': reading
        }
813880
def get_current_object(self):
        
        if not hasattr(self.__local, '__release_local__'):
            return self.__local()
        try:
            return getattr(self.__local, self.__name__)
        except AttributeError:
            raise RuntimeError('no object bound to %s' % self.__name__)
639588
def open(self):
        
        if self._f is not None:
            return self._f
        try:
            rv, self.should_close = open_stream(self.name, self.mode,
                                                self.encoding,
                                                self.errors,
                                                atomic=self.atomic)
        except (IOError, OSError) as e:
            from .exceptions import FileError
            raise FileError(self.name, hint=get_streerror(e))
        self._f = rv
        return rv
294326
def read_nowait(self):
        
        result = self._queue.get_nowait()

        self._can_write.set()

        if self._queue.empty():
            self._can_read.clear()

        return result
286098
def _handle_uninitialized_read(self, addr, inspect=True, events=True):
        
        if self._uninitialized_read_handler is None:
            v = self.state.solver.Unconstrained("%s_%s" % (self.id, addr), self.width*self.state.arch.byte_width, key=self.variable_key_prefix + (addr,), inspect=inspect, events=events)
            return v.reversed if self.endness == "Iend_LE" else v
        else:
            return self._uninitialized_read_handler(self, addr, inspect=inspect, events=events)
801890
def _get_current_object(self):
        
        if not hasattr(self.__local, '__release_local__'):
            return self.__local()
        try:
            return getattr(self.__local, self.__name__)
        except AttributeError:
            raise RuntimeError('no object bound to %s' % self.__name__)
208346
def do_read(self, args):
        """"""

        if not self.current:
            print('There are no resources in use. Use the command "open".')
            return

        try:
            print(self.current.read())
        except Exception as e:
            print(e)
525337
def readall(self):
        
        if not self._readable:
            raise UnsupportedOperation('read')

        with self._seek_lock:
            # Get data starting from seek
            with handle_os_exceptions():
                if self._seek and self._seekable:
                    data = self._read_range(self._seek)

                # Get all data
                else:
                    data = self._readall()

            # Update seek
            self._seek += len(data)
        return data
1041239
public function current()
	{
		$doc = new DOMDocument();
		$object = simplexml_import_dom($doc->importNode($this->reader->expand(), true));
		return json_decode(json_encode($object));
	}
541811
def readObject(self):
        
        obj = pyamf.ASObject()
        self.context.addObject(obj)

        obj.update(self.readObjectAttributes(obj))

        return obj
664484
def get_reader(self):
        """"""
        assert self._closed, "Archive not closed"
        buf = io.BytesIO(self.get_bytes())
        return zipfile.ZipFile(buf, mode='r')