Exemple #1
0
def getSylCMU(lowercase):
    '''
		Receives lowercase (a string).
		Returns two values, low and high.
		Checks CMU[dict] for the minimum and maximum syllable counts
	'''
    low = min([len([y for y in x if isdigit(y[-1])]) for x in CMU[lowercase]])
    high = max([len([y for y in x if isdigit(y[-1])]) for x in CMU[lowercase]])
    return low, high
Exemple #2
0
def getSylCMU(lowercase):
	'''
		Receives lowercase (a string).
		Returns two values, low and high.
		Checks CMU[dict] for the minimum and maximum syllable counts
	'''
	low = min([len([y for y in x if isdigit(y[-1])]) for x in CMU[lowercase]])
	high = max([len([y for y in x if isdigit(y[-1])]) for x in CMU[lowercase]])
	return low, high
Exemple #3
0
def getMaxMin(word):
  lowercase = word['word']
  if lowercase not in cmu:
    print lowercase,' not in dictionary'
    lowercase = stripEndings(word)
    return word
  else:
    word['low'] = min([len([y for y in x if isdigit(y[-1])]) for x in cmu[lowercase]])
    word['high'] = max([len([y for y in x if isdigit(y[-1])]) for x in cmu[lowercase]])
    return word
Exemple #4
0
def nsyl(word):
    try:
        print d[word.lower()]
        out = [len(list(y for y in x if isdigit(y[-1]))) for x in cmudict[word.lower()]][0]
    except Exception as e:
        f = urllib.urlopen("http://rhymebrain.com/talk?function=getWordInfo&word="+word)
        a = json.loads(f.read())['pron'].split()
        d = []
        for word in a:
            d.append(word.encode("utf-8"))
        out = [len(list(y for y in x if isdigit(y[-1]))) for x in [d]][0]
    return out
Exemple #5
0
    def __to_matrix(self, string):
        """
        Private method.
        Creates main sudoku matrix from string
        Return: main matrix and list of bool's (is currnet element const).
        """
        matrix = []
        tmp = []
        is_const = []
        j = 0
        for i in range(len(string)):
            if isdigit(string[i]):
                tmp.append(int(string[i]))
                j += 1
                if j == SUDOKU_SIZE:  # add line to main matrix
                    matrix.append(tmp)
                    j = 0
                    tmp = []
                    if len(matrix) == SUDOKU_SIZE:  # main matrix completed
                        break
        tmp = []
        for i in range(SUDOKU_SIZE):
            for j in range(SUDOKU_SIZE):
                tmp.append(matrix[i][j])
            is_const.append(tmp)
            tmp = []

        return matrix, is_const
Exemple #6
0
def nsyl(word):
    pronounce = cmu.get(word.lower())
    if pronounce:
        pronounce = pronounce[0]
        return len(list(y for y in pronounce if isdigit(y[-1])))
    else:
        return 3
def AO_iSylables(word):
    # print word
    # print DICT[word.lower()]
    # return syllables_en.count(word)
    return [
        len(list(y for y in x if isdigit(y[-1]))) for x in DICT[word.lower()]
    ][0]
Exemple #8
0
def evaluate_infix_line(line: str) -> int:
    operators: List[str] = []
    values: List[int] = []
    op: str

    for c in line.replace(" ", ""):
        if isdigit(c):
            values.append(int(c))
        elif c == "(":
            operators.append(c)
        elif c == ")":
            op = operators.pop()
            while op != "(":
                eval_operator(values, op)
                op = operators.pop()
        elif c in "+*":
            while (operators
                   and (op_precedence(operators[-1]) >= op_precedence(c))):
                eval_operator(values, operators.pop())
            operators.append(c)

    while operators:
        op = operators.pop()
        eval_operator(values, op)

    assert len(values) == 1
    return values.pop()
