creates a new word
355390
def get_word(self, word=None):
        '''  '''
        word = word if not word == None else self.initial
        if not self.terminal in word:
            if len(word) > self.average_word_length and \
                    self.terminal in self.links[word[-self.chunk_size:]] \
                    and random.randint(0, 1):
                addon = self.terminal
            else:
                options = self.links[word[-self.chunk_size:]]
                addon = random.choice(options)

            word = word + addon
            return self.get_word(word)
        return word[1:-1]
790938
def newline(self):
        """"""
        self.write(self.term.move_down)
        self.write(self.term.clear_bol)
1036883
def new(self, string=None, *args, **kwargs):
        """"""
        if len(self):
            hobj = _ChainedHashAlgorithm(self, *args, **kwargs)
        else:
            hobj = _NopHashAlgorithm(*args, **kwargs)
        if string is not None:
            hobj.update(string)
        return hobj
1204126
def random_word(size=6):
	
	words = shutit_assets.get_words().splitlines()
	word = ''
	while len(word) != size or "'" in word:
		word = words[int(random.random() * (len(words) - 1))]
	return word.lower()
1044358
def create_new_code(cls,**kwargs):
        '''
        
        '''
        prefix = kwargs.pop('prefix','')

        new = False
        while not new:
            # Standard is a ten-letter random string of uppercase letters
            random_string = ''.join(random.choice(string.ascii_uppercase) for z in range(10))
            if not Voucher.objects.filter(voucherId='%s%s' % (prefix, random_string)).exists():
                new = True

        return Voucher.objects.create(voucherId='%s%s' % (prefix, random_string),**kwargs)
1335654
public final Morpheme createMorpheme(final String word, final String tag) {
    final Morpheme morpheme = new Morpheme();
    morpheme.setValue(word);
    morpheme.setTag(tag);
    return morpheme;
  }
775823
def word(cap=False):
    
    syllables = []
    for x in range(random.randint(2,3)):
        syllables.append(_syllable())
    word = "".join(syllables)
    if cap: word = word[0].upper() + word[1:]
    return word
419210
public Token add( String word ) {
        Token t = new Token(word);
        push( t );
        return t;
    }
1147412
def create_derivative(self, word):
        '''  '''
        result = None
        if self.char_to_strip != '':
            if self.opt == "PFX":
                result = word[len(self.char_to_strip):len(word)]
                result = self.affix + result 
            else: # SFX
                result = word[0:len(word) - len(self.char_to_strip)]
                result = result + self.affix
        else: # No characters to strip
            if self.opt == "PFX":
                result = self.affix + word
            else: # SFX
                result = word + self.affix

        # None means word does not meet the set condition
        return result
227726
function breakWord (word) {
  if (replaceAnsi(word).length > this.options.width) {
    const letters = word.split('')
    let piece
    const pieces = []
    while ((piece = letters.splice(0, this.options.width)).length) {
      pieces.push(piece.join(''))
    }
    return pieces
  } else {
    return word
  }
}
408225
function _paintWords(prefix, words){
        _flushWordsContainer.call(this);
        this._words = [];
        let docFrag = document.createDocumentFragment();
        for (let i = 0; i < words.length; i++){
            let wordElement = document.createElement('p');
            wordElement.className = 'ac__word';
            wordElement.style.cursor = 'pointer';
            let prefixElement = document.createElement('span');
            prefixElement.className = 'ac__prefix';
            prefixElement.style.pointerEvents = 'none';
            let suffix = document.createTextNode(words[i].slice(prefix.length));
            prefixElement.appendChild(document.createTextNode(prefix));
            wordElement.appendChild(prefixElement);
            wordElement.appendChild(suffix);
            docFrag.appendChild(wordElement);
            this._words.push(wordElement);
        }
        this._container.appendChild(docFrag);
    }
999677
def add_words(self):
        

        data_blocks = len(self.buffer.getvalue()) // 8
        total_blocks = tables.data_capacity[self.version][self.error][0] // 8
        needed_blocks = total_blocks - data_blocks

        if needed_blocks == 0:
            return None

        #This will return item1, item2, item1, item2, etc.
        block = itertools.cycle(['11101100', '00010001'])

        #Create a string of the needed blocks
        return ''.join([next(block) for x in range(needed_blocks)])
203138
def _make_name(current, new):
    '''
    
    '''

    current_tokens = current.split()
    new_tokens = new.split()

    new = ' '.join(
        new_token for new_token in new_tokens
        if new_token not in current_tokens
    )

    return '/'.join((current, new))
626462
function createWordNode (item) {
      var wordNode = parser.createParentNode('Word')

      if (options && options.pos) {
        wordNode.data = item
      }

      var textNode = parser.createTextNode('Text', item.surface_form)

      parser.add(textNode, wordNode)

      return wordNode
    }
1340801
def word_game_round(self, message):
        ""

        letter = random.choice(string.ascii_uppercase)
        topics = []

        while len(topics) < 10:
            new_topic = random.choice(WORD_GAME_TOPICS)
            if new_topic not in topics:
                topics.append({
                    "index": len(topics) + 1,
                    "topic": new_topic
                })

        context = {
            "letter": letter,
            "topics": topics
        }
        self.say(rendered_template("word_game.html", context), message=message)
1192203
def encodeWord(self, word):
        
        encoded_word = word.encode(encoding=self.encoding, errors='strict')
        return Encoder.encodeLength(len(word)) + encoded_word
602065
def _writeWordFromSentenceInBlock(word, blockID, sentenceID, wordID):
    ''''''
    with open("wordIDs.txt", "a") as fp:
        fp.write("wordID: " + str(blockID) + "_" +
                 str(sentenceID) + "_" + str(wordID) + "\n")
        fp.write("wordString: " + word + "\n")
        fp.write("\n")