Use this API to fetch nslimitidentifier resources of given names .
353392
public static nslimitidentifier[] get(nitro_service service, String limitidentifier[]) throws Exception{
		if (limitidentifier !=null && limitidentifier.length>0) {
			nslimitidentifier response[] = new nslimitidentifier[limitidentifier.length];
			nslimitidentifier obj[] = new nslimitidentifier[limitidentifier.length];
			for (int i=0;i<limitidentifier.length;i++) {
				obj[i] = new nslimitidentifier();
				obj[i].set_limitidentifier(limitidentifier[i]);
				response[i] = (nslimitidentifier) obj[i].get_resource(service);
			}
			return response;
		}
		return null;
	}
382797
def get_limits(self):
        
        if self.limits != {}:
            return self.limits
        limits = {}
        limits.update(self._get_limits_instances())
        limits.update(self._get_limits_networking())
        limits.update(self._get_limits_spot())
        self.limits = limits
        return self.limits
361913
def get_namespace_keys(app, limit):
  """"""
  ns_query = datastore.Query('__namespace__', keys_only=True, _app=app)
  return list(ns_query.Run(limit=limit, batch_size=limit))
1335922
def _get_ns(self, reply):
        '''
        '''

        def get_prefix(url):
            if url in special_prefixes:
                return special_prefixes[url]
            for i in self.namespaces:
                if url == i[2]:
                    return i[1]
            return None

        root = reply.getroottree()
        urls = set()
        for node in root.iter():
            urls.update([u for p, u in node.nsmap.items()])
        ret = {url: get_prefix(url) for url in urls}
        i = 0
        for url in [url for url in ret if ret[url] is None]:
            logger.warning('{} cannot be found in namespaces of any ' \
                           'models'.format(url))
            ret[url] = 'ns{:02d}'.format(i)
            i += 1
        return {p: u for u, p in ret.items()}
385537
def get_limits(self):
        
        logger.debug("Getting limits for Lambda")
        if self.limits != {}:
            return self.limits

        self._construct_limits()

        return self.limits
292791
public static base_responses update(nitro_service client, nslimitselector resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			nslimitselector updateresources[] = new nslimitselector[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new nslimitselector();
				updateresources[i].selectorname = resources[i].selectorname;
				updateresources[i].rule = resources[i].rule;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
106537
@Override
	public SortedSet<String> getDomainNames(String name) {
		if ( name.length() < 4)
			throw new IllegalArgumentException("Can't interpret IDs that are shorter than 4 residues!");

		String url = String.format("%srepresentativeDomains?cluster=%s&structureId=%s",
				base, cutoff, name);
		return requestRepresentativeDomains(url);
	}
66793
def limit_spec(self, spec):
        
        if list(spec.keys()) == ['name']:
            # if we're just resolving on name, include other names
            return ((Q(name=spec['name']) | Q(other_names__name=spec['name'])) &
                    Q(memberships__organization__jurisdiction_id=self.jurisdiction_id))
        spec['memberships__organization__jurisdiction_id'] = self.jurisdiction_id
        return spec
1065193
public static base_response unset(nitro_service client, nslimitidentifier resource, String[] args) throws Exception{
		nslimitidentifier unsetresource = new nslimitidentifier();
		unsetresource.limitidentifier = resource.limitidentifier;
		return unsetresource.unset_resource(client,args);
	}
658065
public static base_responses unset(nitro_service client, String limitidentifier[], String args[]) throws Exception {
		base_responses result = null;
		if (limitidentifier != null && limitidentifier.length > 0) {
			nslimitidentifier unsetresources[] = new nslimitidentifier[limitidentifier.length];
			for (int i=0;i<limitidentifier.length;i++){
				unsetresources[i] = new nslimitidentifier();
				unsetresources[i].limitidentifier = limitidentifier[i];
			}
			result = unset_bulk_request(client, unsetresources,args);
		}
		return result;
	}
565086
private int findRunLimit(int index, int limit, byte[] validSet) {
        --index;
        loop:
            while (++index < limit) {
                byte t = resultTypes[index];
                for (int i = 0; i < validSet.length; ++i) {
                    if (t == validSet[i]) {
                        continue loop;
                    }
                }
                // didn't find a match in validSet
                return index;
            }
            return limit;
    }
1162529
public static nslimitselector[] get(nitro_service service) throws Exception{
		nslimitselector obj = new nslimitselector();
		nslimitselector[] response = (nslimitselector[])obj.get_resources(service);
		return response;
	}
897315
protected function fetchLimits()
    {
        $result = $this->get('/rate_limit') ?: [];

        // Assemble Limit instances
        foreach ($result['resources'] as $resourceName => $resource) {
            $this->resources[$resourceName] = new RateLimitResource($resourceName, $resource);
        }

        return $result;
    }
1105456
static UserLimits getLimitsFromToken(HTTPServerConfig config, String jwtToken) {
    Objects.requireNonNull(jwtToken);
    try {
      String secretKey = config.getSecretTokenKey();
      if (secretKey == null) {
        throw new RuntimeException("You specified a 'token' parameter but this server doesn't accept tokens");
      }
      Algorithm algorithm = Algorithm.HMAC256(secretKey);
      DecodedJWT decodedToken;
      try {
        JWT.require(algorithm).build().verify(jwtToken);
        decodedToken = JWT.decode(jwtToken);
      } catch (JWTDecodeException e) {
        throw new AuthException("Could not decode token '" + jwtToken + "'", e);
      }
      Claim maxTextLengthClaim = decodedToken.getClaim("maxTextLength");
      Claim premiumClaim = decodedToken.getClaim("premium");
      boolean hasPremium = !premiumClaim.isNull() && premiumClaim.asBoolean();
      Claim uidClaim = decodedToken.getClaim("uid");
      long uid = uidClaim.isNull() ? -1 : uidClaim.asLong();
      return new UserLimits(
              maxTextLengthClaim.isNull() ? config.maxTextLength : maxTextLengthClaim.asInt(),
              config.maxCheckTimeMillis,
              hasPremium ? uid : null);
    } catch (UnsupportedEncodingException e) {
      throw new RuntimeException(e);
    }
  }
104315
public static nslimitidentifier get(nitro_service service, String limitidentifier) throws Exception{
		nslimitidentifier obj = new nslimitidentifier();
		obj.set_limitidentifier(limitidentifier);
		nslimitidentifier response = (nslimitidentifier) obj.get_resource(service);
		return response;
	}
301442
public static nslicense get(nitro_service service) throws Exception{
		nslicense obj = new nslicense();
		nslicense[] response = (nslicense[])obj.get_resources(service);
		return response[0];
	}
36215
def getAnnotations_via_tid(self,
                               tids,
                               LIMIT=25,
                               _print=True,
                               crawl=False):
        
        url_base = self.base_url + \
            '/api/1/term/get-annotations/{tid}?key=' + self.api_key
        urls = [url_base.format(tid=str(tid)) for tid in tids]
        return self.get(urls,
                        LIMIT=LIMIT,
                        _print=_print,
                        crawl=crawl)