enqueue a render into the current request's hypernova batch
510596
def hypernova_batch_render(job)
      if @hypernova_batch.nil?
        raise NilBatchError.new('called hypernova_batch_render without calling '\
          'hypernova_batch_before. Check your around_filter for :hypernova_render_support')
      end
      batch_token = @hypernova_batch.render(job)
      template_safe_token = Hypernova.render_token(batch_token)
      @hypernova_batch_mapping[template_safe_token] = batch_token
      template_safe_token
    end
208871
function enqueueUpdate(component) {
  ensureInjected();

  // Various parts of our code (such as ReactCompositeComponent's
  // _renderValidatedComponent) assume that calls to render aren't nested;
  // verify that that's the case. (This is called by each top-level update
  // function, like setProps, setState, forceUpdate, etc.; creation and
  // destruction of top-level components is guarded in ReactMount.)
  ("production" !== process.env.NODE_ENV ? warning(
    ReactCurrentOwner.current == null,
    'enqueueUpdate(): Render methods should be a pure function of props ' +
    'and state; triggering nested component updates from render is not ' +
    'allowed. If necessary, trigger nested updates in ' +
    'componentDidUpdate.'
  ) : null);

  if (!batchingStrategy.isBatchingUpdates) {
    batchingStrategy.batchedUpdates(enqueueUpdate, component);
    return;
  }

  dirtyComponents.push(component);
}
886130
def enqueue_job(request, queue_index, job_id):
    
    queue_index = int(queue_index)
    queue = get_queue_by_index(queue_index)
    job = Job.fetch(job_id, connection=queue.connection)

    if request.method == 'POST':
        queue.enqueue_job(job)

        # Remove job from correct registry if needed
        if job.get_status() == JobStatus.DEFERRED:
            registry = DeferredJobRegistry(queue.name, queue.connection)
            registry.remove(job)
        elif job.get_status() == JobStatus.FINISHED:
            registry = FinishedJobRegistry(queue.name, queue.connection)
            registry.remove(job)

        messages.info(request, 'You have successfully enqueued %s' % job.id)
        return redirect('rq_job_detail', queue_index, job_id)

    context_data = {
        'queue_index': queue_index,
        'job': job,
        'queue': queue,
    }
    return render(request, 'django_rq/delete_job.html', context_data)
601786
def render
    content = output_capture(@block) do
      instance_exec( *@args, &@block )
    end
    content_wrapped = output_capture() { wrap( content ) }
    output_concat content_wrapped
  end
748208
function enqueueUpdate(component) {
  ensureInjected();

  // Various parts of our code (such as ReactCompositeComponent's
  // _renderValidatedComponent) assume that calls to render aren't nested;
  // verify that that's the case. (This is called by each top-level update
  // function, like setState, forceUpdate, etc.; creation and
  // destruction of top-level components is guarded in ReactMount.)

  if (!batchingStrategy.isBatchingUpdates) {
    batchingStrategy.batchedUpdates(enqueueUpdate, component);
    return;
  }

  dirtyComponents.push(component);
  if (component._updateBatchNumber == null) {
    component._updateBatchNumber = updateBatchNumber + 1;
  }
}
163205
def render_request(self, sort=True):
        
        if not sort:
            return ("; ".join(
                cookie.render_request() for cookie in self.values()))
        return ("; ".join(sorted(
            cookie.render_request() for cookie in self.values())))
95351
function (err, req, res, next) {
    err = this.coerceError(err);

    if (err instanceof errors.NotFound && req.accepts('html')) {
      if (err instanceof errors.BinNotFound) {
        if (req.editor) {
          return (new BinHandler(this.sandbox)).notFound(req, res, next);
        }
      }

      return this.renderErrorPage('error', err, req, res);
    } else if (err instanceof errors.HTTPError) {
      // return this.renderError(err, req, res);
      return this.renderErrorPage(err.status, err, req, res);
    }

    if (err) {
      // console.error(err.stack);
    }

    next(err);
  }
