lesya 0.0.1__py3-none-any.whl

lesya/__init__.py

@@ -0,0 +1,3 @@
+from .language.case_helpers import CaseUA
+from .language.case_helpers import Gender
+from .language.name_case import Lesya

lesya/language/case_helpers.py

@@ -0,0 +1,138 @@
+class Gender:
+    """
+    A class containing constants for gender determination
+    """
+    MALE = 'male'
+    FEMALE = 'female'
+    MAN = 'male'
+    WOMAN = 'female'
+
+
+class CaseUA:
+    """
+    A class containing constants for grammatical cases in Ukrainian
+    """
+    NOMINATIVE = "nominative"  # "Називний відмінок (Nominative)"  # Nominative case
+    GENITIVE = "genitive"  # "Родовий відмінок (Genitive)"  # Genitive case
+    DATIVE = "dative"  # "Давальний відмінок (Dative)"  # Dative case
+    ACCUSATIVE = "accusative"  # "Знахідний відмінок (Accusative)"  # Accusative case
+    INSTRUMENTAL = "instrumental"  # "Орудний відмінок (Instrumental)"  # Instrumental case
+    PREPOSITIONAL = "prepositional"  # "Місцевий відмінок (Prepositional)"  # Prepositional case
+    VOCATIVE = "vocative"  # "Кличний відмінок (Vocative)"  # Vocative case
+
+    @classmethod
+    def __getitem__(cls, number: int):
+        if number in range(7):
+            return {0: cls.NOMINATIVE,
+                    1: cls.GENITIVE,
+                    2: cls.DATIVE,
+                    3: cls.ACCUSATIVE,
+                    4: cls.INSTRUMENTAL,
+                    5: cls.PREPOSITIONAL,
+                    6: cls.VOCATIVE}.get(number)
+        raise TypeError("The number must be in the range from 0 to 6")
+
+    def all(self, lang='en'):
+        if lang == 'en':
+            return [self.NOMINATIVE, self.GENITIVE, self.DATIVE, self.ACCUSATIVE, self.INSTRUMENTAL, self.PREPOSITIONAL,
+                    self.VOCATIVE]
+        elif lang == 'ua':
+            return ['називний', 'родовий', 'давальний', 'знахідний', 'орудний', 'місцевий', 'кличний']
+
+    @staticmethod
+    def count():
+        return 7
+
+    @classmethod
+    def __len__(cls):
+        return cls.count()
+
+
+class NamePart:
+    FIRSTNAME = 'firstname'
+    LASTNAME = 'lastname'
+    PATRONYMIC = 'patronymic'
+
+
+class NCLNameCaseWord:
+    """
+    A class representing a word with additional properties and methods for handling name cases and gender determination.
+    """
+    def __init__(self, word):
+        self.word = word.lower()
+        self.word_orig = word
+        self.name_part = None
+        self.gender_man = 0
+        self.gender_woman = 0
+        self.gender_solved = None
+        # mask to define origin capital and string letters: X, or x
+        self.letter_mask = ''
+        # array of cases for the word
+        self.name_cases = []
+        # self.rule = 0
+        self.create_mask(word)
+
+    def create_mask(self, word):
+        """
+        Generating mask for the word
+        """
+        for letter in word:
+            if letter.isupper():
+                self.letter_mask += 'X'
+            else:
+                self.letter_mask += 'x'
+
+    def return_mask(self):
+        """ Convert the word to the capital / small letter format according to its mask
+        """
+        mask_length = len(self.letter_mask)
+        for i, case in enumerate(self.name_cases):
+            case_length = len(case)
+            max_len = min(case_length, mask_length)
+            new_case = ''
+            for j in range(max_len):
+                letter = case[j]
+                if self.letter_mask[j] == 'X':
+                    letter = letter.upper()
+                new_case += letter
+            new_case += case[max_len:case_length]
+            self.name_cases[i] = new_case
+
+    def set_name_cases(self, name_cases, is_return_mask=True):
+        self.name_cases = name_cases
+        if is_return_mask:
+            self.return_mask()
+
+    def get_name_cases(self):
+        return self.name_cases
+
+    def gender(self):
+        if not self.gender_solved:
+            if self.gender_man >= self.gender_woman:
+                self.gender_solved = Gender.MALE
+            else:
+                self.gender_solved = Gender.FEMALE
+        return self.gender_solved
+
+    def set_gender(self, man, woman):
+        self.gender_man = man
+        self.gender_woman = woman
+
+    def set_true_gender(self, gender):
+        self.gender_solved = gender
+
+    def get_gender(self):
+        return {Gender.MALE: self.gender_man, Gender.FEMALE: self.gender_woman}
+
+    def is_gender_solved(self):
+        return bool(self.gender_solved)
+
+    def __repr__(self):
+        return f'{self.word_orig} - {self.name_cases}'
+
+    def __eq__(self, other):
+        if isinstance(other, str):
+            return self.word_orig == other
+        elif isinstance(other, NCLNameCaseWord):
+            return self.word_orig == other.word_orig
+        return False

lesya/language/name_case.py

