Appends a named entity to the lexicon,
            e.g., Entities.append("Hooloovoo", "PERS")
189513
def append(self, entity, name="pers"):
        
        e = map(lambda s: s.lower(), entity.split(" ") + [name])
        self.setdefault(e[0], []).append(e)
56869
def put(self, entity):
    
    actual_entity = _normalize_entity(entity)
    if actual_entity is None:
      return self.ndb_put(entity)
    self.puts.append(actual_entity)
91689
protected function addFluentIndexes()
	{
		foreach ( $this->columns as $column )
		{
			foreach ( ['primary', 'unique', 'index'] as $index )
			{
				// If the index has been specified on the given column, but is simply
				// equal to "true" (boolean), no name has been specified for this
				// index, so we will simply call the index methods without one.
				if ( $column->$index === true )
				{
					$this->$index( $column->name );

					continue 2;
				}

				// If the index has been specified on the column and it is something
				// other than boolean true, we will assume a name was provided on
				// the index specification, and pass in the name to the method.
				elseif ( isset( $column->$index ) )
				{
					$this->$index( $column->name, $column->$index );

					continue 2;
				}
			}
		}
	}
486890
def append_text(self, content):
        
        Core.append_text(self, content)
        known = self.resolver.top().resolved
        content.text = self.translated(content.text, known)
916596
def append(self):
        
        tag = self._schema.tag
        children = self._root.getchildren()
        if len(children) >= self._schema.max_occurs:
            raise WSDLParseError("Too many items in tag '%s'" % tag)
        schema = self._schema.child
        tag = "item"
        if self._namespace is not None:
            tag = "{%s}%s" % (self._namespace, tag)
        child = etree.SubElement(self._root, tag)
        return schema.create(child)
943891
def insert_doc(self, p_elem, docstring):
        """"""
        dtag = self.namespaces[self.a_uri] + ":documentation"
        elem = SchemaNode(dtag, text=docstring)
        p_elem.annots.append(elem)
859246
def addOntology(self, ontology):
        
        self._ontologyNameMap[ontology.getName()] = ontology
        self._ontologyIdMap[ontology.getId()] = ontology
        self._ontologyIds.append(ontology.getId())
33483
def add_person_entity(self, entity, instances_json):
        
        check_type(instances_json, dict, [entity.plural])
        entity_ids = list(map(str, instances_json.keys()))
        self.persons_plural = entity.plural
        self.entity_ids[self.persons_plural] = entity_ids
        self.entity_counts[self.persons_plural] = len(entity_ids)

        for instance_id, instance_object in instances_json.items():
            check_type(instance_object, dict, [entity.plural, instance_id])
            self.init_variable_values(entity, instance_object, str(instance_id))

        return self.get_ids(entity.plural)
670470
def add_term(self,term_obj):
        
        if term_obj.get_id() in self.idx:
            raise ValueError("Term with id {} already exists!"
                             .format(term_obj.get_id()))
        self.node.append(term_obj.get_node())
        self.idx[term_obj.get_id()] = term_obj
55442
function(entity, options) {
      options = options ? langx.clone(options) : {};
      var wait = options.wait;
      entity = this._prepareEntity(entity, options);
      if (!entity) return false;
      if (!wait) this.add(entity, options);
      var collection = this;
      var success = options.success;
      options.success = function(m, resp, callbackOpts) {
        if (wait) collection.add(m, callbackOpts);
        if (success) success.call(callbackOpts.context, m, resp, callbackOpts);
      };
      entity.save(null, options);
      return entity;
    }
1106642
def add_corpus(self, name, description):
        ''''''
        corpora_url = self.base_url + self.CORPORA_PAGE
        data = {'name': name, 'description': description}
        result = self.session.post(corpora_url, data=data)
        if result.status_code == 201:
            return Corpus(session=self.session, **result.json())
        else:
            raise RuntimeError("Corpus creation failed with status "
                               "{}. The response was: '{}'".format(result.status_code,
                                result.text))
58621
def to_add(self):
        '''
        
        '''
        kwd = {
            'pager': '',
        }
        self.render('misc/entity/entity_add.html',
                    cfg=config.CMS_CFG,
                    kwd=kwd,
                    userinfo=self.userinfo)
221659
def tag_named_entities(self):
        
        if not self.is_tagged(LABEL):
            self.tag_labels()
        nes = []
        word_start = -1
        labels = self.labels + ['O'] # last is sentinel
        words = self.words
        label = 'O'
        for i, l in enumerate(labels):
            if l.startswith('B-') or l == 'O':
                if word_start != -1:
                    nes.append({START: words[word_start][START],
                                END: words[i-1][END],
                                LABEL: label})
                if l.startswith('B-'):
                    word_start = i
                    label = l[2:]
                else:
                    word_start = -1
        self[NAMED_ENTITIES] = nes
        return self
346471
def add_synonym(self, syn):
        
        n = self.node(syn.class_id)
        if 'meta' not in n:
            n['meta'] = {}
        meta = n['meta']
        if 'synonyms' not in meta:
            meta['synonyms'] = []
        meta['synonyms'].append(syn.as_dict())
1302530
def append(self, child, *args, **kwargs):
        """"""
        #Accept Word instances instead of WordReference, references will be automagically used upon serialisation
        if isinstance(child, (Word, Morpheme, Phoneme)) and WordReference in self.ACCEPTED_DATA:
            #We don't really append but do an insertion so all references are in proper order
            insertionpoint = len(self.data)
            for i, sibling in enumerate(self.data):
                if isinstance(sibling, (Word, Morpheme, Phoneme)):
                    try:
                        if not sibling.precedes(child):
                            insertionpoint = i
                    except: #happens if we can't determine common ancestors
                        pass

            self.data.insert(insertionpoint, child)
            return child
        elif isinstance(child, AbstractSpanAnnotation): #(covers span roles just as well)
            insertionpoint = len(self.data)
            try:
                firstword = child.wrefs(0)
            except IndexError:
                #we have no basis to determine an insertionpoint for this child, just append it then
                return super(AbstractSpanAnnotation,self).append(child, *args, **kwargs)

            insertionpoint = len(self.data)
            for i, sibling in enumerate(self.data):
                if isinstance(sibling, (Word, Morpheme, Phoneme)):
                    try:
                        if not sibling.precedes(firstword):
                            insertionpoint = i
                    except: #happens if we can't determine common ancestors
                        pass
            return super(AbstractSpanAnnotation,self).insert(insertionpoint, child, *args, **kwargs)
        else:
            return super(AbstractSpanAnnotation,self).append(child, *args, **kwargs)
1244464
def add_synonym(self, other):
        """"""
        self.synonyms.extend(other.synonyms)
        other.synonyms = self.synonyms
617697
public void add(IWord word)
    {
        //check and extends the entity from the base word
        if ( word.getEntity() == null ) {
            word.setEntity(rootWord.getEntity());
        }
        
        //check and extends the part of speech from the base word
        if ( word.getPartSpeech() == null ) {
            word.setPartSpeech(rootWord.getPartSpeech());
        }
        
        word.setSyn(this);
        synsList.add(word);
    }