https://developer.zendesk.com/rest_api/docs/core/users#show-user
968231
def user_show(self, id, **kwargs):
        ""
        api_path = "/api/v2/users/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, **kwargs)
796231
public Optional<User> show(long userId)
    {
        return HTTP.GET(String.format("/v2/users/%d.json", userId), USER);
    }
1339912
def get_presence(self, user_name):
        
        user_id = self.get_id_by_name(user_name)
        self.params.update({
            'user': user_id,
            })
        return FromUrl('https://slack.com/api/users.getPresence', self._requests)(data=self.params).get()
1325748
def user_related(self, id, **kwargs):
        ""
        api_path = "/api/v2/users/{id}/related.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, **kwargs)
1155492
def user_info(access_token, request):
  
  user = access_token.user
  data = {
      'username': user.username,
      'first_name': user.first_name,
      'last_name': user.last_name,
      'email': user.email}

  return HttpResponse(content=json.dumps(data),
                      content_type='application/json',
                      status=200)
387636
def prj_view_user(self, *args, **kwargs):
        
        if not self.cur_prj:
            return
        i = self.prj_user_tablev.currentIndex()
        item = i.internalPointer()
        if item:
            user = item.internal_data()
            self.view_user(user)
341325
def get_user(self, uid):
		""""""
		
		r = requests.get(api_url+'users/'+str(uid)+'/', headers=self.headers)
		print(request_status(r))
		r.raise_for_status()
		return User(r.json())
48184
def get_user_brief():
    """"""
    client = get_user_api()

    with catch_raise_api_exception():
        data, _, headers = client.user_self_with_http_info()

    ratelimits.maybe_rate_limit(client, headers)
    return data.authenticated, data.slug, data.email, data.name
299015
function userJSON(user, options) {
	return {
		FullName: user.fullname,
		UserName: user.username,
		Location: api.join(options.usersRoot, user.username),
		Email: user.email,
		EmailConfirmed: emailConfirmed(user),
		HasPassword: true,
		OAuth: user.oauth || undefined,
		LastLoginTimestamp: user.login_timestamp ? user.login_timestamp.getTime() : 0,
		DiskUsageTimestamp: user.disk_usage_timestamp ? user.disk_usage_timestamp.getTime() : 0,
		DiskUsage: user.disk_usage || 0 ,
		jwt: user.jwt
	};
}
1344911
def user_session_show(self, user_id, id, **kwargs):
        ""
        api_path = "/api/v2/users/{user_id}/sessions/{id}.json"
        api_path = api_path.format(user_id=user_id, id=id)
        return self.call(api_path, **kwargs)
1161563
def related(self, user):
        
        return self._query_zendesk(self.endpoint.related, 'user_related', id=user)
591743
def user_info(self, username):
        
        request_url = "{}/api/0/user/{}".format(self.instance, username)

        return_value = self._call_api(request_url)

        return return_value
1190857
def view_user_full_description(id)
      response = connection.get do |req|
        req.url "users/#{id}/full"
      end
      return_error_or_body(response)
    end
82884
def find_by_user(user: str) -> List['ApiKey']:
        
        return [ApiKey.from_db(key) for key in db.get_keys(qb.from_dict({'user': user}))]
1340540
def user_data(self, access_token, *args, **kwargs):
        """"""
        url = '{}/userinfo'.format(self.BASE_URL)
        response = self.get_json(
            url,
            headers={'Authorization': 'Bearer ' + access_token},
        )
        self.check_correct_audience(response['audience'])

        userdata = response['user']
        return userdata
563187
def show_user(self, login=None, envs=[], query='/users/'):
        
        juicer.utils.Log.log_debug("Show User: %s", login)

        # keep track of which iteration of environment we're in
        count = 0

        for env in self.args.envs:
            count += 1

            juicer.utils.Log.log_info("%s:", env)
            if not juicer.utils.user_exists_p(login, self.connectors[env]):
                juicer.utils.Log.log_info("user `%s` doesn't exist in %s... skipping!",
                                          (login, env))
                continue
            else:
                url = "%s%s/" % (query, login)
                _r = self.connectors[env].get(url)
                if _r.status_code == Constants.PULP_GET_OK:
                    user = juicer.utils.load_json_str(_r.content)

                    juicer.utils.Log.log_info("Login: %s" % user['login'])
                    juicer.utils.Log.log_info("Name: %s" % user['name'])
                    juicer.utils.Log.log_info("Roles: %s" % ', '.join(user['roles']))

                    if count < len(envs):
                        # just want a new line
                        juicer.utils.Log.log_info("")
                else:
                    _r.raise_for_status()
        return True
1042343
def get_user(user, driver):  # noqa: E501
    

    response = ApitaxResponse()

    driver: Driver = LoadedDrivers.getDriver(driver)
    user: User = driver.getApitaxUser(User(username=user))
    response.body.add({'user': {'username': user.username, 'role': user.role}})

    return Response(status=200, body=response.getResponseBody())