710376
def enqueue(self, stream_url, offset=0, opaque_token=None):
        """"""
        directive = self._play_directive('ENQUEUE')
        audio_item = self._audio_item(stream_url=stream_url,
                                      offset=offset,
                                      push_buffer=False,
                                      opaque_token=opaque_token)
        audio_item['stream']['expectedPreviousToken'] = current_stream.token

        directive['audioItem'] = audio_item
        self._response['directives'].append(directive)
        return self
1284986
function asyncBatch (
  renderer,
  pushable,
  resolve,
  reject
) {
  const pull = pullBatch(renderer, pushable);

  pull.then(result => {
    if (result === EXHAUSTED) {
      resolve();
    } else {
      setImmediate(
        asyncBatch,
        renderer,
        pushable,
        resolve,
        reject,
      );
    }
  }).catch(err => {
    reject(err);
  });
}
741120
def run_request(name='default', **kwargs):
    '''
    
    '''
    req = check_request()
    if name not in req:
        return {}
    n_req = req[name]
    if 'mods' not in n_req or 'kwargs' not in n_req:
        return {}
    req[name]['kwargs'].update(kwargs)
    if 'test' in n_req['kwargs']:
        n_req['kwargs'].pop('test')
    if req:
        ret = apply_(n_req['mods'], **n_req['kwargs'])
        try:
            os.remove(os.path.join(__opts__['cachedir'], 'req_state.p'))
        except (IOError, OSError):
            pass
        return ret
    return {}
932026
def render_request(self):
        
        # Use whatever renderers are defined for name and value.
        name, value = self.name, self.value
        renderer = self.attribute_renderers.get('name', None)
        if renderer:
            name = renderer(name)
        renderer = self.attribute_renderers.get('value', None)
        if renderer:
            value = renderer(value)
        return ''.join((name, "=", value))
284708
def render(self, tmpl_name, request_env):
        
        return super(WebApplication, self).render(tmpl_name, request_env)
1169032
def render(request, templates, dictionary=None, context_instance=None,
           **kwargs):
    

    warnings.warn(
        "yacms.utils.views.render is deprecated and will be removed "
        "in a future version. Please update your project to use Django's "
        "TemplateResponse, which now provides equivalent functionality.",
        DeprecationWarning
    )

    dictionary = dictionary or {}
    if context_instance:
        context_instance.update(dictionary)
    else:
        context_instance = RequestContext(request, dictionary)
    return TemplateResponse(request, templates, context_instance, **kwargs)
1363491
async def Enqueue(self, actions):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='Action',
                   request='Enqueue',
                   version=3,
                   params=_params)
        _params['actions'] = actions
        reply = await self.rpc(msg)
        return reply
1304592
function render(vm) {
	var observerData = vm._mobxObserver,
		that = this,
		args = arguments,
		result;

	// If vm was unmounted and is now being reused:
	if (!observerData.reaction)
		setReaction(vm);

	// Note: the following is allowed to run by MobX even if the reaction is not stale:
	observerData.reaction.track(function() {
		mobx._allowStateChanges(false, function() {
			result = observerData.render.apply(that, args);
		});
	});
	observerData.stale = false;

	return result;
}
652045
def render(self, *args, **kwargs):
        """"""
        output = super(HeavySelect2Mixin, self).render(*args, **kwargs)
        self.set_to_cache()
        return output
327163
function chain_requests(ml, url) {
  return (batches) => {
    let promise = new Promise((resolve, reject) => resolve(new MonkeyLearnResponse()));

    // attach requests for all the batches sequentially to the original promise and return _that_
    return batches.reduce((promise, batch) =>
      promise.then((response) =>

        request(ml, {
          url: url,
          method: 'POST',
          body: batch,
          parse_response: false
        })

        .then(raw_response => {
          response._add_raw_response(raw_response);
          return response;
        })

        .catch(error => {
          if (error.hasOwnProperty('response')) {
            response._add_raw_response(error.response);
            error.response = response;
          } else {
            // if it's not a MonkeyLearn Error (so, some other js runtime error),
            // return as-is but add the response
            // not the cleanest solution but I don't want the error to lose the context
            error.response = response;
            error.error_code = '';
          }
          throw error;
        })
      )
    , promise)
  }
}