GET // 
FUNCTION: get( opts, clbk )
Get user details.

@param {Object} opts - options
@param {Function} clbk - callback to invoke after getting user details
@returns {Void}
508690
function get( opts, clbk ) {
	var ratelimit;
	var scount;
	var fcount;
	var count;
	var users;
	var eFLG;
	var out;
	var idx;
	var len;
	var i;

	// Output data store:
	out = {};
	out.meta = {};
	out.data = {};
	out.failures = {};

	// Number of completed requests:
	count = 0;
	scount = 0; // success
	fcount = 0; // failures

	// Request id:
	idx = 0;

	users = opts.usernames;
	len = users.length;

	debug( 'Number of usernames: %d.', len );
	out.meta.total = len;

	debug( 'Beginning queries...' );
	for ( i = 0; i < NUM_CONCURRENT_REQUESTS; i++ ) {
		next();
	}
	/**
	* FUNCTION: next()
	*	Requests user details data for the next username in the queue. Once requests for all desired usernames have completed, invokes the provided callback.
	*
	* @private
	* @returns {Void}
	*/
	function next() {
		var u;
		if ( count === len ) {
			debug( 'Finished all queries.' );
			out.meta.success = scount;
			out.meta.failure = fcount;
			return clbk( null, out, ratelimit );
		}
		if ( idx < len ) {
			u = users[ idx ];
			debug( 'Querying for username: `%s` (%d).', u, idx );
			opts.pathname = '/users/' + u;
			request( opts, onResponse( u, idx ) );
			idx += 1;
		}
	} // end FUNCTION next()

	/**
	* FUNCTION: onResponse( username, idx )
	*	Returns a response callback.
	*
	* @private
	* @param {String} username - username
	* @param {Number} idx - request index
	* @returns {Function} response callback
	*/
	function onResponse( username, idx ) {
		/**
		* FUNCTION: onResponse( error, details, info )
		*	Callback invoked upon receiving a request response.
		*
		* @private
		* @param {Error|Null} error - error object
		* @param {Object} details - response data
		* @param {Object} info - rate limit info
		* @returns {Void}
		*/
		return function onResponse( error, details, info ) {
			if ( eFLG ) {
				return;
			}
			debug( 'Response received for username: `%s` (%d).', username, idx );
			if ( arguments.length === 1 ) {
				eFLG = true;
				debug( 'Encountered an application-level error for username `%s` (%d): %s', username, idx, error.message );
				return clbk( error );
			}
			ratelimit = updateRateLimit( ratelimit, info );
			if ( error ) {
				debug( 'Failed to resolve username `%s` (%d): %s', username, idx, error.message );
				out.failures[ username ] = error.message;
				fcount += 1;
			} else {
				debug( 'Successfully resolved username `%s` (%d).', username, idx );
				out.data[ username ] = details;
				scount += 1;
			}
			count += 1;
			debug( 'Request %d of %d complete.', count, len );
			next();
		}; // end FUNCTION onResponse()
	} // end FUNCTION onResponse()
}
620126
function getConfigOptions(opts) {
    opts = formatOptions(opts);
    _.forEach(config, function(value, key) {
      opts[key] = opts[key] || value;
    });
    opts.headers = opts.headers || {};

    return opts;
  }
1010959
def get_user(user_or_username=None):
    
    if user_or_username is None:
        return None
    if hasattr(user_or_username, "getUserId"):
        return ploneapi.user.get(user_or_username.getUserId())
    return ploneapi.user.get(userid=u.to_string(user_or_username))
1279668
function getOption(opts) {
  return {
    tag: 'option',
    attrs: {
      disabled: opts.disabled,
      value: opts.value
    },
    children: opts.text,
    key: opts.value
  };
}
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}
466495
function getUrls (opts) {

    var list    = [];

    var bsLocal = require("url").parse(opts.urls.local);

    list.push([bsLocal.protocol + "//", bsLocal.hostname, ":", opts.port].join(""));

    if (opts.urls.external) {
        var external = require("url").parse(opts.urls.external);
        list.push([bsLocal.protocol + "//", external.hostname, ":", opts.port].join(""));
    }

    return Immutable.List(list);
}
1079311
def get(*args)
      params = arguments(args).params

      if user_name = params.delete('user')
        get_request("/users/#{user_name}", params)
      else
        get_request("/user", params)
      end
    end