@@ -0,0 +1,409 @@
+from lesya.language.nc_core import NameCaseCore, NamePart
+from lesya.language.name_constants import NAMES, FEMALE_NAMES, LASTNAME_ENDINGS2, LASTNAME_ENDINGS3
+from lesya.language.case_helpers import CaseUA
+
+NAMES_LIST = {n.lower() for n in NAMES + FEMALE_NAMES}
+NAMES = {n.lower() for n in NAMES}
+FEMALE_NAMES = {n.lower() for n in FEMALE_NAMES}
+
+
+class NameCaseUa(NameCaseCore):
+    def __init__(self):
+        super().__init__()
+        self.vowels = 'аеиоуіїєюя'
+        self.consonant = "бвгджзйклмнпрстфхцчшщ"
+        self.shyplyachi = "жчшщ"
+        self.neshyplyachi = "бвгдзклмнпрстфхц"
+        self.myaki = 'ьюяєї'
+        self.gubni = 'мвпбф'
+
+    @property
+    def forms(self):
+        if self.finished:
+            all_forms = dict()
+            for i, case in enumerate(self.cases):
+                all_forms[case] = ' '.join([w.name_cases[i] for w in self.words])
+            return all_forms
+        return None
+
+    def get_firstname(self):
+        words = [w for w in self.words if w.name_part == NamePart.FIRSTNAME]
+        return words[0].word_orig if words else None
+
+    def get_lastname(self):
+        words = [w for w in self.words if w.name_part == NamePart.LASTNAME]
+        return words[0].word_orig if words else None
+
+    def get_patronym(self):
+        words = [w for w in self.words if w.name_part == NamePart.PATRONYMIC]
+        return words[0].word_orig if words else None
+
+    @staticmethod
+    def inverse_gkh(letter):
+        return {'г': 'з', 'к': 'ц', 'х': 'с'}.get(letter, letter)
+
+    @staticmethod
+    def inverse_gk2(letter):
+        return {'к': 'ч', 'г': 'ж'}.get(letter, letter)
+
+    @staticmethod
+    def is_apostrof(char):
+        return char in "'`’\""
+
+    @staticmethod
+    def first_last_vowel(word, vowels):
+        for char in word[::-1]:
+            if char in vowels:
+                return char
+        return None
+
+    def get_base_word(self, word):
+        base_word = word.lower()
+        while base_word[-1] in self.vowels + 'ь':
+            base_word = base_word[:-1]
+        return base_word.lower()
+
+    def male_rule1(self):
+        last2 = self.working_word[-2]
+        if self.working_word[-1] == 'а':
+            self.word_forms(self.working_word,
+                            [last2 + 'и', self.inverse_gkh(last2) + 'і', last2 + 'у', last2 + 'ою',
+                             self.inverse_gkh(last2) + 'і', last2 + 'о'], 2)
+            return True
+        elif self.working_word[-1] == 'я':
+            if last2 == 'і':
+                self.word_forms(self.working_word, ['ї', 'ї', 'ю', 'єю', 'ї', 'є'], 1)
+                return True
+            else:
+                self.word_forms(self.working_word,
+                                [last2 + 'і', self.inverse_gkh(last2) + 'і', last2 + 'ю',
+                                 last2 + 'ею', self.inverse_gkh(last2) + 'і',
+                                 last2 + 'е'], 2)
+                return True
+        return False
+
+    def male_rule2(self):
+        if self.working_word[-1] == 'р':
+            base_word = self.working_word
+            if self.working_word in ('Ігор', 'Лазар') or self.working_word.lower().endswith('якір'):
+                endings = ['я', 'еві', 'я', 'ем', 'еві', 'е']
+                if base_word[-2] == 'і':
+                    base_word = base_word[:-2] + 'о' + base_word[-1]
+            else:
+                # це має працювати на іменах (Федір -Федора, Сидір-Сидора)
+                # а не на прізвищах (Кушнір -Кушніра)
+                if base_word[-2] == 'і':
+                    word = [w for w in self.words if w == self.working_word]
+                    if word[0].name_part == NamePart.FIRSTNAME:
+                        base_word = base_word[:-2] + 'о' + base_word[-1]
+                endings = ['а', 'у', 'а', 'ом', 'ові', 'е']
+            self.word_forms(base_word, endings)
+            return True
+        return False
+
+    def male_rule3(self):
+        last2 = self.working_word[-2]
+        if self.working_word[-1] in self.consonant + 'оь':
+            group = self.detect_second_group(self.working_word)
+            base_word = self.get_base_word(self.working_word)
+            last = base_word[-1]
+            if (last not in 'йм' and base_word[-2] == 'і'
+                    and not base_word.lower() in ('світ', 'цвіт')
+                    and self.working_word not in ('Гліб', 'Леонід')
+                    and not self.working_word[-2:] in ('ік', 'іч')):
+                if self.working_word[-4:] in ('бідь', 'мінь'):
+                    # заміна на -е-
+                    base_word = base_word[:-2] + 'е' + base_word[-1]
+                elif self.working_word[-4:] in ('сіль'):
+                    # не змінюється
+                    pass
+                else:
+                    # заміна на -о-
+                    base_word = base_word[:-2] + 'о' + base_word[-1]
+
+            if (base_word[0] in ('о', 'О') and self.first_last_vowel(base_word, self.vowels + 'гк') == 'е'
+                    and not self.working_word[-2:] in ('сь', 'ць', 'нь', 'ть', 'дь', 'ль', 'рь')):
+                delim = base_word.rfind('е')
+                base_word = base_word[:delim] + base_word[delim + 1:]
+            if group == 1:
+                if self.working_word[-2:] == 'ок' and self.working_word[-3:] != 'оок':
+                    self.word_forms(self.working_word, ['ка', 'кові', 'ка', 'ком', 'кові', 'че'], 2)
+                    return True
+                elif self.working_word[-2:] in ('ов', 'ев', 'єв') and not self.working_word in ('Лев', 'Остромов'):
+                    self.word_forms(base_word, [last + 'а', last + 'у', last + 'а', last + 'им', last + 'у',
+                                                self.inverse_gk2(last) + 'е'], 1)
+                    return True
+                elif self.working_word[-2:] == 'ін':
+                    self.word_forms(self.working_word, ['а', 'у', 'а', 'ом', 'у', 'е'])
+                    return True
+                else:
+                    if self.working_word.lower() == 'пес':
+                        base_word = 'пс'
+                    if self.working_word[-3:] in ('ких', 'гих', 'чих', 'дих'):
+                        return False
+                    self.word_forms(base_word, [last + 'а', last + 'у', last + 'а', last + 'ом', last + 'ові',
+                                                self.inverse_gk2(last) + 'е'], 1)
+                    return True
+            if group == 2:
+                self.word_forms(base_word, ['а', 'у', 'а', 'ем', 'еві', 'е'])
+                return True
+            if group == 3:
+                if self.working_word[-2:] == 'ей' and self.working_word[-3] in self.gubni:
+                    base_word = self.working_word[:-2] + '’'
+                    self.word_forms(base_word, ['я', 'єві', 'я', 'єм', 'єві', 'ю'])
+                    return True
+                elif self.working_word[-1] == 'й' or last2 == 'і':
+                    if self.working_word[-3:] == 'ній':
+                        self.word_forms(self.working_word, ['ього', 'ьому', 'ього', 'ім', 'ьому', 'ій'], 2)
+                    else:
+                        self.word_forms(self.working_word, ['я', 'єві', 'я', 'єм', 'єві', 'ю'], 1)
+                    return True
+                elif self.working_word[-3:] == 'ець':
+                    base_word = self.get_exclusions(base_word)
+                    self.word_forms(base_word, ['ця', 'цеві', 'ця', 'цем', 'цеві', 'цю'], 2)
+                    return True
+                elif self.working_word[-3:] in ('єць', 'яць'):
+                    self.word_forms(self.working_word, ['йця', 'йцеві', 'йця', 'йцем', 'йцеві', 'йцю'], 3)
+                    return True
+                else:
+                    if self.working_word[-4:] in ('вель', 'вень', 'день'):
+                        base_word = self.working_word[:-3] + base_word[-1]
+                    self.word_forms(base_word, ['я', 'еві', 'я', 'ем', 'еві', 'ю'])
+                    return True
+        return False
+
+    def male_rule4(self):
+        if self.working_word[-1] == 'і':
+            self.word_forms(self.working_word, ['их', 'им', 'их', 'ими', 'их', 'і'], 1)
+            return True
+        return False
+
+    def male_rule5(self):
+        if self.working_word[-2:] in ['ий', 'ой']:
+            self.word_forms(self.working_word, ['ого', 'ому', 'ого', 'им', 'ому', 'ий'], 2)
+            return True
+        return False
+
+    def noun_is_not_declined(self):
+        """ exclusions for words that are not declined """
+        if self.working_word[-1] in self.vowels and self.working_word[-2] in self.vowels:
+            return True
+        if self.working_word[-2:] in ('ьє', 'ні', 'лі', 'рі', 'ьї', 'те', 'се', 'же', 'хе',):
+            return True
+        if self.working_word.lower() in ('педро', 'дюма', 'дідро', ):
+            return True
+        return False
+
+    def get_exclusions(self, base_word):
+        if base_word[-3] in self.gubni + "н" and sum([1 for ch in base_word if ch in self.vowels]) > 1:
+            # Кравець, правдивець, але не Швець
+            return base_word[:-2] + 'ц*'
+        if base_word[-3:] == 'лец' and sum([1 for ch in base_word if ch in self.vowels]) > 1:
+            # Слепець, але не Лець
+            return base_word[:-3] + 'льц*'
+        return self.working_word
+
+    def female_rule1(self):
+        last2 = self.working_word[-2]
+        if self.working_word[-1] == 'а':
+            self.word_forms(self.working_word,
+                            [last2 + 'и', self.inverse_gkh(last2) + 'і', last2 + 'у', last2 + 'ою',
+                             self.inverse_gkh(last2) + 'і', last2 + 'о'], 2)
+            return True
+        elif self.working_word[-2:] == 'яя':
+            self.word_forms(self.working_word, ['ьої', 'ій', 'ю', 'ьою', 'ій', 'яя'], 2)
+            return True
+        elif self.working_word[-1] == 'я':
+            if last2 in self.vowels or self.is_apostrof(last2):
+                self.word_forms(self.working_word, ['ї', 'ї', 'ю', 'єю', 'ї', 'є'], 1)
+                return True
+            else:
+                self.word_forms(self.working_word,
+                                [last2 + 'і', self.inverse_gkh(last2) + 'і', last2 + 'ю',
+                                 last2 + 'ею', self.inverse_gkh(last2) + 'і',
+                                 last2 + 'е'], 2)
+                return True
+        return False
+
+    def female_rule2(self):
+        if self.working_word[-1] in self.consonant + 'ь':
+            base_word = self.get_base_word(self.working_word)
+            apostrof = ''
+            duplicate = ''
+            last = base_word[-1]
+            last2 = base_word[-2]
+            if last in self.gubni and last2 in self.vowels:
+                apostrof = '’'
+            if last in 'дтзсцлн':
+                duplicate = last
+            if self.working_word[-1] == 'ь':
+                self.word_forms(base_word, ['і', 'і', 'ь', duplicate + apostrof + 'ю', 'і', 'е'])
+                return True
+            else:
+                self.word_forms(base_word, ['і', 'і', '', duplicate + apostrof + 'ю', 'і', 'е'])
+                return True
+        return False
+
+    def female_rule3(self):
+        last2 = self.working_word[-2]
+        if self.working_word[-2:] == 'ая':
+            self.word_forms(self.working_word, ['ої', 'ій', 'ую', 'ою', 'ій', 'ая'], 2)
+            return
+        if self.working_word[-1] == 'а' and (self.working_word[-2] in 'чнв' or self.working_word[-3:-1] in ['ьк']):
+            self.word_forms(self.working_word,
+                            [last2 + 'ої', last2 + 'ій', last2 + 'у', last2 + 'ою',
+                             last2 + 'ій', last2 + 'о'], 2)
+            return True
+        return False
+
+    def detect_second_group(self, word):
+        base_word = word
+        stack = []
+        while base_word[-1] in self.vowels + 'ь':
+            stack.append(base_word[-1])
+            base_word = base_word[0: -1]
+        last = 'Z'
+        if stack:
+            last = stack[- 1]
+        base_word_end = base_word[-1]
+        if base_word_end in self.neshyplyachi and last not in self.myaki:
+            return 1
+        elif base_word_end in self.shyplyachi and last not in self.myaki:
+            return 2
+        else:
+            return 3
+
+    def male_first_name(self):
+        if self.noun_is_not_declined():
+            return False
+        return self.rules_chain('male', [1, 2, 3])
+
+    def female_first_name(self):
+        return self.rules_chain('female', [1, 2])
+
+    def male_second_name(self):
+        if self.noun_is_not_declined():
+            return False
+        return self.rules_chain('male', [5, 1, 2, 3, 4])
+
+    def female_second_name(self):
+        return self.rules_chain('female', [3, 1])
+
+    def male_father_name(self):
+        if self.working_word[-2:] in ['ич', 'іч']:
+            self.word_forms(self.working_word, ['а', 'у', 'а', 'ем', 'у', 'у'])
+            return True
+        return False
+
+    def female_father_name(self):
+        if self.working_word[-3:] == 'вна':
+            self.word_forms(self.working_word, ['и', 'і', 'у', 'ою', 'і', 'о'], 1)
+            return True
+        return False
+
+    def gender_by_first_name(self, word):
+        self.working_word = word.word
+        man = 0
+        woman = 0
+        if self.working_word[-1] == 'й':
+            man += 0.9
+        if self.working_word in NAMES:
+            man += 30
+        if self.working_word in FEMALE_NAMES:
+            woman += 30
+        if self.working_word[-2:] in {'ро', 'яр', 'ус', 'ис', 'ст', 'ив', 'им', 'ам', 'іт', 'ід', 'ат', 'іб', 'нн',
+                                      'ап', 'ік', 'ів', 'ас', 'ир', 'ил', 'ет', 'ип', 'ик', 'ол', 'лк', 'ім', 'єр',
+                                      'ок', 'ур', 'їл', 'ох', 'сл', 'ад', 'др', 'ор', 'ар', 'ав', 'сь', 'ій', 'ло',
+                                      'ко', 'ен', 'ин', 'юб', 'ін', 'ид', 'од', 'ем', 'ум', 'рт', 'ян', 'ег', 'он'}:
+            man += 0.5
+        if self.working_word[-3:] in {"'я", 'ая', 'га', 'да', 'дь', 'ер', 'ея', 'за', 'ит', 'иф', 'йя', 'на', 'па',
+                                      'ря', 'ся', 'тя', 'фа', 'ха', 'ша', 'ія'}:
+            woman += 0.5
+        if self.working_word[-1] in self.consonant:
+            man += 0.01
+        if self.working_word[-1] == 'ь':
+            man += 0.02
+
+        word.set_gender(man, woman)
+
+    def gender_by_patronym(self, word):
+        self.working_word = word.word
+        if self.working_word[-2:] in ('ич', 'іч'):
+            word.set_gender(10, 0)
+        if self.working_word[-2:] == 'на':
+            word.set_gender(0, 12)
+
+    def detect_name_part(self, word):
+        name_part = word.word
+        self.working_word = name_part
+
+        first = 0
+        second = 0
+        father = 0
+
+        if self.working_word[-3:] in ('вна', 'чна', 'ліч') or self.working_word[-4:] in ('ьмич', 'ович', 'огли'):
+            father += 3
+        if (self.working_word[-3:] == 'тин'
+                or self.working_word[-4:] in ('ьмич', 'юбов', 'івна', 'явка', 'орив', 'кіян')):
+            first += 0.5
+        if name_part in NAMES_LIST:
+            first += 10
+        if self.working_word[-2:] in LASTNAME_ENDINGS2:
+            second += 0.4
+        if self.working_word[-3:] in LASTNAME_ENDINGS3:
+            second += 0.4
+
+        max_val = max(first, second, father)
+        if first == max_val:
+            word.name_part = NamePart.FIRSTNAME
+        elif second == max_val:
+            word.name_part = NamePart.LASTNAME
+        else:
+            word.name_part = NamePart.PATRONYMIC
+
+
+class Lesya:
+    def __init__(self, name, gender=None):
+        self._core = NameCaseUa()
+        self._core.q(name, gender=gender)
+        self.forms = self._core.forms
+
+    @property
+    def nominative(self):
+        return self._core[CaseUA.NOMINATIVE]
+
+    @property
+    def genitive(self):
+        return self._core[CaseUA.GENITIVE]
+
+    @property
+    def dative(self):
+        return self._core[CaseUA.DATIVE]
+
+    @property
+    def accusative(self):
+        return self._core[CaseUA.ACCUSATIVE]
+
+    @property
+    def instrumental(self):
+        return self._core[CaseUA.INSTRUMENTAL]
+
+    @property
+    def prepositional(self):
+        return self._core[CaseUA.PREPOSITIONAL]
+
+    @property
+    def vocative(self):
+        return self._core[CaseUA.VOCATIVE]
+    
+    def __getitem__(self, item):
+        if not self._core.finished:
+            return None
+        if isinstance(item, int) and item in range(self._core.case_count):
+            return self._core.forms[self._core.cases[item]]
+        if isinstance(item, str):
+            if item in self._core.cases:
+                return self._core.forms[item]
+            if item in CaseUA().all():
+                index = CaseUA().all().index(item)
+                return self[index]