def check(opstring  ,count , target , nlist ,idx , result,closFlag):
    print(opstring)
    rnum = 0 
    if opstring == '()':
        return
    if opstring != "" :
        try :
            rnum = eval(opstring)
        except:
            rnum = rnum
        
    if rnum > target:
            return
    if rnum == target :
        result.append(count)       

    if idx != len(nlist):
        if  isdigit(opstring[-1]):
            check(opstring + '+' , count  , target , nlist , idx , result , closFlag)
            check(opstring + '*' , count  , target , nlist , idx , result , closFlag)
            if closFlag == False :
                check(opstring + ')' , count  , target , nlist , idx  , result, True)
        else:
            if opstring[-1] == ')':
                check(opstring + '+' , count  , target , nlist , idx , result , closFlag)
                check(opstring + '*' , count  , target , nlist , idx , result , closFlag)
            check(opstring + str(nlist[idx]) ,count + 1, target , nlist , idx +1  , result, closFlag)

    return  result
Exemple #10
0
def getAvgSentenceLengthAndFleschFogAndWord(filename):
    sentences = getSentences(filename)

    totCharLength = 0
    totWords = 0
    syllableCt = 0
    totWordLength = 0
    complexWordCt = 0
    for sentence in sentences:
        totCharLength += len(sentence)
        words = nltk.word_tokenize(sentence)
        global d
        for word in words:
            if word in d:
                totWordLength += len(word)
                wordSyl = [
                    len(list(y for y in x if isdigit(y[-1])))
                    for x in d[word.lower()]
                ][0]
                syllableCt += wordSyl
                if wordSyl >= 3: complexWordCt += 1
        totWords += len(words)
    flesch = 206.835 - 1.105 * (totWords / len(sentences)) - 84.6 * (
        syllableCt / totWords)
    fog = .4 * (totWords / len(sentences) + 100 * complexWordCt / totWords)
    return totCharLength / len(sentences), totWords / len(sentences), \
    flesch, fog, totWordLength / totWords
Exemple #11
0
 def nsyl(word, d):
     """
     :param word: str
     :param d: NLTK dictionary instance
     :return: a list. How many syllables are in a word
     """
     return [len(list(y for y in x if isdigit(y[-1]))) for x in d[word.lower()]]
Exemple #12
0
    def __to_matrix(self, string):
        """
        Private method.
        Creates main sudoku matrix from string
        Return: main matrix and list of bool's (is currnet element const).
        """
        matrix = []
        tmp = []
        is_const = []
        j = 0
        for i in range(len(string)):
            if isdigit(string[i]):          
                tmp.append(int(string[i]));
                j += 1; 
                if j == SUDOKU_SIZE:            # add line to main matrix
                    matrix.append(tmp)
                    j = 0
                    tmp = []
                    if len(matrix) == SUDOKU_SIZE: # main matrix completed
                        break;
        tmp = []
        for i in range(SUDOKU_SIZE):
            for j in range(SUDOKU_SIZE):
                tmp.append(matrix[i][j])
            is_const.append(tmp)
            tmp = []

        return matrix, is_const;
Exemple #13
0
def nsyl(word): 
    if word.lower() in d:
        possy = [len(list(y for y in x if isdigit(y[-1]))) for x in d[word.lower()]] 
        ### Just one way to deal with the list of numbers that are returned back.
        return max(possy)
    else:
        return 100
def AO_iSylables(AO_sWord):

'''
This function returns a count of the sylbles is a word.
'''

    return [len(list(y for y in x if isdigit(y[-1]))) for x in DICT[AO_sWord.lower()]][0]
Exemple #15
0
def brailleify(rel):
    '''Turn 1.3.45 or AKPR54633-1PHI into UEB'''
    # FIXME: if we do this at all it should be in braille.py, and we
    # probably shouldn't be trying to do liblouis-level translation at
    # all.
    ret = u''
    digits = False
    for c in rel:
        if ASCII.isdigit(c):
            if not digits:
                ret += u'⠼'
                digits = True
            c = ueb_number_mapping[int(c)]
            ret += alpha_to_unicode(c)
        elif c == '.':
            ret += u'⠲'
        elif ASCII.isalpha(c):
            if digits:
                # UEB 'guidelines for technical material' suggests capital
                # letter marker, not letter sign
                ret += u'⠠'
                digits = False
            ret += alpha_to_unicode(c)
        else:  # e.g. dash in serial
            digits = False
            ret += alpha_to_unicode(c)
    return ret
def count_syllables_primary(word, d):
    try:
        return [
            len(list(y for y in x if isdigit(y[-1]))) for x in d[word.lower()]
        ]
    except:
        return 0
def nsyl(word):
    try:
        return [
            len(list(y for y in x if isdigit(str(y[-1]))))
            for x in d[word.lower()]
        ]
    except KeyError:
        return [0]
