Runs a getVariantSet request for the specified ID.
342840
def runGetVariantSet(self, id_):
        
        compoundId = datamodel.VariantSetCompoundId.parse(id_)
        dataset = self.getDataRepository().getDataset(compoundId.dataset_id)
        variantSet = dataset.getVariantSet(id_)
        return self.runGetRequest(variantSet)
1241057
@Deprecated
  public StreamVariantsRequest getStreamVariantsRequest(String variantSetId) {
    return StreamVariantsRequest.newBuilder()
        .setVariantSetId(variantSetId)
        .setReferenceName(referenceName)
        .setStart(start)
        .setEnd(end)
        .build();
  }
735148
@SuppressWarnings({"TypeParameterUnusedInFormals", "unchecked"})
  private <T> T fetch(final String id) {
    checkNotNull(id);
    checkArgument(!id.isEmpty());
    final T ret = (T) idMap.get(id);
    if (ret == null) {
      throw new EREException(String.format("Lookup failed for id %s.", id));
    }
    return ret;
  }
1364004
def get(self, id):
        
        with rconnect() as conn:
            if id is None:
                raise ValueError

            if isinstance(id, uuid.UUID):
                id = str(id)

            if type(id) != str and type(id) != unicode:
                raise ValueError

            try:
                query = self._base().get(id)
                log.debug(query)
                rv = query.run(conn)
            except ReqlOpFailedError as e:
                log.warn(e)
                raise
            except Exception as e:
                log.warn(e)
                raise
            if rv is not None:
                return self._model(rv)

            return None
117116
def get(self, ids, **kwargs):
        

        url = build_uri_with_ids('api/v3/interface/%s/', ids)

        return super(ApiInterfaceRequest, self).get(self.prepare_url(url, kwargs))
605875
public Response getTemplate(String id) throws RequestException, LocalOperationException {
        Request request = new Request(this);
        return new Response(request.get("/templates/" + id));
    }
1327598
def _heavyQuery(variantSetId, callSetIds):
    
    request = protocol.SearchVariantsRequest()
    request.reference_name = '2'
    request.variant_set_id = variantSetId
    for callSetId in callSetIds:
        request.call_set_ids.add(callSetId)
    request.page_size = 100
    request.end = 100000
    return request
474509
def run(self, *args):
        """"""

        params = self.parser.parse_args(args)

        from_id = params.from_id
        to_uuid = params.to_uuid

        code = self.move(from_id, to_uuid)

        return code
496628
private Map<String, VariantSet> getVariants(String defaultSkin, Set<String> skinNames, String defaultLocaleName,
			Set<String> localeVariants) {

		Map<String, VariantSet> skinVariants = new HashMap<>();
		if (!skinNames.isEmpty()) {
			skinVariants.put(JawrConstant.SKIN_VARIANT_TYPE,
					new VariantSet(JawrConstant.SKIN_VARIANT_TYPE, defaultSkin, skinNames));
		}
		if (!localeVariants.isEmpty()) {

			skinVariants.put(JawrConstant.LOCALE_VARIANT_TYPE,
					new VariantSet(JawrConstant.LOCALE_VARIANT_TYPE, defaultLocaleName, localeVariants));
		}

		return skinVariants;
	}
1166990
def getVariantSetByName(self, name):
        
        if name not in self._variantSetNameMap:
            raise exceptions.VariantSetNameNotFoundException(name)
        return self._variantSetNameMap[name]
225000
def getVariantAnnotationSet(self, id_):
        
        if id_ not in self._variantAnnotationSetIdMap:
            raise exceptions.AnnotationSetNotFoundException(id_)
        return self._variantAnnotationSetIdMap[id_]
1213621
def runSearchVariantAnnotationSets(self, request):
        
        return self.runSearchRequest(
            request, protocol.SearchVariantAnnotationSetsRequest,
            protocol.SearchVariantAnnotationSetsResponse,
            self.variantAnnotationSetsGenerator)
980388
@Override
	public Map<String, VariantSet> getAvailableVariants(String resource) {

		List<String> localeVariants = getAvailableLocales(resource);
		if (localeVariants.isEmpty()) {
			throw new BundlingProcessException("Enable to find the resource bundle : " + resource);
		}
		Map<String, VariantSet> variants = new HashMap<>();
		VariantSet variantSet = new VariantSet(JawrConstant.LOCALE_VARIANT_TYPE, "", localeVariants);
		variants.put(JawrConstant.LOCALE_VARIANT_TYPE, variantSet);
		return variants;
	}
261133
public static linkset_interface_binding[] get(nitro_service service, String id) throws Exception{
		linkset_interface_binding obj = new linkset_interface_binding();
		obj.set_id(id);
		linkset_interface_binding response[] = (linkset_interface_binding[]) obj.get_resources(service);
		return response;
	}
764205
def runSearchFeatureSets(self, request):
        
        return self.runSearchRequest(
            request, protocol.SearchFeatureSetsRequest,
            protocol.SearchFeatureSetsResponse,
            self.featureSetsGenerator)
595223
def get(cls, id):
        '''
        
        '''
        client = cls._new_api_client()
        return client.make_request(cls, 'get', url_params={'id': id})
89832
@Override
	public String resolveVariant(HttpServletRequest request) {

		String browser = null;
		String userAgent = request.getHeader("User-Agent");
		if (userAgent != null) {
			Matcher matcher = IE_PATTERN.matcher(userAgent);
			if (matcher.find()) {
				browser = "ie" + matcher.group(1);
			} else if (userAgent.contains("AppleWebKit")) {
				browser = "webkit";
			} else if (userAgent.contains("Firefox")) {
				browser = "firefox";
			} else if (userAgent.contains("Opera")) {
				browser = "opera";
			}
		}

		return browser;
	}