lesya/language/name_constants.py

@@ -0,0 +1,131 @@
+NAMES = (
+'Євген', 'Євгеній', 'Євлампій', 'Євстафій', 'Єгор', 'Єремій', 'Іван', 'Ігор', 'Ізяслав', 'Іларіон', 'Ілля', 'Іоанн',
+'Адам', 'Адріан', 'Адріян', 'Азар', 'Азарій', 'Алевтин', 'Альберт', 'Амвросій', 'Анастас', 'Анастасій', 'Анатолій',
+'Андрон', 'Андрій', 'Антон', 'Антоній', 'Анісій', 'Аркадій', 'Арсен', 'Арсеній', 'Артем', 'Артур', 'Архип', 'Атанас',
+'Афанасій', 'Благовіст', 'Благодар', 'Богдан', 'Богуслав', 'Божемир', 'Божен', 'Болеслав', 'Боримир', 'Боримисл',
+'Борис', 'Борислав', 'Боронислав', 'Братислав', 'Братослав', 'Бронислав', 'Будимир', 'Будислав', 'Буйтур', 'Буревій',
+'Буревіст', "В'ячеслав", 'Вадим', 'Вакула', 'Валентин', 'Валерій', 'Варфоломій', 'Василь', 'Велемир', 'Велемудр',
+'Велет', 'Веремій', 'Вернислав', 'Вишеслав', 'Влад', 'Владислав', 'Власт', 'Вогнедар', 'Вогнян', 'Волелюб', 'Володар',
+'Володимир', 'Володислав', 'Воротислав', 'Воїслав', 'Вратислав', 'Всевлад', 'Всеволод', 'Всеслав', 'Вукол', 'Віктор',
+'Вір', 'Вірослав', 'Віталій', 'Вітан', 'Вітомир', 'Гаврило', 'Геннадій', 'Георгій', 'Герасим', 'Гліб', 'Гнат',
+'Годомир', 'Гордислав', 'Гордомисл', 'Гордослав', 'Гордій', 'Горимир', 'Горимисл', 'Горисвіт', 'Горислав', 'Градимир',
+'Градислав', 'Гранислав', 'Григорій', 'Давид', 'Далемил', 'Далемир', 'Данило', 'Данко', 'Даромир', 'Дарій', "Дем'ян",
+'Демид', 'Денис', 'Дмитро', 'Добрик', 'Добриня', 'Добромир', 'Добромисл', 'Доморад', 'Домослав', 'Домінік', 'Дорогомир',
+'Дорогомисл', 'Дорофій', 'Драган', 'Драгомир', 'Жадан', 'Ждан', 'Живослав', 'Захар', 'Захарій', 'Зборислав', 'Звенигор',
+'Звенимир', 'Зиновій', 'Злат', 'Златан', 'Златомир', 'Златоус', 'Зореслав', 'Зорян', 'Зіновій', 'Кий', 'Кирило', 'Киян',
+'Корнелій', 'Корнило', 'Корнилій', 'Корній', 'Костянтин', 'Кузьма', 'Курило', 'Кіндрат', 'Лаврентій', 'Лаврін',
+'Ладимир', 'Ладислав', 'Ладолюб', 'Ладомир', 'Лев', 'Левко', 'Леонід', "Лук'ян", 'Лука', 'Любим', 'Любовир', 'Любодар',
+'Любозар', 'Любомил', 'Любомир', 'Любомисл', 'Любослав', 'Людислав', 'Людомил', 'Лютобор', 'Лютомисл', 'Маврикій',
+'Магадар', 'Магамир', 'Магаслав', 'Май', 'Макар', 'Максим', "Мар'ян", 'Марко', 'Маркіян', 'Мартин', 'Матвій', 'Медомир',
+'Межамир', 'Мечислав', 'Микита', 'Микола', 'Милан', 'Милован', 'Милодар', 'Милослав', 'Мир', 'Миролюб', 'Мирон',
+'Мирослав', 'Михайло', 'Мстислав', 'Мудролюб', 'Мусій', 'Надій', 'Назарій', 'Наслав', 'Нестор', 'Никифор', 'Никодим',
+'Ничипор', 'Ничипір', 'Нікіта', 'Олег', 'Олекса', 'Олександр', 'Олексій', 'Олесь', 'Омелян', 'Ондрій', 'Онтін',
+'Онуфрій', 'Онісій', 'Опанас', 'Орест', 'Орхип', 'Остап', 'Остромир', 'Остромисл', 'Остромов', 'Охрім', "П'єр", 'Павло',
+'Панас', 'Пантелеймон', 'Перелюб', 'Перемил', 'Перемисл', 'Пересвіт', 'Переяслав', 'Першик', 'Петро', 'Пилип', 'Пимен',
+'Пимон', 'Пимін', 'Порфир', 'Потап', 'Рава', 'Рад', 'Радан', 'Радимир', 'Радован', 'Радомир', 'Радомисл', 'Радослав',
+'Ратибор', 'Ратимир', 'Рафаїл', 'Родослав', 'Родіон', 'Роксолан', 'Роман', 'Ростислав', 'Русан', 'Руслан', 'Сармат',
+'Свирид', 'Святовид', 'Святогор', 'Святолюб', 'Святополк', 'Святослав', 'Святояр', 'Світлан', 'Світлогор', 'Світогор',
+'Світодар', 'Світозар', 'Світолюб', 'Світослав', 'Світояр', 'Северин', 'Семен', 'Серафим', 'Сергій', 'Сидор', 'Сидір',
+'Силослав', 'Синьоок', 'Слава', 'Славомир', 'Сновид', 'Снозір', 'Сніжан', 'Спас', 'Станимир', 'Станислав', 'Стародум',
+'Степан', 'Стефаній', 'Стожар', 'Судислав', 'Тарас', 'Тарослав', 'Твердислав', 'Творислав', 'Теодозій', 'Терентій',
+'Тимофій', 'Тимур', 'Тихомир', 'Тихон', 'Толислав', 'Тригост', 'Тімох', 'Улас', 'Уличан', 'Устим', 'Фауст', 'Федор',
+'Федір', 'Флор', 'Фрол', 'Хвалимир', 'Ходота', 'Хорив', 'Хотимир', 'Христофор', 'Чара', 'Чеслав', 'Честислав', 'Щек',
+'Юліан', 'Юлій', 'Юрій', 'Юхим', 'Яволод', 'Явір', 'Яків', 'Ян', 'Яр', 'Ярема', 'Ярило', 'Яромисл', 'Ярополк',
+'Яросвіт', 'Ярослав', 'Ясновид', 'Ясногор', 'Яснозір', 'Яснолик')
+
+FEMALE_NAMES = (
+'Єва', 'Євгенія', 'Євдокія', 'Євфросинія', 'Єкатерина', 'Єлизавета', 'Єпистима', 'Єпистимія', 'Єфросинія', 'Іванна',
+'Ігорина', 'Іларія', 'Ілона', 'Інга', 'Інеса', 'Інна', 'Ірина', 'Ірма', 'Ісидора', 'Ія', 'Ївга', 'Августа', 'Аврелія',
+'Аврора', 'Агапія', 'Агата', 'Агафоника', 'Агафія', 'Аглая', 'Аглаїда', 'Агнеса', 'Агнія', 'Агрипина', 'Ада',
+'Аделаїда', 'Аделіна', 'Адріана', 'Аеліта', 'Аза', 'Азалія', 'Акилина', 'Аксенія', 'Алевтина', 'Алла', 'Альбертина',
+'Альбертіна', 'Альбіна', 'Альвіна', 'Альфреда', 'Аліна', 'Аліса', 'Анастасія', 'Анатолія', 'Ангеліна', 'Анжела',
+'Анжеліка', 'Анна', 'Антонида', 'Антоніна', 'Антонія', 'Анфіса', 'Аполлонія', 'Аполлінарія', 'Аркадія', 'Арсена',
+'Арсенія', 'Артеміза', 'Артемізія', 'Артемісія', 'Артемія', 'Аріадна', 'Аскліпія', 'Ася', 'Атена', 'Аурика', 'Афанасія',
+'Афродіта', 'Афіна', 'Аїда', 'Бажана', 'Барбара', 'Беатриса', 'Белла', 'Берта', 'Богдана', 'Богуслава', 'Божена',
+'Болеслава', 'Борислава', "В'ячеслава", 'Валентина', 'Валерія', 'Ванда', 'Варвара', 'Василина', 'Васса', 'Векла',
+'Венера', 'Вероніка', 'Влада', 'Владислава', 'Владлена', 'Власта', 'Володимира', 'Всеслава', 'Вікторина', 'Вікторія',
+'Вілена', 'Віленіна', 'Віліна', 'Віола', 'Віолетта', 'Віра', 'Віргінія', 'Віринея', 'Віта', 'Віталіна', 'Віталія',
+'Галина', 'Ганна', 'Гафія', 'Гаїна', 'Гелена', 'Георгіна', 'Гертруда', 'Глафира', 'Глафіра', 'Гликерія', 'Горпина',
+'Густава', 'Дана', 'Дарина', 'Дарія', 'Дзвенислава', 'Дзвінка', 'Домаха', 'Домна', 'Домініка', 'Донна', 'Доротея',
+'Дорофея', 'Діана', 'Діна', 'Евеліна', 'Едіта', 'Елвіна', 'Елеонора', 'Елла', 'Ельвіра', 'Емма', 'Еммануель',
+'Еммануїла', 'Емілія', 'Еріка', 'Есмеральда', 'Естер', 'Есфір', 'Жадана', 'Жанна', 'Ждана', 'Жозефіна', 'Звенислава',
+'Звонимира', 'Земфіра', 'Злата', 'Зореслава', 'Зоря', 'Зоряна', 'Зоя', 'Зінаїда', 'Зірка', 'Йосипа', 'Йосифата',
+'Казимира', 'Калина', 'Камілла', 'Капитолина', 'Капитоліна', 'Капітоліна', 'Карина', 'Кароліна', 'Кассандра',
+'Катерина', 'Катря', 'Квітка', 'Кикилія', 'Килина', 'Клавдія', 'Клара', 'Клеопатра', 'Констанція', 'Кора', 'Корина',
+'Корнелія', 'Ксенія', 'Кіра', 'Лада', 'Лариса', 'Леля', 'Леся', 'Либідь', 'Ликера', 'Ликерія', 'Лисавета', 'Лола',
+'Лоліта', 'Лукина', 'Лукреція', 'Лукія', 'Любов', 'Любомира', 'Людмила', 'Лідія', 'Лілея', 'Лілія', 'Ліна', 'Мавка',
+'Магда', 'Магдалена', 'Магдалина', 'Майя', 'Макрина', 'Малуша', 'Мальва', 'Мальвіна', "Мар'я", "Мар'яна", 'Маргарита',
+'Марина', 'Марта', 'Мартина', 'Мартіна', 'Марфа', 'Маріамна', 'Маріанна', 'Марічка', 'Марія', 'Матрона', 'Меланія',
+'Мелітина', 'Мечислава', 'Милана', 'Мирослава', 'Михайлина', 'Млада', 'Мокрина', 'Моніка', 'Мотрона', 'Мотря',
+'Мстислава', 'Надія', 'Найда', 'Найдена', 'Настасія', 'Настя', 'Наталка', 'Наталя', 'Наталія', 'Неля', 'Нонна', 'Ніка',
+'Ніна', 'Нінель', 'Одарина', 'Одарка', 'Оксана', 'Оксенія', 'Октавія', 'Олександра', 'Олена', 'Олеся', 'Ольга',
+'Олівія', 'Олімпіада', 'Олімпія', 'Ореста', 'Орина', 'Орися', 'Осипа', 'Пава', 'Павла', 'Павлина', 'Палагна', 'Палазга',
+'Параскева', 'Параскевія', 'Парасковія', 'Пелагея', 'Пелагія', 'Пистина', 'Поліна', 'Пріська', 'Пульхера', 'Пульхерія',
+'Рада', 'Радимира', 'Радмила', 'Радогоста', 'Радомира', 'Радослава', 'Ракель', 'Рахель', 'Рахіль', 'Раїна', 'Раїса',
+'Ребекка', 'Ревека', 'Регіна', 'Рената', 'Римма', 'Рогволода', 'Рогнеда', 'Рогніда', 'Родослава', 'Рожана', 'Роза',
+'Розалія', 'Роксана', 'Роксолана', 'Романа', 'Романна', 'Романія', 'Ростислава', 'Рошель', 'Рузалія', 'Руслана',
+'Русудан', 'Русудана', 'Рут', 'Руф', 'Руфина', 'Руфіна', 'Ріана', 'Ріанна', 'Сабріна', 'Санта', 'Сара', 'Сарра',
+'Святогора', 'Святослава', 'Світлана', 'Світозара', 'Світояра', 'Севастіана', 'Северина', 'Секлета', 'Секлетина',
+'Серафима', 'Синезора', 'Слава', 'Сніжана', 'Соломія', 'Соня', 'Сосанна', 'Софія', 'Станіслава', 'Стелла', 'Стефанида',
+'Стефанія', 'Судислава', 'Сусанна', 'Сюзанна', 'Сільвія', 'Сімона', 'Тава', 'Тамара', 'Таїса', 'Таїсія', 'Текля',
+'Теодозія', 'Тереза', 'Тетяна', 'Тодора', 'Трояна', 'Тіна', 'Уляна', 'Фаїна', 'Февронія', 'Февросія', 'Федора',
+'Федосія', 'Фекла', 'Фелікса', 'Феліція', 'Феодора', 'Феодосія', 'Филікитата', 'Филіцата', 'Филіцитата', 'Фота',
+'Фотина', 'Фотинія', 'Харита', 'Харитина', 'Харитя', 'Хотина', 'Хриса', 'Христина', 'Христя', 'Хівря', 'Цветана',
+'Цвітана', 'Цецилія', 'Цецілія', 'Чеслава', 'Чухрія', 'Югина', 'Юдит', 'Юдита', 'Юдиф', 'Юзефа', 'Юлина', 'Юліана',
+'Юліанна', 'Юліанія', 'Юлія', 'Юнія', 'Юстина', 'Юхимина', 'Юхимія', 'Явдоха', 'Ядвіга', 'Яна', 'Яніна', 'Ярина',
+'Яромира', 'Ярослава')
+
+FOREIGN_NAMES = (
+'Ігнас', 'Ігнатій', 'Іда', 'Іден', 'Ідріс', 'Ізабел', 'Ізідор', 'Ілай', 'Іммануїл', 'Імоджен', 'Інез', 'Інесса',
+'Ірвін', 'Ірена', 'Ісаак', 'Істер', 'Ісідора', 'Ієн', 'Айвес', 'Айвор', 'Айда', 'Айзек', 'Айк', 'Айлін', 'Айра',
+'Айрін', 'Айріс', 'Айседора', 'Аптон', 'Аян', 'Бейлі', 'Бентлі', 'Бет', 'Боб', 'Біл', 'Валентайн', 'Валері', 'Ванесса',
+'Вебб', 'Вейн', 'Венда', 'Венді', 'Вера', 'Верджил', 'Вериті', 'Водделл', 'Вокер', 'Воллі', 'Волт', 'Волтер', 'Вудро',
+'Вуді', "Вів'єн", 'Вілберт', 'Вілла', 'Віллі', 'Вілфред', 'Вілфрід', 'Вільгельміна', 'Вільям', 'Вінн', 'Вінні',
+'Вінстон', 'Вінфред', 'Вінфрід', 'Вінцент', 'Вініфред', 'Вірджил', 'Вірджинія', 'Віт', 'Вітні', "Г'ю", "Г'юберт",
+"Г'юм", "Г'юґо", 'Гайрем', 'Ганнібал', 'Гарві', 'Гарді', 'Гарольд', 'Гаррі', 'Гаррієт', 'Гектор', 'Генк', 'Генрі',
+'Генрієтта', 'Герберт', 'Герміона', 'Гетті', 'Говард', 'Голлі', 'Голі', 'Гомер', 'Горацій', 'Гораціо', 'Гоуп', 'Гуго',
+'Гумберт', 'Гілларі', 'Гільда', 'Джайлс', 'Джаклін', 'Джасмін', 'Джаспер', 'Джастін', 'Джейд', 'Джейкоб', 'Джеймс',
+'Джейн', 'Джейсон', 'Джек', 'Джеклін', 'Дженніфер', 'Дженіс', 'Джералд', 'Джерард', 'Джервас', 'Джеремі', 'Джером',
+'Джессі', 'Джессіка', 'Джеффрі', 'Джилл', 'Джим', 'Джин', 'Джинджер', 'Джинна', 'Джинні', 'Джо', 'Джоаким', 'Джоан',
+'Джоб', 'Джоді', 'Джоел', 'Джозеф', 'Джозефіна', 'Джой', 'Джойс', 'Джолін', 'Джон', 'Джонас', 'Джонатан', 'Джордан',
+'Джордж', 'Джорджія', 'Джоселін', 'Джудіт', 'Джуелл', 'Джуліан', 'Джуліус', 'Джулія', 'Джун', 'Джія', 'Дональд',
+'Ебенезер', 'Ева', 'Еван', 'Еванджелін', 'Едвард', 'Едвін', 'Едвіна', 'Едді', 'Едмунд', 'Едіт', 'Едґар', 'Ездра',
+'Езра', 'Ейлін', 'Елвін', 'Елдред', 'Елеазар', 'Елеанор', 'Елейн', 'Еллен', 'Елліс', 'Елмер', 'Елрой', 'Елса', 'Елтон',
+'Елфріда', 'Еліас', 'Елізабет', 'Елінора', 'Еліот', 'Еліса', 'Еммануїл', 'Еммелін', 'Еммерік', 'Еммі', 'Емілі', 'Енох',
+'Ервін', 'Ернест', 'Ернестіна', 'Ерік', 'Ерін', 'Есмі', 'Етель', 'Еґберт', 'Жаклін', 'Зак', 'Йоланда', 'Кайла',
+'Каміла', 'Карен', 'Карл', 'Каріна', 'Карісса', 'Квентін', 'Кевін', 'Кейт', 'Келлі', 'Кеннет', 'Кент', 'Керрі',
+'Кетлін', 'Кортні', 'Корі', 'Кріс', 'Крістал', 'Крістофер', 'Крістіан', 'Крістіна', "Ксав'єр", 'Кімберлі', 'Лавінія',
+'Лайонел', 'Ламберт', 'Ланс', 'Ланселот', 'Ларрі', 'Лаура', 'Леа', 'Ленора', 'Лео', 'Леон', 'Леона', 'Леонард',
+'Леопольд', 'Леслі', 'Лестер', 'Летиція', 'Летіша', 'Лора', 'Лорейн', 'Лорен', 'Лоренс', 'Лорін', 'Лотта', 'Лоґан',
+'Лукас', 'Луїза', 'Луїс', 'Льюїс', 'Люк', 'Люсінда', 'Лі', 'Лізбет', 'Ліллі', 'Ліліана', 'Лін', 'Лінда', 'Ліндон',
+'Ліса', 'Лія', 'Майкл', 'Майлз', 'Майра', 'Майрон', 'Макс', 'Максиміліан', 'Малкольм', 'Мануїл', 'Манфред', "Мар'янна",
+'Марджері', 'Марджорі', 'Марк', 'Маркус', 'Марлен', 'Марсел', 'Марсі', 'Мартін', 'Маріон', 'Марґарет', 'Матіас',
+'Матільда', 'Маґдален', 'Маґнус', 'Медді', 'Меделін', 'Мей', 'Мейбел', 'Мелані', 'Мелвін', 'Мелінда', 'Мелісса',
+'Мередіт', 'Мерил', 'Мерилін', 'Мерлін', 'Меррі', 'Мерсі', 'Мері', 'Меріан', 'Мерілу', 'Меттью', 'Метью', 'Меґан',
+'Меґґі', 'Мод', 'Мозес', 'Моллі', 'Моріс', 'Морґан', 'Мюріель', 'Мідж', 'Мілдред', 'Міллі', 'Мірабелла', 'Міранда',
+'Мішел', 'Найджел', 'Наомі', 'Натаніель', 'Неллі', 'Ненсі', 'Ноа', 'Ноел', 'Ноемі', 'Ной', 'Нора', 'Норберт', 'Норма',
+'Норман', 'Ніколас', 'Ніколь', 'Нікі', 'Ніл', 'Ніро', 'Одетта', 'Олівер', 'Омар', 'Осборн', 'Освальд', 'Освін', 'Оскар',
+'Оттвел', 'Отто', 'Оттілія', 'Оуен', 'Офелія', 'Памела', 'Патриція', 'Патрік', 'Педді', 'Пенелопа', 'Пенні', 'Переґрін',
+'Перл', 'Персиваль', 'Персі', 'Періс', 'Пол', 'Пола', 'Поллі', 'Поппі', 'Порція', 'Порша', 'Проспер', 'Пруденс',
+'Прімроуз', 'Прісцилла', 'Пірс', 'Пітер', 'Райс', 'Ральф', 'Рандольф', 'Ранульф', 'Рафаель', 'Ред', 'Реджина',
+'Реджинальд', 'Реймонд', 'Рейнард', 'Рейнер', 'Рейнольд', 'Рейчел', 'Рендел', 'Ренні', 'Роб', 'Роббі', 'Роберт',
+'Роберта', 'Робін', 'Рода', 'Родерік', 'Роджер', 'Родні', 'Розалінда', 'Розмарі', 'Рой', 'Роланд', 'Рольф', 'Рональд',
+'Ронні', 'Росс', 'Роуз', 'Рубен', 'Рубі', 'Рудольф', 'Руперт', 'Руфус', 'Рік', 'Ріта', 'Річард', 'Сабіна', 'Сайлас',
+'Саймон', 'Саллі', 'Саманта', 'Сандра', 'Себастьян', 'Севідж', 'Седі', 'Селіна', 'Сем', 'Семюел', 'Серена', 'Сетон',
+'Сибілла', 'Сильвестер', 'Симон', 'Скарлетт', 'Скот', 'Сол', 'Спенсер', 'Стефані', 'Стефен', 'Стівен', 'Сьюард',
+'Сьюзан', 'Сьюзанна', 'Сідні', 'Табіта', 'Тай', 'Тед', 'Тедді', 'Темзін', 'Теобальд', 'Теодора', 'Теофілус', 'Теренс',
+'Террі', 'Тит', 'Тобі', 'Тобіас', 'Том', 'Томазіна', 'Томас', 'Томмі', 'Тоні', 'Труді', 'Трістан', 'Тімоті', 'Тіффані',
+'Ульріка', 'Улісс', 'Уна', 'Урсула', 'Урія', 'Фабіан', 'Фалкон', 'Фанні', 'Фейт', 'Фелікс', 'Фелісія', 'Фердінанд',
+'Ферфакс', 'Флора', 'Флоренс', 'Форд', 'Франс', 'Франциск', 'Фред', 'Фредерік', 'Фредеріка', 'Френк', 'Френсіс',
+'Фріда', 'Фібі', 'Філандер', 'Філліп', 'Філомена', 'Філіп', 'Філіппа', "Х'юго", 'Харві', 'Хенк', 'Холлі', 'Холі',
+'Хілларі', 'Челсі', 'Шейн', 'Шерон', 'Шон', 'Юджин', 'Юм', 'Юна', 'Юніс', 'Янґ', 'Ґабрієла', 'Ґабрієль', 'Ґай', 'Ґарет',
+'Ґаррі', 'Ґвен', 'Ґвендолін', 'Ґевін', 'Ґеддес', 'Ґедеон', 'Ґерда', 'Ґерміна', 'Ґеррі', 'Ґертруда', 'Ґерті', 'Ґледіс',
+'Ґлен', 'Ґлорія', 'Ґодвін', 'Ґор', 'Ґордон', 'Ґрей', 'Ґрейс', 'Ґреґорі', 'Ґризельда', 'Ґріффін', 'Ґустав', 'Ґідеон',
+'Ґілберт')
+
+with open('lesya/language/language_data/family-names.csv') as f:
+    lines = [l.strip() for l in f.readlines()]
+
+LASTNAME_ENDINGS2 = {l[-2:] for l in lines}
+LASTNAME_ENDINGS3 = {l[-3:] for l in lines if len(l) > 4}
+LASTNAME_ENDINGS4 = {l[-4:] for l in lines if len(l) > 6}