def syllablecnt (word):
    """Returns the number of syllables in a word."""
    if word.lower() in d:
        counts = [len(list(y for y in x if isdigit(y[-1]))) 
                  for x in d[word.lower()]]
        if len(counts) > 0:
            return counts[0]
    return len(h.syllables(word+' '))
Exemple #19
0
  def countSyllablesInWord(cls,word):
    lowercase = word.lower()

    cmud = cls.__getCMUDict()
    if lowercase not in cmud:
      return 0
    else:
      return max([len([y for y in x if isdigit(y[-1])]) for x in cmud[lowercase]])
Exemple #20
0
def num_syllables(word):
	# if word in string.punctuation:
	# 	return 0
	word = word.translate(None, string.punctuation)
	try:
		return [len(list(y for y in x if isdigit(y[-1]))) for x in d[word.lower()]][0]
	except KeyError:
		return 18
def countSyllables(word):
    """
    Returns the amount of syllables in a word
    """
    try:
        return max([len([y for y in x if isdigit(y[-1])]) for x in d[word.lower()]])
    except:
        return None
Exemple #22
0
def countsyl(word): 
  word = word.lower()
  if not(word in d): return countsylManual(word)
  numSyl = 0
  for y in d[word][0]: # Use first pronunciation
    if isdigit(str(y)[-1]):
      numSyl += 1
  return numSyl
Exemple #23
0
def print_stress(word):
    forms = [list(y for y in x if isdigit(y[-1])) for x in d[word.lower()]]
    #print forms
    stress = [list(pick_stress(syll) for syll in sylls) for sylls in forms]
    #print stress

    print " ".join(stress[0])
    print word
Exemple #24
0
def nsyl(word):
    try:
        out = [len(list(y
        for y in x if isdigit(y[-1])))
            for x in d[word.lower()]]
    except KeyError:
        out = [0]
    finally:
        return out
Exemple #25
0
def nsyl(word):
    ''' Return the number of syllables in word.'''
    try:
        res = [
            len(list(y for y in x if isdigit(y[-1]))) for x in d[word.lower()]
        ][0]
    except:
        res = np.round(textstat.syllable_count(word))
    return res
Exemple #26
0
def ShowAscii(char, code):
    if ascii.isalpha(code):
        print char, 'is an ascii alphabeta'
    elif ascii.isdigit(code):
        print char, 'is an ascii digital'
    elif ascii.ispunct(code):
        print char, 'is an ascii punctuation'
    else:
        print char, 'is an ascii code(not alphabeta, number or punctuation)'
	def 分開音標(self, 連做伙音標):
		頂一个音 = None
		音標結果 = ''
		for 音 in 連做伙音標:
			if 頂一个音 != None and isalpha(音) and isdigit(頂一个音):
				音標結果 += ' '
			音標結果 += 音
			頂一个音 = 音
		return 音標結果
Exemple #28
0
    def word(self, word):
        phonemes = get_phoneme(word.lower())

        result = [len(list(y for y in x if isdigit(y[-1]))) for x in phonemes]

        if len(result):
            return result[0]

        return None
Exemple #29
0
def num_syllables(word):
    d = cmudict.dict()
    if "-" in word:
        word2 = "".join(word.split("-"))
        if word2 in d:
            word = word2
        else:
            return sum([num_syllables(w) for w in word.split("-")])
    return list((len(list(y for y in x if isdigit(y[-1]))) for x in d[word.lower()]))[0]
Exemple #30
0
def rhyme_from_phonemes(list1, list2):
    i = -1
    while i >= 0 - len(list1):
        if isdigit(list1[i][-1]):
            if i >= 0 - len(list2) and list1[i][:-1] == list2[i][:-1] and (i == -1 or list1[i + 1:] == list2[i + 1:]):
                return True
            else:
                return False
        i -= 1
Exemple #31
0
    def SyllableCount(AszWord):
        """return the max syllable count in the case of multiple pronunciations"""

        #http://groups.google.com/group/nltk-users/msg/81e70cb6704dc01e?pli=1

        return [
            len([y for y in x if isdigit(y[-1])])
            for x in GzzCMUDict[AszWord.lower()]
        ]
