Passes user inputs to GetGist() and calls get()
334432
def run_getgist(filename, user, **kwargs):
    """"""
    assume_yes = kwargs.get("yes_to_all")
    getgist = GetGist(user=user, filename=filename, assume_yes=assume_yes)
    getgist.get()
981869
def GetInput(self):
    """"""
    clients = GetAllClients(token=self.token)
    logging.debug("Got %d clients", len(clients))
    return clients
280314
function simulatedUserInput(numArray) {
    // pause + first one
    // forEach after the first: outer + inner
    const rest$ = numOrArray => {
      if (!numOrArray.length) return after(pause, () => numOrArray)
      let rest = after(pause, () => numOrArray[0])
      for (let i = 1; i < numOrArray.length; i++) {
        rest = concat(rest, after(outer, () => numOrArray[i]))
      }
      return rest
    }

    return from(numArray).pipe(concatMap(rest$))
  }
798768
def _get_user(session, slug_or_user_id):
        
        user_json_items = session.fetch('users.get', user_ids=slug_or_user_id, fields=User.USER_FIELDS)
        return User.from_json(session, user_json_items[0])
76879
function genWeexHandler (params, handlerCode) {
  var innerHandlerCode = handlerCode;
  var exps = params.filter(function (exp) { return simplePathRE.test(exp) && exp !== '$event'; });
  var bindings = exps.map(function (exp) { return ({ '@binding': exp }); });
  var args = exps.map(function (exp, i) {
    var key = "$_" + (i + 1);
    innerHandlerCode = innerHandlerCode.replace(exp, key);
    return key
  });
  args.push('$event');
  return '{\n' +
    "handler:function(" + (args.join(',')) + "){" + innerHandlerCode + "},\n" +
    "params:" + (JSON.stringify(bindings)) + "\n" +
    '}'
}
1113530
def get_input(params: Union[dict, list]) -> Tuple[list, dict]:
    
    # Backwards compatibility for old clients that send params as a list
    if isinstance(params, list):
        args = params
        kwargs = {}
    elif isinstance(params, dict):
        args = params.pop('*args', [])
        kwargs = params
    else:  # pragma no coverage
        raise TypeError(
            'Unknown type {} of params, must be list or dict'.format(type(params)))

    return args, kwargs
921162
def make_input(self):
        """"""
        # Set the file paths.
        all_files ={"ddkfile_" + str(n + 1): ddk for n, ddk in enumerate(self.ddk_filepaths)}
        all_files.update({"wfkfile": self.wfk_filepath})
        files_nml = {"FILES": all_files}
        files= nmltostring(files_nml)

        # Get the input specified by the user
        user_file = nmltostring(self.input.as_dict())

        # Join them.
        return files + user_file
1026323
def get(method, hmc, uri, uri_parms, logon_required):
        """"""
        query_str = uri_parms[0]
        try:
            console = hmc.consoles.lookup_by_oid(None)
        except KeyError:
            raise InvalidResourceError(method, uri)
        result_users = []
        filter_args = parse_query_parms(method, uri, query_str)
        for user in console.users.list(filter_args):
            result_user = {}
            for prop in user.properties:
                if prop in ('object-uri', 'name', 'type'):
                    result_user[prop] = user.properties[prop]
            result_users.append(result_user)
        return {'users': result_users}
699840
public Object get(int access, String name) throws PageException {
	return get(access, KeyImpl.init(name));
    }
7217
void handleGet(
    Object value,
    MatchSpaceKey msg,
    EvalCache cache,
    Object contextValue,
    SearchResults result)
    throws MatchingException, BadMessageFormatMatchingException
  {
    if (tc.isEntryEnabled())
      tc.entry(
        this,
        cclass,
        "handleGet",
        "value: "
          + value
          + "msg: "
          + msg
          + ", context: "
          + contextValue
          + ", result: "
          + result);

    if (!(value instanceof String))
      return;
    char[] chars = ((String) value).toCharArray();
    subTree.get(chars, 0, chars.length, false, msg, cache, contextValue, result);
    if (haveEqualityMatches())
      handleEqualityGet(value, msg, cache, contextValue, result);
    if (tc.isEntryEnabled())
      tc.exit(this,cclass, "handleGet");
  }