lesya/language/nc_core.py

@@ -0,0 +1,371 @@
+from lesya.language.case_helpers import NamePart, CaseUA, NCLNameCaseWord, Gender
+
+
+class NameCaseCore:
+    """
+    Base class for name case handling.
+    """
+    def __init__(self):
+        self.case_count = 7
+        # System readiness:
+        # - All words are identified (know which part of FIO the word belongs to)
+        # - Gender is determined for all words
+        # If all is done, the flag is set to true, adding a new word resets the flag to false
+        self._ready = False
+        # If all current words have been declined and each word already has a declination result,
+        # then true. Adding a new word resets the flag to false
+        self._finished = False
+        # Array contains elements of type NCLNameCaseWord. These are all the words to be processed and declined
+        self.words = []
+        # Variable into which the current working word is placed
+        self.working_word = None
+        # Array contains the result of the declination of the word - the word in all cases
+        self.last_result = []
+        # Array contains information about which words from the array <var>$this->words</var> belong to
+        # the surname, which to the patronymic, and which to the first name. The array is needed because when adding words
+        # we do not always know which part of the FIO it is, so after identifying all words, an array of
+        # indexes for quick search is generated.
+        self.index = {NamePart.FIRSTNAME: [], NamePart.LASTNAME: [], NamePart.PATRONYMIC: []}
+        self.cases = CaseUA().all('ua')
+
+    def __repr__(self):
+        return f'{self.words}'
+
+    def forms(self):
+        pass
+
+    @property
+    def ready(self):
+        return self._ready
+
+    @property
+    def finished(self):
+        return self._finished
+
+    def full_reset(self):
+        """
+        Resets all information to the initial state. Clears all words added to the system.
+        After execution, the system is ready to work from scratch.
+        :return: NCLNameCaseCore
+        """
+        self.words = []
+        self.last_result = []
+        self.index = {NamePart.FIRSTNAME: [], NamePart.LASTNAME: [], NamePart.PATRONYMIC: []}
+        self.not_ready()
+        return self
+
+    def not_ready(self):
+        """
+        Sets flags that the system is not ready and the words have not yet been declined.
+        """
+        self._ready = False
+        self._finished = False
+
+    def rules_chain(self, gender, rules_array):
+        for rule_id in rules_array:
+            rule_method = f"{gender}_rule{rule_id}"
+            if getattr(self, rule_method)():
+                return True
+        return False
+
+    def word_forms(self, word, endings, replace_last=0):
+        result = [self.working_word]
+        # word = NCLStr.substr(word, 0, len(word) - replace_last)
+        word = word[0:len(word) - replace_last]
+        for case_index in range(1, self.case_count):
+            result.append(word + endings[case_index - 1])
+        self.last_result = result
+
+    def set_first_name(self, firstname=""):
+        if firstname:
+            index = len(self.words)
+            self.words.append(NCLNameCaseWord(firstname))
+            self.words[index].name_part = NamePart.FIRSTNAME
+            self.not_ready()
+        return self
+
+    def set_second_name(self, secondname=""):
+        if secondname:
+            index = len(self.words)
+            self.words.append(NCLNameCaseWord(secondname))
+            self.words[index].name_part = NamePart.LASTNAME
+            self.not_ready()
+        return self
+
+    def set_father_name(self, fathername=""):
+        if fathername:
+            index = len(self.words)
+            self.words.append(NCLNameCaseWord(fathername))
+            self.words[index].name_part = NamePart.PATRONYMIC
+            self.not_ready()
+        return self
+
+    def set_gender(self, gender):
+        for word in self.words:
+            word.set_true_gender(gender)
+        return self
+
+    def set_full_name(self, second_name="", first_name="", father_name=""):
+        self.set_first_name(first_name)
+        self.set_second_name(second_name)
+        self.set_father_name(father_name)
+        return self
+
+    def set_name(self, firstname=""):
+        return self.set_first_name(firstname)
+
+    def set_last_name(self, secondname=""):
+        return self.set_second_name(secondname)
+
+    def set_sir_name(self, secondname=""):
+        return self.set_second_name(secondname)
+
+    def prepare_name_part(self, word):
+        if not word.name_part:
+            self.detect_name_part(word)
+
+    def prepare_all_name_parts(self):
+        for word in self.words:
+            self.prepare_name_part(word)
+
+    def prepare_gender(self, word):
+        if not word.is_gender_solved():
+            name_part = word.name_part
+            if name_part == NamePart.FIRSTNAME:
+                self.gender_by_first_name(word)
+            elif name_part == NamePart.PATRONYMIC:
+                self.gender_by_patronym(word)
+            elif name_part == NamePart.LASTNAME:
+                self.gender_by_lastname(word)
+
+    def solve_gender(self):
+        for word in self.words:
+            if word.is_gender_solved():
+                self.set_gender(word.gender())
+                return True
+        man, woman = 0, 0
+        for word in self.words:
+            self.prepare_gender(word)
+            gender = word.get_gender()
+            man += gender[Gender.MAN]
+            woman += gender[Gender.WOMAN]
+        self.set_gender(Gender.MAN if man > woman else Gender.WOMAN)
+        return True
+
+    def generate_index(self):
+        self.index = {NamePart.FIRSTNAME: [], NamePart.LASTNAME: [], NamePart.PATRONYMIC: []}
+        for index, word in enumerate(self.words):
+            name_part = word.name_part
+            self.index[name_part].append(index)
+
+    def prepare_everything(self):
+        if not self._ready:
+            self.prepare_all_name_parts()
+            self.solve_gender()
+            self.generate_index()
+            self._ready = True
+
+    def split_full_name(self, fullname):
+        fullname = fullname.strip()
+        words_list = [w for w in fullname.split() if w]
+        for word in words_list:
+            self.words.append(NCLNameCaseWord(word))
+        self.prepare_everything()
+        return self.words
+
+    def word_case(self, word):
+        gender = 'male' if word.gender() == Gender.MAN else 'female'
+        name_part = {NamePart.FIRSTNAME: 'first', NamePart.LASTNAME: 'second', NamePart.PATRONYMIC: 'father'}.get(
+            word.name_part)
+        method = f'{gender}_{name_part}_name'
+        tmp = word.word_orig
+        cur_words = tmp.split('-')
+        o_cur_words = []
+        result = ['']*self.case_count
+        cnt = len(cur_words)
+        for k, cur_word in enumerate(cur_words):
+            is_norm_rules = True
+            o_ncw = NCLNameCaseWord(cur_word)
+            if word.name_part == NamePart.LASTNAME and cnt > 1 and k < cnt - 1:
+                if cur_word.lower() not in ('тулуз'):
+                    self.detect_name_part(o_ncw)
+                    is_norm_rules = o_ncw.name_part == NamePart.LASTNAME
+                else:
+                    is_norm_rules = False
+
+            self.working_word = cur_word
+
+            if is_norm_rules and getattr(self, method)():
+                result_tmp = self.last_result
+            else:
+                result_tmp = [cur_word] * self.case_count
+
+            o_ncw.set_name_cases(result_tmp)
+            o_cur_words.append(o_ncw)
+
+        for o_ncw in o_cur_words:
+            namecases = o_ncw.get_name_cases()
+            for k, namecase in enumerate(namecases):
+                if result[k]:
+                    result[k] = result[k] + '-' + namecase
+                else:
+                    result[k] = namecase
+
+        word.set_name_cases(result, False)
+
+    def all_word_cases(self):
+        if not self._finished:
+            self.prepare_everything()
+            for word in self.words:
+                self.word_case(word)
+            self._finished = True
+
+    def get_word_case(self, word, number=None):
+        cases = word.get_name_cases()
+        if number is None or number < 0 or number > (self.case_count - 1):
+            return cases
+        else:
+            return cases[number]
+
+    def get_cases_connected(self, index_array, number=None):
+        ready = []
+        for index in index_array:
+            ready.append(self.get_word_case(self.words[index], number))
+
+        all_cases = len(ready)
+        if all_cases:
+            if isinstance(ready[0], list):
+                result = []
+                for case in range(self.case_count):
+                    tmp = []
+                    for i in range(all_cases):
+                        tmp.append(ready[i][case])
+                    result.append(' '.join(tmp))
+                return result
+            else:
+                return ' '.join(ready)
+        return ''
+
+    def get_firstname_case(self, number=None):
+        self.all_word_cases()
+        return self.get_cases_connected(self.index[NamePart.FIRSTNAME], number)
+
+    def get_lastname_case(self, number=None):
+        self.all_word_cases()
+        return self.get_cases_connected(self.index[NamePart.LASTNAME], number)
+
+    def get_patronymic_case(self, number=None):
+        self.all_word_cases()
+        return self.get_cases_connected(self.index[NamePart.PATRONYMIC], number)
+
+    def get_formatted_array(self, format_):
+        if isinstance(format_, list):
+            return self.get_formatted_array_forced(format_)
+        result = []
+        cases = {
+            NamePart.LASTNAME: self.get_cases_connected(self.index[NamePart.LASTNAME]),
+            NamePart.FIRSTNAME: self.get_cases_connected(self.index[NamePart.FIRSTNAME]),
+            NamePart.PATRONYMIC: self.get_cases_connected(self.index[NamePart.PATRONYMIC])
+        }
+        for cur_case in range(self.case_count):
+            line = ""
+            for symbol in format_.split():
+                if symbol == 'S':
+                    line += cases[NamePart.LASTNAME][cur_case]
+                elif symbol == 'N':
+                    line += cases[NamePart.FIRSTNAME][cur_case]
+                elif symbol == 'F':
+                    line += cases[NamePart.PATRONYMIC][cur_case]
+                else:
+                    line += symbol
+            result.append(line)
+        return result
+
+    def get_formatted_array_forced(self, format_):
+        result = []
+        cases = []
+        for word in format_:
+            cases.append(word.get_name_cases())
+        for curCase in range(self.case_count):
+            line = ""
+            for value in cases:
+                line += value[curCase] + ' '
+            result.append(line.strip())
+        return result
+
+    @staticmethod
+    def get_formatted_forced(case_num=0, format_=None):
+        format_ = format_ if format_ else []
+        result = ""
+        for word in format_:
+            cases = word.get_name_cases()
+            result += cases[case_num] + ' '
+        return result.strip()
+
+    def get_formatted(self, case_num=0, format_="S N F"):
+        self.all_word_cases()
+        if case_num is None or not case_num:
+            return self.get_formatted_array(format_)
+        elif isinstance(format_, list):
+            return self.get_formatted_forced(case_num, format_)
+        else:
+            result = ""
+            for symbol in format_.split():
+                if symbol == 'S':
+                    result += self.get_lastname_case(case_num)
+                elif symbol == 'N':
+                    result += self.get_firstname_case(case_num)
+                elif symbol == 'F':
+                    result += self.get_patronymic_case(case_num)
+                else:
+                    result += symbol
+            return result
+
+    def q(self, fullname, case_num=None, gender=None):
+        self.full_reset()
+        format_ = self.split_full_name(fullname)
+        if gender:
+            self.set_gender(gender)
+        return self.get_formatted(case_num, format_)
+
+    def male_first_name(self):
+        return False
+
+    def female_first_name(self):
+        return False
+
+    def male_second_name(self):
+        return False
+
+    def female_second_name(self):
+        return False
+
+    def male_father_name(self):
+        return False
+
+    def female_father_name(self):
+        return False
+
+    def gender_by_first_name(self, word):
+        pass
+
+    def gender_by_lastname(self, word):
+        pass
+
+    def gender_by_patronym(self, word):
+        pass
+
+    def detect_name_part(self, word):
+        pass
+
+    def __getitem__(self, item):
+        if not self._finished:
+            return None
+        if isinstance(item, int) and item in range(self.case_count):
+            return self.forms[self.cases[item]]
+        if isinstance(item, str):
+            if item in self.cases:
+                return self.forms[item]
+            if item in CaseUA().all():
+                index = CaseUA().all().index(item)
+                return self[index]