def changePostions(fname):
    csvf = open(fname, 'r', encoding='utf8')
    freader= csv.reader(csvf,delimiter=',',quotechar='"')
    header = next(freader)
    d = {}
    for row in freader:
        for i in range(28,54):
            if "+" in row[i]:
                row[i] = sum([int(x) for x in row[i].split("+")])
        release = row[-3]
        if len(release) != 0:
            if isdigit(release[0]) == False: #euro sign
                release = release[1:]
            if "M" in release:
                release = float(release[:-1])*1000000
            elif "K" in release:
                release = float(release[:-1])*1000
            else:
                release = float(release)
        row[-3] = release
        value = row[11]
        if len(value) != 0:
            if isdigit(value[0]) == False: #euro sign
                value = value[1:]
            if "M" in value:
                value = float(value[:-1])*1000000
            elif "K" in value:
                value = float(value[:-1])*1000
            else:
                value = float(value)
            row[11] = value
        d[row[1]] = row    
    print(d['20801'])    
    with open('finalProcessed.csv', 'w') as myfile:
        wr = csv.writer(myfile)
        header = ['place'] + header[1:] + ['FUT Price']
        
        wr.writerow(header)
        for k, v in sorted(d.items(), key = lambda x: x[1][-1], reverse = True):
            if v[-1] != 0:
                v = [strip_accents(str(x)) for x in v]
                wr.writerow(v)
        myfile.close()
    print('done')
Exemple #33
0
    def is_haiku(self, text):

        text_orig = text
        text = text.lower()
        if filter(str.isdigit, str(text)):
            return False
        words = nltk.wordpunct_tokenize(re.sub('[^a-zA-Z_ ]', '', text))
        #print words
        syl_count = 0
        word_count = 0
        haiku_line_count = 0
        lines = []
        d = self.d

        for word in words:
            if word.lower() in d.keys():
                syl_count += [
                    len(list(y for y in x if isdigit(y[-1])))
                    for x in d[word.lower()]
                ][0]
            if haiku_line_count == 0:
                if syl_count == 5:
                    lines.append(word)
                    haiku_line_count += 1
            elif haiku_line_count == 1:
                if syl_count == 12:
                    lines.append(word)
                    haiku_line_count += 1
            else:
                if syl_count == 17:
                    lines.append(word)
                    haiku_line_count += 1

        if syl_count == 17:
            try:
                final_lines = []

                str_tmp = ""
                counter = 0
                for word in text_orig.split():
                    str_tmp += str(word) + " "
                    if lines[counter].lower() in str(word).lower():
                        final_lines.append(str_tmp.strip())
                        counter += 1
                        str_tmp = ""
                if len(str_tmp) > 0:
                    final_lines.append(str_tmp.strip())
                return True

            except Exception as e:
                print e
                return False
        else:
            return False

        return True
Exemple #34
0
def stripEndings(word):
  temp = (word['word'])
  if (len(temp) > 1):
    tempCheck, tempLetter = temp[:-1], temp[-1]
    print 'temp check: ',tempCheck
  if (tempCheck in cmu):
    a = tempCheck
    '''
      for some reason, if I try to run tempCheck through the below, it gives
      an error... changing it to a diff variable, (set after entering this if
        statement, makes it okay. I don't understand why.)
    '''
    word['low'] = min([len([y for y in tempCheck if isdigit(y[-1])]) for tempCheck in cmu[tempCheck]])
    print 'word["low"]: ',word['low']
    word['high'] = max([len([y for y in a if isdigit(y[-1])]) for a in cmu[a]])
    print 'word["high"]: ',word['high']
  else:
    word = dumbGuess(word)
  return word
Exemple #35
0
def rhyme_from_phonemes(list1, list2):
    i = -1
    while i >= 0 - len(list1):
        if isdigit(list1[i][-1]):
            if i >= 0 - len(list2) and list1[i][:-1] == list2[i][:-1] and (
                    i == -1 or list1[i + 1:] == list2[i + 1:]):
                return True
            else:
                return False
        i -= 1
def count_syllables(word, dictionary):
    """returns number of syllables in a given word using CMU's syllable dictionary"""
    phenom_list = dictionary.get(word)
    if phenom_list == None:
        return count_syllables_pseudo(word)
    syllable_count = 0
    for phenom in phenom_list[0]:
        if isdigit(phenom[-1]):  #cmu dictionary looks things up with
            syllable_count += 1
    return syllable_count
