Yield the async reuslt values for the context.
161072
def values(self):
        """"""
        for _, task in self._tasks:
            if not (task and task.result):
                yield None
            else:
                yield json.loads(task.result)["payload"]
805289
def fetch_data_async(blob, start_index, end_index, **options):
  """"""
  if isinstance(blob, BlobInfo):
    blob = blob.key()
  rpc = blobstore.create_rpc(**options)
  rpc = blobstore.fetch_data_async(blob, start_index, end_index, rpc=rpc)
  result = yield rpc
  raise tasklets.Return(result)
394141
def _items(self):
        """"""
        for name in self.declarations:
            yield name, self.declarations[name]
            for subkey, value in self.contexts[name].items():
                yield self.join(name, subkey), value
415895
async function _evaluateContexts(contexts = []) {
  const c = Array.isArray(contexts) ? contexts : [contexts]
  const ep = c.map(evaluateContext)
  const res = await Promise.all(ep)
  return res
}
514219
def CommentContext(self):
        """"""
        old_context = self.__comment_context
        self.__comment_context = True
        yield
        self.__comment_context = old_context
1366488
def process_text(self, kind, context):
		""""""
		
		result = None
		
		while True:
			chunk = yield None
			
			if chunk is None:
				if result:
					yield result.clone(line=repr(result.line))
				
				return
			
			if not result:
				result = chunk
				continue
			
			result.line += chunk.line
1333298
def ensure_context(**vars):
    
    ctx = _context_stack.top
    stacked = False
    if not ctx:
        ctx = Context()
        stacked = True
        _context_stack.push(ctx)
    ctx.update(vars)
    try:
        yield ctx
    finally:
        if stacked:
            _context_stack.pop()
2411
def prepare(self, context):
		""""""
		if __debug__:
			log.debug("Assigning thread local request context.")
		
		self.local.context = context
963409
def something(TokenClass):
    """"""
    def callback(lexer, match, context):
        text = match.group()
        if not text:
            return
        yield match.start(), TokenClass, text
        context.pos = match.end()
    return callback
1077750
async def chain(*sources):
    
    for source in sources:
        async with streamcontext(source) as streamer:
            async for item in streamer:
                yield item
447134
def execution_context_from_async(async):
    
    local_context = _local.get_local_context()

    if local_context._executing_async_context:
        raise errors.ContextExistsError

    execution_context = _ExecutionContext(async)
    local_context._executing_async_context = execution_context
    return execution_context
1046656
def and_yields(self, *values):
        
        def generator():
            for value in values:
                yield value
        self.__expect(Expectation, Invoke(generator))
22466
async def _stream_helper(self, response, decode=False):
        """"""

        if decode:
            async for chunk in json_stream(
                    self._stream_helper(response, False)):
                yield chunk
        else:
            async with response.context as res:
                reader = res.content
                while True:
                    # this read call will block until we get a chunk
                    data = await reader.read(1)
                    if not data:
                        break
                    data += await reader.read(io.DEFAULT_BUFFER_SIZE)
                    yield data
1151060
def execute(self, context):
        """"""
        for ware in self.middleware:
            ware.premessage(context)
            context = ware.bind(context)
            ware.postmessage(context)
        return context
122230
async def power(source, exponent):
    """"""
    async with streamcontext(source) as streamer:
        async for item in streamer:
            yield item ** exponent
594495
def values(self):
    
    if self._data:
      for key in xrange(self.order + 1):
        yield self[key]
1015458
def items(self):
        """"""
        for key, task in self._tasks:
            if not (task and task.result):
                yield key, None
            else:
                yield key, json.loads(task.result)["payload"]