lesya-0.0.1.dist-info/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lesya-0.0.1.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.1
+Name: lesya
+Version: 0.0.1
+Summary: Python package to form Ukrainian names cases : 'Леся Українка' -- 'Лесі Українки' , 'Лесі Українці', 'Лесею Українкою' ... etc.
+Author: Dmytro Ustynov
+Author-email: Dmytro Ustynov <ustynov.dev@gmail.com>
+License: Copyright (c) 2018 The Python Packaging Authority
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Homepage, https://github.com/ustynov-py-dev/lesya.git
+Project-URL: Issues, https://github.com/ustynov-py-dev/lesya/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Lesya
+
+Lesya is a simple Python package for declining Ukrainian personal names into Ukrainian grammatical cases (_відмінки_): NOMINATIVE, GENITIVE, DATIVE, ACCUSATIVE, INSTRUMENTAL, PREPOSITIONAL, and VOCATIVE (_називний, родовий, давальний, знахідний, орудний, місцевий, кличний_).
+
+## Usage example
+
+The most common usage is to convert a name into all cases:
+
+```python
+from lesya import Lesya
+
+person = Lesya('Леся Українка')
+print(person.nominative) # Леся Українка
+print(person.genitive) # Лесі Українки
+print(person.dative) # Лесі Українці
+print(person.accusative) # Лесю Українку
+print(person.instrumental) # Лесею Українкою
+print(person.prepositional) # Лесі Українці
+print(person.vocative) # Лесе Українко
+```
+
+You can also get a name in a specific case:
+
+```python
+from lesya import Lesya
+from lesya import CaseUA
+
+person = Lesya('Тарас Григорович Шевченко')
+print(person[CaseUA.DATIVE]) # Тарасу Григоровичу Шевченку
+print(person[CaseUA.PREPOSITIONAL]) # Тарасові Григоровичу Шевченкові
+print(person['орудний']) # Тарасом Григоровичем Шевченком
+```
+
+## Double names support
+
+Lesya works well with double last names:
+    
+```python
+from lesya import Lesya
+
+person = Lesya('Іван Семенович Нечуй-Левицький')
+print(person.forms)
+# Output:
+{
+    'називний': 'Іван Семенович Нечуй-Левицький', 
+    'родовий': 'Івана Семеновича Нечуя-Левицького', 
+    'давальний': 'Івану Семеновичу Нечуєві-Левицькому', 
+    'знахідний': 'Івана Семеновича Нечуя-Левицького', 
+    'орудний': 'Іваном Семеновичем Нечуєм-Левицьким', 
+    'місцевий': 'Іванові Семеновичу Нечуєві-Левицькому', 
+    'кличний': 'Іване Семеновичу Нечую-Левицький'
+}
+```
+
+## `forms` attribute
+
+You can get all cases at once using the forms attribute. It returns a dictionary where the keys are case names (in lowercase Ukrainian), and the values are the corresponding declined names.
+
+## Foreign names support
+
+Lesya supports foreign names. However, since it does not use an ML model to automatically detect a person's gender, it works better if you explicitly provide the gender:
+
+```python
+from lesya import Lesya
+from lesya import CaseUA
+from lesya import Gender
+
+person = Lesya('Джозеф Байден', gender='male')  
+print(person[CaseUA.DATIVE]) # Джозефу Байдену
+print(person[CaseUA.PREPOSITIONAL]) # Джозефові Байденові
+
+person = Lesya('Камала Гаріс', gender=Gender.FEMALE)
+print(person[CaseUA.DATIVE]) # Камалі Гаріс
+print(person[CaseUA.PREPOSITIONAL]) # Камалі Гаріс
+```

