#
# Natural Language Toolkit: Snowball Stemmer
#
# Copyright (C) 2001-2023 NLTK Project
# Author: Peter Michael Stahl <pemistahl@gmail.com>
# Peter Ljunglof <peter.ljunglof@heatherleaf.se> (revisions)
# Lakhdar Benzahia <lakhdar.benzahia@gmail.com> (co-writer)
# Assem Chelli <assem.ch@gmail.com> (reviewer arabicstemmer)
# Abdelkrim Aries <ab_aries@esi.dz> (reviewer arabicstemmer)
# Algorithms: Dr Martin Porter <martin@tartarus.org>
# Assem Chelli <assem.ch@gmail.com> arabic stemming algorithm
# Benzahia Lakhdar <lakhdar.benzahia@gmail.com>
# URL: <https://www.nltk.org/>
# For license information, see LICENSE.TXT
"""
Snowball stemmers
This module provides a port of the Snowball stemmers
developed by Martin Porter.
There is also a demo function: `snowball.demo()`.
"""
import re
from nltk.corpus import stopwords
from nltk.stem import porter
from nltk.stem.api import StemmerI
from nltk.stem.util import prefix_replace, suffix_replace
[docs]class SnowballStemmer(StemmerI):
"""
Snowball Stemmer
The following languages are supported:
Arabic, Danish, Dutch, English, Finnish, French, German,
Hungarian, Italian, Norwegian, Portuguese, Romanian, Russian,
Spanish and Swedish.
The algorithm for English is documented here:
Porter, M. \"An algorithm for suffix stripping.\"
Program 14.3 (1980): 130-137.
The algorithms have been developed by Martin Porter.
These stemmers are called Snowball, because Porter created
a programming language with this name for creating
new stemming algorithms. There is more information available
at http://snowball.tartarus.org/
The stemmer is invoked as shown below:
>>> from nltk.stem import SnowballStemmer # See which languages are supported
>>> print(" ".join(SnowballStemmer.languages)) # doctest: +NORMALIZE_WHITESPACE
arabic danish dutch english finnish french german hungarian
italian norwegian porter portuguese romanian russian
spanish swedish
>>> stemmer = SnowballStemmer("german") # Choose a language
>>> stemmer.stem("Autobahnen") # Stem a word
'autobahn'
Invoking the stemmers that way is useful if you do not know the
language to be stemmed at runtime. Alternatively, if you already know
the language, then you can invoke the language specific stemmer directly:
>>> from nltk.stem.snowball import GermanStemmer
>>> stemmer = GermanStemmer()
>>> stemmer.stem("Autobahnen")
'autobahn'
:param language: The language whose subclass is instantiated.
:type language: str or unicode
:param ignore_stopwords: If set to True, stopwords are
not stemmed and returned unchanged.
Set to False by default.
:type ignore_stopwords: bool
:raise ValueError: If there is no stemmer for the specified
language, a ValueError is raised.
"""
languages = (
"arabic",
"danish",
"dutch",
"english",
"finnish",
"french",
"german",
"hungarian",
"italian",
"norwegian",
"porter",
"portuguese",
"romanian",
"russian",
"spanish",
"swedish",
)
[docs] def __init__(self, language, ignore_stopwords=False):
if language not in self.languages:
raise ValueError(f"The language '{language}' is not supported.")
stemmerclass = globals()[language.capitalize() + "Stemmer"]
self.stemmer = stemmerclass(ignore_stopwords)
self.stem = self.stemmer.stem
self.stopwords = self.stemmer.stopwords
[docs] def stem(self, token):
return self.stemmer.stem(self, token)
class _LanguageSpecificStemmer(StemmerI):
"""
This helper subclass offers the possibility
to invoke a specific stemmer directly.
This is useful if you already know the language to be stemmed at runtime.
Create an instance of the Snowball stemmer.
:param ignore_stopwords: If set to True, stopwords are
not stemmed and returned unchanged.
Set to False by default.
:type ignore_stopwords: bool
"""
def __init__(self, ignore_stopwords=False):
# The language is the name of the class, minus the final "Stemmer".
language = type(self).__name__.lower()
if language.endswith("stemmer"):
language = language[:-7]
self.stopwords = set()
if ignore_stopwords:
try:
for word in stopwords.words(language):
self.stopwords.add(word)
except OSError as e:
raise ValueError(
"{!r} has no list of stopwords. Please set"
" 'ignore_stopwords' to 'False'.".format(self)
) from e
def __repr__(self):
"""
Print out the string representation of the respective class.
"""
return f"<{type(self).__name__}>"
[docs]class PorterStemmer(_LanguageSpecificStemmer, porter.PorterStemmer):
"""
A word stemmer based on the original Porter stemming algorithm.
Porter, M. \"An algorithm for suffix stripping.\"
Program 14.3 (1980): 130-137.
A few minor modifications have been made to Porter's basic
algorithm. See the source code of the module
nltk.stem.porter for more information.
"""
[docs] def __init__(self, ignore_stopwords=False):
_LanguageSpecificStemmer.__init__(self, ignore_stopwords)
porter.PorterStemmer.__init__(self)
class _ScandinavianStemmer(_LanguageSpecificStemmer):
"""
This subclass encapsulates a method for defining the string region R1.
It is used by the Danish, Norwegian, and Swedish stemmer.
"""
def _r1_scandinavian(self, word, vowels):
"""
Return the region R1 that is used by the Scandinavian stemmers.
R1 is the region after the first non-vowel following a vowel,
or is the null region at the end of the word if there is no
such non-vowel. But then R1 is adjusted so that the region
before it contains at least three letters.
:param word: The word whose region R1 is determined.
:type word: str or unicode
:param vowels: The vowels of the respective language that are
used to determine the region R1.
:type vowels: unicode
:return: the region R1 for the respective word.
:rtype: unicode
:note: This helper method is invoked by the respective stem method of
the subclasses DanishStemmer, NorwegianStemmer, and
SwedishStemmer. It is not to be invoked directly!
"""
r1 = ""
for i in range(1, len(word)):
if word[i] not in vowels and word[i - 1] in vowels:
if 3 > len(word[: i + 1]) > 0:
r1 = word[3:]
elif len(word[: i + 1]) >= 3:
r1 = word[i + 1 :]
else:
return word
break
return r1
class _StandardStemmer(_LanguageSpecificStemmer):
"""
This subclass encapsulates two methods for defining the standard versions
of the string regions R1, R2, and RV.
"""
def _r1r2_standard(self, word, vowels):
"""
Return the standard interpretations of the string regions R1 and R2.
R1 is the region after the first non-vowel following a vowel,
or is the null region at the end of the word if there is no
such non-vowel.
R2 is the region after the first non-vowel following a vowel
in R1, or is the null region at the end of the word if there
is no such non-vowel.
:param word: The word whose regions R1 and R2 are determined.
:type word: str or unicode
:param vowels: The vowels of the respective language that are
used to determine the regions R1 and R2.
:type vowels: unicode
:return: (r1,r2), the regions R1 and R2 for the respective word.
:rtype: tuple
:note: This helper method is invoked by the respective stem method of
the subclasses DutchStemmer, FinnishStemmer,
FrenchStemmer, GermanStemmer, ItalianStemmer,
PortugueseStemmer, RomanianStemmer, and SpanishStemmer.
It is not to be invoked directly!
:note: A detailed description of how to define R1 and R2
can be found at http://snowball.tartarus.org/texts/r1r2.html
"""
r1 = ""
r2 = ""
for i in range(1, len(word)):
if word[i] not in vowels and word[i - 1] in vowels:
r1 = word[i + 1 :]
break
for i in range(1, len(r1)):
if r1[i] not in vowels and r1[i - 1] in vowels:
r2 = r1[i + 1 :]
break
return (r1, r2)
def _rv_standard(self, word, vowels):
"""
Return the standard interpretation of the string region RV.
If the second letter is a consonant, RV is the region after the
next following vowel. If the first two letters are vowels, RV is
the region after the next following consonant. Otherwise, RV is
the region after the third letter.
:param word: The word whose region RV is determined.
:type word: str or unicode
:param vowels: The vowels of the respective language that are
used to determine the region RV.
:type vowels: unicode
:return: the region RV for the respective word.
:rtype: unicode
:note: This helper method is invoked by the respective stem method of
the subclasses ItalianStemmer, PortugueseStemmer,
RomanianStemmer, and SpanishStemmer. It is not to be
invoked directly!
"""
rv = ""
if len(word) >= 2:
if word[1] not in vowels:
for i in range(2, len(word)):
if word[i] in vowels:
rv = word[i + 1 :]
break
elif word[0] in vowels and word[1] in vowels:
for i in range(2, len(word)):
if word[i] not in vowels:
rv = word[i + 1 :]
break
else:
rv = word[3:]
return rv
[docs]class ArabicStemmer(_StandardStemmer):
"""
https://github.com/snowballstem/snowball/blob/master/algorithms/arabic/stem_Unicode.sbl (Original Algorithm)
The Snowball Arabic light Stemmer
Algorithm:
- Assem Chelli
- Abdelkrim Aries
- Lakhdar Benzahia
NLTK Version Author:
- Lakhdar Benzahia
"""
# Normalize_pre stes
__vocalization = re.compile(
r"[\u064b-\u064c-\u064d-\u064e-\u064f-\u0650-\u0651-\u0652]"
) # ً، ٌ، ٍ، َ، ُ، ِ، ّ، ْ
__kasheeda = re.compile(r"[\u0640]") # ـ tatweel/kasheeda
__arabic_punctuation_marks = re.compile(r"[\u060C-\u061B-\u061F]") # ؛ ، ؟
# Normalize_post
__last_hamzat = ("\u0623", "\u0625", "\u0622", "\u0624", "\u0626") # أ، إ، آ، ؤ، ئ
# normalize other hamza's
__initial_hamzat = re.compile(r"^[\u0622\u0623\u0625]") # أ، إ، آ
__waw_hamza = re.compile(r"[\u0624]") # ؤ
__yeh_hamza = re.compile(r"[\u0626]") # ئ
__alefat = re.compile(r"[\u0623\u0622\u0625]") # أ، إ، آ
# Checks
__checks1 = (
"\u0643\u0627\u0644",
"\u0628\u0627\u0644", # بال، كال
"\u0627\u0644",
"\u0644\u0644", # لل، ال
)
__checks2 = ("\u0629", "\u0627\u062a") # ة # female plural ات
# Suffixes
__suffix_noun_step1a = (
"\u064a",
"\u0643",
"\u0647", # ي، ك، ه
"\u0646\u0627",
"\u0643\u0645",
"\u0647\u0627",
"\u0647\u0646",
"\u0647\u0645", # نا، كم، ها، هن، هم
"\u0643\u0645\u0627",
"\u0647\u0645\u0627", # كما، هما
)
__suffix_noun_step1b = "\u0646" # ن
__suffix_noun_step2a = ("\u0627", "\u064a", "\u0648") # ا، ي، و
__suffix_noun_step2b = "\u0627\u062a" # ات
__suffix_noun_step2c1 = "\u062a" # ت
__suffix_noun_step2c2 = "\u0629" # ة
__suffix_noun_step3 = "\u064a" # ي
__suffix_verb_step1 = (
"\u0647",
"\u0643", # ه، ك
"\u0646\u064a",
"\u0646\u0627",
"\u0647\u0627",
"\u0647\u0645", # ني، نا، ها، هم
"\u0647\u0646",
"\u0643\u0645",
"\u0643\u0646", # هن، كم، كن
"\u0647\u0645\u0627",
"\u0643\u0645\u0627",
"\u0643\u0645\u0648", # هما، كما، كمو
)
__suffix_verb_step2a = (
"\u062a",
"\u0627",
"\u0646",
"\u064a", # ت، ا، ن، ي
"\u0646\u0627",
"\u062a\u0627",
"\u062a\u0646", # نا، تا، تن Past
"\u0627\u0646",
"\u0648\u0646",
"\u064a\u0646", # ان، هن، ين Present
"\u062a\u0645\u0627", # تما
)
__suffix_verb_step2b = ("\u0648\u0627", "\u062a\u0645") # وا، تم
__suffix_verb_step2c = ("\u0648", "\u062a\u0645\u0648") # و # تمو
__suffix_all_alef_maqsura = "\u0649" # ى
# Prefixes
__prefix_step1 = (
"\u0623", # أ
"\u0623\u0623",
"\u0623\u0622",
"\u0623\u0624",
"\u0623\u0627",
"\u0623\u0625", # أأ، أآ، أؤ، أا، أإ
)
__prefix_step2a = ("\u0641\u0627\u0644", "\u0648\u0627\u0644") # فال، وال
__prefix_step2b = ("\u0641", "\u0648") # ف، و
__prefix_step3a_noun = (
"\u0627\u0644",
"\u0644\u0644", # لل، ال
"\u0643\u0627\u0644",
"\u0628\u0627\u0644", # بال، كال
)
__prefix_step3b_noun = (
"\u0628",
"\u0643",
"\u0644", # ب، ك، ل
"\u0628\u0628",
"\u0643\u0643", # بب، كك
)
__prefix_step3_verb = (
"\u0633\u064a",
"\u0633\u062a",
"\u0633\u0646",
"\u0633\u0623",
) # سي، ست، سن، سأ
__prefix_step4_verb = (
"\u064a\u0633\u062a",
"\u0646\u0633\u062a",
"\u062a\u0633\u062a",
) # يست، نست، تست
# Suffixes added due to Conjugation Verbs
__conjugation_suffix_verb_1 = ("\u0647", "\u0643") # ه، ك
__conjugation_suffix_verb_2 = (
"\u0646\u064a",
"\u0646\u0627",
"\u0647\u0627", # ني، نا، ها
"\u0647\u0645",
"\u0647\u0646",
"\u0643\u0645", # هم، هن، كم
"\u0643\u0646", # كن
)
__conjugation_suffix_verb_3 = (
"\u0647\u0645\u0627",
"\u0643\u0645\u0627",
"\u0643\u0645\u0648",
) # هما، كما، كمو
__conjugation_suffix_verb_4 = ("\u0627", "\u0646", "\u064a") # ا، ن، ي
__conjugation_suffix_verb_past = (
"\u0646\u0627",
"\u062a\u0627",
"\u062a\u0646",
) # نا، تا، تن
__conjugation_suffix_verb_present = (
"\u0627\u0646",
"\u0648\u0646",
"\u064a\u0646",
) # ان، ون، ين
# Suffixes added due to derivation Names
__conjugation_suffix_noun_1 = ("\u064a", "\u0643", "\u0647") # ي، ك، ه
__conjugation_suffix_noun_2 = (
"\u0646\u0627",
"\u0643\u0645", # نا، كم
"\u0647\u0627",
"\u0647\u0646",
"\u0647\u0645", # ها، هن، هم
)
__conjugation_suffix_noun_3 = (
"\u0643\u0645\u0627",
"\u0647\u0645\u0627",
) # كما، هما
# Prefixes added due to derivation Names
__prefixes1 = ("\u0648\u0627", "\u0641\u0627") # فا، وا
__articles_3len = ("\u0643\u0627\u0644", "\u0628\u0627\u0644") # بال كال
__articles_2len = ("\u0627\u0644", "\u0644\u0644") # ال لل
# Prepositions letters
__prepositions1 = ("\u0643", "\u0644") # ك، ل
__prepositions2 = ("\u0628\u0628", "\u0643\u0643") # بب، كك
is_verb = True
is_noun = True
is_defined = False
suffixes_verb_step1_success = False
suffix_verb_step2a_success = False
suffix_verb_step2b_success = False
suffix_noun_step2c2_success = False
suffix_noun_step1a_success = False
suffix_noun_step2a_success = False
suffix_noun_step2b_success = False
suffixe_noun_step1b_success = False
prefix_step2a_success = False
prefix_step3a_noun_success = False
prefix_step3b_noun_success = False
def __normalize_pre(self, token):
"""
:param token: string
:return: normalized token type string
"""
# strip diacritics
token = self.__vocalization.sub("", token)
# strip kasheeda
token = self.__kasheeda.sub("", token)
# strip punctuation marks
token = self.__arabic_punctuation_marks.sub("", token)
return token
def __normalize_post(self, token):
# normalize last hamza
for hamza in self.__last_hamzat:
if token.endswith(hamza):
token = suffix_replace(token, hamza, "\u0621")
break
# normalize other hamzat
token = self.__initial_hamzat.sub("\u0627", token)
token = self.__waw_hamza.sub("\u0648", token)
token = self.__yeh_hamza.sub("\u064a", token)
token = self.__alefat.sub("\u0627", token)
return token
def __checks_1(self, token):
for prefix in self.__checks1:
if token.startswith(prefix):
if prefix in self.__articles_3len and len(token) > 4:
self.is_noun = True
self.is_verb = False
self.is_defined = True
break
if prefix in self.__articles_2len and len(token) > 3:
self.is_noun = True
self.is_verb = False
self.is_defined = True
break
def __checks_2(self, token):
for suffix in self.__checks2:
if token.endswith(suffix):
if suffix == "\u0629" and len(token) > 2:
self.is_noun = True
self.is_verb = False
break
if suffix == "\u0627\u062a" and len(token) > 3:
self.is_noun = True
self.is_verb = False
break
def __Suffix_Verb_Step1(self, token):
for suffix in self.__suffix_verb_step1:
if token.endswith(suffix):
if suffix in self.__conjugation_suffix_verb_1 and len(token) >= 4:
token = token[:-1]
self.suffixes_verb_step1_success = True
break
if suffix in self.__conjugation_suffix_verb_2 and len(token) >= 5:
token = token[:-2]
self.suffixes_verb_step1_success = True
break
if suffix in self.__conjugation_suffix_verb_3 and len(token) >= 6:
token = token[:-3]
self.suffixes_verb_step1_success = True
break
return token
def __Suffix_Verb_Step2a(self, token):
for suffix in self.__suffix_verb_step2a:
if token.endswith(suffix) and len(token) > 3:
if suffix == "\u062a" and len(token) >= 4:
token = token[:-1]
self.suffix_verb_step2a_success = True
break
if suffix in self.__conjugation_suffix_verb_4 and len(token) >= 4:
token = token[:-1]
self.suffix_verb_step2a_success = True
break
if suffix in self.__conjugation_suffix_verb_past and len(token) >= 5:
token = token[:-2] # past
self.suffix_verb_step2a_success = True
break
if suffix in self.__conjugation_suffix_verb_present and len(token) > 5:
token = token[:-2] # present
self.suffix_verb_step2a_success = True
break
if suffix == "\u062a\u0645\u0627" and len(token) >= 6:
token = token[:-3]
self.suffix_verb_step2a_success = True
break
return token
def __Suffix_Verb_Step2c(self, token):
for suffix in self.__suffix_verb_step2c:
if token.endswith(suffix):
if suffix == "\u062a\u0645\u0648" and len(token) >= 6:
token = token[:-3]
break
if suffix == "\u0648" and len(token) >= 4:
token = token[:-1]
break
return token
def __Suffix_Verb_Step2b(self, token):
for suffix in self.__suffix_verb_step2b:
if token.endswith(suffix) and len(token) >= 5:
token = token[:-2]
self.suffix_verb_step2b_success = True
break
return token
def __Suffix_Noun_Step2c2(self, token):
for suffix in self.__suffix_noun_step2c2:
if token.endswith(suffix) and len(token) >= 3:
token = token[:-1]
self.suffix_noun_step2c2_success = True
break
return token
def __Suffix_Noun_Step1a(self, token):
for suffix in self.__suffix_noun_step1a:
if token.endswith(suffix):
if suffix in self.__conjugation_suffix_noun_1 and len(token) >= 4:
token = token[:-1]
self.suffix_noun_step1a_success = True
break
if suffix in self.__conjugation_suffix_noun_2 and len(token) >= 5:
token = token[:-2]
self.suffix_noun_step1a_success = True
break
if suffix in self.__conjugation_suffix_noun_3 and len(token) >= 6:
token = token[:-3]
self.suffix_noun_step1a_success = True
break
return token
def __Suffix_Noun_Step2a(self, token):
for suffix in self.__suffix_noun_step2a:
if token.endswith(suffix) and len(token) > 4:
token = token[:-1]
self.suffix_noun_step2a_success = True
break
return token
def __Suffix_Noun_Step2b(self, token):
for suffix in self.__suffix_noun_step2b:
if token.endswith(suffix) and len(token) >= 5:
token = token[:-2]
self.suffix_noun_step2b_success = True
break
return token
def __Suffix_Noun_Step2c1(self, token):
for suffix in self.__suffix_noun_step2c1:
if token.endswith(suffix) and len(token) >= 4:
token = token[:-1]
break
return token
def __Suffix_Noun_Step1b(self, token):
for suffix in self.__suffix_noun_step1b:
if token.endswith(suffix) and len(token) > 5:
token = token[:-1]
self.suffixe_noun_step1b_success = True
break
return token
def __Suffix_Noun_Step3(self, token):
for suffix in self.__suffix_noun_step3:
if token.endswith(suffix) and len(token) >= 3:
token = token[:-1] # ya' nisbiya
break
return token
def __Suffix_All_alef_maqsura(self, token):
for suffix in self.__suffix_all_alef_maqsura:
if token.endswith(suffix):
token = suffix_replace(token, suffix, "\u064a")
return token
def __Prefix_Step1(self, token):
for prefix in self.__prefix_step1:
if token.startswith(prefix) and len(token) > 3:
if prefix == "\u0623\u0623":
token = prefix_replace(token, prefix, "\u0623")
break
elif prefix == "\u0623\u0622":
token = prefix_replace(token, prefix, "\u0622")
break
elif prefix == "\u0623\u0624":
token = prefix_replace(token, prefix, "\u0624")
break
elif prefix == "\u0623\u0627":
token = prefix_replace(token, prefix, "\u0627")
break
elif prefix == "\u0623\u0625":
token = prefix_replace(token, prefix, "\u0625")
break
return token
def __Prefix_Step2a(self, token):
for prefix in self.__prefix_step2a:
if token.startswith(prefix) and len(token) > 5:
token = token[len(prefix) :]
self.prefix_step2a_success = True
break
return token
def __Prefix_Step2b(self, token):
for prefix in self.__prefix_step2b:
if token.startswith(prefix) and len(token) > 3:
if token[:2] not in self.__prefixes1:
token = token[len(prefix) :]
break
return token
def __Prefix_Step3a_Noun(self, token):
for prefix in self.__prefix_step3a_noun:
if token.startswith(prefix):
if prefix in self.__articles_2len and len(token) > 4:
token = token[len(prefix) :]
self.prefix_step3a_noun_success = True
break
if prefix in self.__articles_3len and len(token) > 5:
token = token[len(prefix) :]
break
return token
def __Prefix_Step3b_Noun(self, token):
for prefix in self.__prefix_step3b_noun:
if token.startswith(prefix):
if len(token) > 3:
if prefix == "\u0628":
token = token[len(prefix) :]
self.prefix_step3b_noun_success = True
break
if prefix in self.__prepositions2:
token = prefix_replace(token, prefix, prefix[1])
self.prefix_step3b_noun_success = True
break
if prefix in self.__prepositions1 and len(token) > 4:
token = token[len(prefix) :] # BUG: cause confusion
self.prefix_step3b_noun_success = True
break
return token
def __Prefix_Step3_Verb(self, token):
for prefix in self.__prefix_step3_verb:
if token.startswith(prefix) and len(token) > 4:
token = prefix_replace(token, prefix, prefix[1])
break
return token
def __Prefix_Step4_Verb(self, token):
for prefix in self.__prefix_step4_verb:
if token.startswith(prefix) and len(token) > 4:
token = prefix_replace(token, prefix, "\u0627\u0633\u062a")
self.is_verb = True
self.is_noun = False
break
return token
[docs] def stem(self, word):
"""
Stem an Arabic word and return the stemmed form.
:param word: string
:return: string
"""
# set initial values
self.is_verb = True
self.is_noun = True
self.is_defined = False
self.suffix_verb_step2a_success = False
self.suffix_verb_step2b_success = False
self.suffix_noun_step2c2_success = False
self.suffix_noun_step1a_success = False
self.suffix_noun_step2a_success = False
self.suffix_noun_step2b_success = False
self.suffixe_noun_step1b_success = False
self.prefix_step2a_success = False
self.prefix_step3a_noun_success = False
self.prefix_step3b_noun_success = False
modified_word = word
# guess type and properties
# checks1
self.__checks_1(modified_word)
# checks2
self.__checks_2(modified_word)
# Pre_Normalization
modified_word = self.__normalize_pre(modified_word)
# Avoid stopwords
if modified_word in self.stopwords or len(modified_word) <= 2:
return modified_word
# Start stemming
if self.is_verb:
modified_word = self.__Suffix_Verb_Step1(modified_word)
if self.suffixes_verb_step1_success:
modified_word = self.__Suffix_Verb_Step2a(modified_word)
if not self.suffix_verb_step2a_success:
modified_word = self.__Suffix_Verb_Step2c(modified_word)
# or next TODO: How to deal with or next instruction
else:
modified_word = self.__Suffix_Verb_Step2b(modified_word)
if not self.suffix_verb_step2b_success:
modified_word = self.__Suffix_Verb_Step2a(modified_word)
if self.is_noun:
modified_word = self.__Suffix_Noun_Step2c2(modified_word)
if not self.suffix_noun_step2c2_success:
if not self.is_defined:
modified_word = self.__Suffix_Noun_Step1a(modified_word)
# if self.suffix_noun_step1a_success:
modified_word = self.__Suffix_Noun_Step2a(modified_word)
if not self.suffix_noun_step2a_success:
modified_word = self.__Suffix_Noun_Step2b(modified_word)
if (
not self.suffix_noun_step2b_success
and not self.suffix_noun_step2a_success
):
modified_word = self.__Suffix_Noun_Step2c1(modified_word)
# or next ? todo : how to deal with or next
else:
modified_word = self.__Suffix_Noun_Step1b(modified_word)
if self.suffixe_noun_step1b_success:
modified_word = self.__Suffix_Noun_Step2a(modified_word)
if not self.suffix_noun_step2a_success:
modified_word = self.__Suffix_Noun_Step2b(modified_word)
if (
not self.suffix_noun_step2b_success
and not self.suffix_noun_step2a_success
):
modified_word = self.__Suffix_Noun_Step2c1(modified_word)
else:
if not self.is_defined:
modified_word = self.__Suffix_Noun_Step2a(modified_word)
modified_word = self.__Suffix_Noun_Step2b(modified_word)
modified_word = self.__Suffix_Noun_Step3(modified_word)
if not self.is_noun and self.is_verb:
modified_word = self.__Suffix_All_alef_maqsura(modified_word)
# prefixes
modified_word = self.__Prefix_Step1(modified_word)
modified_word = self.__Prefix_Step2a(modified_word)
if not self.prefix_step2a_success:
modified_word = self.__Prefix_Step2b(modified_word)
modified_word = self.__Prefix_Step3a_Noun(modified_word)
if not self.prefix_step3a_noun_success and self.is_noun:
modified_word = self.__Prefix_Step3b_Noun(modified_word)
else:
if not self.prefix_step3b_noun_success and self.is_verb:
modified_word = self.__Prefix_Step3_Verb(modified_word)
modified_word = self.__Prefix_Step4_Verb(modified_word)
# post normalization stemming
modified_word = self.__normalize_post(modified_word)
stemmed_word = modified_word
return stemmed_word
[docs]class DanishStemmer(_ScandinavianStemmer):
"""
The Danish Snowball stemmer.
:cvar __vowels: The Danish vowels.
:type __vowels: unicode
:cvar __consonants: The Danish consonants.
:type __consonants: unicode
:cvar __double_consonants: The Danish double consonants.
:type __double_consonants: tuple
:cvar __s_ending: Letters that may directly appear before a word final 's'.
:type __s_ending: unicode
:cvar __step1_suffixes: Suffixes to be deleted in step 1 of the algorithm.
:type __step1_suffixes: tuple
:cvar __step2_suffixes: Suffixes to be deleted in step 2 of the algorithm.
:type __step2_suffixes: tuple
:cvar __step3_suffixes: Suffixes to be deleted in step 3 of the algorithm.
:type __step3_suffixes: tuple
:note: A detailed description of the Danish
stemming algorithm can be found under
http://snowball.tartarus.org/algorithms/danish/stemmer.html
"""
# The language's vowels and other important characters are defined.
__vowels = "aeiouy\xE6\xE5\xF8"
__consonants = "bcdfghjklmnpqrstvwxz"
__double_consonants = (
"bb",
"cc",
"dd",
"ff",
"gg",
"hh",
"jj",
"kk",
"ll",
"mm",
"nn",
"pp",
"qq",
"rr",
"ss",
"tt",
"vv",
"ww",
"xx",
"zz",
)
__s_ending = "abcdfghjklmnoprtvyz\xE5"
# The different suffixes, divided into the algorithm's steps
# and organized by length, are listed in tuples.
__step1_suffixes = (
"erendes",
"erende",
"hedens",
"ethed",
"erede",
"heden",
"heder",
"endes",
"ernes",
"erens",
"erets",
"ered",
"ende",
"erne",
"eren",
"erer",
"heds",
"enes",
"eres",
"eret",
"hed",
"ene",
"ere",
"ens",
"ers",
"ets",
"en",
"er",
"es",
"et",
"e",
"s",
)
__step2_suffixes = ("gd", "dt", "gt", "kt")
__step3_suffixes = ("elig", "l\xF8st", "lig", "els", "ig")
[docs] def stem(self, word):
"""
Stem a Danish word and return the stemmed form.
:param word: The word that is stemmed.
:type word: str or unicode
:return: The stemmed form.
:rtype: unicode
"""
# Every word is put into lower case for normalization.
word = word.lower()
if word in self.stopwords:
return word
# After this, the required regions are generated
# by the respective helper method.
r1 = self._r1_scandinavian(word, self.__vowels)
# Then the actual stemming process starts.
# Every new step is explicitly indicated
# according to the descriptions on the Snowball website.
# STEP 1
for suffix in self.__step1_suffixes:
if r1.endswith(suffix):
if suffix == "s":
if word[-2] in self.__s_ending:
word = word[:-1]
r1 = r1[:-1]
else:
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
break
# STEP 2
for suffix in self.__step2_suffixes:
if r1.endswith(suffix):
word = word[:-1]
r1 = r1[:-1]
break
# STEP 3
if r1.endswith("igst"):
word = word[:-2]
r1 = r1[:-2]
for suffix in self.__step3_suffixes:
if r1.endswith(suffix):
if suffix == "l\xF8st":
word = word[:-1]
r1 = r1[:-1]
else:
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
if r1.endswith(self.__step2_suffixes):
word = word[:-1]
r1 = r1[:-1]
break
# STEP 4: Undouble
for double_cons in self.__double_consonants:
if word.endswith(double_cons) and len(word) > 3:
word = word[:-1]
break
return word
[docs]class DutchStemmer(_StandardStemmer):
"""
The Dutch Snowball stemmer.
:cvar __vowels: The Dutch vowels.
:type __vowels: unicode
:cvar __step1_suffixes: Suffixes to be deleted in step 1 of the algorithm.
:type __step1_suffixes: tuple
:cvar __step3b_suffixes: Suffixes to be deleted in step 3b of the algorithm.
:type __step3b_suffixes: tuple
:note: A detailed description of the Dutch
stemming algorithm can be found under
http://snowball.tartarus.org/algorithms/dutch/stemmer.html
"""
__vowels = "aeiouy\xE8"
__step1_suffixes = ("heden", "ene", "en", "se", "s")
__step3b_suffixes = ("baar", "lijk", "bar", "end", "ing", "ig")
[docs] def stem(self, word):
"""
Stem a Dutch word and return the stemmed form.
:param word: The word that is stemmed.
:type word: str or unicode
:return: The stemmed form.
:rtype: unicode
"""
word = word.lower()
if word in self.stopwords:
return word
step2_success = False
# Vowel accents are removed.
word = (
word.replace("\xE4", "a")
.replace("\xE1", "a")
.replace("\xEB", "e")
.replace("\xE9", "e")
.replace("\xED", "i")
.replace("\xEF", "i")
.replace("\xF6", "o")
.replace("\xF3", "o")
.replace("\xFC", "u")
.replace("\xFA", "u")
)
# An initial 'y', a 'y' after a vowel,
# and an 'i' between self.__vowels is put into upper case.
# As from now these are treated as consonants.
if word.startswith("y"):
word = "".join(("Y", word[1:]))
for i in range(1, len(word)):
if word[i - 1] in self.__vowels and word[i] == "y":
word = "".join((word[:i], "Y", word[i + 1 :]))
for i in range(1, len(word) - 1):
if (
word[i - 1] in self.__vowels
and word[i] == "i"
and word[i + 1] in self.__vowels
):
word = "".join((word[:i], "I", word[i + 1 :]))
r1, r2 = self._r1r2_standard(word, self.__vowels)
# R1 is adjusted so that the region before it
# contains at least 3 letters.
for i in range(1, len(word)):
if word[i] not in self.__vowels and word[i - 1] in self.__vowels:
if 3 > len(word[: i + 1]) > 0:
r1 = word[3:]
elif len(word[: i + 1]) == 0:
return word
break
# STEP 1
for suffix in self.__step1_suffixes:
if r1.endswith(suffix):
if suffix == "heden":
word = suffix_replace(word, suffix, "heid")
r1 = suffix_replace(r1, suffix, "heid")
if r2.endswith("heden"):
r2 = suffix_replace(r2, suffix, "heid")
elif (
suffix in ("ene", "en")
and not word.endswith("heden")
and word[-len(suffix) - 1] not in self.__vowels
and word[-len(suffix) - 3 : -len(suffix)] != "gem"
):
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
r2 = r2[: -len(suffix)]
if word.endswith(("kk", "dd", "tt")):
word = word[:-1]
r1 = r1[:-1]
r2 = r2[:-1]
elif (
suffix in ("se", "s")
and word[-len(suffix) - 1] not in self.__vowels
and word[-len(suffix) - 1] != "j"
):
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
r2 = r2[: -len(suffix)]
break
# STEP 2
if r1.endswith("e") and word[-2] not in self.__vowels:
step2_success = True
word = word[:-1]
r1 = r1[:-1]
r2 = r2[:-1]
if word.endswith(("kk", "dd", "tt")):
word = word[:-1]
r1 = r1[:-1]
r2 = r2[:-1]
# STEP 3a
if r2.endswith("heid") and word[-5] != "c":
word = word[:-4]
r1 = r1[:-4]
r2 = r2[:-4]
if (
r1.endswith("en")
and word[-3] not in self.__vowels
and word[-5:-2] != "gem"
):
word = word[:-2]
r1 = r1[:-2]
r2 = r2[:-2]
if word.endswith(("kk", "dd", "tt")):
word = word[:-1]
r1 = r1[:-1]
r2 = r2[:-1]
# STEP 3b: Derivational suffixes
for suffix in self.__step3b_suffixes:
if r2.endswith(suffix):
if suffix in ("end", "ing"):
word = word[:-3]
r2 = r2[:-3]
if r2.endswith("ig") and word[-3] != "e":
word = word[:-2]
else:
if word.endswith(("kk", "dd", "tt")):
word = word[:-1]
elif suffix == "ig" and word[-3] != "e":
word = word[:-2]
elif suffix == "lijk":
word = word[:-4]
r1 = r1[:-4]
if r1.endswith("e") and word[-2] not in self.__vowels:
word = word[:-1]
if word.endswith(("kk", "dd", "tt")):
word = word[:-1]
elif suffix == "baar":
word = word[:-4]
elif suffix == "bar" and step2_success:
word = word[:-3]
break
# STEP 4: Undouble vowel
if len(word) >= 4:
if word[-1] not in self.__vowels and word[-1] != "I":
if word[-3:-1] in ("aa", "ee", "oo", "uu"):
if word[-4] not in self.__vowels:
word = "".join((word[:-3], word[-3], word[-1]))
# All occurrences of 'I' and 'Y' are put back into lower case.
word = word.replace("I", "i").replace("Y", "y")
return word
[docs]class EnglishStemmer(_StandardStemmer):
"""
The English Snowball stemmer.
:cvar __vowels: The English vowels.
:type __vowels: unicode
:cvar __double_consonants: The English double consonants.
:type __double_consonants: tuple
:cvar __li_ending: Letters that may directly appear before a word final 'li'.
:type __li_ending: unicode
:cvar __step0_suffixes: Suffixes to be deleted in step 0 of the algorithm.
:type __step0_suffixes: tuple
:cvar __step1a_suffixes: Suffixes to be deleted in step 1a of the algorithm.
:type __step1a_suffixes: tuple
:cvar __step1b_suffixes: Suffixes to be deleted in step 1b of the algorithm.
:type __step1b_suffixes: tuple
:cvar __step2_suffixes: Suffixes to be deleted in step 2 of the algorithm.
:type __step2_suffixes: tuple
:cvar __step3_suffixes: Suffixes to be deleted in step 3 of the algorithm.
:type __step3_suffixes: tuple
:cvar __step4_suffixes: Suffixes to be deleted in step 4 of the algorithm.
:type __step4_suffixes: tuple
:cvar __step5_suffixes: Suffixes to be deleted in step 5 of the algorithm.
:type __step5_suffixes: tuple
:cvar __special_words: A dictionary containing words
which have to be stemmed specially.
:type __special_words: dict
:note: A detailed description of the English
stemming algorithm can be found under
http://snowball.tartarus.org/algorithms/english/stemmer.html
"""
__vowels = "aeiouy"
__double_consonants = ("bb", "dd", "ff", "gg", "mm", "nn", "pp", "rr", "tt")
__li_ending = "cdeghkmnrt"
__step0_suffixes = ("'s'", "'s", "'")
__step1a_suffixes = ("sses", "ied", "ies", "us", "ss", "s")
__step1b_suffixes = ("eedly", "ingly", "edly", "eed", "ing", "ed")
__step2_suffixes = (
"ization",
"ational",
"fulness",
"ousness",
"iveness",
"tional",
"biliti",
"lessli",
"entli",
"ation",
"alism",
"aliti",
"ousli",
"iviti",
"fulli",
"enci",
"anci",
"abli",
"izer",
"ator",
"alli",
"bli",
"ogi",
"li",
)
__step3_suffixes = (
"ational",
"tional",
"alize",
"icate",
"iciti",
"ative",
"ical",
"ness",
"ful",
)
__step4_suffixes = (
"ement",
"ance",
"ence",
"able",
"ible",
"ment",
"ant",
"ent",
"ism",
"ate",
"iti",
"ous",
"ive",
"ize",
"ion",
"al",
"er",
"ic",
)
__step5_suffixes = ("e", "l")
__special_words = {
"skis": "ski",
"skies": "sky",
"dying": "die",
"lying": "lie",
"tying": "tie",
"idly": "idl",
"gently": "gentl",
"ugly": "ugli",
"early": "earli",
"only": "onli",
"singly": "singl",
"sky": "sky",
"news": "news",
"howe": "howe",
"atlas": "atlas",
"cosmos": "cosmos",
"bias": "bias",
"andes": "andes",
"inning": "inning",
"innings": "inning",
"outing": "outing",
"outings": "outing",
"canning": "canning",
"cannings": "canning",
"herring": "herring",
"herrings": "herring",
"earring": "earring",
"earrings": "earring",
"proceed": "proceed",
"proceeds": "proceed",
"proceeded": "proceed",
"proceeding": "proceed",
"exceed": "exceed",
"exceeds": "exceed",
"exceeded": "exceed",
"exceeding": "exceed",
"succeed": "succeed",
"succeeds": "succeed",
"succeeded": "succeed",
"succeeding": "succeed",
}
[docs] def stem(self, word):
"""
Stem an English word and return the stemmed form.
:param word: The word that is stemmed.
:type word: str or unicode
:return: The stemmed form.
:rtype: unicode
"""
word = word.lower()
if word in self.stopwords or len(word) <= 2:
return word
elif word in self.__special_words:
return self.__special_words[word]
# Map the different apostrophe characters to a single consistent one
word = (
word.replace("\u2019", "\x27")
.replace("\u2018", "\x27")
.replace("\u201B", "\x27")
)
if word.startswith("\x27"):
word = word[1:]
if word.startswith("y"):
word = "".join(("Y", word[1:]))
for i in range(1, len(word)):
if word[i - 1] in self.__vowels and word[i] == "y":
word = "".join((word[:i], "Y", word[i + 1 :]))
step1a_vowel_found = False
step1b_vowel_found = False
r1 = ""
r2 = ""
if word.startswith(("gener", "commun", "arsen")):
if word.startswith(("gener", "arsen")):
r1 = word[5:]
else:
r1 = word[6:]
for i in range(1, len(r1)):
if r1[i] not in self.__vowels and r1[i - 1] in self.__vowels:
r2 = r1[i + 1 :]
break
else:
r1, r2 = self._r1r2_standard(word, self.__vowels)
# STEP 0
for suffix in self.__step0_suffixes:
if word.endswith(suffix):
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
r2 = r2[: -len(suffix)]
break
# STEP 1a
for suffix in self.__step1a_suffixes:
if word.endswith(suffix):
if suffix == "sses":
word = word[:-2]
r1 = r1[:-2]
r2 = r2[:-2]
elif suffix in ("ied", "ies"):
if len(word[: -len(suffix)]) > 1:
word = word[:-2]
r1 = r1[:-2]
r2 = r2[:-2]
else:
word = word[:-1]
r1 = r1[:-1]
r2 = r2[:-1]
elif suffix == "s":
for letter in word[:-2]:
if letter in self.__vowels:
step1a_vowel_found = True
break
if step1a_vowel_found:
word = word[:-1]
r1 = r1[:-1]
r2 = r2[:-1]
break
# STEP 1b
for suffix in self.__step1b_suffixes:
if word.endswith(suffix):
if suffix in ("eed", "eedly"):
if r1.endswith(suffix):
word = suffix_replace(word, suffix, "ee")
if len(r1) >= len(suffix):
r1 = suffix_replace(r1, suffix, "ee")
else:
r1 = ""
if len(r2) >= len(suffix):
r2 = suffix_replace(r2, suffix, "ee")
else:
r2 = ""
else:
for letter in word[: -len(suffix)]:
if letter in self.__vowels:
step1b_vowel_found = True
break
if step1b_vowel_found:
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
r2 = r2[: -len(suffix)]
if word.endswith(("at", "bl", "iz")):
word = "".join((word, "e"))
r1 = "".join((r1, "e"))
if len(word) > 5 or len(r1) >= 3:
r2 = "".join((r2, "e"))
elif word.endswith(self.__double_consonants):
word = word[:-1]
r1 = r1[:-1]
r2 = r2[:-1]
elif (
r1 == ""
and len(word) >= 3
and word[-1] not in self.__vowels
and word[-1] not in "wxY"
and word[-2] in self.__vowels
and word[-3] not in self.__vowels
) or (
r1 == ""
and len(word) == 2
and word[0] in self.__vowels
and word[1] not in self.__vowels
):
word = "".join((word, "e"))
if len(r1) > 0:
r1 = "".join((r1, "e"))
if len(r2) > 0:
r2 = "".join((r2, "e"))
break
# STEP 1c
if len(word) > 2 and word[-1] in "yY" and word[-2] not in self.__vowels:
word = "".join((word[:-1], "i"))
if len(r1) >= 1:
r1 = "".join((r1[:-1], "i"))
else:
r1 = ""
if len(r2) >= 1:
r2 = "".join((r2[:-1], "i"))
else:
r2 = ""
# STEP 2
for suffix in self.__step2_suffixes:
if word.endswith(suffix):
if r1.endswith(suffix):
if suffix == "tional":
word = word[:-2]
r1 = r1[:-2]
r2 = r2[:-2]
elif suffix in ("enci", "anci", "abli"):
word = "".join((word[:-1], "e"))
if len(r1) >= 1:
r1 = "".join((r1[:-1], "e"))
else:
r1 = ""
if len(r2) >= 1:
r2 = "".join((r2[:-1], "e"))
else:
r2 = ""
elif suffix == "entli":
word = word[:-2]
r1 = r1[:-2]
r2 = r2[:-2]
elif suffix in ("izer", "ization"):
word = suffix_replace(word, suffix, "ize")
if len(r1) >= len(suffix):
r1 = suffix_replace(r1, suffix, "ize")
else:
r1 = ""
if len(r2) >= len(suffix):
r2 = suffix_replace(r2, suffix, "ize")
else:
r2 = ""
elif suffix in ("ational", "ation", "ator"):
word = suffix_replace(word, suffix, "ate")
if len(r1) >= len(suffix):
r1 = suffix_replace(r1, suffix, "ate")
else:
r1 = ""
if len(r2) >= len(suffix):
r2 = suffix_replace(r2, suffix, "ate")
else:
r2 = "e"
elif suffix in ("alism", "aliti", "alli"):
word = suffix_replace(word, suffix, "al")
if len(r1) >= len(suffix):
r1 = suffix_replace(r1, suffix, "al")
else:
r1 = ""
if len(r2) >= len(suffix):
r2 = suffix_replace(r2, suffix, "al")
else:
r2 = ""
elif suffix == "fulness":
word = word[:-4]
r1 = r1[:-4]
r2 = r2[:-4]
elif suffix in ("ousli", "ousness"):
word = suffix_replace(word, suffix, "ous")
if len(r1) >= len(suffix):
r1 = suffix_replace(r1, suffix, "ous")
else:
r1 = ""
if len(r2) >= len(suffix):
r2 = suffix_replace(r2, suffix, "ous")
else:
r2 = ""
elif suffix in ("iveness", "iviti"):
word = suffix_replace(word, suffix, "ive")
if len(r1) >= len(suffix):
r1 = suffix_replace(r1, suffix, "ive")
else:
r1 = ""
if len(r2) >= len(suffix):
r2 = suffix_replace(r2, suffix, "ive")
else:
r2 = "e"
elif suffix in ("biliti", "bli"):
word = suffix_replace(word, suffix, "ble")
if len(r1) >= len(suffix):
r1 = suffix_replace(r1, suffix, "ble")
else:
r1 = ""
if len(r2) >= len(suffix):
r2 = suffix_replace(r2, suffix, "ble")
else:
r2 = ""
elif suffix == "ogi" and word[-4] == "l":
word = word[:-1]
r1 = r1[:-1]
r2 = r2[:-1]
elif suffix in ("fulli", "lessli"):
word = word[:-2]
r1 = r1[:-2]
r2 = r2[:-2]
elif suffix == "li" and word[-3] in self.__li_ending:
word = word[:-2]
r1 = r1[:-2]
r2 = r2[:-2]
break
# STEP 3
for suffix in self.__step3_suffixes:
if word.endswith(suffix):
if r1.endswith(suffix):
if suffix == "tional":
word = word[:-2]
r1 = r1[:-2]
r2 = r2[:-2]
elif suffix == "ational":
word = suffix_replace(word, suffix, "ate")
if len(r1) >= len(suffix):
r1 = suffix_replace(r1, suffix, "ate")
else:
r1 = ""
if len(r2) >= len(suffix):
r2 = suffix_replace(r2, suffix, "ate")
else:
r2 = ""
elif suffix == "alize":
word = word[:-3]
r1 = r1[:-3]
r2 = r2[:-3]
elif suffix in ("icate", "iciti", "ical"):
word = suffix_replace(word, suffix, "ic")
if len(r1) >= len(suffix):
r1 = suffix_replace(r1, suffix, "ic")
else:
r1 = ""
if len(r2) >= len(suffix):
r2 = suffix_replace(r2, suffix, "ic")
else:
r2 = ""
elif suffix in ("ful", "ness"):
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
r2 = r2[: -len(suffix)]
elif suffix == "ative" and r2.endswith(suffix):
word = word[:-5]
r1 = r1[:-5]
r2 = r2[:-5]
break
# STEP 4
for suffix in self.__step4_suffixes:
if word.endswith(suffix):
if r2.endswith(suffix):
if suffix == "ion":
if word[-4] in "st":
word = word[:-3]
r1 = r1[:-3]
r2 = r2[:-3]
else:
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
r2 = r2[: -len(suffix)]
break
# STEP 5
if r2.endswith("l") and word[-2] == "l":
word = word[:-1]
elif r2.endswith("e"):
word = word[:-1]
elif r1.endswith("e"):
if len(word) >= 4 and (
word[-2] in self.__vowels
or word[-2] in "wxY"
or word[-3] not in self.__vowels
or word[-4] in self.__vowels
):
word = word[:-1]
word = word.replace("Y", "y")
return word
[docs]class FinnishStemmer(_StandardStemmer):
"""
The Finnish Snowball stemmer.
:cvar __vowels: The Finnish vowels.
:type __vowels: unicode
:cvar __restricted_vowels: A subset of the Finnish vowels.
:type __restricted_vowels: unicode
:cvar __long_vowels: The Finnish vowels in their long forms.
:type __long_vowels: tuple
:cvar __consonants: The Finnish consonants.
:type __consonants: unicode
:cvar __double_consonants: The Finnish double consonants.
:type __double_consonants: tuple
:cvar __step1_suffixes: Suffixes to be deleted in step 1 of the algorithm.
:type __step1_suffixes: tuple
:cvar __step2_suffixes: Suffixes to be deleted in step 2 of the algorithm.
:type __step2_suffixes: tuple
:cvar __step3_suffixes: Suffixes to be deleted in step 3 of the algorithm.
:type __step3_suffixes: tuple
:cvar __step4_suffixes: Suffixes to be deleted in step 4 of the algorithm.
:type __step4_suffixes: tuple
:note: A detailed description of the Finnish
stemming algorithm can be found under
http://snowball.tartarus.org/algorithms/finnish/stemmer.html
"""
__vowels = "aeiouy\xE4\xF6"
__restricted_vowels = "aeiou\xE4\xF6"
__long_vowels = ("aa", "ee", "ii", "oo", "uu", "\xE4\xE4", "\xF6\xF6")
__consonants = "bcdfghjklmnpqrstvwxz"
__double_consonants = (
"bb",
"cc",
"dd",
"ff",
"gg",
"hh",
"jj",
"kk",
"ll",
"mm",
"nn",
"pp",
"qq",
"rr",
"ss",
"tt",
"vv",
"ww",
"xx",
"zz",
)
__step1_suffixes = (
"kaan",
"k\xE4\xE4n",
"sti",
"kin",
"han",
"h\xE4n",
"ko",
"k\xF6",
"pa",
"p\xE4",
)
__step2_suffixes = ("nsa", "ns\xE4", "mme", "nne", "si", "ni", "an", "\xE4n", "en")
__step3_suffixes = (
"siin",
"tten",
"seen",
"han",
"hen",
"hin",
"hon",
"h\xE4n",
"h\xF6n",
"den",
"tta",
"tt\xE4",
"ssa",
"ss\xE4",
"sta",
"st\xE4",
"lla",
"ll\xE4",
"lta",
"lt\xE4",
"lle",
"ksi",
"ine",
"ta",
"t\xE4",
"na",
"n\xE4",
"a",
"\xE4",
"n",
)
__step4_suffixes = (
"impi",
"impa",
"imp\xE4",
"immi",
"imma",
"imm\xE4",
"mpi",
"mpa",
"mp\xE4",
"mmi",
"mma",
"mm\xE4",
"eja",
"ej\xE4",
)
[docs] def stem(self, word):
"""
Stem a Finnish word and return the stemmed form.
:param word: The word that is stemmed.
:type word: str or unicode
:return: The stemmed form.
:rtype: unicode
"""
word = word.lower()
if word in self.stopwords:
return word
step3_success = False
r1, r2 = self._r1r2_standard(word, self.__vowels)
# STEP 1: Particles etc.
for suffix in self.__step1_suffixes:
if r1.endswith(suffix):
if suffix == "sti":
if suffix in r2:
word = word[:-3]
r1 = r1[:-3]
r2 = r2[:-3]
else:
if word[-len(suffix) - 1] in "ntaeiouy\xE4\xF6":
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
r2 = r2[: -len(suffix)]
break
# STEP 2: Possessives
for suffix in self.__step2_suffixes:
if r1.endswith(suffix):
if suffix == "si":
if word[-3] != "k":
word = word[:-2]
r1 = r1[:-2]
r2 = r2[:-2]
elif suffix == "ni":
word = word[:-2]
r1 = r1[:-2]
r2 = r2[:-2]
if word.endswith("kse"):
word = suffix_replace(word, "kse", "ksi")
if r1.endswith("kse"):
r1 = suffix_replace(r1, "kse", "ksi")
if r2.endswith("kse"):
r2 = suffix_replace(r2, "kse", "ksi")
elif suffix == "an":
if word[-4:-2] in ("ta", "na") or word[-5:-2] in (
"ssa",
"sta",
"lla",
"lta",
):
word = word[:-2]
r1 = r1[:-2]
r2 = r2[:-2]
elif suffix == "\xE4n":
if word[-4:-2] in ("t\xE4", "n\xE4") or word[-5:-2] in (
"ss\xE4",
"st\xE4",
"ll\xE4",
"lt\xE4",
):
word = word[:-2]
r1 = r1[:-2]
r2 = r2[:-2]
elif suffix == "en":
if word[-5:-2] in ("lle", "ine"):
word = word[:-2]
r1 = r1[:-2]
r2 = r2[:-2]
else:
word = word[:-3]
r1 = r1[:-3]
r2 = r2[:-3]
break
# STEP 3: Cases
for suffix in self.__step3_suffixes:
if r1.endswith(suffix):
if suffix in ("han", "hen", "hin", "hon", "h\xE4n", "h\xF6n"):
if (
(suffix == "han" and word[-4] == "a")
or (suffix == "hen" and word[-4] == "e")
or (suffix == "hin" and word[-4] == "i")
or (suffix == "hon" and word[-4] == "o")
or (suffix == "h\xE4n" and word[-4] == "\xE4")
or (suffix == "h\xF6n" and word[-4] == "\xF6")
):
word = word[:-3]
r1 = r1[:-3]
r2 = r2[:-3]
step3_success = True
elif suffix in ("siin", "den", "tten"):
if (
word[-len(suffix) - 1] == "i"
and word[-len(suffix) - 2] in self.__restricted_vowels
):
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
r2 = r2[: -len(suffix)]
step3_success = True
else:
continue
elif suffix == "seen":
if word[-6:-4] in self.__long_vowels:
word = word[:-4]
r1 = r1[:-4]
r2 = r2[:-4]
step3_success = True
else:
continue
elif suffix in ("a", "\xE4"):
if word[-2] in self.__vowels and word[-3] in self.__consonants:
word = word[:-1]
r1 = r1[:-1]
r2 = r2[:-1]
step3_success = True
elif suffix in ("tta", "tt\xE4"):
if word[-4] == "e":
word = word[:-3]
r1 = r1[:-3]
r2 = r2[:-3]
step3_success = True
elif suffix == "n":
word = word[:-1]
r1 = r1[:-1]
r2 = r2[:-1]
step3_success = True
if word[-2:] == "ie" or word[-2:] in self.__long_vowels:
word = word[:-1]
r1 = r1[:-1]
r2 = r2[:-1]
else:
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
r2 = r2[: -len(suffix)]
step3_success = True
break
# STEP 4: Other endings
for suffix in self.__step4_suffixes:
if r2.endswith(suffix):
if suffix in ("mpi", "mpa", "mp\xE4", "mmi", "mma", "mm\xE4"):
if word[-5:-3] != "po":
word = word[:-3]
r1 = r1[:-3]
r2 = r2[:-3]
else:
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
r2 = r2[: -len(suffix)]
break
# STEP 5: Plurals
if step3_success and len(r1) >= 1 and r1[-1] in "ij":
word = word[:-1]
r1 = r1[:-1]
elif (
not step3_success
and len(r1) >= 2
and r1[-1] == "t"
and r1[-2] in self.__vowels
):
word = word[:-1]
r1 = r1[:-1]
r2 = r2[:-1]
if r2.endswith("imma"):
word = word[:-4]
r1 = r1[:-4]
elif r2.endswith("mma") and r2[-5:-3] != "po":
word = word[:-3]
r1 = r1[:-3]
# STEP 6: Tidying up
if r1[-2:] in self.__long_vowels:
word = word[:-1]
r1 = r1[:-1]
if len(r1) >= 2 and r1[-2] in self.__consonants and r1[-1] in "a\xE4ei":
word = word[:-1]
r1 = r1[:-1]
if r1.endswith(("oj", "uj")):
word = word[:-1]
r1 = r1[:-1]
if r1.endswith("jo"):
word = word[:-1]
r1 = r1[:-1]
# If the word ends with a double consonant
# followed by zero or more vowels, the last consonant is removed.
for i in range(1, len(word)):
if word[-i] in self.__vowels:
continue
else:
if i == 1:
if word[-i - 1 :] in self.__double_consonants:
word = word[:-1]
else:
if word[-i - 1 : -i + 1] in self.__double_consonants:
word = "".join((word[:-i], word[-i + 1 :]))
break
return word
[docs]class FrenchStemmer(_StandardStemmer):
"""
The French Snowball stemmer.
:cvar __vowels: The French vowels.
:type __vowels: unicode
:cvar __step1_suffixes: Suffixes to be deleted in step 1 of the algorithm.
:type __step1_suffixes: tuple
:cvar __step2a_suffixes: Suffixes to be deleted in step 2a of the algorithm.
:type __step2a_suffixes: tuple
:cvar __step2b_suffixes: Suffixes to be deleted in step 2b of the algorithm.
:type __step2b_suffixes: tuple
:cvar __step4_suffixes: Suffixes to be deleted in step 4 of the algorithm.
:type __step4_suffixes: tuple
:note: A detailed description of the French
stemming algorithm can be found under
http://snowball.tartarus.org/algorithms/french/stemmer.html
"""
__vowels = "aeiouy\xE2\xE0\xEB\xE9\xEA\xE8\xEF\xEE\xF4\xFB\xF9"
__step1_suffixes = (
"issements",
"issement",
"atrices",
"atrice",
"ateurs",
"ations",
"logies",
"usions",
"utions",
"ements",
"amment",
"emment",
"ances",
"iqUes",
"ismes",
"ables",
"istes",
"ateur",
"ation",
"logie",
"usion",
"ution",
"ences",
"ement",
"euses",
"ments",
"ance",
"iqUe",
"isme",
"able",
"iste",
"ence",
"it\xE9s",
"ives",
"eaux",
"euse",
"ment",
"eux",
"it\xE9",
"ive",
"ifs",
"aux",
"if",
)
__step2a_suffixes = (
"issaIent",
"issantes",
"iraIent",
"issante",
"issants",
"issions",
"irions",
"issais",
"issait",
"issant",
"issent",
"issiez",
"issons",
"irais",
"irait",
"irent",
"iriez",
"irons",
"iront",
"isses",
"issez",
"\xEEmes",
"\xEEtes",
"irai",
"iras",
"irez",
"isse",
"ies",
"ira",
"\xEEt",
"ie",
"ir",
"is",
"it",
"i",
)
__step2b_suffixes = (
"eraIent",
"assions",
"erions",
"assent",
"assiez",
"\xE8rent",
"erais",
"erait",
"eriez",
"erons",
"eront",
"aIent",
"antes",
"asses",
"ions",
"erai",
"eras",
"erez",
"\xE2mes",
"\xE2tes",
"ante",
"ants",
"asse",
"\xE9es",
"era",
"iez",
"ais",
"ait",
"ant",
"\xE9e",
"\xE9s",
"er",
"ez",
"\xE2t",
"ai",
"as",
"\xE9",
"a",
)
__step4_suffixes = ("i\xE8re", "I\xE8re", "ion", "ier", "Ier", "e", "\xEB")
[docs] def stem(self, word):
"""
Stem a French word and return the stemmed form.
:param word: The word that is stemmed.
:type word: str or unicode
:return: The stemmed form.
:rtype: unicode
"""
word = word.lower()
if word in self.stopwords:
return word
step1_success = False
rv_ending_found = False
step2a_success = False
step2b_success = False
# Every occurrence of 'u' after 'q' is put into upper case.
for i in range(1, len(word)):
if word[i - 1] == "q" and word[i] == "u":
word = "".join((word[:i], "U", word[i + 1 :]))
# Every occurrence of 'u' and 'i'
# between vowels is put into upper case.
# Every occurrence of 'y' preceded or
# followed by a vowel is also put into upper case.
for i in range(1, len(word) - 1):
if word[i - 1] in self.__vowels and word[i + 1] in self.__vowels:
if word[i] == "u":
word = "".join((word[:i], "U", word[i + 1 :]))
elif word[i] == "i":
word = "".join((word[:i], "I", word[i + 1 :]))
if word[i - 1] in self.__vowels or word[i + 1] in self.__vowels:
if word[i] == "y":
word = "".join((word[:i], "Y", word[i + 1 :]))
r1, r2 = self._r1r2_standard(word, self.__vowels)
rv = self.__rv_french(word, self.__vowels)
# STEP 1: Standard suffix removal
for suffix in self.__step1_suffixes:
if word.endswith(suffix):
if suffix == "eaux":
word = word[:-1]
step1_success = True
elif suffix in ("euse", "euses"):
if suffix in r2:
word = word[: -len(suffix)]
step1_success = True
elif suffix in r1:
word = suffix_replace(word, suffix, "eux")
step1_success = True
elif suffix in ("ement", "ements") and suffix in rv:
word = word[: -len(suffix)]
step1_success = True
if word[-2:] == "iv" and "iv" in r2:
word = word[:-2]
if word[-2:] == "at" and "at" in r2:
word = word[:-2]
elif word[-3:] == "eus":
if "eus" in r2:
word = word[:-3]
elif "eus" in r1:
word = "".join((word[:-1], "x"))
elif word[-3:] in ("abl", "iqU"):
if "abl" in r2 or "iqU" in r2:
word = word[:-3]
elif word[-3:] in ("i\xE8r", "I\xE8r"):
if "i\xE8r" in rv or "I\xE8r" in rv:
word = "".join((word[:-3], "i"))
elif suffix == "amment" and suffix in rv:
word = suffix_replace(word, "amment", "ant")
rv = suffix_replace(rv, "amment", "ant")
rv_ending_found = True
elif suffix == "emment" and suffix in rv:
word = suffix_replace(word, "emment", "ent")
rv_ending_found = True
elif (
suffix in ("ment", "ments")
and suffix in rv
and not rv.startswith(suffix)
and rv[rv.rindex(suffix) - 1] in self.__vowels
):
word = word[: -len(suffix)]
rv = rv[: -len(suffix)]
rv_ending_found = True
elif suffix == "aux" and suffix in r1:
word = "".join((word[:-2], "l"))
step1_success = True
elif (
suffix in ("issement", "issements")
and suffix in r1
and word[-len(suffix) - 1] not in self.__vowels
):
word = word[: -len(suffix)]
step1_success = True
elif (
suffix
in (
"ance",
"iqUe",
"isme",
"able",
"iste",
"eux",
"ances",
"iqUes",
"ismes",
"ables",
"istes",
)
and suffix in r2
):
word = word[: -len(suffix)]
step1_success = True
elif (
suffix
in ("atrice", "ateur", "ation", "atrices", "ateurs", "ations")
and suffix in r2
):
word = word[: -len(suffix)]
step1_success = True
if word[-2:] == "ic":
if "ic" in r2:
word = word[:-2]
else:
word = "".join((word[:-2], "iqU"))
elif suffix in ("logie", "logies") and suffix in r2:
word = suffix_replace(word, suffix, "log")
step1_success = True
elif suffix in ("usion", "ution", "usions", "utions") and suffix in r2:
word = suffix_replace(word, suffix, "u")
step1_success = True
elif suffix in ("ence", "ences") and suffix in r2:
word = suffix_replace(word, suffix, "ent")
step1_success = True
elif suffix in ("it\xE9", "it\xE9s") and suffix in r2:
word = word[: -len(suffix)]
step1_success = True
if word[-4:] == "abil":
if "abil" in r2:
word = word[:-4]
else:
word = "".join((word[:-2], "l"))
elif word[-2:] == "ic":
if "ic" in r2:
word = word[:-2]
else:
word = "".join((word[:-2], "iqU"))
elif word[-2:] == "iv":
if "iv" in r2:
word = word[:-2]
elif suffix in ("if", "ive", "ifs", "ives") and suffix in r2:
word = word[: -len(suffix)]
step1_success = True
if word[-2:] == "at" and "at" in r2:
word = word[:-2]
if word[-2:] == "ic":
if "ic" in r2:
word = word[:-2]
else:
word = "".join((word[:-2], "iqU"))
break
# STEP 2a: Verb suffixes beginning 'i'
if not step1_success or rv_ending_found:
for suffix in self.__step2a_suffixes:
if word.endswith(suffix):
if (
suffix in rv
and len(rv) > len(suffix)
and rv[rv.rindex(suffix) - 1] not in self.__vowels
):
word = word[: -len(suffix)]
step2a_success = True
break
# STEP 2b: Other verb suffixes
if not step2a_success:
for suffix in self.__step2b_suffixes:
if rv.endswith(suffix):
if suffix == "ions" and "ions" in r2:
word = word[:-4]
step2b_success = True
elif suffix in (
"eraIent",
"erions",
"\xE8rent",
"erais",
"erait",
"eriez",
"erons",
"eront",
"erai",
"eras",
"erez",
"\xE9es",
"era",
"iez",
"\xE9e",
"\xE9s",
"er",
"ez",
"\xE9",
):
word = word[: -len(suffix)]
step2b_success = True
elif suffix in (
"assions",
"assent",
"assiez",
"aIent",
"antes",
"asses",
"\xE2mes",
"\xE2tes",
"ante",
"ants",
"asse",
"ais",
"ait",
"ant",
"\xE2t",
"ai",
"as",
"a",
):
word = word[: -len(suffix)]
rv = rv[: -len(suffix)]
step2b_success = True
if rv.endswith("e"):
word = word[:-1]
break
# STEP 3
if step1_success or step2a_success or step2b_success:
if word[-1] == "Y":
word = "".join((word[:-1], "i"))
elif word[-1] == "\xE7":
word = "".join((word[:-1], "c"))
# STEP 4: Residual suffixes
else:
if len(word) >= 2 and word[-1] == "s" and word[-2] not in "aiou\xE8s":
word = word[:-1]
for suffix in self.__step4_suffixes:
if word.endswith(suffix):
if suffix in rv:
if suffix == "ion" and suffix in r2 and rv[-4] in "st":
word = word[:-3]
elif suffix in ("ier", "i\xE8re", "Ier", "I\xE8re"):
word = suffix_replace(word, suffix, "i")
elif suffix == "e":
word = word[:-1]
elif suffix == "\xEB" and word[-3:-1] == "gu":
word = word[:-1]
break
# STEP 5: Undouble
if word.endswith(("enn", "onn", "ett", "ell", "eill")):
word = word[:-1]
# STEP 6: Un-accent
for i in range(1, len(word)):
if word[-i] not in self.__vowels:
i += 1
else:
if i != 1 and word[-i] in ("\xE9", "\xE8"):
word = "".join((word[:-i], "e", word[-i + 1 :]))
break
word = word.replace("I", "i").replace("U", "u").replace("Y", "y")
return word
def __rv_french(self, word, vowels):
"""
Return the region RV that is used by the French stemmer.
If the word begins with two vowels, RV is the region after
the third letter. Otherwise, it is the region after the first
vowel not at the beginning of the word, or the end of the word
if these positions cannot be found. (Exceptionally, u'par',
u'col' or u'tap' at the beginning of a word is also taken to
define RV as the region to their right.)
:param word: The French word whose region RV is determined.
:type word: str or unicode
:param vowels: The French vowels that are used to determine
the region RV.
:type vowels: unicode
:return: the region RV for the respective French word.
:rtype: unicode
:note: This helper method is invoked by the stem method of
the subclass FrenchStemmer. It is not to be invoked directly!
"""
rv = ""
if len(word) >= 2:
if word.startswith(("par", "col", "tap")) or (
word[0] in vowels and word[1] in vowels
):
rv = word[3:]
else:
for i in range(1, len(word)):
if word[i] in vowels:
rv = word[i + 1 :]
break
return rv
[docs]class GermanStemmer(_StandardStemmer):
"""
The German Snowball stemmer.
:cvar __vowels: The German vowels.
:type __vowels: unicode
:cvar __s_ending: Letters that may directly appear before a word final 's'.
:type __s_ending: unicode
:cvar __st_ending: Letter that may directly appear before a word final 'st'.
:type __st_ending: unicode
:cvar __step1_suffixes: Suffixes to be deleted in step 1 of the algorithm.
:type __step1_suffixes: tuple
:cvar __step2_suffixes: Suffixes to be deleted in step 2 of the algorithm.
:type __step2_suffixes: tuple
:cvar __step3_suffixes: Suffixes to be deleted in step 3 of the algorithm.
:type __step3_suffixes: tuple
:note: A detailed description of the German
stemming algorithm can be found under
http://snowball.tartarus.org/algorithms/german/stemmer.html
"""
__vowels = "aeiouy\xE4\xF6\xFC"
__s_ending = "bdfghklmnrt"
__st_ending = "bdfghklmnt"
__step1_suffixes = ("ern", "em", "er", "en", "es", "e", "s")
__step2_suffixes = ("est", "en", "er", "st")
__step3_suffixes = ("isch", "lich", "heit", "keit", "end", "ung", "ig", "ik")
[docs] def stem(self, word):
"""
Stem a German word and return the stemmed form.
:param word: The word that is stemmed.
:type word: str or unicode
:return: The stemmed form.
:rtype: unicode
"""
word = word.lower()
if word in self.stopwords:
return word
word = word.replace("\xDF", "ss")
# Every occurrence of 'u' and 'y'
# between vowels is put into upper case.
for i in range(1, len(word) - 1):
if word[i - 1] in self.__vowels and word[i + 1] in self.__vowels:
if word[i] == "u":
word = "".join((word[:i], "U", word[i + 1 :]))
elif word[i] == "y":
word = "".join((word[:i], "Y", word[i + 1 :]))
r1, r2 = self._r1r2_standard(word, self.__vowels)
# R1 is adjusted so that the region before it
# contains at least 3 letters.
for i in range(1, len(word)):
if word[i] not in self.__vowels and word[i - 1] in self.__vowels:
if 3 > len(word[: i + 1]) > 0:
r1 = word[3:]
elif len(word[: i + 1]) == 0:
return word
break
# STEP 1
for suffix in self.__step1_suffixes:
if r1.endswith(suffix):
if (
suffix in ("en", "es", "e")
and word[-len(suffix) - 4 : -len(suffix)] == "niss"
):
word = word[: -len(suffix) - 1]
r1 = r1[: -len(suffix) - 1]
r2 = r2[: -len(suffix) - 1]
elif suffix == "s":
if word[-2] in self.__s_ending:
word = word[:-1]
r1 = r1[:-1]
r2 = r2[:-1]
else:
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
r2 = r2[: -len(suffix)]
break
# STEP 2
for suffix in self.__step2_suffixes:
if r1.endswith(suffix):
if suffix == "st":
if word[-3] in self.__st_ending and len(word[:-3]) >= 3:
word = word[:-2]
r1 = r1[:-2]
r2 = r2[:-2]
else:
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
r2 = r2[: -len(suffix)]
break
# STEP 3: Derivational suffixes
for suffix in self.__step3_suffixes:
if r2.endswith(suffix):
if suffix in ("end", "ung"):
if (
"ig" in r2[-len(suffix) - 2 : -len(suffix)]
and "e" not in r2[-len(suffix) - 3 : -len(suffix) - 2]
):
word = word[: -len(suffix) - 2]
else:
word = word[: -len(suffix)]
elif (
suffix in ("ig", "ik", "isch")
and "e" not in r2[-len(suffix) - 1 : -len(suffix)]
):
word = word[: -len(suffix)]
elif suffix in ("lich", "heit"):
if (
"er" in r1[-len(suffix) - 2 : -len(suffix)]
or "en" in r1[-len(suffix) - 2 : -len(suffix)]
):
word = word[: -len(suffix) - 2]
else:
word = word[: -len(suffix)]
elif suffix == "keit":
if "lich" in r2[-len(suffix) - 4 : -len(suffix)]:
word = word[: -len(suffix) - 4]
elif "ig" in r2[-len(suffix) - 2 : -len(suffix)]:
word = word[: -len(suffix) - 2]
else:
word = word[: -len(suffix)]
break
# Umlaut accents are removed and
# 'u' and 'y' are put back into lower case.
word = (
word.replace("\xE4", "a")
.replace("\xF6", "o")
.replace("\xFC", "u")
.replace("U", "u")
.replace("Y", "y")
)
return word
[docs]class HungarianStemmer(_LanguageSpecificStemmer):
"""
The Hungarian Snowball stemmer.
:cvar __vowels: The Hungarian vowels.
:type __vowels: unicode
:cvar __digraphs: The Hungarian digraphs.
:type __digraphs: tuple
:cvar __double_consonants: The Hungarian double consonants.
:type __double_consonants: tuple
:cvar __step1_suffixes: Suffixes to be deleted in step 1 of the algorithm.
:type __step1_suffixes: tuple
:cvar __step2_suffixes: Suffixes to be deleted in step 2 of the algorithm.
:type __step2_suffixes: tuple
:cvar __step3_suffixes: Suffixes to be deleted in step 3 of the algorithm.
:type __step3_suffixes: tuple
:cvar __step4_suffixes: Suffixes to be deleted in step 4 of the algorithm.
:type __step4_suffixes: tuple
:cvar __step5_suffixes: Suffixes to be deleted in step 5 of the algorithm.
:type __step5_suffixes: tuple
:cvar __step6_suffixes: Suffixes to be deleted in step 6 of the algorithm.
:type __step6_suffixes: tuple
:cvar __step7_suffixes: Suffixes to be deleted in step 7 of the algorithm.
:type __step7_suffixes: tuple
:cvar __step8_suffixes: Suffixes to be deleted in step 8 of the algorithm.
:type __step8_suffixes: tuple
:cvar __step9_suffixes: Suffixes to be deleted in step 9 of the algorithm.
:type __step9_suffixes: tuple
:note: A detailed description of the Hungarian
stemming algorithm can be found under
http://snowball.tartarus.org/algorithms/hungarian/stemmer.html
"""
__vowels = "aeiou\xF6\xFC\xE1\xE9\xED\xF3\xF5\xFA\xFB"
__digraphs = ("cs", "dz", "dzs", "gy", "ly", "ny", "ty", "zs")
__double_consonants = (
"bb",
"cc",
"ccs",
"dd",
"ff",
"gg",
"ggy",
"jj",
"kk",
"ll",
"lly",
"mm",
"nn",
"nny",
"pp",
"rr",
"ss",
"ssz",
"tt",
"tty",
"vv",
"zz",
"zzs",
)
__step1_suffixes = ("al", "el")
__step2_suffixes = (
"k\xE9ppen",
"onk\xE9nt",
"enk\xE9nt",
"ank\xE9nt",
"k\xE9pp",
"k\xE9nt",
"ban",
"ben",
"nak",
"nek",
"val",
"vel",
"t\xF3l",
"t\xF5l",
"r\xF3l",
"r\xF5l",
"b\xF3l",
"b\xF5l",
"hoz",
"hez",
"h\xF6z",
"n\xE1l",
"n\xE9l",
"\xE9rt",
"kor",
"ba",
"be",
"ra",
"re",
"ig",
"at",
"et",
"ot",
"\xF6t",
"ul",
"\xFCl",
"v\xE1",
"v\xE9",
"en",
"on",
"an",
"\xF6n",
"n",
"t",
)
__step3_suffixes = ("\xE1nk\xE9nt", "\xE1n", "\xE9n")
__step4_suffixes = (
"astul",
"est\xFCl",
"\xE1stul",
"\xE9st\xFCl",
"stul",
"st\xFCl",
)
__step5_suffixes = ("\xE1", "\xE9")
__step6_suffixes = (
"ok\xE9",
"\xF6k\xE9",
"ak\xE9",
"ek\xE9",
"\xE1k\xE9",
"\xE1\xE9i",
"\xE9k\xE9",
"\xE9\xE9i",
"k\xE9",
"\xE9i",
"\xE9\xE9",
"\xE9",
)
__step7_suffixes = (
"\xE1juk",
"\xE9j\xFCk",
"\xFCnk",
"unk",
"juk",
"j\xFCk",
"\xE1nk",
"\xE9nk",
"nk",
"uk",
"\xFCk",
"em",
"om",
"am",
"od",
"ed",
"ad",
"\xF6d",
"ja",
"je",
"\xE1m",
"\xE1d",
"\xE9m",
"\xE9d",
"m",
"d",
"a",
"e",
"o",
"\xE1",
"\xE9",
)
__step8_suffixes = (
"jaitok",
"jeitek",
"jaink",
"jeink",
"aitok",
"eitek",
"\xE1itok",
"\xE9itek",
"jaim",
"jeim",
"jaid",
"jeid",
"eink",
"aink",
"itek",
"jeik",
"jaik",
"\xE1ink",
"\xE9ink",
"aim",
"eim",
"aid",
"eid",
"jai",
"jei",
"ink",
"aik",
"eik",
"\xE1im",
"\xE1id",
"\xE1ik",
"\xE9im",
"\xE9id",
"\xE9ik",
"im",
"id",
"ai",
"ei",
"ik",
"\xE1i",
"\xE9i",
"i",
)
__step9_suffixes = ("\xE1k", "\xE9k", "\xF6k", "ok", "ek", "ak", "k")
[docs] def stem(self, word):
"""
Stem an Hungarian word and return the stemmed form.
:param word: The word that is stemmed.
:type word: str or unicode
:return: The stemmed form.
:rtype: unicode
"""
word = word.lower()
if word in self.stopwords:
return word
r1 = self.__r1_hungarian(word, self.__vowels, self.__digraphs)
# STEP 1: Remove instrumental case
if r1.endswith(self.__step1_suffixes):
for double_cons in self.__double_consonants:
if word[-2 - len(double_cons) : -2] == double_cons:
word = "".join((word[:-4], word[-3]))
if r1[-2 - len(double_cons) : -2] == double_cons:
r1 = "".join((r1[:-4], r1[-3]))
break
# STEP 2: Remove frequent cases
for suffix in self.__step2_suffixes:
if word.endswith(suffix):
if r1.endswith(suffix):
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
if r1.endswith("\xE1"):
word = "".join((word[:-1], "a"))
r1 = suffix_replace(r1, "\xE1", "a")
elif r1.endswith("\xE9"):
word = "".join((word[:-1], "e"))
r1 = suffix_replace(r1, "\xE9", "e")
break
# STEP 3: Remove special cases
for suffix in self.__step3_suffixes:
if r1.endswith(suffix):
if suffix == "\xE9n":
word = suffix_replace(word, suffix, "e")
r1 = suffix_replace(r1, suffix, "e")
else:
word = suffix_replace(word, suffix, "a")
r1 = suffix_replace(r1, suffix, "a")
break
# STEP 4: Remove other cases
for suffix in self.__step4_suffixes:
if r1.endswith(suffix):
if suffix == "\xE1stul":
word = suffix_replace(word, suffix, "a")
r1 = suffix_replace(r1, suffix, "a")
elif suffix == "\xE9st\xFCl":
word = suffix_replace(word, suffix, "e")
r1 = suffix_replace(r1, suffix, "e")
else:
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
break
# STEP 5: Remove factive case
for suffix in self.__step5_suffixes:
if r1.endswith(suffix):
for double_cons in self.__double_consonants:
if word[-1 - len(double_cons) : -1] == double_cons:
word = "".join((word[:-3], word[-2]))
if r1[-1 - len(double_cons) : -1] == double_cons:
r1 = "".join((r1[:-3], r1[-2]))
break
# STEP 6: Remove owned
for suffix in self.__step6_suffixes:
if r1.endswith(suffix):
if suffix in ("\xE1k\xE9", "\xE1\xE9i"):
word = suffix_replace(word, suffix, "a")
r1 = suffix_replace(r1, suffix, "a")
elif suffix in ("\xE9k\xE9", "\xE9\xE9i", "\xE9\xE9"):
word = suffix_replace(word, suffix, "e")
r1 = suffix_replace(r1, suffix, "e")
else:
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
break
# STEP 7: Remove singular owner suffixes
for suffix in self.__step7_suffixes:
if word.endswith(suffix):
if r1.endswith(suffix):
if suffix in ("\xE1nk", "\xE1juk", "\xE1m", "\xE1d", "\xE1"):
word = suffix_replace(word, suffix, "a")
r1 = suffix_replace(r1, suffix, "a")
elif suffix in ("\xE9nk", "\xE9j\xFCk", "\xE9m", "\xE9d", "\xE9"):
word = suffix_replace(word, suffix, "e")
r1 = suffix_replace(r1, suffix, "e")
else:
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
break
# STEP 8: Remove plural owner suffixes
for suffix in self.__step8_suffixes:
if word.endswith(suffix):
if r1.endswith(suffix):
if suffix in (
"\xE1im",
"\xE1id",
"\xE1i",
"\xE1ink",
"\xE1itok",
"\xE1ik",
):
word = suffix_replace(word, suffix, "a")
r1 = suffix_replace(r1, suffix, "a")
elif suffix in (
"\xE9im",
"\xE9id",
"\xE9i",
"\xE9ink",
"\xE9itek",
"\xE9ik",
):
word = suffix_replace(word, suffix, "e")
r1 = suffix_replace(r1, suffix, "e")
else:
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
break
# STEP 9: Remove plural suffixes
for suffix in self.__step9_suffixes:
if word.endswith(suffix):
if r1.endswith(suffix):
if suffix == "\xE1k":
word = suffix_replace(word, suffix, "a")
elif suffix == "\xE9k":
word = suffix_replace(word, suffix, "e")
else:
word = word[: -len(suffix)]
break
return word
def __r1_hungarian(self, word, vowels, digraphs):
"""
Return the region R1 that is used by the Hungarian stemmer.
If the word begins with a vowel, R1 is defined as the region
after the first consonant or digraph (= two letters stand for
one phoneme) in the word. If the word begins with a consonant,
it is defined as the region after the first vowel in the word.
If the word does not contain both a vowel and consonant, R1
is the null region at the end of the word.
:param word: The Hungarian word whose region R1 is determined.
:type word: str or unicode
:param vowels: The Hungarian vowels that are used to determine
the region R1.
:type vowels: unicode
:param digraphs: The digraphs that are used to determine the
region R1.
:type digraphs: tuple
:return: the region R1 for the respective word.
:rtype: unicode
:note: This helper method is invoked by the stem method of the subclass
HungarianStemmer. It is not to be invoked directly!
"""
r1 = ""
if word[0] in vowels:
for digraph in digraphs:
if digraph in word[1:]:
r1 = word[word.index(digraph[-1]) + 1 :]
return r1
for i in range(1, len(word)):
if word[i] not in vowels:
r1 = word[i + 1 :]
break
else:
for i in range(1, len(word)):
if word[i] in vowels:
r1 = word[i + 1 :]
break
return r1
[docs]class ItalianStemmer(_StandardStemmer):
"""
The Italian Snowball stemmer.
:cvar __vowels: The Italian vowels.
:type __vowels: unicode
:cvar __step0_suffixes: Suffixes to be deleted in step 0 of the algorithm.
:type __step0_suffixes: tuple
:cvar __step1_suffixes: Suffixes to be deleted in step 1 of the algorithm.
:type __step1_suffixes: tuple
:cvar __step2_suffixes: Suffixes to be deleted in step 2 of the algorithm.
:type __step2_suffixes: tuple
:note: A detailed description of the Italian
stemming algorithm can be found under
http://snowball.tartarus.org/algorithms/italian/stemmer.html
"""
__vowels = "aeiou\xE0\xE8\xEC\xF2\xF9"
__step0_suffixes = (
"gliela",
"gliele",
"glieli",
"glielo",
"gliene",
"sene",
"mela",
"mele",
"meli",
"melo",
"mene",
"tela",
"tele",
"teli",
"telo",
"tene",
"cela",
"cele",
"celi",
"celo",
"cene",
"vela",
"vele",
"veli",
"velo",
"vene",
"gli",
"ci",
"la",
"le",
"li",
"lo",
"mi",
"ne",
"si",
"ti",
"vi",
)
__step1_suffixes = (
"atrice",
"atrici",
"azione",
"azioni",
"uzione",
"uzioni",
"usione",
"usioni",
"amento",
"amenti",
"imento",
"imenti",
"amente",
"abile",
"abili",
"ibile",
"ibili",
"mente",
"atore",
"atori",
"logia",
"logie",
"anza",
"anze",
"iche",
"ichi",
"ismo",
"ismi",
"ista",
"iste",
"isti",
"ist\xE0",
"ist\xE8",
"ist\xEC",
"ante",
"anti",
"enza",
"enze",
"ico",
"ici",
"ica",
"ice",
"oso",
"osi",
"osa",
"ose",
"it\xE0",
"ivo",
"ivi",
"iva",
"ive",
)
__step2_suffixes = (
"erebbero",
"irebbero",
"assero",
"assimo",
"eranno",
"erebbe",
"eremmo",
"ereste",
"eresti",
"essero",
"iranno",
"irebbe",
"iremmo",
"ireste",
"iresti",
"iscano",
"iscono",
"issero",
"arono",
"avamo",
"avano",
"avate",
"eremo",
"erete",
"erono",
"evamo",
"evano",
"evate",
"iremo",
"irete",
"irono",
"ivamo",
"ivano",
"ivate",
"ammo",
"ando",
"asse",
"assi",
"emmo",
"enda",
"ende",
"endi",
"endo",
"erai",
"erei",
"Yamo",
"iamo",
"immo",
"irai",
"irei",
"isca",
"isce",
"isci",
"isco",
"ano",
"are",
"ata",
"ate",
"ati",
"ato",
"ava",
"avi",
"avo",
"er\xE0",
"ere",
"er\xF2",
"ete",
"eva",
"evi",
"evo",
"ir\xE0",
"ire",
"ir\xF2",
"ita",
"ite",
"iti",
"ito",
"iva",
"ivi",
"ivo",
"ono",
"uta",
"ute",
"uti",
"uto",
"ar",
"ir",
)
[docs] def stem(self, word):
"""
Stem an Italian word and return the stemmed form.
:param word: The word that is stemmed.
:type word: str or unicode
:return: The stemmed form.
:rtype: unicode
"""
word = word.lower()
if word in self.stopwords:
return word
step1_success = False
# All acute accents are replaced by grave accents.
word = (
word.replace("\xE1", "\xE0")
.replace("\xE9", "\xE8")
.replace("\xED", "\xEC")
.replace("\xF3", "\xF2")
.replace("\xFA", "\xF9")
)
# Every occurrence of 'u' after 'q'
# is put into upper case.
for i in range(1, len(word)):
if word[i - 1] == "q" and word[i] == "u":
word = "".join((word[:i], "U", word[i + 1 :]))
# Every occurrence of 'u' and 'i'
# between vowels is put into upper case.
for i in range(1, len(word) - 1):
if word[i - 1] in self.__vowels and word[i + 1] in self.__vowels:
if word[i] == "u":
word = "".join((word[:i], "U", word[i + 1 :]))
elif word[i] == "i":
word = "".join((word[:i], "I", word[i + 1 :]))
r1, r2 = self._r1r2_standard(word, self.__vowels)
rv = self._rv_standard(word, self.__vowels)
# STEP 0: Attached pronoun
for suffix in self.__step0_suffixes:
if rv.endswith(suffix):
if rv[-len(suffix) - 4 : -len(suffix)] in ("ando", "endo"):
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
r2 = r2[: -len(suffix)]
rv = rv[: -len(suffix)]
elif rv[-len(suffix) - 2 : -len(suffix)] in ("ar", "er", "ir"):
word = suffix_replace(word, suffix, "e")
r1 = suffix_replace(r1, suffix, "e")
r2 = suffix_replace(r2, suffix, "e")
rv = suffix_replace(rv, suffix, "e")
break
# STEP 1: Standard suffix removal
for suffix in self.__step1_suffixes:
if word.endswith(suffix):
if suffix == "amente" and r1.endswith(suffix):
step1_success = True
word = word[:-6]
r2 = r2[:-6]
rv = rv[:-6]
if r2.endswith("iv"):
word = word[:-2]
r2 = r2[:-2]
rv = rv[:-2]
if r2.endswith("at"):
word = word[:-2]
rv = rv[:-2]
elif r2.endswith(("os", "ic")):
word = word[:-2]
rv = rv[:-2]
elif r2.endswith("abil"):
word = word[:-4]
rv = rv[:-4]
elif suffix in ("amento", "amenti", "imento", "imenti") and rv.endswith(
suffix
):
step1_success = True
word = word[:-6]
rv = rv[:-6]
elif r2.endswith(suffix):
step1_success = True
if suffix in ("azione", "azioni", "atore", "atori"):
word = word[: -len(suffix)]
r2 = r2[: -len(suffix)]
rv = rv[: -len(suffix)]
if r2.endswith("ic"):
word = word[:-2]
rv = rv[:-2]
elif suffix in ("logia", "logie"):
word = word[:-2]
rv = word[:-2]
elif suffix in ("uzione", "uzioni", "usione", "usioni"):
word = word[:-5]
rv = rv[:-5]
elif suffix in ("enza", "enze"):
word = suffix_replace(word, suffix, "te")
rv = suffix_replace(rv, suffix, "te")
elif suffix == "it\xE0":
word = word[:-3]
r2 = r2[:-3]
rv = rv[:-3]
if r2.endswith(("ic", "iv")):
word = word[:-2]
rv = rv[:-2]
elif r2.endswith("abil"):
word = word[:-4]
rv = rv[:-4]
elif suffix in ("ivo", "ivi", "iva", "ive"):
word = word[:-3]
r2 = r2[:-3]
rv = rv[:-3]
if r2.endswith("at"):
word = word[:-2]
r2 = r2[:-2]
rv = rv[:-2]
if r2.endswith("ic"):
word = word[:-2]
rv = rv[:-2]
else:
word = word[: -len(suffix)]
rv = rv[: -len(suffix)]
break
# STEP 2: Verb suffixes
if not step1_success:
for suffix in self.__step2_suffixes:
if rv.endswith(suffix):
word = word[: -len(suffix)]
rv = rv[: -len(suffix)]
break
# STEP 3a
if rv.endswith(("a", "e", "i", "o", "\xE0", "\xE8", "\xEC", "\xF2")):
word = word[:-1]
rv = rv[:-1]
if rv.endswith("i"):
word = word[:-1]
rv = rv[:-1]
# STEP 3b
if rv.endswith(("ch", "gh")):
word = word[:-1]
word = word.replace("I", "i").replace("U", "u")
return word
[docs]class NorwegianStemmer(_ScandinavianStemmer):
"""
The Norwegian Snowball stemmer.
:cvar __vowels: The Norwegian vowels.
:type __vowels: unicode
:cvar __s_ending: Letters that may directly appear before a word final 's'.
:type __s_ending: unicode
:cvar __step1_suffixes: Suffixes to be deleted in step 1 of the algorithm.
:type __step1_suffixes: tuple
:cvar __step2_suffixes: Suffixes to be deleted in step 2 of the algorithm.
:type __step2_suffixes: tuple
:cvar __step3_suffixes: Suffixes to be deleted in step 3 of the algorithm.
:type __step3_suffixes: tuple
:note: A detailed description of the Norwegian
stemming algorithm can be found under
http://snowball.tartarus.org/algorithms/norwegian/stemmer.html
"""
__vowels = "aeiouy\xE6\xE5\xF8"
__s_ending = "bcdfghjlmnoprtvyz"
__step1_suffixes = (
"hetenes",
"hetene",
"hetens",
"heter",
"heten",
"endes",
"ande",
"ende",
"edes",
"enes",
"erte",
"ede",
"ane",
"ene",
"ens",
"ers",
"ets",
"het",
"ast",
"ert",
"en",
"ar",
"er",
"as",
"es",
"et",
"a",
"e",
"s",
)
__step2_suffixes = ("dt", "vt")
__step3_suffixes = (
"hetslov",
"eleg",
"elig",
"elov",
"slov",
"leg",
"eig",
"lig",
"els",
"lov",
"ig",
)
[docs] def stem(self, word):
"""
Stem a Norwegian word and return the stemmed form.
:param word: The word that is stemmed.
:type word: str or unicode
:return: The stemmed form.
:rtype: unicode
"""
word = word.lower()
if word in self.stopwords:
return word
r1 = self._r1_scandinavian(word, self.__vowels)
# STEP 1
for suffix in self.__step1_suffixes:
if r1.endswith(suffix):
if suffix in ("erte", "ert"):
word = suffix_replace(word, suffix, "er")
r1 = suffix_replace(r1, suffix, "er")
elif suffix == "s":
if word[-2] in self.__s_ending or (
word[-2] == "k" and word[-3] not in self.__vowels
):
word = word[:-1]
r1 = r1[:-1]
else:
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
break
# STEP 2
for suffix in self.__step2_suffixes:
if r1.endswith(suffix):
word = word[:-1]
r1 = r1[:-1]
break
# STEP 3
for suffix in self.__step3_suffixes:
if r1.endswith(suffix):
word = word[: -len(suffix)]
break
return word
[docs]class PortugueseStemmer(_StandardStemmer):
"""
The Portuguese Snowball stemmer.
:cvar __vowels: The Portuguese vowels.
:type __vowels: unicode
:cvar __step1_suffixes: Suffixes to be deleted in step 1 of the algorithm.
:type __step1_suffixes: tuple
:cvar __step2_suffixes: Suffixes to be deleted in step 2 of the algorithm.
:type __step2_suffixes: tuple
:cvar __step4_suffixes: Suffixes to be deleted in step 4 of the algorithm.
:type __step4_suffixes: tuple
:note: A detailed description of the Portuguese
stemming algorithm can be found under
http://snowball.tartarus.org/algorithms/portuguese/stemmer.html
"""
__vowels = "aeiou\xE1\xE9\xED\xF3\xFA\xE2\xEA\xF4"
__step1_suffixes = (
"amentos",
"imentos",
"uço~es",
"amento",
"imento",
"adoras",
"adores",
"a\xE7o~es",
"logias",
"\xEAncias",
"amente",
"idades",
"an\xE7as",
"ismos",
"istas",
"adora",
"a\xE7a~o",
"antes",
"\xE2ncia",
"logia",
"uça~o",
"\xEAncia",
"mente",
"idade",
"an\xE7a",
"ezas",
"icos",
"icas",
"ismo",
"\xE1vel",
"\xEDvel",
"ista",
"osos",
"osas",
"ador",
"ante",
"ivas",
"ivos",
"iras",
"eza",
"ico",
"ica",
"oso",
"osa",
"iva",
"ivo",
"ira",
)
__step2_suffixes = (
"ar\xEDamos",
"er\xEDamos",
"ir\xEDamos",
"\xE1ssemos",
"\xEAssemos",
"\xEDssemos",
"ar\xEDeis",
"er\xEDeis",
"ir\xEDeis",
"\xE1sseis",
"\xE9sseis",
"\xEDsseis",
"\xE1ramos",
"\xE9ramos",
"\xEDramos",
"\xE1vamos",
"aremos",
"eremos",
"iremos",
"ariam",
"eriam",
"iriam",
"assem",
"essem",
"issem",
"ara~o",
"era~o",
"ira~o",
"arias",
"erias",
"irias",
"ardes",
"erdes",
"irdes",
"asses",
"esses",
"isses",
"astes",
"estes",
"istes",
"\xE1reis",
"areis",
"\xE9reis",
"ereis",
"\xEDreis",
"ireis",
"\xE1veis",
"\xEDamos",
"armos",
"ermos",
"irmos",
"aria",
"eria",
"iria",
"asse",
"esse",
"isse",
"aste",
"este",
"iste",
"arei",
"erei",
"irei",
"aram",
"eram",
"iram",
"avam",
"arem",
"erem",
"irem",
"ando",
"endo",
"indo",
"adas",
"idas",
"ar\xE1s",
"aras",
"er\xE1s",
"eras",
"ir\xE1s",
"avas",
"ares",
"eres",
"ires",
"\xEDeis",
"ados",
"idos",
"\xE1mos",
"amos",
"emos",
"imos",
"iras",
"ada",
"ida",
"ar\xE1",
"ara",
"er\xE1",
"era",
"ir\xE1",
"ava",
"iam",
"ado",
"ido",
"ias",
"ais",
"eis",
"ira",
"ia",
"ei",
"am",
"em",
"ar",
"er",
"ir",
"as",
"es",
"is",
"eu",
"iu",
"ou",
)
__step4_suffixes = ("os", "a", "i", "o", "\xE1", "\xED", "\xF3")
[docs] def stem(self, word):
"""
Stem a Portuguese word and return the stemmed form.
:param word: The word that is stemmed.
:type word: str or unicode
:return: The stemmed form.
:rtype: unicode
"""
word = word.lower()
if word in self.stopwords:
return word
step1_success = False
step2_success = False
word = (
word.replace("\xE3", "a~")
.replace("\xF5", "o~")
.replace("q\xFC", "qu")
.replace("g\xFC", "gu")
)
r1, r2 = self._r1r2_standard(word, self.__vowels)
rv = self._rv_standard(word, self.__vowels)
# STEP 1: Standard suffix removal
for suffix in self.__step1_suffixes:
if word.endswith(suffix):
if suffix == "amente" and r1.endswith(suffix):
step1_success = True
word = word[:-6]
r2 = r2[:-6]
rv = rv[:-6]
if r2.endswith("iv"):
word = word[:-2]
r2 = r2[:-2]
rv = rv[:-2]
if r2.endswith("at"):
word = word[:-2]
rv = rv[:-2]
elif r2.endswith(("os", "ic", "ad")):
word = word[:-2]
rv = rv[:-2]
elif (
suffix in ("ira", "iras")
and rv.endswith(suffix)
and word[-len(suffix) - 1 : -len(suffix)] == "e"
):
step1_success = True
word = suffix_replace(word, suffix, "ir")
rv = suffix_replace(rv, suffix, "ir")
elif r2.endswith(suffix):
step1_success = True
if suffix in ("logia", "logias"):
word = suffix_replace(word, suffix, "log")
rv = suffix_replace(rv, suffix, "log")
elif suffix in ("uça~o", "uço~es"):
word = suffix_replace(word, suffix, "u")
rv = suffix_replace(rv, suffix, "u")
elif suffix in ("\xEAncia", "\xEAncias"):
word = suffix_replace(word, suffix, "ente")
rv = suffix_replace(rv, suffix, "ente")
elif suffix == "mente":
word = word[:-5]
r2 = r2[:-5]
rv = rv[:-5]
if r2.endswith(("ante", "avel", "ivel")):
word = word[:-4]
rv = rv[:-4]
elif suffix in ("idade", "idades"):
word = word[: -len(suffix)]
r2 = r2[: -len(suffix)]
rv = rv[: -len(suffix)]
if r2.endswith(("ic", "iv")):
word = word[:-2]
rv = rv[:-2]
elif r2.endswith("abil"):
word = word[:-4]
rv = rv[:-4]
elif suffix in ("iva", "ivo", "ivas", "ivos"):
word = word[: -len(suffix)]
r2 = r2[: -len(suffix)]
rv = rv[: -len(suffix)]
if r2.endswith("at"):
word = word[:-2]
rv = rv[:-2]
else:
word = word[: -len(suffix)]
rv = rv[: -len(suffix)]
break
# STEP 2: Verb suffixes
if not step1_success:
for suffix in self.__step2_suffixes:
if rv.endswith(suffix):
step2_success = True
word = word[: -len(suffix)]
rv = rv[: -len(suffix)]
break
# STEP 3
if step1_success or step2_success:
if rv.endswith("i") and word[-2] == "c":
word = word[:-1]
rv = rv[:-1]
### STEP 4: Residual suffix
if not step1_success and not step2_success:
for suffix in self.__step4_suffixes:
if rv.endswith(suffix):
word = word[: -len(suffix)]
rv = rv[: -len(suffix)]
break
# STEP 5
if rv.endswith(("e", "\xE9", "\xEA")):
word = word[:-1]
rv = rv[:-1]
if (word.endswith("gu") and rv.endswith("u")) or (
word.endswith("ci") and rv.endswith("i")
):
word = word[:-1]
elif word.endswith("\xE7"):
word = suffix_replace(word, "\xE7", "c")
word = word.replace("a~", "\xE3").replace("o~", "\xF5")
return word
[docs]class RomanianStemmer(_StandardStemmer):
"""
The Romanian Snowball stemmer.
:cvar __vowels: The Romanian vowels.
:type __vowels: unicode
:cvar __step0_suffixes: Suffixes to be deleted in step 0 of the algorithm.
:type __step0_suffixes: tuple
:cvar __step1_suffixes: Suffixes to be deleted in step 1 of the algorithm.
:type __step1_suffixes: tuple
:cvar __step2_suffixes: Suffixes to be deleted in step 2 of the algorithm.
:type __step2_suffixes: tuple
:cvar __step3_suffixes: Suffixes to be deleted in step 3 of the algorithm.
:type __step3_suffixes: tuple
:note: A detailed description of the Romanian
stemming algorithm can be found under
http://snowball.tartarus.org/algorithms/romanian/stemmer.html
"""
__vowels = "aeiou\u0103\xE2\xEE"
__step0_suffixes = (
"iilor",
"ului",
"elor",
"iile",
"ilor",
"atei",
"a\u0163ie",
"a\u0163ia",
"aua",
"ele",
"iua",
"iei",
"ile",
"ul",
"ea",
"ii",
)
__step1_suffixes = (
"abilitate",
"abilitati",
"abilit\u0103\u0163i",
"ibilitate",
"abilit\u0103i",
"ivitate",
"ivitati",
"ivit\u0103\u0163i",
"icitate",
"icitati",
"icit\u0103\u0163i",
"icatori",
"ivit\u0103i",
"icit\u0103i",
"icator",
"a\u0163iune",
"atoare",
"\u0103toare",
"i\u0163iune",
"itoare",
"iciva",
"icive",
"icivi",
"iciv\u0103",
"icala",
"icale",
"icali",
"ical\u0103",
"ativa",
"ative",
"ativi",
"ativ\u0103",
"atori",
"\u0103tori",
"itiva",
"itive",
"itivi",
"itiv\u0103",
"itori",
"iciv",
"ical",
"ativ",
"ator",
"\u0103tor",
"itiv",
"itor",
)
__step2_suffixes = (
"abila",
"abile",
"abili",
"abil\u0103",
"ibila",
"ibile",
"ibili",
"ibil\u0103",
"atori",
"itate",
"itati",
"it\u0103\u0163i",
"abil",
"ibil",
"oasa",
"oas\u0103",
"oase",
"anta",
"ante",
"anti",
"ant\u0103",
"ator",
"it\u0103i",
"iune",
"iuni",
"isme",
"ista",
"iste",
"isti",
"ist\u0103",
"i\u015Fti",
"ata",
"at\u0103",
"ati",
"ate",
"uta",
"ut\u0103",
"uti",
"ute",
"ita",
"it\u0103",
"iti",
"ite",
"ica",
"ice",
"ici",
"ic\u0103",
"osi",
"o\u015Fi",
"ant",
"iva",
"ive",
"ivi",
"iv\u0103",
"ism",
"ist",
"at",
"ut",
"it",
"ic",
"os",
"iv",
)
__step3_suffixes = (
"seser\u0103\u0163i",
"aser\u0103\u0163i",
"iser\u0103\u0163i",
"\xE2ser\u0103\u0163i",
"user\u0103\u0163i",
"seser\u0103m",
"aser\u0103m",
"iser\u0103m",
"\xE2ser\u0103m",
"user\u0103m",
"ser\u0103\u0163i",
"sese\u015Fi",
"seser\u0103",
"easc\u0103",
"ar\u0103\u0163i",
"ur\u0103\u0163i",
"ir\u0103\u0163i",
"\xE2r\u0103\u0163i",
"ase\u015Fi",
"aser\u0103",
"ise\u015Fi",
"iser\u0103",
"\xe2se\u015Fi",
"\xE2ser\u0103",
"use\u015Fi",
"user\u0103",
"ser\u0103m",
"sesem",
"indu",
"\xE2ndu",
"eaz\u0103",
"e\u015Fti",
"e\u015Fte",
"\u0103\u015Fti",
"\u0103\u015Fte",
"ea\u0163i",
"ia\u0163i",
"ar\u0103m",
"ur\u0103m",
"ir\u0103m",
"\xE2r\u0103m",
"asem",
"isem",
"\xE2sem",
"usem",
"se\u015Fi",
"ser\u0103",
"sese",
"are",
"ere",
"ire",
"\xE2re",
"ind",
"\xE2nd",
"eze",
"ezi",
"esc",
"\u0103sc",
"eam",
"eai",
"eau",
"iam",
"iai",
"iau",
"a\u015Fi",
"ar\u0103",
"u\u015Fi",
"ur\u0103",
"i\u015Fi",
"ir\u0103",
"\xE2\u015Fi",
"\xe2r\u0103",
"ase",
"ise",
"\xE2se",
"use",
"a\u0163i",
"e\u0163i",
"i\u0163i",
"\xe2\u0163i",
"sei",
"ez",
"am",
"ai",
"au",
"ea",
"ia",
"ui",
"\xE2i",
"\u0103m",
"em",
"im",
"\xE2m",
"se",
)
[docs] def stem(self, word):
"""
Stem a Romanian word and return the stemmed form.
:param word: The word that is stemmed.
:type word: str or unicode
:return: The stemmed form.
:rtype: unicode
"""
word = word.lower()
if word in self.stopwords:
return word
step1_success = False
step2_success = False
for i in range(1, len(word) - 1):
if word[i - 1] in self.__vowels and word[i + 1] in self.__vowels:
if word[i] == "u":
word = "".join((word[:i], "U", word[i + 1 :]))
elif word[i] == "i":
word = "".join((word[:i], "I", word[i + 1 :]))
r1, r2 = self._r1r2_standard(word, self.__vowels)
rv = self._rv_standard(word, self.__vowels)
# STEP 0: Removal of plurals and other simplifications
for suffix in self.__step0_suffixes:
if word.endswith(suffix):
if suffix in r1:
if suffix in ("ul", "ului"):
word = word[: -len(suffix)]
if suffix in rv:
rv = rv[: -len(suffix)]
else:
rv = ""
elif (
suffix == "aua"
or suffix == "atei"
or (suffix == "ile" and word[-5:-3] != "ab")
):
word = word[:-2]
elif suffix in ("ea", "ele", "elor"):
word = suffix_replace(word, suffix, "e")
if suffix in rv:
rv = suffix_replace(rv, suffix, "e")
else:
rv = ""
elif suffix in ("ii", "iua", "iei", "iile", "iilor", "ilor"):
word = suffix_replace(word, suffix, "i")
if suffix in rv:
rv = suffix_replace(rv, suffix, "i")
else:
rv = ""
elif suffix in ("a\u0163ie", "a\u0163ia"):
word = word[:-1]
break
# STEP 1: Reduction of combining suffixes
while True:
replacement_done = False
for suffix in self.__step1_suffixes:
if word.endswith(suffix):
if suffix in r1:
step1_success = True
replacement_done = True
if suffix in (
"abilitate",
"abilitati",
"abilit\u0103i",
"abilit\u0103\u0163i",
):
word = suffix_replace(word, suffix, "abil")
elif suffix == "ibilitate":
word = word[:-5]
elif suffix in (
"ivitate",
"ivitati",
"ivit\u0103i",
"ivit\u0103\u0163i",
):
word = suffix_replace(word, suffix, "iv")
elif suffix in (
"icitate",
"icitati",
"icit\u0103i",
"icit\u0103\u0163i",
"icator",
"icatori",
"iciv",
"iciva",
"icive",
"icivi",
"iciv\u0103",
"ical",
"icala",
"icale",
"icali",
"ical\u0103",
):
word = suffix_replace(word, suffix, "ic")
elif suffix in (
"ativ",
"ativa",
"ative",
"ativi",
"ativ\u0103",
"a\u0163iune",
"atoare",
"ator",
"atori",
"\u0103toare",
"\u0103tor",
"\u0103tori",
):
word = suffix_replace(word, suffix, "at")
if suffix in r2:
r2 = suffix_replace(r2, suffix, "at")
elif suffix in (
"itiv",
"itiva",
"itive",
"itivi",
"itiv\u0103",
"i\u0163iune",
"itoare",
"itor",
"itori",
):
word = suffix_replace(word, suffix, "it")
if suffix in r2:
r2 = suffix_replace(r2, suffix, "it")
else:
step1_success = False
break
if not replacement_done:
break
# STEP 2: Removal of standard suffixes
for suffix in self.__step2_suffixes:
if word.endswith(suffix):
if suffix in r2:
step2_success = True
if suffix in ("iune", "iuni"):
if word[-5] == "\u0163":
word = "".join((word[:-5], "t"))
elif suffix in (
"ism",
"isme",
"ist",
"ista",
"iste",
"isti",
"ist\u0103",
"i\u015Fti",
):
word = suffix_replace(word, suffix, "ist")
else:
word = word[: -len(suffix)]
break
# STEP 3: Removal of verb suffixes
if not step1_success and not step2_success:
for suffix in self.__step3_suffixes:
if word.endswith(suffix):
if suffix in rv:
if suffix in (
"seser\u0103\u0163i",
"seser\u0103m",
"ser\u0103\u0163i",
"sese\u015Fi",
"seser\u0103",
"ser\u0103m",
"sesem",
"se\u015Fi",
"ser\u0103",
"sese",
"a\u0163i",
"e\u0163i",
"i\u0163i",
"\xE2\u0163i",
"sei",
"\u0103m",
"em",
"im",
"\xE2m",
"se",
):
word = word[: -len(suffix)]
rv = rv[: -len(suffix)]
else:
if (
not rv.startswith(suffix)
and rv[rv.index(suffix) - 1] not in "aeio\u0103\xE2\xEE"
):
word = word[: -len(suffix)]
break
# STEP 4: Removal of final vowel
for suffix in ("ie", "a", "e", "i", "\u0103"):
if word.endswith(suffix):
if suffix in rv:
word = word[: -len(suffix)]
break
word = word.replace("I", "i").replace("U", "u")
return word
[docs]class RussianStemmer(_LanguageSpecificStemmer):
"""
The Russian Snowball stemmer.
:cvar __perfective_gerund_suffixes: Suffixes to be deleted.
:type __perfective_gerund_suffixes: tuple
:cvar __adjectival_suffixes: Suffixes to be deleted.
:type __adjectival_suffixes: tuple
:cvar __reflexive_suffixes: Suffixes to be deleted.
:type __reflexive_suffixes: tuple
:cvar __verb_suffixes: Suffixes to be deleted.
:type __verb_suffixes: tuple
:cvar __noun_suffixes: Suffixes to be deleted.
:type __noun_suffixes: tuple
:cvar __superlative_suffixes: Suffixes to be deleted.
:type __superlative_suffixes: tuple
:cvar __derivational_suffixes: Suffixes to be deleted.
:type __derivational_suffixes: tuple
:note: A detailed description of the Russian
stemming algorithm can be found under
http://snowball.tartarus.org/algorithms/russian/stemmer.html
"""
__perfective_gerund_suffixes = (
"ivshis'",
"yvshis'",
"vshis'",
"ivshi",
"yvshi",
"vshi",
"iv",
"yv",
"v",
)
__adjectival_suffixes = (
"ui^ushchi^ui^u",
"ui^ushchi^ai^a",
"ui^ushchimi",
"ui^ushchymi",
"ui^ushchego",
"ui^ushchogo",
"ui^ushchemu",
"ui^ushchomu",
"ui^ushchikh",
"ui^ushchykh",
"ui^ushchui^u",
"ui^ushchaia",
"ui^ushchoi^u",
"ui^ushchei^u",
"i^ushchi^ui^u",
"i^ushchi^ai^a",
"ui^ushchee",
"ui^ushchie",
"ui^ushchye",
"ui^ushchoe",
"ui^ushchei`",
"ui^ushchii`",
"ui^ushchyi`",
"ui^ushchoi`",
"ui^ushchem",
"ui^ushchim",
"ui^ushchym",
"ui^ushchom",
"i^ushchimi",
"i^ushchymi",
"i^ushchego",
"i^ushchogo",
"i^ushchemu",
"i^ushchomu",
"i^ushchikh",
"i^ushchykh",
"i^ushchui^u",
"i^ushchai^a",
"i^ushchoi^u",
"i^ushchei^u",
"i^ushchee",
"i^ushchie",
"i^ushchye",
"i^ushchoe",
"i^ushchei`",
"i^ushchii`",
"i^ushchyi`",
"i^ushchoi`",
"i^ushchem",
"i^ushchim",
"i^ushchym",
"i^ushchom",
"shchi^ui^u",
"shchi^ai^a",
"ivshi^ui^u",
"ivshi^ai^a",
"yvshi^ui^u",
"yvshi^ai^a",
"shchimi",
"shchymi",
"shchego",
"shchogo",
"shchemu",
"shchomu",
"shchikh",
"shchykh",
"shchui^u",
"shchai^a",
"shchoi^u",
"shchei^u",
"ivshimi",
"ivshymi",
"ivshego",
"ivshogo",
"ivshemu",
"ivshomu",
"ivshikh",
"ivshykh",
"ivshui^u",
"ivshai^a",
"ivshoi^u",
"ivshei^u",
"yvshimi",
"yvshymi",
"yvshego",
"yvshogo",
"yvshemu",
"yvshomu",
"yvshikh",
"yvshykh",
"yvshui^u",
"yvshai^a",
"yvshoi^u",
"yvshei^u",
"vshi^ui^u",
"vshi^ai^a",
"shchee",
"shchie",
"shchye",
"shchoe",
"shchei`",
"shchii`",
"shchyi`",
"shchoi`",
"shchem",
"shchim",
"shchym",
"shchom",
"ivshee",
"ivshie",
"ivshye",
"ivshoe",
"ivshei`",
"ivshii`",
"ivshyi`",
"ivshoi`",
"ivshem",
"ivshim",
"ivshym",
"ivshom",
"yvshee",
"yvshie",
"yvshye",
"yvshoe",
"yvshei`",
"yvshii`",
"yvshyi`",
"yvshoi`",
"yvshem",
"yvshim",
"yvshym",
"yvshom",
"vshimi",
"vshymi",
"vshego",
"vshogo",
"vshemu",
"vshomu",
"vshikh",
"vshykh",
"vshui^u",
"vshai^a",
"vshoi^u",
"vshei^u",
"emi^ui^u",
"emi^ai^a",
"nni^ui^u",
"nni^ai^a",
"vshee",
"vshie",
"vshye",
"vshoe",
"vshei`",
"vshii`",
"vshyi`",
"vshoi`",
"vshem",
"vshim",
"vshym",
"vshom",
"emimi",
"emymi",
"emego",
"emogo",
"ememu",
"emomu",
"emikh",
"emykh",
"emui^u",
"emai^a",
"emoi^u",
"emei^u",
"nnimi",
"nnymi",
"nnego",
"nnogo",
"nnemu",
"nnomu",
"nnikh",
"nnykh",
"nnui^u",
"nnai^a",
"nnoi^u",
"nnei^u",
"emee",
"emie",
"emye",
"emoe",
"emei`",
"emii`",
"emyi`",
"emoi`",
"emem",
"emim",
"emym",
"emom",
"nnee",
"nnie",
"nnye",
"nnoe",
"nnei`",
"nnii`",
"nnyi`",
"nnoi`",
"nnem",
"nnim",
"nnym",
"nnom",
"i^ui^u",
"i^ai^a",
"imi",
"ymi",
"ego",
"ogo",
"emu",
"omu",
"ikh",
"ykh",
"ui^u",
"ai^a",
"oi^u",
"ei^u",
"ee",
"ie",
"ye",
"oe",
"ei`",
"ii`",
"yi`",
"oi`",
"em",
"im",
"ym",
"om",
)
__reflexive_suffixes = ("si^a", "s'")
__verb_suffixes = (
"esh'",
"ei`te",
"ui`te",
"ui^ut",
"ish'",
"ete",
"i`te",
"i^ut",
"nno",
"ila",
"yla",
"ena",
"ite",
"ili",
"yli",
"ilo",
"ylo",
"eno",
"i^at",
"uet",
"eny",
"it'",
"yt'",
"ui^u",
"la",
"na",
"li",
"em",
"lo",
"no",
"et",
"ny",
"t'",
"ei`",
"ui`",
"il",
"yl",
"im",
"ym",
"en",
"it",
"yt",
"i^u",
"i`",
"l",
"n",
)
__noun_suffixes = (
"ii^ami",
"ii^akh",
"i^ami",
"ii^am",
"i^akh",
"ami",
"iei`",
"i^am",
"iem",
"akh",
"ii^u",
"'i^u",
"ii^a",
"'i^a",
"ev",
"ov",
"ie",
"'e",
"ei",
"ii",
"ei`",
"oi`",
"ii`",
"em",
"am",
"om",
"i^u",
"i^a",
"a",
"e",
"i",
"i`",
"o",
"u",
"y",
"'",
)
__superlative_suffixes = ("ei`she", "ei`sh")
__derivational_suffixes = ("ost'", "ost")
[docs] def stem(self, word):
"""
Stem a Russian word and return the stemmed form.
:param word: The word that is stemmed.
:type word: str or unicode
:return: The stemmed form.
:rtype: unicode
"""
if word in self.stopwords:
return word
chr_exceeded = False
for i in range(len(word)):
if ord(word[i]) > 255:
chr_exceeded = True
break
if not chr_exceeded:
return word
word = self.__cyrillic_to_roman(word)
step1_success = False
adjectival_removed = False
verb_removed = False
undouble_success = False
superlative_removed = False
rv, r2 = self.__regions_russian(word)
# Step 1
for suffix in self.__perfective_gerund_suffixes:
if rv.endswith(suffix):
if suffix in ("v", "vshi", "vshis'"):
if (
rv[-len(suffix) - 3 : -len(suffix)] == "i^a"
or rv[-len(suffix) - 1 : -len(suffix)] == "a"
):
word = word[: -len(suffix)]
r2 = r2[: -len(suffix)]
rv = rv[: -len(suffix)]
step1_success = True
break
else:
word = word[: -len(suffix)]
r2 = r2[: -len(suffix)]
rv = rv[: -len(suffix)]
step1_success = True
break
if not step1_success:
for suffix in self.__reflexive_suffixes:
if rv.endswith(suffix):
word = word[: -len(suffix)]
r2 = r2[: -len(suffix)]
rv = rv[: -len(suffix)]
break
for suffix in self.__adjectival_suffixes:
if rv.endswith(suffix):
if suffix in (
"i^ushchi^ui^u",
"i^ushchi^ai^a",
"i^ushchui^u",
"i^ushchai^a",
"i^ushchoi^u",
"i^ushchei^u",
"i^ushchimi",
"i^ushchymi",
"i^ushchego",
"i^ushchogo",
"i^ushchemu",
"i^ushchomu",
"i^ushchikh",
"i^ushchykh",
"shchi^ui^u",
"shchi^ai^a",
"i^ushchee",
"i^ushchie",
"i^ushchye",
"i^ushchoe",
"i^ushchei`",
"i^ushchii`",
"i^ushchyi`",
"i^ushchoi`",
"i^ushchem",
"i^ushchim",
"i^ushchym",
"i^ushchom",
"vshi^ui^u",
"vshi^ai^a",
"shchui^u",
"shchai^a",
"shchoi^u",
"shchei^u",
"emi^ui^u",
"emi^ai^a",
"nni^ui^u",
"nni^ai^a",
"shchimi",
"shchymi",
"shchego",
"shchogo",
"shchemu",
"shchomu",
"shchikh",
"shchykh",
"vshui^u",
"vshai^a",
"vshoi^u",
"vshei^u",
"shchee",
"shchie",
"shchye",
"shchoe",
"shchei`",
"shchii`",
"shchyi`",
"shchoi`",
"shchem",
"shchim",
"shchym",
"shchom",
"vshimi",
"vshymi",
"vshego",
"vshogo",
"vshemu",
"vshomu",
"vshikh",
"vshykh",
"emui^u",
"emai^a",
"emoi^u",
"emei^u",
"nnui^u",
"nnai^a",
"nnoi^u",
"nnei^u",
"vshee",
"vshie",
"vshye",
"vshoe",
"vshei`",
"vshii`",
"vshyi`",
"vshoi`",
"vshem",
"vshim",
"vshym",
"vshom",
"emimi",
"emymi",
"emego",
"emogo",
"ememu",
"emomu",
"emikh",
"emykh",
"nnimi",
"nnymi",
"nnego",
"nnogo",
"nnemu",
"nnomu",
"nnikh",
"nnykh",
"emee",
"emie",
"emye",
"emoe",
"emei`",
"emii`",
"emyi`",
"emoi`",
"emem",
"emim",
"emym",
"emom",
"nnee",
"nnie",
"nnye",
"nnoe",
"nnei`",
"nnii`",
"nnyi`",
"nnoi`",
"nnem",
"nnim",
"nnym",
"nnom",
):
if (
rv[-len(suffix) - 3 : -len(suffix)] == "i^a"
or rv[-len(suffix) - 1 : -len(suffix)] == "a"
):
word = word[: -len(suffix)]
r2 = r2[: -len(suffix)]
rv = rv[: -len(suffix)]
adjectival_removed = True
break
else:
word = word[: -len(suffix)]
r2 = r2[: -len(suffix)]
rv = rv[: -len(suffix)]
adjectival_removed = True
break
if not adjectival_removed:
for suffix in self.__verb_suffixes:
if rv.endswith(suffix):
if suffix in (
"la",
"na",
"ete",
"i`te",
"li",
"i`",
"l",
"em",
"n",
"lo",
"no",
"et",
"i^ut",
"ny",
"t'",
"esh'",
"nno",
):
if (
rv[-len(suffix) - 3 : -len(suffix)] == "i^a"
or rv[-len(suffix) - 1 : -len(suffix)] == "a"
):
word = word[: -len(suffix)]
r2 = r2[: -len(suffix)]
rv = rv[: -len(suffix)]
verb_removed = True
break
else:
word = word[: -len(suffix)]
r2 = r2[: -len(suffix)]
rv = rv[: -len(suffix)]
verb_removed = True
break
if not adjectival_removed and not verb_removed:
for suffix in self.__noun_suffixes:
if rv.endswith(suffix):
word = word[: -len(suffix)]
r2 = r2[: -len(suffix)]
rv = rv[: -len(suffix)]
break
# Step 2
if rv.endswith("i"):
word = word[:-1]
r2 = r2[:-1]
# Step 3
for suffix in self.__derivational_suffixes:
if r2.endswith(suffix):
word = word[: -len(suffix)]
break
# Step 4
if word.endswith("nn"):
word = word[:-1]
undouble_success = True
if not undouble_success:
for suffix in self.__superlative_suffixes:
if word.endswith(suffix):
word = word[: -len(suffix)]
superlative_removed = True
break
if word.endswith("nn"):
word = word[:-1]
if not undouble_success and not superlative_removed:
if word.endswith("'"):
word = word[:-1]
word = self.__roman_to_cyrillic(word)
return word
def __regions_russian(self, word):
"""
Return the regions RV and R2 which are used by the Russian stemmer.
In any word, RV is the region after the first vowel,
or the end of the word if it contains no vowel.
R2 is the region after the first non-vowel following
a vowel in R1, or the end of the word if there is no such non-vowel.
R1 is the region after the first non-vowel following a vowel,
or the end of the word if there is no such non-vowel.
:param word: The Russian word whose regions RV and R2 are determined.
:type word: str or unicode
:return: the regions RV and R2 for the respective Russian word.
:rtype: tuple
:note: This helper method is invoked by the stem method of the subclass
RussianStemmer. It is not to be invoked directly!
"""
r1 = ""
r2 = ""
rv = ""
vowels = ("A", "U", "E", "a", "e", "i", "o", "u", "y")
word = word.replace("i^a", "A").replace("i^u", "U").replace("e`", "E")
for i in range(1, len(word)):
if word[i] not in vowels and word[i - 1] in vowels:
r1 = word[i + 1 :]
break
for i in range(1, len(r1)):
if r1[i] not in vowels and r1[i - 1] in vowels:
r2 = r1[i + 1 :]
break
for i in range(len(word)):
if word[i] in vowels:
rv = word[i + 1 :]
break
r2 = r2.replace("A", "i^a").replace("U", "i^u").replace("E", "e`")
rv = rv.replace("A", "i^a").replace("U", "i^u").replace("E", "e`")
return (rv, r2)
def __cyrillic_to_roman(self, word):
"""
Transliterate a Russian word into the Roman alphabet.
A Russian word whose letters consist of the Cyrillic
alphabet are transliterated into the Roman alphabet
in order to ease the forthcoming stemming process.
:param word: The word that is transliterated.
:type word: unicode
:return: the transliterated word.
:rtype: unicode
:note: This helper method is invoked by the stem method of the subclass
RussianStemmer. It is not to be invoked directly!
"""
word = (
word.replace("\u0410", "a")
.replace("\u0430", "a")
.replace("\u0411", "b")
.replace("\u0431", "b")
.replace("\u0412", "v")
.replace("\u0432", "v")
.replace("\u0413", "g")
.replace("\u0433", "g")
.replace("\u0414", "d")
.replace("\u0434", "d")
.replace("\u0415", "e")
.replace("\u0435", "e")
.replace("\u0401", "e")
.replace("\u0451", "e")
.replace("\u0416", "zh")
.replace("\u0436", "zh")
.replace("\u0417", "z")
.replace("\u0437", "z")
.replace("\u0418", "i")
.replace("\u0438", "i")
.replace("\u0419", "i`")
.replace("\u0439", "i`")
.replace("\u041A", "k")
.replace("\u043A", "k")
.replace("\u041B", "l")
.replace("\u043B", "l")
.replace("\u041C", "m")
.replace("\u043C", "m")
.replace("\u041D", "n")
.replace("\u043D", "n")
.replace("\u041E", "o")
.replace("\u043E", "o")
.replace("\u041F", "p")
.replace("\u043F", "p")
.replace("\u0420", "r")
.replace("\u0440", "r")
.replace("\u0421", "s")
.replace("\u0441", "s")
.replace("\u0422", "t")
.replace("\u0442", "t")
.replace("\u0423", "u")
.replace("\u0443", "u")
.replace("\u0424", "f")
.replace("\u0444", "f")
.replace("\u0425", "kh")
.replace("\u0445", "kh")
.replace("\u0426", "t^s")
.replace("\u0446", "t^s")
.replace("\u0427", "ch")
.replace("\u0447", "ch")
.replace("\u0428", "sh")
.replace("\u0448", "sh")
.replace("\u0429", "shch")
.replace("\u0449", "shch")
.replace("\u042A", "''")
.replace("\u044A", "''")
.replace("\u042B", "y")
.replace("\u044B", "y")
.replace("\u042C", "'")
.replace("\u044C", "'")
.replace("\u042D", "e`")
.replace("\u044D", "e`")
.replace("\u042E", "i^u")
.replace("\u044E", "i^u")
.replace("\u042F", "i^a")
.replace("\u044F", "i^a")
)
return word
def __roman_to_cyrillic(self, word):
"""
Transliterate a Russian word back into the Cyrillic alphabet.
A Russian word formerly transliterated into the Roman alphabet
in order to ease the stemming process, is transliterated back
into the Cyrillic alphabet, its original form.
:param word: The word that is transliterated.
:type word: str or unicode
:return: word, the transliterated word.
:rtype: unicode
:note: This helper method is invoked by the stem method of the subclass
RussianStemmer. It is not to be invoked directly!
"""
word = (
word.replace("i^u", "\u044E")
.replace("i^a", "\u044F")
.replace("shch", "\u0449")
.replace("kh", "\u0445")
.replace("t^s", "\u0446")
.replace("ch", "\u0447")
.replace("e`", "\u044D")
.replace("i`", "\u0439")
.replace("sh", "\u0448")
.replace("k", "\u043A")
.replace("e", "\u0435")
.replace("zh", "\u0436")
.replace("a", "\u0430")
.replace("b", "\u0431")
.replace("v", "\u0432")
.replace("g", "\u0433")
.replace("d", "\u0434")
.replace("e", "\u0435")
.replace("z", "\u0437")
.replace("i", "\u0438")
.replace("l", "\u043B")
.replace("m", "\u043C")
.replace("n", "\u043D")
.replace("o", "\u043E")
.replace("p", "\u043F")
.replace("r", "\u0440")
.replace("s", "\u0441")
.replace("t", "\u0442")
.replace("u", "\u0443")
.replace("f", "\u0444")
.replace("''", "\u044A")
.replace("y", "\u044B")
.replace("'", "\u044C")
)
return word
[docs]class SpanishStemmer(_StandardStemmer):
"""
The Spanish Snowball stemmer.
:cvar __vowels: The Spanish vowels.
:type __vowels: unicode
:cvar __step0_suffixes: Suffixes to be deleted in step 0 of the algorithm.
:type __step0_suffixes: tuple
:cvar __step1_suffixes: Suffixes to be deleted in step 1 of the algorithm.
:type __step1_suffixes: tuple
:cvar __step2a_suffixes: Suffixes to be deleted in step 2a of the algorithm.
:type __step2a_suffixes: tuple
:cvar __step2b_suffixes: Suffixes to be deleted in step 2b of the algorithm.
:type __step2b_suffixes: tuple
:cvar __step3_suffixes: Suffixes to be deleted in step 3 of the algorithm.
:type __step3_suffixes: tuple
:note: A detailed description of the Spanish
stemming algorithm can be found under
http://snowball.tartarus.org/algorithms/spanish/stemmer.html
"""
__vowels = "aeiou\xE1\xE9\xED\xF3\xFA\xFC"
__step0_suffixes = (
"selas",
"selos",
"sela",
"selo",
"las",
"les",
"los",
"nos",
"me",
"se",
"la",
"le",
"lo",
)
__step1_suffixes = (
"amientos",
"imientos",
"amiento",
"imiento",
"acion",
"aciones",
"uciones",
"adoras",
"adores",
"ancias",
"log\xEDas",
"encias",
"amente",
"idades",
"anzas",
"ismos",
"ables",
"ibles",
"istas",
"adora",
"aci\xF3n",
"antes",
"ancia",
"log\xEDa",
"uci\xf3n",
"encia",
"mente",
"anza",
"icos",
"icas",
"ismo",
"able",
"ible",
"ista",
"osos",
"osas",
"ador",
"ante",
"idad",
"ivas",
"ivos",
"ico",
"ica",
"oso",
"osa",
"iva",
"ivo",
)
__step2a_suffixes = (
"yeron",
"yendo",
"yamos",
"yais",
"yan",
"yen",
"yas",
"yes",
"ya",
"ye",
"yo",
"y\xF3",
)
__step2b_suffixes = (
"ar\xEDamos",
"er\xEDamos",
"ir\xEDamos",
"i\xE9ramos",
"i\xE9semos",
"ar\xEDais",
"aremos",
"er\xEDais",
"eremos",
"ir\xEDais",
"iremos",
"ierais",
"ieseis",
"asteis",
"isteis",
"\xE1bamos",
"\xE1ramos",
"\xE1semos",
"ar\xEDan",
"ar\xEDas",
"ar\xE9is",
"er\xEDan",
"er\xEDas",
"er\xE9is",
"ir\xEDan",
"ir\xEDas",
"ir\xE9is",
"ieran",
"iesen",
"ieron",
"iendo",
"ieras",
"ieses",
"abais",
"arais",
"aseis",
"\xE9amos",
"ar\xE1n",
"ar\xE1s",
"ar\xEDa",
"er\xE1n",
"er\xE1s",
"er\xEDa",
"ir\xE1n",
"ir\xE1s",
"ir\xEDa",
"iera",
"iese",
"aste",
"iste",
"aban",
"aran",
"asen",
"aron",
"ando",
"abas",
"adas",
"idas",
"aras",
"ases",
"\xEDais",
"ados",
"idos",
"amos",
"imos",
"emos",
"ar\xE1",
"ar\xE9",
"er\xE1",
"er\xE9",
"ir\xE1",
"ir\xE9",
"aba",
"ada",
"ida",
"ara",
"ase",
"\xEDan",
"ado",
"ido",
"\xEDas",
"\xE1is",
"\xE9is",
"\xEDa",
"ad",
"ed",
"id",
"an",
"i\xF3",
"ar",
"er",
"ir",
"as",
"\xEDs",
"en",
"es",
)
__step3_suffixes = ("os", "a", "e", "o", "\xE1", "\xE9", "\xED", "\xF3")
[docs] def stem(self, word):
"""
Stem a Spanish word and return the stemmed form.
:param word: The word that is stemmed.
:type word: str or unicode
:return: The stemmed form.
:rtype: unicode
"""
word = word.lower()
if word in self.stopwords:
return word
step1_success = False
r1, r2 = self._r1r2_standard(word, self.__vowels)
rv = self._rv_standard(word, self.__vowels)
# STEP 0: Attached pronoun
for suffix in self.__step0_suffixes:
if not (word.endswith(suffix) and rv.endswith(suffix)):
continue
if (
rv[: -len(suffix)].endswith(
(
"ando",
"\xE1ndo",
"ar",
"\xE1r",
"er",
"\xE9r",
"iendo",
"i\xE9ndo",
"ir",
"\xEDr",
)
)
) or (
rv[: -len(suffix)].endswith("yendo")
and word[: -len(suffix)].endswith("uyendo")
):
word = self.__replace_accented(word[: -len(suffix)])
r1 = self.__replace_accented(r1[: -len(suffix)])
r2 = self.__replace_accented(r2[: -len(suffix)])
rv = self.__replace_accented(rv[: -len(suffix)])
break
# STEP 1: Standard suffix removal
for suffix in self.__step1_suffixes:
if not word.endswith(suffix):
continue
if suffix == "amente" and r1.endswith(suffix):
step1_success = True
word = word[:-6]
r2 = r2[:-6]
rv = rv[:-6]
if r2.endswith("iv"):
word = word[:-2]
r2 = r2[:-2]
rv = rv[:-2]
if r2.endswith("at"):
word = word[:-2]
rv = rv[:-2]
elif r2.endswith(("os", "ic", "ad")):
word = word[:-2]
rv = rv[:-2]
elif r2.endswith(suffix):
step1_success = True
if suffix in (
"adora",
"ador",
"aci\xF3n",
"adoras",
"adores",
"acion",
"aciones",
"ante",
"antes",
"ancia",
"ancias",
):
word = word[: -len(suffix)]
r2 = r2[: -len(suffix)]
rv = rv[: -len(suffix)]
if r2.endswith("ic"):
word = word[:-2]
rv = rv[:-2]
elif suffix in ("log\xEDa", "log\xEDas"):
word = suffix_replace(word, suffix, "log")
rv = suffix_replace(rv, suffix, "log")
elif suffix in ("uci\xF3n", "uciones"):
word = suffix_replace(word, suffix, "u")
rv = suffix_replace(rv, suffix, "u")
elif suffix in ("encia", "encias"):
word = suffix_replace(word, suffix, "ente")
rv = suffix_replace(rv, suffix, "ente")
elif suffix == "mente":
word = word[: -len(suffix)]
r2 = r2[: -len(suffix)]
rv = rv[: -len(suffix)]
if r2.endswith(("ante", "able", "ible")):
word = word[:-4]
rv = rv[:-4]
elif suffix in ("idad", "idades"):
word = word[: -len(suffix)]
r2 = r2[: -len(suffix)]
rv = rv[: -len(suffix)]
for pre_suff in ("abil", "ic", "iv"):
if r2.endswith(pre_suff):
word = word[: -len(pre_suff)]
rv = rv[: -len(pre_suff)]
elif suffix in ("ivo", "iva", "ivos", "ivas"):
word = word[: -len(suffix)]
r2 = r2[: -len(suffix)]
rv = rv[: -len(suffix)]
if r2.endswith("at"):
word = word[:-2]
rv = rv[:-2]
else:
word = word[: -len(suffix)]
rv = rv[: -len(suffix)]
break
# STEP 2a: Verb suffixes beginning 'y'
if not step1_success:
for suffix in self.__step2a_suffixes:
if rv.endswith(suffix) and word[-len(suffix) - 1 : -len(suffix)] == "u":
word = word[: -len(suffix)]
rv = rv[: -len(suffix)]
break
# STEP 2b: Other verb suffixes
for suffix in self.__step2b_suffixes:
if rv.endswith(suffix):
word = word[: -len(suffix)]
rv = rv[: -len(suffix)]
if suffix in ("en", "es", "\xE9is", "emos"):
if word.endswith("gu"):
word = word[:-1]
if rv.endswith("gu"):
rv = rv[:-1]
break
# STEP 3: Residual suffix
for suffix in self.__step3_suffixes:
if rv.endswith(suffix):
word = word[: -len(suffix)]
if suffix in ("e", "\xE9"):
rv = rv[: -len(suffix)]
if word[-2:] == "gu" and rv.endswith("u"):
word = word[:-1]
break
word = self.__replace_accented(word)
return word
def __replace_accented(self, word):
"""
Replaces all accented letters on a word with their non-accented
counterparts.
:param word: A spanish word, with or without accents
:type word: str or unicode
:return: a word with the accented letters (á, é, í, ó, ú) replaced with
their non-accented counterparts (a, e, i, o, u)
:rtype: str or unicode
"""
return (
word.replace("\xE1", "a")
.replace("\xE9", "e")
.replace("\xED", "i")
.replace("\xF3", "o")
.replace("\xFA", "u")
)
[docs]class SwedishStemmer(_ScandinavianStemmer):
"""
The Swedish Snowball stemmer.
:cvar __vowels: The Swedish vowels.
:type __vowels: unicode
:cvar __s_ending: Letters that may directly appear before a word final 's'.
:type __s_ending: unicode
:cvar __step1_suffixes: Suffixes to be deleted in step 1 of the algorithm.
:type __step1_suffixes: tuple
:cvar __step2_suffixes: Suffixes to be deleted in step 2 of the algorithm.
:type __step2_suffixes: tuple
:cvar __step3_suffixes: Suffixes to be deleted in step 3 of the algorithm.
:type __step3_suffixes: tuple
:note: A detailed description of the Swedish
stemming algorithm can be found under
http://snowball.tartarus.org/algorithms/swedish/stemmer.html
"""
__vowels = "aeiouy\xE4\xE5\xF6"
__s_ending = "bcdfghjklmnoprtvy"
__step1_suffixes = (
"heterna",
"hetens",
"heter",
"heten",
"anden",
"arnas",
"ernas",
"ornas",
"andes",
"andet",
"arens",
"arna",
"erna",
"orna",
"ande",
"arne",
"aste",
"aren",
"ades",
"erns",
"ade",
"are",
"ern",
"ens",
"het",
"ast",
"ad",
"en",
"ar",
"er",
"or",
"as",
"es",
"at",
"a",
"e",
"s",
)
__step2_suffixes = ("dd", "gd", "nn", "dt", "gt", "kt", "tt")
__step3_suffixes = ("fullt", "l\xF6st", "els", "lig", "ig")
[docs] def stem(self, word):
"""
Stem a Swedish word and return the stemmed form.
:param word: The word that is stemmed.
:type word: str or unicode
:return: The stemmed form.
:rtype: unicode
"""
word = word.lower()
if word in self.stopwords:
return word
r1 = self._r1_scandinavian(word, self.__vowels)
# STEP 1
for suffix in self.__step1_suffixes:
if r1.endswith(suffix):
if suffix == "s":
if word[-2] in self.__s_ending:
word = word[:-1]
r1 = r1[:-1]
else:
word = word[: -len(suffix)]
r1 = r1[: -len(suffix)]
break
# STEP 2
for suffix in self.__step2_suffixes:
if r1.endswith(suffix):
word = word[:-1]
r1 = r1[:-1]
break
# STEP 3
for suffix in self.__step3_suffixes:
if r1.endswith(suffix):
if suffix in ("els", "lig", "ig"):
word = word[: -len(suffix)]
elif suffix in ("fullt", "l\xF6st"):
word = word[:-1]
break
return word
[docs]def demo():
"""
This function provides a demonstration of the Snowball stemmers.
After invoking this function and specifying a language,
it stems an excerpt of the Universal Declaration of Human Rights
(which is a part of the NLTK corpus collection) and then prints
out the original and the stemmed text.
"""
from nltk.corpus import udhr
udhr_corpus = {
"arabic": "Arabic_Alarabia-Arabic",
"danish": "Danish_Dansk-Latin1",
"dutch": "Dutch_Nederlands-Latin1",
"english": "English-Latin1",
"finnish": "Finnish_Suomi-Latin1",
"french": "French_Francais-Latin1",
"german": "German_Deutsch-Latin1",
"hungarian": "Hungarian_Magyar-UTF8",
"italian": "Italian_Italiano-Latin1",
"norwegian": "Norwegian-Latin1",
"porter": "English-Latin1",
"portuguese": "Portuguese_Portugues-Latin1",
"romanian": "Romanian_Romana-Latin2",
"russian": "Russian-UTF8",
"spanish": "Spanish-Latin1",
"swedish": "Swedish_Svenska-Latin1",
}
print("\n")
print("******************************")
print("Demo for the Snowball stemmers")
print("******************************")
while True:
language = input(
"Please enter the name of the language "
+ "to be demonstrated\n"
+ "/".join(SnowballStemmer.languages)
+ "\n"
+ "(enter 'exit' in order to leave): "
)
if language == "exit":
break
if language not in SnowballStemmer.languages:
print(
"\nOops, there is no stemmer for this language. "
+ "Please try again.\n"
)
continue
stemmer = SnowballStemmer(language)
excerpt = udhr.words(udhr_corpus[language])[:300]
stemmed = " ".join(stemmer.stem(word) for word in excerpt)
stemmed = re.sub(r"(.{,70})\s", r"\1\n", stemmed + " ").rstrip()
excerpt = " ".join(excerpt)
excerpt = re.sub(r"(.{,70})\s", r"\1\n", excerpt + " ").rstrip()
print("\n")
print("-" * 70)
print("ORIGINAL".center(70))
print(excerpt)
print("\n\n")
print("STEMMED RESULTS".center(70))
print(stemmed)
print("-" * 70)
print("\n")