Return the answer
346137
def ask(question, escape=True):
    ""
    answer = raw_input(question)
    if escape:
        answer.replace('"', '\\"')
    return answer.decode('utf')
204216
def run(self):
        """"""
        try:
            answer = urlopen(self.url + "&mode=queue").read().decode()
        except (HTTPError, URLError) as error:
            self.output = {
                "full_text": str(error.reason),
                "color": "#FF0000"
            }
            return

        answer = json.loads(answer)

        # if answer["status"] exists and is False, an error occured
        if not answer.get("status", True):
            self.output = {
                "full_text": answer["error"],
                "color": "#FF0000"
            }
            return

        queue = answer["queue"]
        self.status = queue["status"]

        if self.is_paused():
            color = self.color_paused
        elif self.is_downloading():
            color = self.color_downloading
        else:
            color = self.color

        if self.is_downloading():
            full_text = self.format.format(**queue)
        else:
            full_text = self.format_paused.format(**queue)

        self.output = {
            "full_text": full_text,
            "color": color
        }
1229879
def confirm(question):
    
    if FORCE_YES:
        return True

    while True:
        answer = input(question + ' <Yes|No>').lower()

        if answer == 'yes' or answer == 'y':
            confirmed = True
            break
        if answer == 'no' or answer == 'n':
            confirmed = False
            break

    return confirmed
778600
def validate(self, answer):
        
        if answer is None:
            return False
        else:
            if isinstance(self.validator, list):
                for v in self.validator:
                    if not v.validate(answer):
                        return False
                return True
            else:
                return self.validator.validate(answer)
928882
private String getAnswerValue(QueryQuestionNumericAnswer answer) {
    return answer != null && answer.getData() != null ? String.valueOf(Math.round(answer.getData())) : null;
  }
724256
function format(answers) {
  // parentheses are only needed when a scope is present
  const scope = answers.scope ? '(' + answers.scope.trim() + ') ' : ''

  // build head line and limit it to 100
  const head = truncate(answers.type + ' ' + scope + answers.subject.trim(), 100)

  // wrap body at 100
  const body = wrap(answers.body, 100)

  const footer = (answers.issues.match(/#\d+/g) || [])
    .map(issue => `Closes ${issue}`)
    .join('\n')

  return [head, body, footer]
    .join('\n\n')
    .trim()
}
1049698
def _at_return(self, calculator, rule, scope, block):
        
        # TODO should assert this only happens within a @function
        ret = calculator.calculate(block.argument)
        raise SassReturn(ret)
294153
def re_ask(self, with_help=True):
        
        if with_help:
            self.show_help()

        return self.get_answer(self.last_question)
743093
def return_type(self):
        
        returns = self.returns
        if returns:
            return [r.type for r in returns]
        return None
887547
public String getAnswer() {
    if (OutputElement_Type.featOkTst && ((OutputElement_Type)jcasType).casFeat_answer == null)
      jcasType.jcas.throwFeatMissing("answer", "edu.cmu.lti.oaqa.framework.types.OutputElement");
    return jcasType.ll_cas.ll_getStringValue(addr, ((OutputElement_Type)jcasType).casFeatCode_answer);}
713957
def handle_answer(answer)
      return nil  if answer.nil?
      answer = convert(answer)
      field = opts[:field]
      if field
        answer = answer[field]
      end
      answer
    end
557321
def answers(self, other):
        """"""
        if other.__class__ == self.__class__:
            return (other.service + 0x40) == self.service or \
                   (self.service == 0x7f and
                    self.request_service_id == other.service)
        return False
326022
def content(self):
        
        answer_wrap = self.soup.find('div', id='zh-question-answer-wrap')
        content = answer_wrap.find('div', class_='zm-editable-content')
        content = answer_content_process(content)
        return content
357179
def get_solution(self) -> Tuple[str, str]:
        
        if self.solution is None:
            raise AssertionError("You need to `run` this algorithm first")
        return self.solution
653887
public Object answer(InvocationOnMock invocation) throws Throwable {
        Object ret = delegate.answer(invocation);
        if (ret != null) {
            return ret;
        }

        Class<?> returnType = invocation.getMethod().getReturnType();
        return returnValueFor(returnType);
    }
912329
def get_value(self):
        
        if (self._value is None) and (self.expr is not None):
            self._value = self.expr.get_value()

        return self._value
1043908
function ask(questions, finish, answers, input, output) {
    finish = finish || function() {};
    input = input || function(cb) {process.stdin.on('data', cb);};
    output = output || function(a) {console.log(a);};

    var i = 0;
    var ret = {};
    var e = questions[0];
    var v = match(ops, e);

    output(getOutput(e, v));
    input(getInput);

    function getOutput(e, v) {
        var o = f.isFunction(v.output)? v.output(e): '';

        return e.q + o;
    }

    function getInput(t) {
        t = t.trim();
        var r = v.exec(t, e);

        if(f.isDefined(r)) {
            ret[e.id] = r;
            i++;

            if(i >= questions.length) {
                // XXX: separate this somehow
                process.stdin.removeListener('data', getInput);
                process.stdin.pause();

                finish(ret);
            }
            else {
                e = questions[i];
                v = match(ops, e);
                output(getOutput(e, v));
            }
        }
    }
}