#!/usr/bin/python # -*- coding=utf-8 -*- #************************************************************************ # $Id: classverb.py, v 0.7 2009/06/02 01:10:00 Taha Zerrouki $ # # ------------ # Description: # ------------ # Copyright (c) 2009, Arabtechies, Arabeyes Taha Zerrouki # # The Main class to do the conjugation # # ----------------- # Revision Details: (Updated by Revision Control System) # ----------------- # $Date: 2009/06/02 01:10:00 $ # $Author: Taha Zerrouki $ # $Revision: 0.7 $ # $Source: arabtechies.sourceforge.net # #***********************************************************************/ """ Verb Class for conjugation @author: Taha Zerrouki @contact: taha dot zerrouki at gmail dot com @copyright: Arabtechies, Arabeyes, Taha Zerrouki @license: GPL @date:2009/06/02 @version: 0.9 """ import copy # from ar_ctype import * #~ import sys #~ import re import pyarabic.araby as araby from pyarabic.araby import FATHA, DAMMA, KASRA, SHADDA, SUKUN, HAMZA, ALEF, \ NOON, YEH_HAMZA, WAW, TATWEEL, MEEM, MEEM, YEH, TEH, ALEF_MAKSURA #~ from libqutrub.ar_verb import * import libqutrub.ar_verb as ar_verb #~ from libqutrub.verb_const import * import libqutrub.verb_const as vconst import libqutrub.conjugatedisplay as conjugatedisplay class ConjugStem: """ A Class to represent a conjugated stem """ # بنية جذع تصريف الجذع #تتكون من الزمن، الحروف والحركات # تستعمل لتخزين جذوع التصريف tense = u"" #~ """ the actual tense""" letters = u"" #~ """ letters of the conjugated stem""" marks = u"" #~ """ marks of the conjugated stem""" def __init__(self, tense, letters, marks): """ init method @param tense: the given tense @type tense: unicode. @param letters: the word letters @type letters: unicode. @param marks: the word marks; @type marks: unicode. """ self.tense = tense self.letters = letters self.marks = marks # a global cache for verbs conjigation cache_standard = {'standard':{}, 'sukun':{}, 'suffix':{}} class VerbClass: """ Verb Class: represent a verb, prepare it to be conjugated and store the conjugation result """ #~ verb = u"" #~ #" internl verb : is the normalized form of the verb" #~ internal_verb = u"" #~ word_letters = u"" #~ word_marks = u"" #~ unvocalized = u"" #~ vlength = 0 #~ vtype = u"" #~ future_type = u'' #~ transitive = u"" #~ hamza_zaida = False #~ #deprecated #~ # teh_zaida=False #~ future_form = u"" #~ conj_display = None #~ tab_conjug_stem = None def __init__(self, verb, transitive, future_type=FATHA): """ init method @param verb: the given verb @type verb: unicode. @param transitive: the verb is transitive or not @type transitive: Boolean. @param future_type: The mark of the third radical letter in the verb, used for triletiral verb only. Default value is Fatha; @type future_type: unicode; one arabic letter (Fatha, Damma, Kasra). """ self.verb = verb # this cache is used to avoid duplicated operatioon in standardisation, # treat_sukun, and uniformate suffix self.cache_standard = cache_standard self.internal_verb = ar_verb.normalize(verb) self.future_type = ar_verb.get_future_type_by_name(future_type) (self.word_letters, self.word_marks) = ar_verb.uniformate_verb(verb) #Before last haraka in the past self.past_haraka = araby.secondlast_char(self.word_marks) self.word_marks = ar_verb.uniformate_alef_origin(self.word_marks, self.internal_verb, self.future_type) self.transitive = transitive self.hamza_zaida = False self.tab_conjug_stem = {} verb = self.verb tab_type = [u"", u"", u"", u"فعل ثلاثي", u"فعل رباعي", u"فعل خماسي", u"فعل سداسي", u"فعل سباعي", u"فعل ثماني", u"فعل تساعي"] verb = ar_verb.normalize(verb) self.unvocalized = araby.strip_harakat(verb) verb_nm = self.unvocalized self.vlength = len(verb_nm) self.vtype = tab_type[self.vlength] # الهمزة زائدة self.hamza_zaida = self._is_hamza_zaida(verb_nm) # التاء الزائدة #deprecated #self.teh_zaida=self.is_teh_zaida(verb_nm) # معالجة حالة الأفعال الشاذة # إذا كان الفعل من الشواذ، استخرجنا جذوع التصريف من جدوله #وإلا ولّدنا جذوع تصريفه # في المضارع والأمر فقط # أما الماضي فليس فيه شذوذ self.past_stem = "" self._prepare_past_stem() self._prepare_passive_past_stem() if self._is_irregular_verb(): self._prepare_irregular_future_imperative_stem() else: self._prepare_future_imperative_stem() # display object self.conj_display = conjugatedisplay.ConjugateDisplay(self.verb) if self.transitive : self.conj_display.add_attribut(u"اللزوم/التعدي", u"متعدي") else : self.conj_display.add_attribut(u"اللزوم/التعدي", u"لازم") self.conj_display.add_attribut(u"الفعل", self.verb) self.conj_display.add_attribut(u"نوع الفعل", self.vtype) self.future_form = self.conjugate_tense_pronoun(vconst.TenseFuture, vconst.PronounHuwa) self.conj_display.set_future_form(self.future_form) if self.transitive : self.conj_display.settransitive() self.conj_display.setbab(self.future_type) def __del__(self): """ Delete instance """ self.conj_display = None self.tab_conjug_stem = None ##################################### #{ Attributes functions ##################################### def set_display(self, mode = 'Text'): """ Set the display mode as: - 'Text': - 'HTML': - 'HTMLColoredDiacritics': - 'DICT': - 'CSV': - 'GUI': - 'TABLE': - 'XML': - 'TeX': - 'ROWS': @param mode: the given mode to display result """ self.conj_display.setmode(mode) def get_conj_display(self): """ Get The conjugation display class with result. @return: an object with result. @rtype: conjugatedisplay class """ return copy.copy(self.conj_display) ##################################### #{ Extract information from verb functions ##################################### def _is_hamza_zaida(self, verb_normalized_unvocalized): """ Function to determine if the first HAMZA in the verb is not original ترجع إذا كانت الهمزة الأولى في الفعل غير أصلية Determine if the verb starts with Hamza and the Teh is not @param verb_normalized_unvocalized: the unvovalized form f the verb. @type verb_normalized_unvocalized: unicde @return: return True if the start Teh is not original @rtype: boolean; """ # if the lenght of verb is exactely 4 letters and starts by hamza # and it is in the AF3Al wazn and not FA33al or FAA3la # ألوزن المعني هو أفعل # الأوزان غير المعنية هي فاعل وفعّل # الأوزان المشتقة هي أفعّ من أفعل # الخلاصة أن يكون الفعل رباعيا، حرفه الأول همزة # ولا يكون حرفه الثاني ألف، لمنع الوزن فاعل # ولا يكون حرفه الثالث شدة، لمنع الوزن فعّل verb = verb_normalized_unvocalized if len(verb) != 4 or not verb.startswith(HAMZA): return False elif len(verb) == 4 and verb.startswith(HAMZA) and \ verb[1]!=ALEF and verb[2]!=SHADDA: return True else : return False def _homogenize_harakat(self, original_harakat, applied_harakat): """ Treat Harakat to be homogenized with letters in conjugation. إذا كان طول الحركات ألأصلية للفعل أقل من طول حركات الماضي المبني للمجهول هذا يعني وجود حركة طويلة نقوم بتحويل الحركة الطويلة إلى ما يوافقها @param original_harakat: given original harakatof the verb. @type original_harakat: unicode. @param applied_harakat: given harakat to be applied to verb. @type applied_harakat: unicode. @return: nesw harakat to be applied to the verb. @rtype: unicode. """ marks = original_harakat new_marks = applied_harakat # إذا كان طول الحركات ألأصلية للفعل أقل من طول حركات الماضي المبني للمجهول # هذا يعني وجود حركة طويلة # نقوم بتحويل الحركة الطويلة إلى ما يوافقها if len(marks) < len(new_marks): alef_haraka_pos = marks.find(vconst.ALEF_HARAKA) if alef_haraka_pos < 0: alef_haraka_pos = marks.find(vconst.ALEF_WAW_HARAKA) if alef_haraka_pos < 0: alef_haraka_pos = marks.find(vconst.ALEF_YEH_HARAKA) if alef_haraka_pos >= 0 and alef_haraka_pos + 1 < len(new_marks): first = new_marks[alef_haraka_pos] second = new_marks[alef_haraka_pos + 1] changed_haraka = \ vconst.HOMOGENIZE_ALEF_HARAKA_TABLE[first][second] new_marks = new_marks[:alef_haraka_pos] + changed_haraka \ + new_marks[alef_haraka_pos+2:] return new_marks ##################################### #{ Preparing conjugation stems for every tense functions ##################################### def _prepare_future_imperative_stem(self): """ Prepare the conjugation stems for future tenses (future, jussive, subjective) and imperative tense. Those stems will be concatenated with conjugation affixes. This function store results in self.tab_conjug_stem. This function prepare conjugation stems for the following tenses: - vconst.TenseFuture : تصريف الفعل المضارع - vconst.TenseJussiveFuture : تصريف الفعل المضارع المجزوم - vconst.TenseSubjunctiveFuture : تصريف الفعل المضارع المنصوب - vconst.TenseConfirmedFuture: المضارع المؤكد الثقيل - vconst.TensePassiveFuture :تصريف الفعل المضارع المبني للمجهول - vconst.TensePassiveJussiveFuture: تصريف الفعل المضارع المجزوم المني للمجهول - vconst.TensePassiveSubjunctiveFuture:تصريف الفعل المضارع المنصوب - vconst.TensePassiveConfirmedFuture:المضارع المؤكد الثقيل المنبي للمجهول - vconst.TenseImperative:الفعل الامر - vconst.TenseConfirmedImperative: الفعل الامر المؤكد. """ letters = self.word_letters marks = self.word_marks future_letters = letters # حالة الفعل الثلاثي if self.vlength == 3: first_future_mark = FATHA first_passive_future_mark = DAMMA future_marks = SUKUN + self.future_type + FATHA passive_future_marks = SUKUN + FATHA + FATHA # معالجة الفعل المثال الواوي #ToDO # الفعل الرباعي elif self.vlength == 4: first_future_mark = DAMMA first_passive_future_mark = DAMMA future_marks = FATHA + SUKUN + KASRA + DAMMA passive_future_marks = FATHA + SUKUN + FATHA + DAMMA # الفعل الخماسي elif self.vlength == 5: first_future_mark = FATHA first_passive_future_mark = DAMMA if letters.startswith(TEH): future_marks = FATHA + FATHA + SUKUN + FATHA + DAMMA passive_future_marks = FATHA + FATHA + SUKUN + FATHA + DAMMA else : future_marks = FATHA + SUKUN + FATHA + KASRA + DAMMA passive_future_marks = FATHA + SUKUN + FATHA + FATHA + DAMMA #الفعل السداسي elif self.vlength == 6: first_future_mark = FATHA first_passive_future_mark = DAMMA future_marks = FATHA + SUKUN + FATHA + SUKUN + KASRA + DAMMA passive_future_marks = FATHA + SUKUN + FATHA + SUKUN + FATHA + DAMMA # معالجة الألفات في الفعل والحركات الطويلة # إذا كان طول الحركات ألأصلية للفعل # أقل من طول حركات الماضي المبني للمجهول # هذا يعني وجود حركة طويلة # نقوم بتحويل الحركة الطويلة إلى ما يوافقها if len(marks) < len(future_marks): future_marks = self._homogenize_harakat(marks, future_marks) passive_future_marks = self._homogenize_harakat(marks, passive_future_marks) imp_marks = future_marks imp_letters = future_letters # حالة الأفعال التي تبدأ بألف وصل if letters.startswith(ALEF) or self.hamza_zaida: future_letters = letters[1:] future_marks = future_marks[1:] passive_future_marks = passive_future_marks[1:] passive_letters = letters[1:] # حالة الفعل المثال elif self.vlength == 3 and self.word_letters.startswith(WAW) and \ (self.future_type == KASRA or (self.future_type==FATHA and \ self.word_marks==FATHA+FATHA+FATHA and \ not self.word_letters.endswith(SHADDA))): future_letters = letters[1:] future_marks = future_marks[1:] ## passive_future_marks=passive_future_marks[1:] passive_letters = letters else: future_letters = letters passive_letters = letters new_marks = first_future_mark + future_marks passive_marks = first_passive_future_mark + passive_future_marks # حالة الأفعال التي تبدأ بألف وصل if imp_letters.startswith(ALEF): imp_letters = letters[1:] imp_marks = imp_marks[1:] elif self.vlength == 3 and self.word_letters.startswith(WAW) and \ (self.future_type == KASRA or (self.future_type==FATHA and \ self.word_marks==FATHA+FATHA+FATHA)): imp_letters = letters[1:] imp_marks = imp_marks[1:] else: imp_letters = letters # معالجة الفعل الناقص عند تصريفه في المجهول # تستبدل واو التاقص الذي حركة عين ماضيه فتحة بياء ## passive_letters=future_letters if self.vlength == 3 and passive_letters.endswith(vconst.ALEF_MAMDUDA): passive_letters = passive_letters[:-1]+ALEF_MAKSURA # القعل الأمر يأخذ نفس حركات الفعل المضارع دون حركة حرف المضارعة ## imp_marks=future_marks ### معلجة إضافة حرف ألف الوصل في الأفعال المسبوقة بالسكون ## new_marks=first_future_mark+future_marks ## passive_marks=first_passive_future_mark+passive_future_marks self.tab_conjug_stem[vconst.TenseFuture] = ConjugStem( vconst.TenseFuture, future_letters, new_marks) # تصريف الفعل المضارع المنصوب والمجزوم self.tab_conjug_stem[vconst.TenseJussiveFuture] = ConjugStem( vconst.TenseJussiveFuture, future_letters, new_marks) self.tab_conjug_stem[vconst.TenseSubjunctiveFuture] = ConjugStem( vconst.TenseSubjunctiveFuture, future_letters, new_marks) # المضارع المؤكد الثقيل self.tab_conjug_stem[vconst.TenseConfirmedFuture] = ConjugStem( vconst.TenseConfirmedFuture, future_letters, new_marks) # المبني للمجهول self.tab_conjug_stem[vconst.TensePassiveFuture] = ConjugStem( vconst.TensePassiveFuture, passive_letters, passive_marks) # تصريف الفعل المضارع المنصوب والمجزوم المني للمجهول self.tab_conjug_stem[vconst.TensePassiveJussiveFuture] = ConjugStem( vconst.TensePassiveJussiveFuture, passive_letters, passive_marks) self.tab_conjug_stem[vconst.TensePassiveSubjunctiveFuture] = \ ConjugStem(vconst.TensePassiveSubjunctiveFuture, passive_letters, passive_marks) # المضارع المؤكد الثقيل المنبي للمجهول self.tab_conjug_stem[vconst.TensePassiveConfirmedFuture] = ConjugStem( vconst.TensePassiveConfirmedFuture, passive_letters, passive_marks) # الفعل الامر self.tab_conjug_stem[vconst.TenseImperative] = ConjugStem( vconst.TenseImperative, imp_letters, imp_marks) # الفعل الامر المؤكد self.tab_conjug_stem[vconst.TenseConfirmedImperative] = ConjugStem( vconst.TenseConfirmedImperative, imp_letters, imp_marks) def _prepare_past_stem(self): """ Prepare the conjugation stems for past tense. Those stems will be concatenated with conjugation affixes. This function store results in self.tab_conjug_stem. This function prepare conjugation stems for the following tenses: - vconst.TensePast: الفعل الماضي. """ self.past_stem = self.internal_verb self.tab_conjug_stem[vconst.TensePast] = ConjugStem( vconst.TensePast, self.word_letters, self.word_marks) def _prepare_passive_past_stem(self): """ Prepare the conjugation stems for past tense. Those stems will be concatenated with conjugation affixes. This function store results in self.tab_conjug_stem. This function prepare conjugation stems for the following tenses: - vconst.TensePast: الفعل الماضي """ letters = self.word_letters marks = self.word_marks if len(letters) == 3 and letters.endswith(vconst.ALEF_MAMDUDA) \ and marks[1] == FATHA: letters = letters[:-1] + ALEF_MAKSURA if self.vlength == 3: passive_marks = DAMMA + KASRA + FATHA elif self.vlength == 4: passive_marks = DAMMA + SUKUN + KASRA + FATHA elif self.vlength == 5: if letters.startswith(TEH): passive_marks = DAMMA + DAMMA + SUKUN + KASRA + FATHA else : passive_marks = DAMMA + SUKUN + DAMMA + KASRA + FATHA elif self.vlength == 6: passive_marks = DAMMA + SUKUN + DAMMA + SUKUN + KASRA + FATHA # إذا كان طول الحركات ألأصلية للفعل أقل من طول حركات الماضي المبني للمجهول # هذا يعني وجود حركة طويلة # نقوم بتحويل الحركة الطويلة إلى ما يوافقها if len(marks) < len(passive_marks): passive_marks = self._homogenize_harakat(marks, passive_marks) # - حالة الفعل الأجوف الذي حركة مضارعه فتحة أو كسرة، #- فيصبح في الماضي عند التقاء الساكنين كسرة، #لذا يجب تعديل ذلك في الماضي المجهول، # بجعلها تتحول إلى ضمة عند التقاء الساكنين. if len(passive_marks) == 2 and passive_marks[0] == vconst.YEH_HARAKA \ and self.future_type in (FATHA, KASRA): passive_marks = vconst.ALTERNATIVE_YEH_HARAKA + FATHA self.tab_conjug_stem[vconst.TensePassivePast] = ConjugStem(\ vconst.TensePassivePast, letters, passive_marks) def conjugate_tense_pronoun(self, tense, pronoun): """ Conjugate a verb in a given tense with a pronoun. @param tense: given tense @type tense: unicode name of the tense @param pronoun: given pronoun @type pronoun: unicode name of the pronoun @return: conjugated verb @rtype: unicode; """ #prefix pre_val = vconst.TableTensePronoun[tense][pronoun][0] #suffix suf_val = vconst.TableTensePronoun[tense][pronoun][1] stem_l = self.tab_conjug_stem[tense].letters stem_m = self.tab_conjug_stem[tense].marks #deprecated ## return self.join(stem_l, stem_m, prefix, suffix) # _m : marks #_l :letters if pre_val != u"": pre_val_l = pre_val pre_val_m = stem_m[0] stem_m = stem_m[1:] else: pre_val_l = u"" pre_val_m = u"" # the suffix already start by a HARAKA, # we add Taweel to ensure valid word in the uniformate function suf_val = TATWEEL + suf_val #uniformate suffix # the case is used to avoid duplicated staddization if suf_val in self.cache_standard['suffix']: (suf_val_l, suf_val_m) = self.cache_standard['suffix'][suf_val] else: (suf_val_l, suf_val_m) = ar_verb.uniformate_suffix(suf_val) self.cache_standard['suffix'][suf_val] = (suf_val_l, suf_val_m) # add affix to the stem conj_l = pre_val_l + stem_l + suf_val_l #The end of the stem marks takes the begining of the suffix marks conj_m = pre_val_m + stem_m[:-1] + suf_val_m # the begining of suffix letters is Tatweel, it will be striped conj_l = pre_val_l + stem_l + suf_val_l[1:] # Treat sukun # the case is used to avoid duplicated staddization key_cache = u'-'.join([conj_l, conj_m]) if key_cache in self.cache_standard['sukun']: conj_m = self.cache_standard['sukun'][key_cache] else: #~ conj_m = ar_verb.treat_sukun2(conj_l, conj_m, self.future_type) conj_m = ar_verb.treat_sukun2(conj_l, conj_m) self.cache_standard['sukun'][key_cache] = conj_m # standard orthographic form # the case is used to avoid duplicated staddization key_cache = u'-'.join([conj_l, conj_m]) if key_cache in self.cache_standard['standard']: conj = self.cache_standard['standard'][key_cache] else: conj = ar_verb.standard2(conj_l, conj_m) self.cache_standard['standard'][key_cache] = conj return conj #---------------------------------------------------------------- # التصريف في الأزمنة المختلفة، # عند وضع قائمة خاصة بالأزمنة المختارة، # تلقائيا كافة الأزمنة #---------------------------------------------------------------- def conjugate_all_tenses(self, listtense = None): """ Conjugate a verb with a list of tenses. @param listtense: given tense @type listtense: list of unicode @return: conjugated verb @rtype: the type is given according to the display mode; """ if not listtense: listtense = vconst.TABLE_TENSE for tense in listtense: if tense == vconst.TensePast: conj_ana = self.conjugate_tense_pronoun(tense, vconst.PronounAna) self.conj_display.add(tense, vconst.PronounAna, conj_ana) conj_ana_without_last_mark = conj_ana[:-1] self.conj_display.add(tense, vconst.PronounAnta, conj_ana_without_last_mark+FATHA) self.conj_display.add(tense, vconst.PronounAnti, conj_ana_without_last_mark+KASRA) self.conj_display.add(tense, vconst.PronounAntuma, conj_ana+MEEM+FATHA+ALEF) self.conj_display.add(tense, vconst.PronounAntuma_f, conj_ana+MEEM+FATHA+ALEF) self.conj_display.add(tense, vconst.PronounAntum, conj_ana+MEEM) self.conj_display.add(tense, vconst.PronounAntunna, conj_ana+NOON+SHADDA+FATHA) self.conj_display.add(tense, vconst.PronounAna, conj_ana) conj_nahnu = self.conjugate_tense_pronoun(tense, vconst.PronounNahnu) self.conj_display.add(tense, vconst.PronounNahnu, conj_nahnu) conj_hunna = self.conjugate_tense_pronoun(tense, vconst.PronounHunna) self.conj_display.add(tense, vconst.PronounHunna, conj_hunna) conj_huma = self.conjugate_tense_pronoun(tense, vconst.PronounHuma) self.conj_display.add(tense, vconst.PronounHuma, conj_huma) conj_hum = self.conjugate_tense_pronoun(tense, vconst.PronounHum) self.conj_display.add(tense, vconst.PronounHum, conj_hum) conj_hunna = self.conjugate_tense_pronoun(tense, vconst.PronounHunna) self.conj_display.add(tense, vconst.PronounHunna, conj_hunna) conj_huwa = self.conjugate_tense_pronoun(tense, vconst.PronounHuwa) self.conj_display.add(tense, vconst.PronounHuwa, conj_huwa) conj_hya = self.conjugate_tense_pronoun(tense, vconst.PronounHya) self.conj_display.add(tense, vconst.PronounHya, conj_hya) self.conj_display.add(tense, vconst.PronounHuma_f, conj_hya[:-1]+FATHA+ALEF) elif tense == vconst.TensePassivePast: conj_ana = self.conjugate_tense_pronoun(tense, vconst.PronounAna) self.conj_display.add(tense, vconst.PronounAna, conj_ana) conj_ana_without_last_mark = conj_ana[:-1] self.conj_display.add(tense, vconst.PronounAnta, conj_ana_without_last_mark+FATHA) self.conj_display.add(tense, vconst.PronounAnti, conj_ana_without_last_mark+KASRA) self.conj_display.add(tense, vconst.PronounAntuma, conj_ana+MEEM+FATHA+ALEF) self.conj_display.add(tense, vconst.PronounAntuma_f, conj_ana+MEEM+FATHA+ALEF) self.conj_display.add(tense, vconst.PronounAntum, conj_ana+MEEM) self.conj_display.add(tense, vconst.PronounAntunna, conj_ana+NOON+SHADDA+FATHA) self.conj_display.add(tense, vconst.PronounAna, conj_ana) conj_nahnu = self.conjugate_tense_pronoun(tense, vconst.PronounNahnu) self.conj_display.add(tense, vconst.PronounNahnu, conj_nahnu) conj_hunna = self.conjugate_tense_pronoun(tense, vconst.PronounHunna) self.conj_display.add(tense, vconst.PronounHunna, conj_hunna) conj_hunna = self.conjugate_tense_pronoun(tense, vconst.PronounHunna) self.conj_display.add(tense, vconst.PronounHunna, conj_hunna) conj_huwa = self.conjugate_tense_pronoun(tense, vconst.PronounHuwa) self.conj_display.add(tense, vconst.PronounHuwa, conj_huwa) conj_hum = self.conjugate_tense_pronoun(tense, vconst.PronounHum) self.conj_display.add(tense, vconst.PronounHum, conj_hum) # حالة الفعل مهموز الآخر if conj_huwa.endswith(YEH+HAMZA+FATHA) : self.conj_display.add(tense, vconst.PronounHya, conj_huwa[:-2]+YEH_HAMZA+FATHA+TEH+SUKUN) self.conj_display.add(tense, vconst.PronounHuma_f, conj_huwa[:-2]+YEH_HAMZA+FATHA+TEH+FATHA+ALEF) ## conj_huma=self.conjugate_tense_pronoun(tense, ## vconst.PronounHuma) self.conj_display.add(tense, vconst.PronounHuma, conj_huwa[:-2]+YEH_HAMZA+FATHA+ALEF) ## conj_hum=self.conjugate_tense_pronoun(tense, # vconst.PronounHum) self.conj_display.add(tense, vconst.PronounHum, conj_huwa[:-2]+YEH_HAMZA+DAMMA+WAW+ALEF) else : self.conj_display.add(tense, vconst.PronounHya, conj_huwa+TEH+SUKUN) self.conj_display.add(tense, vconst.PronounHuma_f, conj_huwa+TEH+FATHA+ALEF) self.conj_display.add(tense, vconst.PronounHuma, conj_huwa+ALEF) #~ if conj_huwa.endswith(KASRA+YEH+FATHA): #~ self.conj_display.add(tense, vconst.PronounHum, #~ conj_huwa[:-3]+DAMMA+WAW+ALEF) #~ else: #~ self.conj_display.add(tense, vconst.PronounHum, #~ conj_huwa[:-1]+DAMMA+WAW+ALEF) elif tense in (vconst.TenseFuture, vconst.TensePassiveFuture, vconst.TenseJussiveFuture, vconst.TenseSubjunctiveFuture, vconst.TenseConfirmedFuture, vconst.TensePassiveJussiveFuture, vconst.TensePassiveSubjunctiveFuture, vconst.TensePassiveConfirmedFuture): conj_ana = self.conjugate_tense_pronoun(tense, vconst.PronounAna) self.conj_display.add(tense, vconst.PronounAna, conj_ana) conj_anta = self.conjugate_tense_pronoun(tense, vconst.PronounAnta) self.conj_display.add(tense, vconst.PronounAnta, conj_anta) conj_anta_without_future_letter = conj_anta[1:] ## self.conj_display.add(tense, vconst.PronounAnta, ## TEH+conj_ana_without_future_letter) self.conj_display.add(tense, vconst.PronounNahnu, NOON+conj_anta_without_future_letter) self.conj_display.add(tense, vconst.PronounHuwa, YEH+conj_anta_without_future_letter) self.conj_display.add(tense, vconst.PronounHya, TEH+conj_anta_without_future_letter) conj_anti = self.conjugate_tense_pronoun(tense, vconst.PronounAnti) self.conj_display.add(tense, vconst.PronounAnti, conj_anti) conj_antuma = self.conjugate_tense_pronoun(tense, vconst.PronounAntuma) self.conj_display.add(tense, vconst.PronounAntuma, conj_antuma) self.conj_display.add(tense, vconst.PronounAntuma_f, conj_antuma) self.conj_display.add(tense, vconst.PronounHuma_f, conj_antuma) self.conj_display.add(tense, vconst.PronounHuma, YEH+conj_antuma[1:]) conj_antum = self.conjugate_tense_pronoun(tense, vconst.PronounAntum) self.conj_display.add(tense, vconst.PronounAntum, conj_antum) self.conj_display.add(tense, vconst.PronounHum, YEH+conj_antum[1:]) conj_antunna = self.conjugate_tense_pronoun(tense, vconst.PronounAntunna) self.conj_display.add(tense, vconst.PronounAntunna, conj_antunna) self.conj_display.add(tense, vconst.PronounHunna, YEH+conj_antunna[1:]) elif tense == vconst.TenseImperative or \ tense == vconst.TenseConfirmedImperative: for pron in vconst.ImperativePronouns: conj = self.conjugate_tense_pronoun(tense, pron) self.conj_display.add(tense, pron, conj) if not self.transitive: for tense in vconst.TablePassiveTense: for pron in vconst.PronounsTableNotPassiveForUntransitive: self.conj_display.add(tense, pron, u"") # if the result is not diplyed directely on the screen, we return it result = self.conj_display.display(self.conj_display.mode, listtense) if result: return result def conjugate_tense_for_pronoun(self, tense, pronoun): """ Conjugate a verb for a pronoun in specific tense, we use an homoginized conjugation @param tense: given tense @type tense: unicode @param pronoun: given pronoun @type pronoun: unicode @return: conjugated verb @rtype: unicode; """ # the idea is to generate some conjugation from others # in particalar cases, we can generate conjugation # from others pronouns. # for each tense we have two pronouns lists: # - direct conjugated pronouns. # - indirect conjugated pronouns. if tense == vconst.TensePast: # direct concongated pronouns if pronoun in (vconst.PronounAna, vconst.PronounNahnu, vconst.PronounHunna, vconst.PronounHuma , vconst.PronounHum, vconst.PronounHunna, vconst.PronounHuwa, vconst.PronounHya): conj = self.conjugate_tense_pronoun( tense, pronoun) self.conj_display.add(tense, pronoun, conj) # indirect conjugation # from Aana Pronoun elif pronoun in (vconst.PronounAnta, vconst.PronounAnta, vconst.PronounAnti, vconst.PronounAntuma, vconst.PronounAntuma_f, vconst.PronounAntum, vconst.PronounAntunna): # test if the verb is conjugated conj_ana = self.conj_display.get_conj(tense, pronoun) if conj_ana == u"": conj_ana = self.conjugate_tense_pronoun(tense, vconst.PronounAna) conj_ana_without_last_mark = conj_ana[:-1] if pronoun == vconst.PronounAnta: self.conj_display.add(tense, vconst.PronounAnta, conj_ana_without_last_mark+FATHA) elif pronoun == vconst.PronounAnti: self.conj_display.add(tense, vconst.PronounAnti, conj_ana_without_last_mark+KASRA) elif pronoun == vconst.PronounAntuma : self.conj_display.add(tense, vconst.PronounAntuma, conj_ana+MEEM+FATHA+ALEF) elif pronoun == vconst.PronounAntuma_f: self.conj_display.add(tense, vconst.PronounAntuma_f, conj_ana+MEEM+FATHA+ALEF) elif pronoun == vconst.PronounAntum: self.conj_display.add(tense, vconst.PronounAntum, conj_ana+MEEM) elif pronoun == vconst.PronounAntunna: self.conj_display.add(tense, vconst.PronounAntunna, conj_ana+NOON+SHADDA+FATHA) # indirect conjugation # from Hya Pronoun elif pronoun == vconst.PronounHuma_f: # test if the verb is conjugated conj_hya = self.conj_display.get_conj(tense, vconst.PronounHya) if conj_hya == u"": conj_hya = self.conjugate_tense_pronoun(tense, vconst.PronounHya) self.conj_display.add(tense, vconst.PronounHuma_f, conj_hya[:-1]+FATHA+ALEF) elif tense == vconst.TensePassivePast: # direct conjugation if pronoun in (vconst.PronounAna, vconst.PronounNahnu, vconst.PronounHunna, vconst.PronounHunna, vconst.PronounHuwa, vconst.PronounHum): conj = self.conjugate_tense_pronoun(tense, pronoun) self.conj_display.add(tense, pronoun, conj) # indirect conjugation # Ana pronoun like conjugation elif pronoun in (vconst.PronounAnta, vconst.PronounAnti, vconst.PronounAntuma, vconst.PronounAntuma_f, vconst.PronounAntum, vconst.PronounAntunna): conj_ana = self.conj_display.get_conj(tense, vconst.PronounAna) if conj_ana == u"": conj_ana = self.conjugate_tense_pronoun(tense, vconst.PronounAna) self.conj_display.add(tense, vconst.PronounAna, conj_ana) conj_ana_without_last_mark = conj_ana[:-1] if pronoun == vconst.PronounAnta: self.conj_display.add(tense, vconst.PronounAnta, conj_ana_without_last_mark+FATHA) elif pronoun == vconst.PronounAnti: self.conj_display.add(tense, vconst.PronounAnti, conj_ana_without_last_mark+KASRA) elif pronoun == vconst.PronounAntuma: self.conj_display.add(tense, vconst.PronounAntuma, conj_ana+MEEM+FATHA+ALEF) elif pronoun == vconst.PronounAntuma_f: self.conj_display.add(tense, vconst.PronounAntuma_f, conj_ana+MEEM+FATHA+ALEF) elif pronoun == vconst.PronounAntum: self.conj_display.add(tense, vconst.PronounAntum, conj_ana+MEEM) elif pronoun == vconst.PronounAntunna: self.conj_display.add(tense, vconst.PronounAntunna, conj_ana+NOON+SHADDA+FATHA) # indirect conjugation # Ana pronoun like conjugation elif pronoun in ( vconst.PronounHya, vconst.PronounHuma_f, #~ vconst.PronounHuma, vconst.PronounHum): vconst.PronounHuma,): conj_huwa = self.conj_display.get_conj(tense, vconst.PronounHuwa) if conj_huwa == u"": conj_huwa = self.conjugate_tense_pronoun(tense, vconst.PronounHuwa) self.conj_display.add(tense, vconst.PronounHuwa, conj_huwa) # حالة الفعل مهموز الآخر if conj_huwa.endswith(YEH+HAMZA+FATHA) : self.conj_display.add(tense, vconst.PronounHya, conj_huwa[:-2]+YEH_HAMZA+FATHA+TEH+SUKUN) self.conj_display.add(tense, vconst.PronounHuma_f, conj_huwa[:-2]+YEH_HAMZA+FATHA+TEH+FATHA+ALEF) self.conj_display.add(tense, vconst.PronounHuma, conj_huwa[:-2]+YEH_HAMZA+FATHA+ALEF) #~ self.conj_display.add(tense, vconst.PronounHum, #~ conj_huwa[:-2]+YEH_HAMZA+DAMMA+WAW+ALEF) else : self.conj_display.add(tense, vconst.PronounHya, conj_huwa+TEH+SUKUN) self.conj_display.add(tense, vconst.PronounHuma_f, conj_huwa+TEH+FATHA+ALEF) self.conj_display.add(tense, vconst.PronounHuma, conj_huwa+ALEF) #~ if conj_huwa.endswith(KASRA+YEH+FATHA): #~ self.conj_display.add(tense, vconst.PronounHum, #~ conj_huwa[:-3]+DAMMA+WAW+ALEF) #~ else: #~ self.conj_display.add(tense, vconst.PronounHum, #~ conj_huwa[:-1]+DAMMA+WAW+ALEF) elif tense in (vconst.TenseFuture, vconst.TensePassiveFuture, vconst.TenseJussiveFuture, vconst.TenseSubjunctiveFuture, vconst.TenseConfirmedFuture, vconst.TensePassiveJussiveFuture, vconst.TensePassiveSubjunctiveFuture, vconst.TensePassiveConfirmedFuture): # direct pronouns conjugations if pronoun in (vconst.PronounAna, vconst.PronounAnta, vconst.PronounAnti, vconst.PronounAntuma, vconst.PronounAntum, vconst.PronounAntunna): conj = self.conjugate_tense_pronoun(tense, pronoun) self.conj_display.add(tense, pronoun, conj) # indirect pronouns # Anta pronouns conjugation like elif pronoun in (vconst.PronounNahnu, vconst.PronounHuwa, vconst.PronounHya): conj_anta = self.conj_display.get_conj(tense, vconst.PronounAnta) if conj_anta == u"": conj_anta = self.conjugate_tense_pronoun(tense, vconst.PronounAnta) self.conj_display.add(tense, vconst.PronounAnta, conj_anta) conj_anta_without_future_letter = conj_anta[1:] if pronoun == vconst.PronounNahnu: self.conj_display.add(tense, vconst.PronounNahnu, NOON+conj_anta_without_future_letter) elif pronoun == vconst.PronounHuwa: self.conj_display.add(tense, vconst.PronounHuwa, YEH+conj_anta_without_future_letter) elif pronoun == vconst.PronounHya: self.conj_display.add(tense, vconst.PronounHya, TEH+conj_anta_without_future_letter) # indirect pronouns # Antuma pronouns conjugation like elif pronoun in (vconst.PronounAntuma, vconst.PronounAntuma_f, vconst.PronounHuma, vconst.PronounHuma_f ): conj_antuma = self.conj_display.get_conj(tense, vconst.PronounAntuma) if conj_antuma == u"": conj_antuma = self.conjugate_tense_pronoun(tense, vconst.PronounAntuma) self.conj_display.add(tense, vconst.PronounAntuma, conj_antuma) if pronoun == vconst.PronounAntuma_f: self.conj_display.add(tense, vconst.PronounAntuma_f, conj_antuma) if pronoun == vconst.PronounHuma_f: self.conj_display.add(tense, vconst.PronounHuma_f, conj_antuma) if pronoun == vconst.PronounHuma: self.conj_display.add(tense, vconst.PronounHuma, YEH+conj_antuma[1:]) # indirect pronouns # Antum pronouns conjugation like elif pronoun == vconst.PronounHum: conj_antum = self.conj_display.get_conj(tense, vconst.PronounAntum) if conj_antum == u"": conj_antum = self.conjugate_tense_pronoun(tense, vconst.PronounAntum) self.conj_display.add(tense, vconst.PronounAntum, conj_antum) self.conj_display.add(tense, vconst.PronounHum, YEH+conj_antum[1:]) # indirect pronouns # Antum pronouns conjugation like elif pronoun == vconst.PronounHunna: conj_antunna = self.conj_display.get_conj(tense, vconst.PronounAntunna) if conj_antunna == u"": conj_antunna = self.conjugate_tense_pronoun(tense, vconst.PronounAntunna) self.conj_display.add(tense, vconst.PronounAntunna, conj_antunna) self.conj_display.add(tense, vconst.PronounHunna, YEH+conj_antunna[1:]) elif tense == vconst.TenseImperative or \ tense == vconst.TenseConfirmedImperative: conj = self.conjugate_tense_pronoun(tense, pronoun) self.conj_display.add(tense, pronoun, conj) # the cnjugated form is stored in cnj_display return self.conj_display.get_conj(tense, pronoun) ##################################### #{ Irregular verbs functions ##################################### def _is_irregular_verb(self): """ Return True if the verb is irregular, founded in the irregular verb table Aإرجاع إّذا كان الفعل ضاذا. الأفعال العربية الخاصة هي رأى، أكل أمر سأل، # ج- إذا كان يتصرف من باب (مَنَعَ يَمْنَعُ)، تحذف واوه, نحو: وَضَعَ، يَضَعُ، وَجَأَ يَجَأُ، وَدَعَ يَدَعُ، وَزَعَ يَزَعُ، وَضَأَ يَضَأُ، وَطَأَ يَطَأُ، وَقَعَ يَقَعُ، وَلَغَ يَلَغُ، وَهَبَ يَهَبُ، عدا خمسة أفعال هي: (وَبَأ)، و(وَبَهَ)، و(وَجَعَ)، و(وَسَعَ)، و(وَهَلَ)، فلا تحذف منها الواو؛ فنقول: يَوْبَأُ، يَوْبَهُ، يَوْجَعُ، يَوْسَعُ، يَوْهَلُ. الأفعال (وَبَأ)، و(وَبَهَ)، و(وَجَعَ)، و(وَسَعَ)، و(وَهَلَ)، الفعل وبَأ يوبأ @return:True if irregular @rtype: Boolean """ if len(self.word_letters) != 3: return False else: # the key is composed from the letters and past and future marks, # to identify irregular verb if self.word_letters == u"ءرى": #~ print self.word_letters.encode("utf8") self.past_haraka = araby.FATHA self.future_type = araby.KASRA #~ self.vlength = 4 key = self.word_letters + self.past_haraka+self.future_type if key in vconst.IRREGULAR_VERB_CONJUG: return True return False def _get_irregular_future_stem(self): """ Get the future stem for irregular verb. @return: the future conjuagtion stem @rtype: unicode; """ # the key is composed from the letters and past and future marks, # to identify irregular verb key = self.word_letters+self.past_haraka+self.future_type if key in vconst.IRREGULAR_VERB_CONJUG: return vconst.IRREGULAR_VERB_CONJUG[key][vconst.TenseFuture] else: return self.word_letters def _get_irregular_passivefuture_stem(self): """ Get the passive future stem for irregular verb. @return: the passive future conjuagtion stem @rtype: unicode; """ # the key is composed from the letters and past and future marks, # to identify irregular verb key = self.word_letters+self.past_haraka+self.future_type if key in vconst.IRREGULAR_VERB_CONJUG: return vconst.IRREGULAR_VERB_CONJUG[key][vconst.TensePassiveFuture] else: return self.word_letters def _get_irregular_imperative_stem(self): """ Get the imperative stem for irregular verb. @return: the passive imperative conjuagtion stem @rtype: unicode; """ # the key is composed from the letters and past and future marks, # to identify irregular verb key = self.word_letters + self.past_haraka+self.future_type if key in vconst.IRREGULAR_VERB_CONJUG: return vconst.IRREGULAR_VERB_CONJUG[key][vconst.TenseImperative] else: return self.word_letters # prepare the irregular conjug for future and imperative # تحضير جذوع التصريف في المضارع والأمر للأفعال الضاذة def _prepare_irregular_future_imperative_stem(self): """ Prepare the conjugation stems for future tenses (future, jussive, subjective) and imperative tense. Those stems will be concatenated with conjugation affixes. """ ## if self.word_letters in vconst.IRREGULAR_VERB_CONJUG.keys(): if self._is_irregular_verb(): (letters, marks) = self._get_irregular_future_stem() #vconst.IRREGULAR_VERB_CONJUG[self.word_letters][vconst.TenseFuture] #تمت إضافة حركة حرف المضارعة إلى الجذع المستعمل في الفعل الشاذ self.tab_conjug_stem[vconst.TenseFuture] = ConjugStem( vconst.TenseFuture, letters, marks) self.tab_conjug_stem[vconst.TenseJussiveFuture] = ConjugStem( vconst.TenseJussiveFuture, letters, marks) self.tab_conjug_stem[vconst.TenseSubjunctiveFuture] = ConjugStem( vconst.TenseSubjunctiveFuture, letters, marks) self.tab_conjug_stem[vconst.TenseConfirmedFuture] = ConjugStem( vconst.TenseConfirmedFuture, letters, marks) (letters1, marks1) = self._get_irregular_passivefuture_stem() #تمت إضافة حركة حرف المضارعة إلى الجذع المستعمل في الفعل الشاذ self.tab_conjug_stem[vconst.TensePassiveFuture] = ConjugStem( vconst.TensePassiveFuture, letters1, marks1) self.tab_conjug_stem[vconst.TensePassiveJussiveFuture] = ConjugStem( vconst.TensePassiveJussiveFuture, letters1, marks1) self.tab_conjug_stem[vconst.TensePassiveSubjunctiveFuture] = \ ConjugStem(vconst.TensePassiveSubjunctiveFuture, letters1, marks1) self.tab_conjug_stem[vconst.TensePassiveConfirmedFuture] = \ ConjugStem(vconst.TensePassiveConfirmedFuture, letters1, marks1) (letters2, marks2) = self._get_irregular_imperative_stem() self.tab_conjug_stem[vconst.TenseImperative] = ConjugStem( vconst.TenseImperative, letters2, marks2) self.tab_conjug_stem[vconst.TenseConfirmedImperative] = \ ConjugStem(vconst.TenseConfirmedImperative, letters2, marks2) return False def get_conj(self, tense, pronoun): """ Get the conjugated verb by tense and pronoun. @param tense: tense of the added conjuagtion. @type tense: unicode @param pronoun: pronoun of the added conjuagtion. @type pronoun: unicode @return : conjugated form of verb if exists. @rtype : unicode """ return self.conj_display.get_conj(tense, pronoun) def get_pronoun_features(self, pronoun): """ Get the features of given pronoun. @param pronoun: pronoun of conjuagtion. @type pronoun: unicode @return : dictionary of pronoun attributes. @rtype : dictionary """ return vconst.PRONOUN_FEATURES.get(pronoun, None) def get_tense_features(self, tense): """ Get the features of given tense. @param tense: tense of the conjuagtion. @type tense: unicode @return : dictionary of tense attributes. @rtype : dictionary """ return vconst.TENSE_FEATURES.get(tense, None)