32363
function get(usernames, options) {
  usernames = usernames || '';
  usernames = (_.isArray(usernames)) ? usernames : usernames.split(',');
  options = options || {};
  var defers = [];
  var collection = {};

  _.each(usernames, function(u) {
    var defer = q.defer();
    u = u.toLowerCase();

    if (u.length === 0) {
      return;
    }

    qG({
      obj: 'user', method: 'getFrom', user: u
    })
    .done(function(data) {
      collection[u] = data[0];

      // Get objects for the specific user
      getObjects(data[0]).done(function(objData) {
        collection[u].objects = collection[u].objects || {};
        collection[u].objects.repos = objData[0];
        collection[u].objects.gists = objData[1];
        collection[u].objects.members = objData[2];

        defer.resolve(collection[u]);
      });
    });

    defers.push(defer.promise);
  });

  return q.all(defers).then(function() {
    return collection;
  });
}
1254335
def process_user_input(self):
        
        user_input = self.get_input()

        try:
            num = int(user_input)
        except Exception:
            return
        if 0 < num < len(self.items) + 1:
            self.current_option = num - 1
            self.select()

        return user_input
1251973
def prompt_user(prompt):
    """"""
    # raw_input returns the empty string for "enter"
    yes = set(['yes', 'y'])
    no = set(['no','n'])

    try:
        print(prompt)
        choice = input().lower()
        # would like to test for exception here, but not sure if we can do that without importing IPython
    except:
        print('Stdin is not implemented.')
        print('You need to set')
        print('overide_manual_authorize=True')
        print('to proceed with the download. Please set that variable and continue.')
        raise


    if choice in yes:
        return True
    elif choice in no:
        return False
    else:
        print(("Your response was a " + choice))
        print("Please respond with 'yes', 'y' or 'no', 'n'")
42732
void handleGet(
    Object value,
    MatchSpaceKey msg,
    EvalCache cache,
    Object contextValue,
    SearchResults result)
    throws MatchingException, BadMessageFormatMatchingException {
      if (tc.isEntryEnabled())
        tc.entry(this,cclass, "handleGet",
          new Object[] {value,msg,cache,contextValue,result} );
      handleEqualityGet(value, msg, cache, contextValue, result);
      if (tc.isEntryEnabled())
        tc.exit(this,cclass, "handleGet");        
  }
1134129
@Override
    public D get()
    {
        try
        {
            if (field != null)
            {
                return (D) field.get(getBase());
            }
            else
            {
                return (D) getter.invoke(getBase());
            }
        }
        catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ex)
        {
            throw new IllegalArgumentException(ex);
        }
    }
883538
def get_raw_input_register(self, name):
        """"""
        if self._update_on_read:
            self.update()
        return self._input_regs[name]
1145415
function input(s,startIndex,_debug) {
  startIndex=startIndex || 0;
  var _this=this;
  return _input(s,startIndex,'start',[],startIndex-1);
  function _input(s,startIndex,fromState,stack,lastIndex) {
    recur:do {
      var c,range,advanceIndex,lastResult;
      var path=_this.router[fromState];
      if (!path) break;
      var eMove=path.eMove,charMove=path.charMove,trans;
      if (startIndex<s.length) {
        c=s[startIndex];
        if (charMove.hasOwnProperty(c)) {
          trans=charMove[c];
        } else if (range=findRange(path.ranges,c)) {
          trans=charMove[range];
        } else {
          trans=eMove;
        }
      } else {
        trans=eMove;
      }

      var sp=stack.length,t,skip,ret,oldLastIndex=lastIndex;
      for (var j=0,n=trans.length;j<n;j++) {
        t=trans[j];
        advanceIndex=t.eMove?0:1;
        lastIndex=oldLastIndex;
        stack.splice(0,stack.length-sp);
        sp=stack.length; // backup stack length
        if (t.assert) {
          if ((skip=t.assert(stack,c,startIndex,fromState,s))===false) continue;
          // For backref skip num chars
          if (typeof skip==='number') {startIndex+=skip;lastIndex+=skip;}
        }
        if (t.action) stack=t.action(stack,c,startIndex,fromState,s) || stack;
        lastIndex=t.eMove?lastIndex:startIndex;
        _debug && K.log(c+":"+fromState+">"+t.to);
        if (j===n-1) {
          startIndex+=advanceIndex;
          fromState=t.to;
          continue recur; // Human flesh tail call optimize?
        } else {
          ret=_input(s,startIndex+advanceIndex,t.to,stack,lastIndex);
        }
        if (ret.acceptable) return ret;
        lastResult=ret;
      }
      if (lastResult) return lastResult;
      break;
    } while (true);

    return {
      stack:stack,lastIndex:lastIndex,lastState:fromState,
      acceptable:_this.accept(fromState)
    };
  }
}