Otherwise, just returns the input.
512189
private <T> T orIfIgnoringFieldAbsence(
      @NullableDecl T input, @NullableDecl T defaultValue, boolean ignoreFieldAbsence) {
    return (input == null && ignoreFieldAbsence) ? defaultValue : input;
  }
253891
def read(self, size=-1):
        """"""
        if self.connected is None:
            return None

        # Extract requested amount of data from the read buffer.
        data = self._get_input(size)

        return data
248854
public function getInput()
    {
        if (is_null($this->_input)) {
            $this->_input = new Input($this->getName());
        }
        return $this->_input;
    }
535654
function assembleInput(input) {
  if (_.isArray(input.context)) {
    return input.context;
  }
  var result = (input.prefix || '') + (input.context || '') + (input.suffix || '');
  return strip(result);
}
1057224
def get_password(from_stdin_only=False):
    
    if not sys.stdin.isatty():
        password = sys.stdin.readline().strip()
    elif not from_stdin_only:
        password = getpass.getpass('Enter the password: ')
    else:
        password = None

    return password
457153
def _get_data(self, read_size):
        """"""
        if NIX:
            return super(Keyboard, self)._get_data(read_size)
        return self._pipe.recv_bytes()
1354167
def input_by_key():
    """"""
    usr_inp = ''
    input_valid = True
    input_flush()
    with term.cbreak():
        while input_valid:
            ui_print("\033[?25h")  # cursor on
            key_raw = term.inkey()
            if key_raw.name == "KEY_ENTER":
                input_valid = False
                ui_print("\033[?25l")  # cursor off
                break
            if key_raw.name == 'KEY_DELETE':
                ui_del_char(len(usr_inp))
                usr_inp = usr_inp[:-1]
            if not key_raw.is_sequence:
                usr_inp += key_raw
                ui_print(key_raw)
    if not usr_inp:
        ui_print("\033[D")
    return usr_inp
157047
protected String input (String type, String name, String extra,
                            Object defaultValue)
    {
        return fixedInput(type, name, getValue(name, defaultValue), extra);
    }
59293
def _preprocess_input(self, input):
        '''
        
        '''
        if not re.search(preprocess_chars, input):
            # No characters that we need to preprocess, so continue without.
            return input

        input = self._add_punctuation_spacing(input)

        return input
502196
function getInputExcerpt(input, pos, len) {
  var excerpt = asEscapedString(input.slice(pos, pos + len));

  // Pad the output if necessary.
  if (excerpt.length < len) {
    return excerpt + common.repeat(' ', len - excerpt.length).join('');
  }
  return excerpt;
}
1084997
def input(self, more=False):
        """"""
        sys.stdout.flush()
        if more:
            msg = more_prompt
        else:
            msg = main_prompt
        if self.style is not None:
            internal_assert(prompt_toolkit is not None, "without prompt_toolkit cannot highlight style", self.style)
            try:
                return self.prompt(msg)
            except EOFError:
                raise  # issubclass(EOFError, Exception), so we have to do this
            except (Exception, AssertionError):
                logger.display_exc()
                logger.show_sig("Syntax highlighting failed; switching to --style none.")
                self.style = None
        return input(msg)
1350169
def process_input(self):
        
        try:
            character = self.window.getch()
        except Exception as e:
            character = -1
            if self.debug:
                self.addstr(self.height-1, self.width - len(e.message) + 1, e.message)

        # Check for any keys we've been told to exit on
        if character in self.exit_keys:
            self.stop()

        # Force redraw the screen on ^L
        if character == 12:
            self.window.clear()
            return

        # Send input to active panes (hidden panes can still receive input)
        if character != -1:
            [pane.process_input(character) for pane in self if pane.active ]

            # Print character codes to the bottom center if debugging.
            if self.debug:
                self.addstr(self.height-1, self.width/2, " "*4)
                self.addstr(self.height-1, self.width/2 - len(str(character)) / 2, str(character))
661620
def get_input_from_submission(self, submission, only_input=False):
        
        inp = bson.BSON.decode(self._gridfs.get(submission['input']).read())
        if only_input:
            return inp
        else:
            submission["input"] = inp
            return submission
840422
def ainput(prompt='', *, streams=None, use_stderr=False, loop=None):
    """"""
    # Get standard streams
    if streams is None:
        streams = yield from get_standard_streams(
            use_stderr=use_stderr, loop=loop)
    reader, writer = streams
    # Write prompt
    writer.write(prompt.encode())
    yield from writer.drain()
    # Get data
    data = yield from reader.readline()
    # Decode data
    data = data.decode()
    # Return or raise EOF
    if not data.endswith('\n'):
        raise EOFError
    return data.rstrip('\n')
262594
def get(self):
        '''
        inputHookFunc = c_void_p.from_address(self.inputHookPtr).value

        Cevent = INPUT_RECORD()
        count = DWORD(0)
        while 1:
            if inputHookFunc:
                call_function(inputHookFunc, ())
            status = self.ReadConsoleInputW(self.hin, 
                                        byref(Cevent), 1, byref(count))
            if status and count.value == 1:
                e = event(self, Cevent)
                return e
1036494
function getInputValue() {
      var input = _this.getInput();

      if (!input) {
        return null;
      }

      switch (innerParams.input) {
        case 'checkbox':
          return input.checked ? 1 : 0;

        case 'radio':
          return input.checked ? input.value : null;

        case 'file':
          return input.files.length ? input.files[0] : null;

        default:
          return innerParams.inputAutoTrim ? input.value.trim() : input.value;
      }
    }
272703
def standard_input():
    """"""
    with click.get_text_stream("stdin") as stdin:
        while stdin.readable():
            line = stdin.readline()
            if line:
                yield line.strip().encode("utf-8")