lesya-0.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+lesya/__init__.py,sha256=3y0FfeVwUx8tdy9tiRJx_YnJ2pQXQzBBym-X2lKZ7ZU,122
+lesya/language/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lesya/language/case_helpers.py,sha256=hmQoMqZ_BKvnWFd6nYir_fYBjOFBJSGZtolgVW9uKek,4649
+lesya/language/name_case.py,sha256=86pCwS676D_sd-nS9KcMrLra0exnKSe9gVTRL0meWH8,17665
+lesya/language/name_constants.py,sha256=IQpG9oNgH_Mkb4jQb8hQoULfIXZOyPp_z1tKkB3iYkc,22141
+lesya/language/nc_core.py,sha256=fB101ZwrFsxUdpAGawKteha3dN2U6b8nkurm2OzrOq0,13003
+lesya-0.0.1.dist-info/LICENSE,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+lesya-0.0.1.dist-info/METADATA,sha256=wrsgKbWxiq9Oi1_4I5DfOIbWR1rMvNeLQP-1K7-DoHY,4990
+lesya-0.0.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+lesya-0.0.1.dist-info/top_level.txt,sha256=G6dTztx6aA4OObUA0lP5EBa39WTk7XJzGvfMMV9F4IE,6
+lesya-0.0.1.dist-info/RECORD,,

lesya-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lesya-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+lesya