Appends variant
        sth to do that it would be possible
        to add Variant object
171955
def addVariantOld(self,
                      literal='',
                      sense=0,
                      gloss='',
                      examples=[]):
        '''

        '''
        var = Variant(literal=literal,
                      sense=sense,
                      gloss=gloss,
                      examples=examples)
        self.variants.append(var)
43030
def _add_thousand_g(self, variant_obj, info_dict):
        
        thousand_g = info_dict.get('1000GAF')
        if thousand_g:
            logger.debug("Updating thousand_g to: {0}".format(
                thousand_g))
            variant_obj.thousand_g = float(thousand_g)
            variant_obj.add_frequency('1000GAF', variant_obj.get('thousand_g'))
942219
def _add_genetic_models(self, variant_obj, info_dict):
        
        genetic_models_entry = info_dict.get('GeneticModels')
        if genetic_models_entry:
            genetic_models = []
            for family_annotation in genetic_models_entry.split(','):
                for genetic_model in family_annotation.split(':')[-1].split('|'):
                    genetic_models.append(genetic_model)
            logger.debug("Updating genetic models to: {0}".format(
                ', '.join(genetic_models)))
                
            variant_obj.genetic_models = genetic_models
699561
private void appendBundle(JoinableResourceBundle bundle, Map<String, String> variants, StringBuffer buf,
			boolean useGzip) {
		buf.append("r(").append(JavascriptStringUtil.quote(bundle.getId())).append(",");
		String path = bundle.getURLPrefix(variants);
		if (useGzip) {
			if (path.charAt(0) == '/') {
				path = path.substring(1); // remove leading '/'
			}
			buf.append(JavascriptStringUtil.quote(BundleRenderer.GZIP_PATH_PREFIX + path));
		} else {
			if (path.charAt(0) != '/') {
				path = "/" + path; // Add leading '/'
			}
			buf.append(JavascriptStringUtil.quote(path));
		}

		boolean skipItems = false;
		if (bundle.getItemPathList().size() == 1 && null == bundle.getExplorerConditionalExpression()) {
			skipItems = bundle.getItemPathList().get(0).getPath().equals(bundle.getId());
		}

		if (!skipItems) {
			buf.append(",[");
			for (Iterator<BundlePath> it = bundle.getItemPathList(variants).iterator(); it.hasNext();) {
				path = it.next().getPath();
				if (this.config.getGeneratorRegistry().isPathGenerated(path)) {
					path = PathNormalizer.createGenerationPath(path, this.config.getGeneratorRegistry(), null);
				}
				if ("".equals(this.config.getContextPathOverride()) && path.startsWith("/"))
					path = path.substring(1);
				buf.append(JavascriptStringUtil.quote(path));
				if (it.hasNext())
					buf.append(",");
			}
			buf.append("]");

			if (null != bundle.getExplorerConditionalExpression()) {
				buf.append(",'").append(bundle.getExplorerConditionalExpression()).append("'");
			}
		}
		if (null != bundle.getAlternateProductionURL()) {
			// Complete the parameters if needed, since the alternate param goes
			// afterwards
			if (skipItems)
				buf.append(",null,null");
			else if (null == bundle.getExplorerConditionalExpression())
				buf.append(",null");
			buf.append(",").append(JavascriptStringUtil.quote(bundle.getAlternateProductionURL()));

		}
		buf.append(")");

	}
417127
def append_config_item(self, key, value):
        

        return _lxc.Container.set_config_item(self, key, value)
1068182
public function addVariant(VariantInterface $variant)
    {
        if (!$this->hasVariant($variant)) {
            $variant->setObject($this);
            $this->variants->add($variant);
        }

        return $this;
    }
274585
def add_profile_variants(self, profile_variants):

        

        results = self.db.profile_variant.insert_many(profile_variants)

        return results
329640
def insertVariantSet(self, variantSet):
        
        # We cheat a little here with the VariantSetMetadata, and encode these
        # within the table as a JSON dump. These should really be stored in
        # their own table
        metadataJson = json.dumps(
            [protocol.toJsonDict(metadata) for metadata in
             variantSet.getMetadata()])
        urlMapJson = json.dumps(variantSet.getReferenceToDataUrlIndexMap())
        try:
            models.Variantset.create(
                id=variantSet.getId(),
                datasetid=variantSet.getParentContainer().getId(),
                referencesetid=variantSet.getReferenceSet().getId(),
                name=variantSet.getLocalId(),
                created=datetime.datetime.now(),
                updated=datetime.datetime.now(),
                metadata=metadataJson,
                dataurlindexmap=urlMapJson,
                attributes=json.dumps(variantSet.getAttributes()))
        except Exception as e:
            raise exceptions.RepoManagerException(e)
        for callSet in variantSet.getCallSets():
            self.insertCallSet(callSet)
921829
def append!(view_or_constant, style=nil, opts = {}, &block)
      opts[:raw_block] = block if block
      append(view_or_constant, style, opts).get
    end
251479
async def load_variant(obj, elem, elem_type=None, params=None, field_archiver=None, wrapped=None):
    
    field_archiver = field_archiver if field_archiver else load_field
    is_wrapped = elem_type.WRAPS_VALUE if wrapped is None else wrapped

    if is_wrapped:
        elem = elem_type() if elem is None else elem

    fname = list(obj.keys())[0]
    for field in elem_type.f_specs():
        if field[0] != fname:
            continue

        fvalue = await field_archiver(obj[fname], field[1], field[2:], elem if not is_wrapped else None)
        if is_wrapped:
            elem.set_variant(field[0], fvalue)

        return elem if is_wrapped else fvalue
    raise ValueError('Unknown tag: %s' % fname)
763360
def add_name_variant(self, name):
        
        self._ensure_field('name', {})
        self.obj['name'].setdefault('name_variants', []).append(name)
750667
def add(self, **kwargs):
        
        for name, var in kwargs.items():
            if iskeyword(name):
                var['name'] = name
                name = '_' + name
            if name in self:
                self[name] = merge(self[name], Variable(self.default_type, **var))
            else:
                self[name] = Variable(self.default_type, **var)
        return self
875101
def add_individual(self, genotype):
        
        logger.debug("Adding genotype {0} to variant {1}".format(
            genotype, self['variant_id']))
        self['individuals'].append(genotype)
1223689
def _append(self, sh):
        '''
        
        '''
        sh._input = self
        self._output = sh
        if self._env:
            sh._env = dict(self._env)
        if self._cwd:
            sh._cwd = self._cwd
1093819
def _add_hgnc_symbols(self, variant_obj):
        
        hgnc_symbols = set()
        if variant_obj.transcripts:
            for transcript in variant_obj.transcripts:
                if transcript.hgnc_symbol:
                    hgnc_symbols.add(transcript.hgnc_symbol)
        else:
            chrom = variant_obj.CHROM
            start = variant_obj.start
            stop = variant_obj.stop
        
            hgnc_symbols = get_gene_symbols(chrom, start, stop)
        #Make unique ids
        variant_obj.gene_symbols = list(hgnc_symbols)
661632
def _add_impact_severity(self, variant_obj):
        
        if variant_obj.most_severe_consequence:
            variant_obj.impact_severity = IMPACT_SEVERITIES.get(
                variant_obj.most_severe_consequence
            )
62877
function appendExtensions (obj, extensions) {
  if (!extensions) {
    return
  }

  for (var i = 0; i < extensions.length; i++) {
    var extension = extensions[i]

    // add extension to the type entry
    appendExtension(obj, extension)
  }
}