1310215
function (opts, cb) {
      var self = this
      opts = opts || {}
      var root = opts.root || RootKey
      var key = opts.key
      if (!key) {
        return cb(new Error(ERR.FA_PARAMS.msg), ERR.FA_PARAMS)
      }
      mq.hget(root, key, function (err, doc) {
        if (err) {
          cb(err, ERR.config.FA_GET_CONFIG)
        } else {
          if (!doc) return cb(null, null)
          doc = self._parse(doc)
          if (doc.err) {
            if (doc === ERR.config.FA_CONFIG_EXPIRED) {
              self.delConfig(opts, function (err, doc) {})
            }
            return cb(new Error(doc.msg), doc)
          }
          cb(null, doc.value)
        }
      })
    }
197728
public function getUsers($opts = [])
    {
        $query = '';
        
        if(isset($opts['search'])) $query .= '?search='.$opts['search'];
        
    	$endpoint = '/users'.$query;        
    	return $this->doRequest('GET', $endpoint);
    }
60624
function get(ignored, cb) {
  assert(this.$session);
  const ugRequest = {
    userId: this.$session.userId,
  };
  this.syscall('UserManager', 'get', ugRequest, (err, userInfo, curVersion) => {
    if (err) return cb(err);

    // Strip security-sensitive information.
    delete userInfo.hashedPassword;
    _.forEach(userInfo.securityEvents, (secEvt) => {
      if (secEvt.eventType === 'password_reset_requested') {
        delete secEvt.data.resetCode;
      }
    });

    return cb(null, userInfo, curVersion);
  });
}
715414
function (opts) {
        var objectName = opts.name
        var object = null

        this.objects.forEach(function (item) {
            if (item.name == objectName) {
                object = item
            }
        })
        if (object !== null) {
            return object
        }
    }
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;
  });
}
1011719
function requestAsync(resource, opts = {}) {
  const settings = {
    followRedirect: true,
    encoding: null,
    rejectUnauthorized: false
  };

  if (opts.user && opts.pass) {
    settings.headers = {Authorization: 'Basic ' + token(opts.user, opts.pass)};
  }

  return new Bluebird((resolve, reject) => {
    // Handle protocol-relative urls
    resource = url.resolve('http://te.st', resource);
    request(resource, settings, (err, resp, body) => {
      let msg;
      if (err) {
        debug('Url failed:', err.message || err);
        return reject(err);
      }
      if (resp.statusCode !== 200) {
        msg = 'Wrong status code ' + resp.statusCode + ' for ' + resource;
        debug(msg);
        return reject(new Error(msg));
      }

      const mimeType =
        result(resp, 'headers.content-type') || mime.getType(resource);

      resolve({
        contents: body,
        path: resource,
        mime: mimeType
      });
    });
  });
}
1185247
function init(client, opts) {
	client.servers = {};
	client.channels = {};
	client.users = {};
	client.directMessages = {};
	client.internals = {
		oauth: {},
		version: CURRENT_VERSION,
		settings: {}
	};
	client._connecting = true;

	setupPing(client.internals);
	return getToken(client, opts);
}
903986
function Link (opts) {
  if(!opts) opts = {}
  this.timeout = opts.timeout || 10*SECONDS
  this.localTransmissionId = 0
  this.lastRemoteTransmissionId = null
  this.credentials = opts.credentials
  this.authenticateFn = opts.authenticate
  this.authorizeReadFn = opts.authorizeRead
  this.authorizeWriteFn = opts.authorizeWrite
  this.authenticated
  this.sentEdit
  this.sentRequestInit
  this.queue
  this.linkBuffer = ''

  Duplex.call(this, {allowHalfOpen: false, objectMode: true})

  this.on('error', function(er) {
    debug('Error in link', 'undefined'!=typeof window? er : er.stack || er)
  }.bind(this))

  this.on('editError', function(er) {
    debug('EditError in link', 'undefined'!=typeof window? er : er.stack || er)
  })

  this.reset()
}
378790
def do_get(endpoint, access_token):
    '''
    '''
    headers = {"Authorization": 'Bearer ' + access_token}
    headers['User-Agent'] = get_user_agent()
    return requests.get(endpoint, headers=headers).json()
264429
function getUser(username, done) {
  return getModels(function(m) {
    return m.collections.user.findOne({ username })
      .populate("tokens")
      .populate("groups")
      .populate("leading")
      .exec(done);
  });
}