def count_syllables(word, dictionary):
    """returns number of syllables in a given word using CMU's syllable dictionary"""
    phenom_list = dictionary.get(word)
    if phenom_list == None:
        return count_syllables_pseudo(word)
    syllable_count = 0
    for phenom in phenom_list[0]:
        if isdigit(phenom[-1]): #cmu dictionary looks things up with 
            syllable_count+=1
    return syllable_count
def SyllableCalculator(text):
    d = cmudict.dict()
    counter = 0.0
    tokens = re.findall("[A-Z]{2,}(?![a-z])|[A-Z][a-z]+(?=[A-Z])|[\'\w\-]+",text)
    for token in tokens:
        count = 1.0
        if token.lower() in d.keys():
            count =max([len(list(y for y in x if isdigit(y[-1]))) for x in d[token.lower()]])
        counter = counter+count
    return counter
Exemple #39
0
 def num_syllables(self, word):
     """
     Returns the number of syllables in a word.  If there's more than one
     pronunciation, take the shorter one.  If there is no entry in the
     dictionary, return 1.
     """
     s = word.lower()
     if s not in self._pronunciations:
         return 1
     else:
         return min([len([y for y in x if isdigit(y[-1])]) for x in self._pronunciations[word.lower()]])
Exemple #40
0
    def is_haiku(self, text):

        text_orig = text
        text = text.lower()
        if filter(str.isdigit, str(text)):
            return False
        words = nltk.wordpunct_tokenize(re.sub('[^a-zA-Z_ ]', '',text))
        #print words
        syl_count = 0
        word_count = 0
        haiku_line_count = 0
        lines = []
        d = self.d

        for word in words:
            if word.lower() in d.keys():
                syl_count += [len(list(y for y in x if isdigit(y[-1]))) for x in
                        d[word.lower()]][0]
            if haiku_line_count == 0:
                if syl_count == 5:
                    lines.append(word)
                    haiku_line_count += 1
            elif haiku_line_count == 1:
                if syl_count == 12:
                    lines.append(word)
                    haiku_line_count += 1
            else:
                if syl_count == 17:
                    lines.append(word)
                    haiku_line_count += 1

        if syl_count == 17:
            try:
                final_lines = []

                str_tmp = ""
                counter = 0
                for word in text_orig.split():
                    str_tmp += str(word) + " "
                    if lines[counter].lower() in str(word).lower():
                        final_lines.append(str_tmp.strip())
                        counter += 1
                        str_tmp = ""
                if len(str_tmp) > 0:
                    final_lines.append(str_tmp.strip())
                return True

            except Exception as e:
                print e
                return False
        else:
            return False

        return True
Exemple #41
0
def rhymesyls_for_pronunciation(pronunciation):
    outlist = str()
    i = -1
    while i >= 0 - len(pronunciation):
        if isdigit(str(pronunciation[i][-1])):
            outlist = pronunciation[i][:-1]
            if i != -1:
                outlist = outlist + " " + pronunciation[i + 1 :][0]
            return outlist
        i -= 1
    return outlist
Exemple #42
0
 def setSyls(self, d):
     """
     Calculate the number of syllables in self.name, and
     set the results equal to set.syls
     Inputs:
         d - A dictionary of words from the nltk.corpus library
     Output:
         None
     """
     if self.name in d:
         self.syls = \
             len([x for x in d[self.name][0] if isdigit(str(x[-1]))])
Exemple #43
0
    def operate(self, c):
        # Add a digit.
        if ascii.isdigit(c):
            self.tag_redraw()
            self._number += chr(c)

        # Delete a character.
        elif c in {ascii.BS, ascii.DEL, curses.KEY_BACKSPACE}:
            self.tag_redraw()
            self._number = self._number[:-1]

        return 'CONTINUE'
Exemple #44
0
def nsyl(word):
    if word.lower() in exc:
        return exc[word.lower()]
    if word.lower() in d:
        prons = [len(list(y for y in x if isdigit(y[-1]))) for x in d[word.lower()]]
        mn = 999
        for p in prons:
            if p < mn:
                mn = p
        return mn
    if "'" in word:
        return nsyl(word.replace("'",""))
Exemple #45
0
 def setSyls(self, d):
     """
     Calculate the number of syllables in self.name, and
     set the results equal to set.syls
     Inputs:
         d - A dictionary of words from the nltk.corpus library
     Output:
         None
     """
     if self.name in d:
         self.syls = \
             len([x for x in d[self.name][0] if isdigit(str(x[-1]))])
def count_syllables(text):
    # count number of syllables
    wordlist = text.split()
    syllable_count = 0
    for word in wordlist:
        word = word.strip('.,!?-*();:\'\"[]{}\\')
        # checks if word is alpha && in the dictionary (prevents key errors)
        if word.isalpha() and word in d:
            syllable_count += [
                len(list(y for y in x if isdigit(y[-1])))
                for x in d[word.lower()]
            ][0]
    return syllable_count
    def nsyl(self, word):
        """
        From http://www.onebloke.com/2011/06/counting-syllables-accurately-in-python-on-google-app-engine/
        
        It works by looking up the pronunciation of the word in the Carnegie Mellon University’s pronunciation dictionary 
        that is part of the Python-based Natural Language Toolkit (NLTK). This returns one or more pronunciations for the
        word. Then the clever bit is that the routine counts the stressed vowels in the word. The raw entry from the cmudict
        file for the word SYLLABLE is shown below.

        SYLLABLE 1 S IH1 L AH0 B AH0 L
        
        """
        return [len(list(y for y in x if isdigit(y[-1]))) for x in self.cmu_dict[word.lower()]]
Exemple #48
0
def nsyl(word):  
    #This is needed for dealing with hypenation stuff below
    if word == "": return 0

    if "-" in word:
      print "Attempting hypenated word: " + str(word)
      return sum([nsyl(w) for w in word.split("-")])
    
    try:    
      #returns the syllable length of a word - d actually returns a list of phonetics, so by default choose first length
      return [len(list(y for y in x if isdigit(y[-1]))) for x in d[word.lower()]][0]
    except KeyError as e:
      return custom_dictionary.get_nsyl(word)
Exemple #49
0
def SyllableCalculator(text):
    d = cmudict.dict()
    counter = 0.0
    tokens = re.findall("[A-Z]{2,}(?![a-z])|[A-Z][a-z]+(?=[A-Z])|[\'\w\-]+",
                        text)
    for token in tokens:
        count = 1.0
        if token.lower() in d.keys():
            count = max([
                len(list(y for y in x if isdigit(y[-1])))
                for x in d[token.lower()]
            ])
        counter = counter + count
    return counter
Exemple #50
0
    def syllable_count(self, word):
        """
        Count syllables in a word.

        Uses NLTK dictionary to find word syllabication.

        Args:
            word (string)

        Returns:
            int syllable count
        """
        self.d = cmudict.dict()
        return min([len([y for y in x if isdigit(y[-1])])
                    for x in self.d[str(word).lower()]])
Exemple #51
0
def suff(dict):
    with open('suff_a.txt', 'a') as f:        
        for word, vals in dict.iteritems():
            if re.search("((?i)[BCDFGHJKLMNPQRSTVWXZ]{1,2}[AEIOUY]+[BCDFGHJKLMNPQRSTVWXZ]*(E|ED)?('[A-Z]{1,2})?)(?![a-zA-Z]+)", word):
                graphemes = re.search("((?i)[BCDFGHJKLMNPQRSTVWXZ]{1,2}[AEIOUY]+[BCDFGHJKLMNPQRSTVWXZ]*(E|ED)?('[A-Z]{1,2})?)(?![a-zA-Z]+)", word).group()
            val = min(vals, key=len)
            # for val in vals:
            i = -1
            while i >= 0 - len(val):
                if isdigit(val[i][-1]):
                    str = " ".join(val[i:])
                    f.write(graphemes + ' ' + str + '\n')
                    f.write(graphemes[1 - len(graphemes):] + ' ' + str + '\n')
                    break
                i -= 1
Exemple #52
0
def rhymesyls(word):
    if word.lower() in cmu_dictionary:
        list1 = min(cmu_dictionary[word.lower()], key=len)
        outlist = str()
        i = -1
        while i >= 0 - len(list1):
            if isdigit(str(list1[i][-1])):
                outlist = list1[i][:-1]
                if i != -1:
                    outlist = outlist + ' ' + list1[i + 1:][0]
                return outlist
            i -= 1
        return outlist
    else:
        return "NORHYME"
Exemple #53
0
 def event(self, ev, c):
     if ascii.isdigit(ev):
         self.batteries = c
     elif c == 'p':
         self.parallel.toggle()
     elif c == 'v':
         self.vowels.toggle()
     elif c == 's':
         self.serial.toggle()
     elif c == 'f':
         self.frk.toggle()
     elif c == 'c':
         self.car.toggle()
     elif ev in [curses.KEY_ENTER, 10]:
         for cb in self.notify_list:
             cb(self)
Exemple #54
0
def suff(dict):
    f = open('suff_a.txt', 'a')
    for word, vals in dict.iteritems():
        if re.search(pattern, word):
            graphemes = re.search(pattern, word).group()
        val = min(vals, key=len)
        # for val in vals:
        i = -1
        while i >= 0 - len(val):
            if isdigit(val[i][-1]):
                str = " ".join(val[i:])
                f.write(graphemes + ' ' + str + '\n')
                f.write(graphemes[1 - len(graphemes):] + ' ' + str + '\n')
                break
            i -= 1
    f.close()
    def nsyl(self, word):
        """
        From http://www.onebloke.com/2011/06/counting-syllables-accurately-in-python-on-google-app-engine/
        
        It works by looking up the pronunciation of the word in the Carnegie Mellon University’s pronunciation dictionary 
        that is part of the Python-based Natural Language Toolkit (NLTK). This returns one or more pronunciations for the
        word. Then the clever bit is that the routine counts the stressed vowels in the word. The raw entry from the cmudict
        file for the word SYLLABLE is shown below.

        SYLLABLE 1 S IH1 L AH0 B AH0 L
        
        """
        return [
            len(list(y for y in x if isdigit(y[-1])))
            for x in self.cmu_dict[word.lower()]
        ]
Exemple #56
0
 def event(self, ev, c):
     if ascii.isdigit(ev):
         self.batteries = c
     elif c == 'p':
         self.parallel.toggle()
     elif c == 'v':
         self.vowels.toggle()
     elif c == 's':
         self.serial.toggle()
     elif c == 'f':
         self.frk.toggle()
     elif c == 'c':
         self.car.toggle()
     elif ev in [curses.KEY_ENTER, 10]:
         for cb in self.notify_list:
             cb(self)
from nltk.corpus import cmudict from operator import itemgetter from collections import defaultdict def getSyllables(word):
	d = cmudict.dict()
	if word == "":
		return 0 	return [len(list(y for y in x if isdigit(y[-1]))) for x in d[word.lower()]][0] def updateInfoNewFile():
	freq = defaultdict(int)
	results = []
	output = ""
	with open('wordfreq.txt') as inputfile:
		for line in inputfile:
			items = line.strip().split(',')
			freq[items[1]] = float(items[4])
			
			#Output the line so far
			output = output.strip("\n") + line 			#If missing syllable info, generate it
			if(len(items) == 5):
				syllables = getSyllables(items[1])
				output += "," + str(syllables) 			output = output + "\n"
			
	return output output = updateInfoNewFile() f = open('workfile.txt', 'w')
Exemple #58
0
def suff(dict):
    f = open('suff_a.txt', 'a')
    for word, vals in dict.iteritems():
        if re.search(
                "((?i)[BCDFGHJKLMNPQRSTVWXZ]{1,2}[AEIOUY]+[BCDFGHJKLMNPQRSTVWXZ]*(E|ED)?('[A-Z]{1,2})?)(?![a-zA-Z]+)",
                word):
            graphemes = re.search(
                "((?i)[BCDFGHJKLMNPQRSTVWXZ]{1,2}[AEIOUY]+[BCDFGHJKLMNPQRSTVWXZ]*(E|ED)?('[A-Z]{1,2})?)(?![a-zA-Z]+)",
                word).group()
        val = min(vals, key=len)
        # for val in vals:
        i = -1
        while i >= 0 - len(val):
            if isdigit(val[i][-1]):
                str = " ".join(val[i:])
                f.write(graphemes + ' ' + str + '\n')
                f.write(graphemes[1 - len(graphemes):] + ' ' + str + '\n')
                break
            i -= 1
    f.close()