Upload 29 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+libqutrub/__pycache__/triverbtable.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+ENV PYTHONUNBUFFERED=1
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

README.md

@@ -1,12 +1,14 @@
 ---
-title: Mosaref
-emoji: 🌖
-colorFrom: yellow
-colorTo: red
+title: Al Mosaref
+emoji: 📚
+colorFrom: green
+colorTo: blue
 sdk: docker
 pinned: false
 license: mit
-short_description: arab verbs conjugator
+short_description: Arabic verb conjugation with Qutrub
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# المصرّف
+
+Application de conjugaison des verbes arabes avec Qutrub + Flask.

app.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+
+from flask import Flask, request, jsonify, render_template
+from libqutrub.mosaref_main import do_sarf
+
+app = Flask(__name__, template_folder="templates")
+
+
+@app.route("/")
+def home():
+    return render_template("index.html")
+
+
+@app.route("/conjugate", methods=["POST"])
+def conjugate():
+    data = request.get_json()
+
+    word = data.get("word", "").strip()
+    future_type = data.get("future_type", "فتحة")
+    tense = data.get("tense", "past")
+
+    params = {
+        "alltense": False,
+        "past": False,
+        "future": False,
+        "imperative": False,
+        "future_moode": False,
+        "confirmed": False,
+        "passive": False,
+        "transitive": True
+    }
+
+    if tense == "past":
+        params["past"] = True
+    elif tense == "future":
+        params["future"] = True
+    elif tense == "jussive":
+        params["future"] = True
+        params["future_moode"] = True
+    elif tense == "subjunctive":
+        params["future"] = True
+        params["future_moode"] = True
+    elif tense == "confirmed":
+        params["future"] = True
+        params["confirmed"] = True
+    elif tense == "imperative":
+        params["imperative"] = True
+    elif tense == "confirmed_imperative":
+        params["imperative"] = True
+        params["confirmed"] = True
+
+    result = do_sarf(
+        word=word,
+        future_type=future_type,
+        display_format="HTML",
+        **params
+    )
+
+    if result is None:
+        return jsonify({"result": "<p>تعذر تصريف الفعل. تأكد من صحة الإدخال.</p>"})
+
+    return jsonify({"result": result})
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860, debug=False)

libqutrub/__init__.py

@@ -0,0 +1 @@
+

libqutrub/__pycache__/triverbtable.cpython-313.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:17ddedc943edf2b9176f73818945e6414f5ad919c2b4c43a517d221b28382c14
+size 737469

libqutrub/alefmaddaverbtable.py

@@ -0,0 +1,77 @@
+AlefMaddaVerbTable={
+u'آبل':[u'أءبل'],
+u'آبه':[u'أءبه'],
+u'آبى':[u'أءبى'],
+u'آتم':[u'أءتم'],
+u'آتن':[u'أءتن'],
+u'آتى':[u'أءتى'],
+u'آتى':[u'أءتى'],
+u'آثر':[u'أءثر'],
+u'آثف':[u'أءثف'],
+u'آثم':[u'أءثم'],
+u'آثى':[u'ءاثى'],
+u'آجد':[u'أءجد'],
+u'آجر':[u'أءجر',u'ءاجر'],
+u'آجل':[u'أءجل'],
+u'آجم':[u'أءجم'],
+u'آحن':[u'ءاحن'],
+u'آخذ':[u'ءاخذ'],
+u'آخى':[u'أءخى',u'ءاخى'],
+u'آدب':[u'أءدب'],
+u'آدم':[u'أءدم'],
+u'آدى':[u'أءدى'],
+u'آذن':[u'أءذن'],
+u'آذى':[u'أءذى'],
+u'آرب':[u'أءرب',u'ءارب'],
+u'آرخ':[u'أءرخ'],
+u'آرس':[u'أءرس'],
+u'آرض':[u'أءرض'],
+u'آرط':[u'أءرط'],
+u'آرف':[u'ءارف'],
+u'آرق':[u'أءرق'],
+u'آرك':[u'أءرك'],
+u'آرم':[u'ءارم'],
+u'آرن':[u'أءرن',u'ءارن'],
+u'آرى':[u'أءرى'],
+u'آزر':[u'ءازر'],
+u'آزف':[u'أءزف'],
+u'آزل':[u'أءزل'],
+u'آزى':[u'أءزى',u'ءازى'],
+u'آسب':[u'أءسب'],
+u'آسد':[u'أءسد'],
+u'آسف':[u'أءسف'],
+u'آسن':[u'أءسن'],
+u'آسى':[u'ءاسى'],
+u'آسى':[u'أءسى',u'ءاسى'],
+u'آشى':[u'أءشى'],
+u'آصد':[u'أءصد'],
+u'آصر':[u'ءاصر'],
+u'آصل':[u'أءصل'],
+u'آضّ':[u'ءاضّ'],
+u'آطم':[u'أءطم'],
+u'آفك':[u'أءفك'],
+u'آفى':[u'أءفى'],
+u'آقط':[u'أءقط'],
+u'آكد':[u'أءكد'],
+u'آكر':[u'ءاكر'],
+u'آكف':[u'أءكف'],
+u'آكل':[u'أءكل',u'ءاكل'],
+u'آلت':[u'أءلت'],
+u'آلس':[u'ءالس'],
+u'آلف':[u'أءلف',u'ءالف'],
+u'آلم':[u'أءلم'],
+u'آلى':[u'أءلى'],
+u'آمر':[u'أءمر',u'ءامر'],
+u'آمن':[u'أءمن'],
+u'آنث':[u'أءنث'],
+u'آنس':[u'أءنس',u'ءانس'],
+u'آنض':[u'أءنض'],
+u'آنف':[u'أءنف'],
+u'آنق':[u'أءنق'],
+u'آنى':[u'أءنى'],
+u'آهل':[u'أءهل'],
+u'آوب':[u'ءاوب'],
+u'آوى':[u'أءوى'],
+u'آيد':[u'ءايد'],
+u'آيس':[u'أءيس'],
+}

libqutrub/ar_ctype.py

@@ -0,0 +1,88 @@
+#!/usr/bin/python
+# -*- coding=utf-8 -*-
+#************************************************************************
+# $Id: ar_ctype.py,v 0.7 2009/06/02 01:10:00 Taha Zerrouki $
+#
+# ------------
+# Description:
+# ------------
+#  Copyright (c) 2009, Arabtechies, Arabeyes Taha Zerrouki
+#
+#  Elementary function to manipulate arabic texte
+#
+# -----------------
+# Revision Details:    (Updated by Revision Control System)
+# -----------------
+#  $Date: 2009/06/02 01:10:00 $
+#  $Author: Taha Zerrouki $
+#  $Revision: 0.7 $
+#  $Source: arabtechies.sourceforge.net
+#
+#***********************************************************************/
+
+import re#, string,sys
+from arabic_const import *
+HARAKAT_pat =re.compile(ur"[%s%s%s%s%s%s%s%s]"%(FATHATAN,DAMMATAN,KASRATAN,FATHA,DAMMA,KASRA,SUKUN,SHADDA) )
+HARAKAT_NO_SHADDA_pat =re.compile(ur"[%s%s%s%s%s%s%s]"%(FATHATAN,DAMMATAN,KASRATAN,FATHA,DAMMA,KASRA,SUKUN) )
+
+
+
+#strip tatweel from a word and return a result word
+#--------------------------------------
+def ar_strip_tatweel(w):
+	"strip tatweel from a word and return a result word"
+	return w.replace(TATWEEL,	'')
+
+#strip tatweel and vowel from a word and return a result word but keep shadda
+#--------------------------------------
+def ar_strip_marks_keepshadda(w):
+	return HARAKAT_NO_SHADDA_pat.sub('',w);
+##	return re.sub(ur'[%s%s%s%s%s%s%s%s]' % (FATHATAN, DAMMATAN, TATWEEL,
+##                                            KASRATAN, FATHA, DAMMA, KASRA, SUKUN),	'', w)
+
+
+#strip tatweel and vowel from a word and return a result word
+#--------------------------------------
+def ar_strip_marks(w):
+	"strip tatweel and vowel from a word and return a result word"
+	return HARAKAT_pat.sub('',w);
+##	return re.sub(ur'[%s%s%s%s%s%s%s%s%s]' % (FATHATAN, DAMMATAN, TATWEEL,
+##                                            KASRATAN, FATHA, DAMMA, KASRA, SUKUN,SHADDA),	'', w)
+
+
+
+#strip pounctuation from the text
+#--------------------------------------
+def ar_strip_punct(w):
+    return re.sub(r'[%s%s%s%s\\]' % (string.punctuation, string.digits,
+                                     string.ascii_letters, string.whitespace),
+                  ' ', w)
+
+
+#--------------------------------------
+def replace_pos (word,rep, pos):
+	return word[0:pos]+rep+word[pos+1:];
+
+def is_valid_arabic_word(word):
+    if word=="": return False;
+##    word_nm=ar_strip_marks_keepshadda(word);
+##    # the alef_madda is  considered as 2 letters
+##    word_nm=word_nm.replace(ALEF_MADDA,HAMZA+ALEF);
+    # in arabic ranges
+##    if re.search(u"([^\u0621-\u0652%s%s%s])"%(LAM_ALEF, LAM_ALEF_HAMZA_ABOVE,LAM_ALEF_MADDA_ABOVE),word):
+    if re.search(u"([^\u0621-\u0652\ufefb\ufef7\ufef5])",word):
+
+        return False;
+
+    elif re.match(u"([\d])+",word):
+        return False;
+##    elif word[0] in (WAW_HAMZA,YEH_HAMZA,FATHA,DAMMA,SUKUN,KASRA):
+##        return False;
+###  إذا كانت الألف المقصورة في غير آخر الفعل
+    elif re.match(u"^(.)*[%s](.)+$"%ALEF_MAKSURA,word):
+        return False;
+    elif re.match(u"^(.)*[%s]([^%s%s%s])(.)+$"%(TEH_MARBUTA,DAMMA,KASRA,FATHA),word):
+        return False;
+    return True;
+
+

libqutrub/ar_verb.py

@@ -0,0 +1,1232 @@
+    #!/usr/bin/python
+# -*- coding = utf-8 -*-
+#************************************************************************
+# $Id: ar_verb.py, v 0.7 2009/06/02 01:10:00 Taha Zerrouki $
+#
+# ------------
+# Description:
+# ------------
+#  Copyright (c) 2009, Arabtechies, Arabeyes Taha Zerrouki
+#
+#  Elementary function to manipulate arabic texte
+#
+# -----------------
+# Revision Details:    (Updated by Revision Control System)
+# -----------------
+#  $Date: 2009/06/02 01:10:00 $
+#  $Author: Taha Zerrouki $
+#  $Revision: 0.7 $
+#  $Source: arabtechies.sourceforge.net
+#
+#***********************************************************************/
+"""
+Basic routines to treat verbs
+ar_verb
+"""
+from __future__ import (
+    #~ absolute_import,
+    print_function,
+    #~ unicode_literals,
+    #~ division,
+    )
+import re
+import libqutrub.verb_const as vconst
+# import ar_ctype 
+import pyarabic.araby as araby
+#~ from pyarabic.araby import *
+from pyarabic.araby import FATHA, DAMMA, KASRA, SHADDA, SUKUN, HAMZA, ALEF,  \
+  WAW, ALEF_HAMZA_ABOVE, ALEF_MADDA, \
+ YEH_HAMZA,   ALEF_MAKSURA, YEH, TEH,  \
+LAM_ALEF, SIMPLE_LAM_ALEF, LAM_ALEF_HAMZA_ABOVE, \
+SIMPLE_LAM_ALEF_HAMZA_ABOVE, LAM_ALEF_MADDA_ABOVE ,SIMPLE_LAM_ALEF_MADDA_ABOVE
+#~ import libqutrub.verb_valid as verb_valid
+
+def replace_pos (word, rep, pos):
+    """
+    Replace a letter in string in position
+    @param word: given string
+    @type word: unicode
+    @param rep: replecment letter
+    @type rep: unicode char
+    @param pos: replemcment position
+    @type pos: int
+    @return: modified string
+    @rtype: unicode string
+    """
+    return word[0:pos]+rep+word[pos+1:]
+#####################################
+#{ verb attributes conversion functions
+#####################################
+
+def get_bab_sarf_harakat(number):
+    """
+    Get the   the past and future marks by the bab sarf number
+        - Bab: past  future
+        - 1  : FATHA DAMMA
+        - 2  : FATHA KASRA
+        - 3  : FATHA FATHA
+        - 4  : KASRA FATHA
+        - 5  : DAMMA DAMMA
+        - 6  : KASRA KASRA
+    @param number: Bab sarf number (1-6).
+    @type number: integer(1-6)
+    @return:  a tuple of (past_mark, future_mark)
+    @rtype: tuple
+    """
+    bab = None
+    if number < 1 or number > 6:
+        bab = None
+    elif number == 1:
+        bab = (FATHA, DAMMA)
+    elif number == 2:
+        bab = (FATHA, KASRA)
+    elif number == 3:
+        bab = (FATHA, FATHA)
+    elif number == 4:
+        bab = (KASRA, FATHA)
+    elif number == 5:
+        bab = (DAMMA, DAMMA)
+    elif number == 6:
+        bab = (KASRA, KASRA)
+    return bab
+
+
+def get_bab_sarf_number(past_haraka, future_haraka):
+    """
+    Get the bab sarf number by the past and future marks
+        - Bab: past  future
+        - 1  : FATHA DAMMA
+        - 2  : FATHA KASRA
+        - 3  : FATHA FATHA
+        - 4  : KASRA FATHA
+        - 5  : DAMMA DAMMA
+        - 6  : KASRA KASRA
+    @param past_haraka: past haraka of the verb.
+    @type past_haraka: unicode
+    @param future_haraka: future haraka of the verb.
+    @type future_haraka: unicode
+    @return: Bab sarf number (1-6)
+    @rtype: integer
+    """
+    bab = 0
+    if past_haraka == FATHA and future_haraka == DAMMA:
+        bab = 1
+    elif past_haraka == FATHA and future_haraka == KASRA:
+        bab = 2
+    elif past_haraka == FATHA and future_haraka == FATHA:
+        bab = 3
+    elif past_haraka == KASRA and future_haraka == FATHA:
+        bab = 4
+    elif past_haraka == DAMMA and future_haraka == DAMMA:
+        bab = 5
+    elif past_haraka == KASRA and future_haraka == KASRA:
+        bab = 6
+    return bab
+
+def write_harakat_in_full(harakat):
+    """
+    Write the harakat name in full  in arabic
+    @param harakat: list of harakat chars.
+    @type  harakat: unicode  string
+    @return: harakat in full
+    @rtype: unicode
+    """
+    full = u""
+    tab_harakat = {
+    FATHA:u"فتحة", 
+    DAMMA:u"ضمة", 
+    KASRA:u"كسرة", 
+    SUKUN:u"سكون", 
+    vconst.ALEF_HARAKA:u"ألف", 
+    vconst.WAW_HARAKA:u"واو", 
+    vconst.YEH_HARAKA:u"ياء", 
+    vconst.ALEF_YEH_HARAKA:u"ى", 
+    vconst.ALEF_WAW_HARAKA:u"و", 
+    vconst.ALEF_YEH_ALTERNATIVE:u"ئ", 
+    }
+    for hrk in harakat:
+        if hrk in tab_harakat:
+            full += u'-'+tab_harakat[hrk]
+        else:
+            full += u"*"
+    return full
+
+
+def get_past_harakat_by_babsarf(vtype):
+    """
+    Get the past harakat for the trileteral verb by bab sarf
+        - Bab: past  future
+        - 1  : FATHA DAMMA
+        - 2  : FATHA KASRA
+        - 3  : FATHA FATHA
+        - 4  : KASRA FATHA
+        - 5  : DAMMA DAMMA
+        - 6  : KASRA KASRA
+    @param vtype: the bab sarf codification.
+    @type vtype: unicode a string of number
+    @return: harakat
+    @rtype: unicode
+    """
+    marks = KASRA*3 # make three kasraat by default
+    if vtype in ('1', '2', '3'):
+        marks = FATHA*3
+    elif vtype in ('4', '6'):
+        marks = u"".join([FATHA, KASRA, FATHA])
+    elif vtype == '5':
+        marks = u"".join([FATHA, DAMMA, FATHA])
+    return marks
+
+def get_future_harakat_by_babsarf(vtype):
+    """
+    Get the future harakat for the trileteral verb by bab sarf
+        - Bab: past  future
+        - 1  : FATHA DAMMA
+        - 2  : FATHA KASRA
+        - 3  : FATHA FATHA
+        - 4  : KASRA FATHA
+        - 5  : DAMMA DAMMA
+        - 6  : KASRA KASRA
+    @param vtype: the bab sarf codification.
+    @type vtype: unicode a string of number
+    @return: harakat
+    @rtype: unicode
+    """
+    #ToDo Review
+    marks = KASRA+KASRA+KASRA
+    if vtype in ('1', '2', '3'):
+        marks = FATHA+FATHA+FATHA
+    elif vtype in ('4', '6'):
+        marks = FATHA+KASRA+FATHA
+    elif vtype == '5':
+        marks = FATHA+DAMMA+FATHA
+    return marks
+
+def get_future_haraka_by_babsarf(vtype):
+    """
+    Get the future_type value from  different codifications. 
+    used also in comand line
+    in différent context the future_type is codified as:
+    values
+    or values used as Conjugation mode ( Bab Tasrif باب التصريف)
+        - Bab: past  future
+        - 1  : FATHA DAMMA
+        - 2  : FATHA KASRA
+        - 3  : FATHA FATHA
+        - 4  : KASRA FATHA
+        - 5  : DAMMA DAMMA
+        - 6  : KASRA KASRA
+    @param vtype: the bab sarf codification.
+    @type vtype: unicode a string of number
+    @return: haraka
+    @rtype: unicode char
+    """
+
+    if vtype == '1':
+        return DAMMA
+    elif vtype in ('2', '6'):
+        return KASRA
+    elif vtype in ('3', '4'):
+        return FATHA
+    elif vtype in ('1', '5'):
+        return DAMMA
+    else:
+        return ""
+
+
+def get_haraka_by_name(haraka_name):
+    """
+    Convert an arabic named harakat to a real haraka
+    values
+        - Fahta:(فتحة)
+        - DAMMA:(ضمة)
+        - KASRA:(كسرة)
+    @param haraka_name: the arabic name of haraka.
+    @type haraka_name: unicode
+    @return: the arabic name of haraka .
+    @rtype: unicode char
+    """
+    if araby.is_shortharaka(haraka_name):
+        return haraka_name
+    if haraka_name == u"فتحة"  :
+        return FATHA
+    elif haraka_name == u"ضمة":
+        return DAMMA
+    elif haraka_name == u"كسرة":
+        return KASRA
+    elif haraka_name == u"سكون":
+        return SUKUN
+    else:
+        return False
+
+
+def get_future_type_by_name(haraka_name):
+    """
+    Get the future_type value by haraka arabic name.
+    values
+        - FATHA:(فتحة)
+        - DAMMA:(ضمة)
+        - KASRA:(كسرة)
+    @param haraka_name: the arabic name of haraka.
+    @type haraka_name: unicode
+    @return: haraka
+    @rtype: unicode char
+    """
+    haraka = get_haraka_by_name(haraka_name)
+    if haraka:
+        return haraka
+    else:
+        return FATHA
+
+
+def get_future_type_entree(future_type):
+    """
+    Get the future_type value from  different codifications.
+     used also in comand line
+    in différent context the future_type is codified as:
+    values
+        - Fahta:(fatha, فتحة, ف, f)
+        - DAMMA:(damma, ضمة, ض, d)
+        - KASRA:(kasra, كسرة, ك, k)
+    or values used as Conjugation mode ( Bab Tasrif باب التصريف)
+        - Bab: past  future
+        - 1  : FATHA DAMMA
+        - 2  : FATHA KASRA
+        - 3  : FATHA FATHA
+        - 4  : KASRA FATHA
+        - 5  : DAMMA DAMMA
+        - 6  : KASRA KASRA
+    @param future_type: the future_type codification.
+    @type future_type: unicode
+    @return: extract the future type mark
+    @rtype: unicode char
+    """
+    future_type = u""+future_type.lower()
+    if future_type in (u'fatha', u'فتحة', u'ف', u'f', u'3', u'4'):
+        return FATHA
+    if future_type in (u'damma', u'ضمة', u'ض', u'd', u'1', u'5'):
+        return DAMMA
+    if future_type in (u'kasra', u'كسرة', u'ك', u'k', u'2', u'6'):
+        return KASRA
+    else: return FATHA
+
+def get_transitive_entree(transitive):
+    """
+    Get the transitive value from  different codifications.
+    in différent context the transitivity is codified as:
+        - "t", "transitive", 
+        - u"متعدي", u"م", u"مشترك", u"ك"
+        - True
+    @param transitive: the transitive codification.
+    @type transitive: unicode
+    @return: True if is transitive
+    @rtype: boolean
+    """
+    return transitive in (u"متعدي", u"م", u"مشترك",
+      u"ك", "t", "transitive", True)
+
+#####################################
+#{verb pretreatment functions
+#####################################
+def  normalize_alef_madda(word):
+    """
+    Convert Alef madda into two letters.
+    @param word: given word.
+    @type word: unicode.
+    @return: converted word.
+    @rtype: unicode.
+    """
+    if word.startswith(ALEF_MADDA):
+        word_nm = araby.strip_harakat(word)
+        #print word, word_nm, len(word), len(word_nm)
+        if len(word_nm) == 2:
+            return word_nm.replace(ALEF_MADDA, HAMZA+ALEF)
+        elif len(word_nm) == 3:
+            if word_nm in vconst.ALEF_MADDA_VERB_TABLE:
+                #print word, "exists in madd table", vconst.ALEF_MADDA_VERB_TABLE[word_nm][0]
+                #return the first one only
+                #mylist = ALEF_MADDA_VERB_TABLE[word_nm]
+                return vconst.ALEF_MADDA_VERB_TABLE[word_nm][0]
+            else:
+                return  word_nm.replace(ALEF_MADDA, HAMZA+ALEF)
+        else:
+            return word_nm.replace(ALEF_MADDA, HAMZA+ALEF)
+    else:
+        return word_nm
+
+
+def normalize(word, wordtype = "affix"):
+    """
+    Normalize the word, by unifoming hamzat, Alef madda, shadda, and lamalefs.
+    @param word: given word.
+    @type word: unicode.
+    @param type: if the word is an affix
+    @type type: unicode.
+    @return: converted word.
+    @rtype: unicode.
+    """
+# تحويل الكلمة إلى شكلها النظري.
+# الشكل اللإملائي للكلمة هو طريقة كتابتها حسب قواعد الإملاء
+# الشكل النظري هو الشكل المتخيل للكلمة دون تطبيق قواعد اللغة
+# ويخص عادة الأشكال المتعددة للهمزة، و التي تكتب همزة على السطر
+# أمثلة
+# إملائي        نظري
+#إِمْلَائِي        ءِمْلَاءِي
+#سَاَلَ        سَءَلَ
+# الهدف : تحويل الكلمة إلى شكل نظري، 
+#ومن ثم إمكانية تصريفها بعيدا عن قواعد الإملاء،
+#وبعد التصريف يتم تطبيق قواعد الإملاء من جديد.
+#الفرضية: الكلمات المدخلة مشكولة شكلا تاما.
+#الطريقة:
+# 1-تحويل جميع أنواع الهمزات إلى همزة على السطر
+# 1-فك الإدغام
+    i = 0
+#   strip tatweel
+# the tatweel is used to uniformate the affix 
+# when the Haraka is used separetely
+    if wordtype != "affix":
+        word = araby.strip_tatweel(word)
+## تستبدل الألف الممدودة في , ل الكلمة بهمزة قطع بعدها همزة أخرى
+    if word.startswith(ALEF_MADDA):
+        word = normalize_alef_madda(word)
+
+    # ignore harakat at the begin of the word
+    len_word = len(word)
+    while i < len_word and araby.is_shortharaka(word[i]): # in HARAKAT:
+        i += 1
+    word = word[i:]
+    # convert all Hamza from into one form
+    word = araby.normalize_hamza(word)
+    #Convert All LAM ALEF Ligature into separate letters
+    word = word.replace(LAM_ALEF, SIMPLE_LAM_ALEF)
+    word = word.replace(LAM_ALEF_HAMZA_ABOVE, SIMPLE_LAM_ALEF_HAMZA_ABOVE)
+    word = word.replace(LAM_ALEF_MADDA_ABOVE, SIMPLE_LAM_ALEF_MADDA_ABOVE)
+    return word
+
+
+def uniformate_alef_origin(marks, word_nm, future_type = KASRA):
+    """
+    Convert toi its origin according to the future type haraka
+    @param marks: given marks.
+    @type marks: unicode.
+    @param word_nm: given word unvocalized.
+    @type word_nm: unicode.
+    @param future_type: The future mark of the triletiral verb.
+    @type future_type: unicode char, default KASRA.
+    @return: converted marks.
+    @rtype: unicode.
+    """
+    if len(marks) != 2:
+        return marks
+# الحرف ماقبل الأخير علة
+    elif marks[len(marks)-2] == vconst.ALEF_HARAKA:
+        if future_type == KASRA:
+            marks = marks[:-2]+vconst.ALEF_YEH_HARAKA+marks[-1:]
+        elif future_type == DAMMA:
+            marks = marks[:-2]+vconst.ALEF_WAW_HARAKA+marks[-1:]
+# الحرف الأخير علة
+    if len(word_nm) == 3 and word_nm[-1:] == ALEF:
+        word_nm = word_nm[:-1]+vconst.ALEF_MAMDUDA
+    elif len(word_nm)>3 and word_nm[-1:] == ALEF:
+        word_nm = word_nm[:-1]+YEH#ALEF_MAKSURA
+    elif word_nm[-1:] == ALEF_MAKSURA:
+        word_nm = word_nm[:-1]+ALEF_MAKSURA
+    return marks
+
+#--------------------------------------
+# Predecated function
+#--------------------------------------
+def normalize_affix(word):
+    """
+    Replace shadda by SUKUN +SHADDA
+    @param word: given word.
+    @type word: unicode.
+    @return: converted word.
+    @rtype: unicode.
+    """
+    # convert SHadda to sukun shadda
+    word = word.replace(SHADDA, SUKUN+SHADDA)
+
+    return word
+
+
+def uniformate_suffix(word):
+    """ separate the harakat and the letters of the given word, 
+    it return two strings ( the word without harakat and the harakat).
+    If the weaked letters are reprsented as long harakat and striped 
+    from the word.
+    """
+    ## type : affix : uniformate affixes
+##    word = normalize_affix(word)
+    word = word.replace(SHADDA, SUKUN+SHADDA)
+    shakl = u""
+    word_nm = u""
+    i = 0
+    len_word = len(word)
+#    print "len word", len(word)
+    while i < len_word:
+        if not araby.is_shortharaka(word[i]):  # not in HARAKAT:
+            word_nm += word[i]
+            if i+1 < len(word) and araby.is_shortharaka(word[i+1]):
+                if word[i+1] == FATHA :
+                    if i+2 < len(word) and word[i+2] == ALEF and \
+                                 i+3 < len(word):
+                        shakl += vconst.ALEF_HARAKA
+                        i += 3
+                    else :
+                        shakl += FATHA
+                        i += 2
+                elif word[i+1] == DAMMA and i+2 < len(word) and \
+                       word[i+2] == WAW:
+                    if i+3 >= len(word) or not araby.is_shortharaka(word[i+3]):
+                        shakl += vconst.WAW_HARAKA
+                        i += 3
+                    else :
+                        shakl += DAMMA
+                        i += 2
+                elif word[i+1] == KASRA and i+2 < len(word) and \
+                 word[i+2] == YEH:
+                    if i+3 >= len(word) or not araby.is_shortharaka(word[i+3]):
+                        shakl += vconst.YEH_HARAKA
+                        i += 3
+                    else :
+                        shakl += KASRA
+                        i += 2
+                else :
+                    shakl += word[i+1]
+                    i += 2
+
+            elif  i+1 < len(word) and araby.is_haraka(word[i+1]):
+                shakl += word[i+1]
+            else:
+                shakl += vconst.NOT_DEF_HARAKA
+                i += 1
+        else: i += 1
+    if len(word_nm) == len(shakl):
+        return (word_nm, shakl)
+    else: return (u"", u"")
+
+
+def uniformate_verb(word):
+    """
+    Separate the harakat and the letters of the given word, 
+    it return two strings ( the word without harakat and the harakat).
+    If the weaked letters are reprsented as long harakat 
+    and striped from the word.
+    @param word: given word.
+    @type word: unicode.
+    @return: (letters, harakat).
+    @rtype: tuple of unicode.
+    """
+    if word == "":
+        return ("", "")
+    #normalize ALEF MADDA
+    if word.startswith(ALEF_MADDA):
+        word = normalize_alef_madda(word)
+    else:
+        word = word.replace(ALEF_MADDA, HAMZA+ALEF)
+
+    word_nm = araby.strip_harakat(word)
+    length = len(word_nm)
+    if len(word_nm) != 3:
+        # تستعمل الهمزات لتخمين حركات الفعل الثلاثي
+        # normalize hamza here, because we use it to 
+        # detect harakat on the trilateral verb.
+        word_nm = vconst.HAMZAT_PATTERN.sub(HAMZA, word_nm)
+    # length of word after normalization
+
+    # اهمزات تستعمل لكشف تشكيل الفعل، يتم توحيدها لاحقا
+    if length == 3:
+        if word_nm[1]in (ALEF, ALEF_HAMZA_ABOVE) or \
+         word_nm[2] in (ALEF_MAKSURA, ALEF_HAMZA_ABOVE, ALEF):
+            marks = FATHA+FATHA+FATHA
+        elif word[1] == YEH_HAMZA or word[2] in (YEH, YEH_HAMZA):
+            marks = FATHA+KASRA+FATHA
+        else:
+            # let the verb haraka
+            i = 0
+        ## ignore harakat at the began of the word
+            while araby.is_shortharaka(word[i]):# in HARAKAT:
+                i += 1
+        # الحرف الأول
+            if not araby.is_shortharaka(word[i]):#not in HARAKAT:
+                i += 1
+        # الحركة الأولى
+            while araby.is_shortharaka(word[i]):#word[i] in HARAKAT:
+                i += 1
+        # الحرف الثاني
+            if not araby.is_shortharaka(word[i]):#word[i] not in HARAKAT:
+                i += 1
+        #الحركة الثانية
+            if not araby.is_shortharaka(word[i]):#word[i] not in HARAKAT:
+            #وجدنا مشاكل في تصريف الفعل المضاعف في الماضي
+            # نجعل الحركة الثانية فتحة مؤقتا
+            #ToDo: review this case
+                secondharaka = FATHA
+            else:
+                secondharaka = word[i]
+            marks = u''.join([FATHA, secondharaka, FATHA])
+        # تستعمل الهمزات لتخمين حركات الفعل الثلاثي
+        # normalize hamza here, because we use it to 
+        # detect harakat on the trilateral verb.
+        word_nm = vconst.HAMZAT_PATTERN.sub(HAMZA, word_nm)
+
+    elif length == 4:
+        marks = vconst.UNIFORMATE_MARKS_4
+    elif length == 5:
+        if word_nm.startswith(TEH):
+            marks = vconst.UNIFORMATE_MARKS_5TEH
+        else :
+            marks = vconst.UNIFORMATE_MARKS_5
+    elif length == 6:
+        marks = vconst.UNIFORMATE_MARKS_6
+    else:
+        marks = FATHA*len(word_nm)
+
+    i = 1
+# first added automaticlly
+    new_word = word_nm[0]
+    new_harakat = marks[0]
+# between the first and the last
+    while i < length-1:
+        if word_nm[i] == ALEF:
+            new_harakat = new_harakat[:-1]+vconst.ALEF_HARAKA
+        else:
+            new_harakat += marks[i]
+            new_word += word_nm[i]
+        i += 1
+# the last letter
+##  حالة الفعل عيا، أعيا، عيّا والتي يتحول إلى ياء بدلا عن واو
+    if word_nm[i] == ALEF:
+        if len(word_nm) == 3 and word_nm[1] != YEH:
+            new_word += vconst.ALEF_MAMDUDA
+        else:
+            new_word += YEH
+    else:
+        new_word += word_nm[i]
+    new_harakat += marks[i]
+##    new_word += word_nm[i]
+    return (new_word, new_harakat)
+
+
+#####################################
+#{verb conjugation output treatment functions
+#####################################
+def standard_harakat(word):
+    """
+    Treat Harakat on the word before output.
+    معالجة الحركات قبل الإخراج،
+    @param word: given vocalized word.
+    @type word: unicode.
+    @return: <vocalized word with ajusted harakat.
+    @rtype: unicode.
+    """
+    k = 1
+    new_word = word[0]
+    len_word = len(word)
+    while k < len_word:
+# الحروف من دون العلة لا تؤخذ بيعين الاعتبار، كما لا تؤخذ إذا كانت في أول الكلمة
+        if word[k] not in (ALEF, YEH, WAW, ALEF_MAKSURA):
+            new_word += word[k]
+        else:
+    ##إذا كان الحرف علة ولم يكن في أول الكلمة
+    ##إذا كان ما قبله ليس حركة، ومابعده ليس حركة، أو انتهت الكلمة
+            if not araby.is_shortharaka(word[k-1]) and \
+            (k+1 >= len_word or not araby.is_shortharaka(word[k+1])) :
+                if word[k] == ALEF:
+                    new_word += FATHA+ALEF
+                elif word[k] == WAW :
+                    new_word += DAMMA+WAW
+                elif word[k] == YEH:
+                    new_word += KASRA+YEH
+                else:
+                    new_word += word[k]
+            else:
+                new_word += word[k]
+        k += 1
+    return new_word
+
+
+def geminating(word_nm, harakat):
+    """ treat geminating cases
+    المدخلات هي من كلمة غير مشكولة يقابلها حركاتها
+    والحرف المضعف يمثل بشدة
+    وإذا كانت الحالة تستوجب الفك، استبدلت الشدة بالحرف المضعف،
+    أمّا إذا كانت لا تستوجب الفك، 
+فتُعدّل حركة الحرف المضعف الأول إلى حركة ملغاة، 
+تحذف في دالة الرسم الإملائي فيما بعد
+    @param word_nm: given unvocalized word.
+    @type word_nm: unicode.
+    @param harakat: given harakat.
+    @type harakat: unicode.
+    @return: (letters, harakat).
+    @rtype: tuple of unicode.
+    """
+    new_word = u""
+    new_harakat = u""
+    i = 0
+    length = len(word_nm)
+    ##    has_shadda = False
+    ##    has_shadda = False
+    if word_nm.find(SHADDA) < 0:
+        return (word_nm, harakat)
+    ##has_shadda and
+    while i < length:
+    # نعالج الحالات التي فيها الحرف الحالي متبوع بحرف شدة،
+    # ندرس الحالات التي يجب فيها فك الإدغام
+        if (i > 0 and i+1 < length and word_nm[i+1] == SHADDA and \
+        harakat[i] in (SUKUN, FATHA, KASRA, DAMMA)) and harakat[i-1]:
+            # treat ungeminating case
+
+#إذا كان الحرف المضعف الأول غير ساكن والحرف المضعّف الثاني (ممثلا بشدة)ساكنا،
+# يفك الإدغام.أمّا إذا كانت لا تستوجب الفك، 
+
+            if  harakat[i] != SUKUN and harakat[i+1] == SUKUN:
+                #ungeminating
+                new_word += word_nm[i]
+                word_nm = replace_pos(word_nm, word_nm[i], i+1)
+                new_harakat += harakat[i]
+                i += 1
+
+            elif  harakat[i] == SUKUN and harakat[i+1] == SUKUN:
+                #no geminating
+                new_word += word_nm[i]
+                word_nm = replace_pos(word_nm, word_nm[i], i+1)
+                new_harakat += FATHA
+                i += 1
+            else:
+
+    # عندما يكون الحرف السابق ساكنا فإنه يستعيع
+    #يض عن حركته بحركة الحرف الأول
+                if i-1 >= 0 and new_harakat[i-1] == SUKUN:
+                    new_word += word_nm[i]+SHADDA
+                    if harakat[i] != SUKUN:
+                        new_harakat = new_harakat[:-1]+harakat[i]+ \
+                           vconst.NOT_DEF_HARAKA+harakat[i+1]
+                    else:
+                        new_harakat = new_harakat[:-1]+FATHA+ \
+                        vconst.NOT_DEF_HARAKA+harakat[i+1]
+    ## يتم الإدغام إذا كان الحرف السابق ذو حركة طويلة
+                elif i-1 >= 0 and new_harakat[i-1] in \
+                (vconst.ALEF_HARAKA, vconst.WAW_HARAKA, \
+                vconst.YEH_HARAKA):
+                    new_word += word_nm[i]+SHADDA
+                    new_harakat += vconst.NOT_DEF_HARAKA+harakat[i+1]
+
+                elif harakat[i] == SUKUN:
+                    new_word += word_nm[i]+SHADDA
+                    new_harakat += vconst.NOT_DEF_HARAKA+harakat[i+1]
+                else:
+    ## مؤقت حتى يتم حل المشكلة
+                    new_word += word_nm[i]+SHADDA
+                    new_harakat += vconst.NOT_DEF_HARAKA+harakat[i+1]
+    ##TODO
+    ## منع الإدغام في بعض الحالات التي لا يمكن فيها ��لإدغام
+    ##مثل حالة سكتتا ، أي الحرفات متحركان وما قبلهاما متحرك
+    ## تم حل هذه المشكلة من خلال خوارزمية التجانس بين التصريفات
+                i += 2
+        elif i > 0 and i+1 < length and word_nm[i+1] == word_nm[i] and \
+        harakat[i]  == SUKUN and harakat[i+1] in (FATHA, DAMMA, KASRA):
+            # treat geminating case
+            new_word += word_nm[i]+SHADDA
+            new_harakat += vconst.NOT_DEF_HARAKA+harakat[i+1]
+            i += 2
+        else :
+            new_word += word_nm[i]
+            new_harakat += harakat[i]
+            i += 1
+    return (new_word, new_harakat)
+
+
+def standard2(word_nm, harakat):
+    """ join the harakat and the letters to the give word
+     in the standard script, 
+    it return one strings ( the word with harakat and the harakat).
+
+    @param word_nm: given unvocalized word.
+    @type word_nm: unicode.
+    @param harakat: given harakat.
+    @type harakat: unicode.
+    @return: vocalized word.
+    @rtype: unicode.
+    """
+    if len(word_nm) != len(harakat):
+        print(word_nm.encode('utf8'),len(word_nm), u"-".join([araby.name(x) for x in harakat]), len(harakat))
+        return u"*"
+    else:
+        word = u""
+        i = 0
+        word_nm, harakat = geminating(word_nm, harakat)
+        if len(word_nm) != len(harakat):
+            return u""
+    ## حالة عدم الابتداء بسكون
+    ##إذا كان الحرف الثاني مضموما  تكون الحركة الأولى مضمومة، وإلا تكون مكسورة
+        if len(harakat) != 0 and harakat.startswith(SUKUN):
+            word_nm = ALEF+word_nm
+            if len(harakat) >= 2 and harakat[1] in \
+                    (DAMMA, vconst.WAW_HARAKA):
+                harakat = DAMMA+harakat
+            else:
+                harakat = KASRA+harakat
+
+    ##        word_nm = tahmeez2(word_nm, harakat)
+        if len(word_nm) != len(harakat):
+            return u""
+        word_before = word_nm
+        harakat_before = harakat
+        word_nm, harakat = homogenize(word_nm, harakat)
+        if len(word_nm) != len(harakat):
+            print("len word: ", len(word_nm), word_nm.encode('utf8') )
+            print("len harakat: ", len(harakat), repr(harakat))
+            print(repr(harakat_before), word_before.encode('utf8'))
+            return u""
+        word_nm = tahmeez2(word_nm, harakat)
+
+        len_word_nm = len(word_nm)
+        while i < len_word_nm:
+            # للعمل :
+    # هذه حالة الألف التي أصلها ياء
+    # وقد استغنينا عنها بأن جعلنا الحرف الناقص من الفعل الناقص حرفا تاما
+            if harakat[i] in vconst.WRITTEN_HARAKA:
+                word += word_nm[i]+vconst.WRITTEN_HARAKA[harakat[i]]
+            else:
+                word += word_nm[i]+harakat[i]
+            i += 1
+
+    #-تحويل همزة القطع على الألف بعدها فتحة 
+#وهمزة القطع على الألف بعدها سكون إلى ألف ممدودة
+    for (pat, rep) in vconst.STANDARD_REPLACEMENT:
+        word = word.replace( pat, rep)
+
+
+    return word
+
+
+def tahmeez2(word_nm, harakat):
+    """ Transform hamza on the standard script. 
+    in entry the word without harakat and the harakat seperately
+    return the word with non uniform hamza.
+    إعلال و إبدال الهمزة.
+    @param word_nm: given unvocalized word.
+    @type word_nm: unicode.
+    @param harakat: given harakat.
+    @type harakat: unicode.
+    @return: (letters, harakat) after treatment.
+    @rtype: tuple of unicode.
+    """
+    # the harakat length  != letters length
+    if len(word_nm) != len(harakat):
+        return u""
+    # if no hamza, no tahmeez
+    elif  HAMZA not in word_nm:
+        return word_nm
+    else:
+        ha2 = u""
+        #eliminate some altenative of HARAKAT to standard.
+        for hrk in harakat:
+            if hrk == vconst.ALEF_YEH_HARAKA or \
+              hrk == vconst.ALEF_WAW_HARAKA:
+                hrk = vconst.ALEF_HARAKA
+            ha2 += hrk
+        harakat = ha2
+        word = u""
+        for i in range(len(word_nm)):
+            if word_nm[i] != HAMZA and word_nm[i] != ALEF_HAMZA_ABOVE:
+                word += word_nm[i]
+            else:
+                if i == 0:
+                    actual = harakat[i]
+                    swap = vconst.INITIAL_TAHMEEZ_TABLE.get(actual, actual)
+                else:
+                    before = harakat[i-1]
+                    actual = harakat[i]
+
+                    if i+1 < len(word_nm):
+    # if the hamza have shadda, it will take the harakat of shadda.
+                        if actual == vconst.NOT_DEF_HARAKA or actual == SUKUN:
+                            if word_nm[i+1] == SHADDA and harakat[i+1] != SUKUN:
+                                actual = harakat[i+1]
+                        if before == vconst.NOT_DEF_HARAKA:
+                            before = FATHA
+                        if actual == vconst.NOT_DEF_HARAKA:
+                            actual = FATHA
+
+                        if  before in vconst.MIDDLE_TAHMEEZ_TABLE and\
+                      actual in  vconst.MIDDLE_TAHMEEZ_TABLE[before]:
+                            swap = vconst.MIDDLE_TAHMEEZ_TABLE[before][actual]
+                            #~ # if the actual haraka is FATHA
+                            if before  in (SUKUN, vconst.YEH_HARAKA, vconst.ALEF_HARAKA, vconst.WAW_HARAKA):
+                                if actual == FATHA and word_nm[i-1] == araby.YEH:
+                                    swap = araby.YEH_HAMZA
+                                #~ #elif word_nm[i-1] in ( araby.WAW, araby.DAL,araby.THAL, 
+                                #~ #   araby.REH, araby.ZAIN ):
+                                #ZZZZ
+                                elif word_nm[i-1] == araby.WAW and actual  not in (KASRA, vconst.YEH_HARAKA):
+                                    swap = araby.HAMZA                            
+                        else :
+                            swap = word_nm[i]
+
+                    else :
+                        if before == vconst.NOT_DEF_HARAKA:
+                            before = FATHA
+                        if actual == vconst.NOT_DEF_HARAKA: 
+                            actual = FATHA
+
+                        if  before in vconst.FINAL_TAHMEEZ_TABLE and \
+                         actual in vconst.FINAL_TAHMEEZ_TABLE[before]:
+                            if word_nm[i-1]  in( araby.WAW, ) and actual in (FATHA, DAMMA):
+                                #pass
+                               swap = araby.HAMZA 
+                            else:
+                                swap = vconst.FINAL_TAHMEEZ_TABLE[before][actual]
+                        else :
+                            swap = word_nm[i]
+                word += swap
+    return word
+
+def treat_sukun2(word_nm, harakat):
+    """ Treat the rencontre of sukun. 
+    in entry the word without harakat and the harakat seperately,
+     and the probably haraka
+    return the new sequence of harakat
+
+    @param word_nm: given unvocalized word.
+    @type word_nm: unicode.
+    @param harakat: given harakat.
+    @type harakat: unicode.
+    @return: (letters, harakat).
+    @rtype: tuple of unicode.
+    """
+    # if no sukun, to treat
+    if harakat.find(SUKUN) < 0:
+        return harakat
+    len_word = len(word_nm)
+    len_harakat = len(harakat)
+
+    if len_word != len_harakat:
+        return harakat
+    else:
+        new_harakat = u""
+        for i in range(len_word):
+            if i+1 < len_harakat and harakat[i+1] == SUKUN:
+                if harakat[i] == vconst.ALEF_HARAKA:
+                    #  other conditions
+                      # إذا كان حرف الألف ثانيا مثل خاف يقلب كسرة،
+                    #أما إذا كان ثالثا أو رابعا فيصبح فتحة،
+                    # مثل خاف لا تخف
+                    # حالة الألف بعدها حرف مشدد
+                    if i+2 < len_word and word_nm[i+2] == SHADDA:
+                        new_harakat += vconst.ALEF_HARAKA
+                    elif i == 0 :
+                        new_harakat += KASRA
+                    else:
+                        new_harakat += FATHA
+                # if the actual haraka is in table use table conversion
+                elif harakat[i] in vconst.CONVERSION_TABLE:
+                    new_harakat += vconst.CONVERSION_TABLE[harakat[i]]
+                else :
+                    new_harakat += harakat[i]
+            else :
+                new_harakat += harakat[i]
+    return new_harakat
+
+
+
+def homogenize(word_nm, harakat):
+    """ لإreat the jonction of WAW, YEH.
+    معالجة التحولات التي تطرا على الياء أو الوا في وسط الكلمة أو في اخرها
+    @param word_nm: given unvocalized word.
+    @type word_nm: unicode.
+    @param harakat: given harakat.
+    @type harakat: unicode.
+    @return: (letters, harakat)after treatment.
+    @rtype: tuple of unicode.
+    """
+    # inequal length between letters and harakat
+    if len(word_nm) != len(harakat):
+        print("Homogenize:inequal length", len(word_nm), len(harakat))
+        return (word_nm, harakat)
+    # word without weak letters doesn't need treatment
+    #~ elif not re.search(ur'[%s%s%s%s]'%(ALEF_MAKSURA, vconst.ALEF_MAMDUDA, \
+    elif not re.search(u'[%s%s%s%s]'%(ALEF_MAKSURA, vconst.ALEF_MAMDUDA, \
+     YEH, WAW), word_nm):
+        return (word_nm, harakat)
+    # treatment
+    else:
+        new_harakat = harakat[0]
+        new_word = word_nm[0]
+        # نبدأ من الحرف الثاني لأن الحرف الأول لا يعالج
+        i = 1
+        ## دراسة حالات الياء والواو قبل النهاية
+        len_word_nm = len(word_nm)
+        while i < len_word_nm-1:
+            actual_letter = word_nm[i]            # Actual letter
+            actual_haraka = harakat[i]            # Actual haraka
+            if i-1 >= 0 :
+                previous_letter = word_nm[i-1]    # previous letter
+                previous_haraka = harakat[i-1]    # previous letter
+            else:
+                previous_letter = ''
+                previous_haraka = ''
+            if i+1 < len_word_nm:
+                next_letter = word_nm[i+1]        # next letter
+                next_haraka = harakat[i+1]        # next haraka
+            else:
+                next_letter = ''
+                next_haraka = ''
+            # إذا كان الحرف التالي مضعف
+            if i+2 < len_word_nm and word_nm[i+2] == SHADDA:
+                shadda_in_next = True
+            else:
+                shadda_in_next = False
+
+            if  actual_letter == ALEF_MAKSURA or actual_letter == YEH:
+ #إذا كانت الياء ساكنة أو مكسورة (كسرا قصيرا أو طويلا)،
+# وكان ما قبلها مكسورا، يأخذ ماقبلها كسرة طويلة            #مثال :
+            # بِ +يْ  = > بِي
+            #بِ +يِ   = > بِي
+            #بِ +يي  = > بِي
+
+                if actual_letter == ALEF_MAKSURA and next_haraka == SUKUN:
+                    new_harakat += ""
+                elif  (actual_haraka in(SUKUN, KASRA, vconst.YEH_HARAKA)) and \
+                 previous_haraka == KASRA and not shadda_in_next:
+                    new_harakat = new_harakat[:-1]+vconst.YEH_HARAKA
+                elif  (actual_haraka in(KASRA)) and previous_haraka == KASRA \
+                  and shadda_in_next:
+                    new_harakat += ''
+                # حالة هو تيسّر في المضارع المبني للمجهول
+                #~ elif  actual_letter == YEH and previous_haraka == DAMMA and \
+                #~ actual_haraka  == DAMMA  and  shadda_in_next:
+                    #~ #pass
+                    #~ new_harakat += DAMMA
+                    #~ new_word += YEH
+                # # مثل تؤدّينّ
+                # elif  previous_haraka in (KASRA, FATHA) and
+                # actual_haraka  == DAMMA  and  shadda_in_next:
+                    # new_harakat += FATHA
+                    # new_word += YEH
+                # ToDO review
+                #سقّى، يُسقُّون
+                elif  actual_haraka  == DAMMA  and  shadda_in_next:
+                    if previous_haraka in (DAMMA, KASRA):
+                    #~ if previous_haraka in DAMMA:
+                        new_harakat = new_harakat[:-1]+DAMMA
+                    else:
+                        new_harakat += DAMMA
+                        new_word += WAW
+                #تحويل الياء إلى واو ساكنة
+                #2 - إذا كانت الياء مضمومة (ضما قصيرا أو طويلا)،
+# وكان ما قبلها مفتوحا، تتحول الياء إلى واو ساكنة.                #مثال :
+                # بَ +يُ  = > بَِوْ
+                #بَ +يو   = > بَوْ
+
+                elif (actual_haraka in (DAMMA, vconst.WAW_HARAKA))and\
+                  previous_haraka == FATHA and not shadda_in_next:
+                    new_harakat += SUKUN
+                    new_word += WAW
+                elif (actual_haraka in (DAMMA, vconst.WAW_HARAKA))and \
+                 previous_haraka == FATHA and shadda_in_next:
+                    new_harakat += actual_haraka
+                    new_word += WAW
+                #إذا كانت ساكنة، وماقبلها مضموما،
+# ولم يكن ما بعدها ياء، أخذ ما قبلها ضمة طويلة.
+                #مثال :
+                # بُ +يُت  = >بُوت
+
+
+                elif  (actual_haraka  == SUKUN) and previous_haraka == DAMMA \
+                 and next_letter != YEH and not shadda_in_next:
+                    new_harakat = new_harakat[:-1]+vconst.WAW_HARAKA
+
+                elif (actual_haraka  == vconst.YEH_HARAKA)and \
+                previous_haraka == FATHA:
+                    new_harakat += SUKUN
+                    new_word += YEH
+                elif  (actual_haraka  == vconst.WAW_HARAKA) and previous_haraka == KASRA :
+                    new_harakat = new_harakat[:-1]+vconst.WAW_HARAKA
+
+                    #~ if araby.is_hamza(previous_letter):
+                        #~ new_word    = new_word[:-1] + araby.WAW_HAMZA
+                        
+
+                else :
+                    new_harakat += actual_haraka
+                    new_word += YEH
+
+            elif   actual_letter == vconst.ALEF_MAMDUDA or \
+             actual_letter == WAW:
+                if actual_letter == vconst.ALEF_MAMDUDA and \
+                next_haraka == SUKUN:
+                    new_harakat += ""
+                elif actual_letter == vconst.ALEF_MAMDUDA and \
+                (actual_haraka in(SUKUN, DAMMA, vconst.WAW_HARAKA))and\
+                 (previous_haraka == DAMMA) and not shadda_in_next:
+                    new_harakat = new_harakat[:-1]+vconst.WAW_HARAKA
+                    
+                elif actual_letter == WAW and (actual_haraka in(SUKUN, DAMMA))\
+                 and (previous_haraka == DAMMA) and not shadda_in_next:
+                    new_harakat = new_harakat[:-1]+vconst.WAW_HARAKA
+                    
+                #تحويل الواو المضمومة  أو الطويلة إلى واو ساكنة
+                elif  (actual_haraka in (DAMMA, vconst.WAW_HARAKA)) \
+                and previous_haraka == FATHA :
+                    new_harakat += SUKUN
+                    new_word += WAW
+                # حالة وجع ايجع
+                elif (actual_haraka  == (SUKUN))and \
+                (previous_haraka == KASRA) and not shadda_in_next:
+                    new_harakat = new_harakat[:-1]+vconst.YEH_HARAKA
+                elif  (actual_haraka == KASRA)and shadda_in_next:
+                    new_harakat = new_harakat[:-1]+KASRA
+                    
+                elif  actual_letter == vconst.ALEF_MAMDUDA and \
+                (actual_haraka == DAMMA) and shadda_in_next:
+                    if previous_haraka == DAMMA:
+                        new_harakat = new_harakat[:-1]+DAMMA
+                    else:
+                        new_harakat += DAMMA
+                        new_word +=  WAW
+                        
+                
+                elif  actual_letter == WAW and (actual_haraka == vconst.WAW_HARAKA):
+                    new_harakat = new_harakat[:-1]+ vconst.WAW_HARAKA
+                elif  actual_letter == WAW and (actual_haraka == DAMMA) and previous_haraka == DAMMA and shadda_in_next:
+                    new_harakat +=""
+                    
+                elif  actual_letter == vconst.ALEF_MAMDUDA and \
+                (actual_haraka == vconst.YEH_HARAKA) and \
+                 not shadda_in_next:
+                    new_harakat = new_harakat[:-1]+vconst.YEH_HARAKA
+                elif  (actual_letter == WAW ) and (actual_haraka == DAMMA) and previous_haraka in (FATHA,) and \
+                 shadda_in_next:
+                    new_harakat += DAMMA
+                    new_word += WAW
+                elif  actual_letter == WAW and (actual_haraka == DAMMA) and previous_haraka in (FATHA,) and \
+                 shadda_in_next:
+                    new_harakat += DAMMA
+                    new_word += WAW
+                elif  actual_letter == WAW and (actual_haraka == DAMMA) and\
+                 shadda_in_next:
+                    new_harakat += DAMMA
+                    new_word += WAW
+                #elif  actual_letter == WAW and actual_haraka == FATHA and (previous_haraka == FATHA):
+                #    new_harakat += "" #actual_haraka
+                 #   new_word += ""#WAW
+                else :
+                    new_harakat += actual_haraka
+                    new_word += WAW
+            else:
+                new_harakat += actual_haraka
+                new_word += actual_letter
+            i += 1
+    # end of while
+    # we have to treat the last letter
+    ## دراسة حالة الحرف الأخير
+        # Actual letter
+        last_letter = word_nm[i]
+        # Actual haraka
+        last_haraka = harakat[i]
+        if i-1 >= 0 :
+            # previous letter
+            previous_letter = word_nm[i-1]
+            # previous haraka
+            previous_haraka = harakat[i-1]
+        else:
+            previous_letter = ''
+            previous_haraka = ''
+
+        if  last_letter == ALEF_MAKSURA or last_letter == YEH :
+            if  (last_haraka in(KASRA, DAMMA))  and previous_haraka == KASRA:
+                new_harakat = new_harakat[:-1]+vconst.YEH_HARAKA
+            elif  (last_haraka in(vconst.YEH_HARAKA)) and\
+             previous_haraka == KASRA :
+                new_harakat = new_harakat[:-1]+vconst.YEH_HARAKA
+            #حذف حركة الحرف الأخير إذا كان ساكنا
+            elif (last_haraka == SUKUN):
+            ## pass
+                new_harakat += ''
+                new_word += ''
+            elif  previous_letter == YEH and \
+            (last_haraka in(KASRA, DAMMA, FATHA)) and previous_haraka == FATHA:
+                new_harakat += vconst.NOT_DEF_HARAKA
+                new_word += ALEF
+            elif  previous_letter != YEH and \
+            (last_haraka in(KASRA, DAMMA, FATHA)) and previous_haraka == FATHA:
+                new_harakat += vconst.NOT_DEF_HARAKA
+                new_word += ALEF_MAKSURA
+            elif  (last_haraka in(vconst.WAW_HARAKA)) and \
+            previous_haraka == KASRA:
+                new_harakat = new_harakat[:-1]+vconst.WAW_HARAKA
+            #حالة تصريف الفعل الناقص في المضارع المجزوم مع أنت للمؤنث
+            elif  (last_haraka == vconst.YEH_HARAKA) and  \
+            previous_haraka == FATHA:
+                new_harakat += SUKUN
+                new_word += YEH
+            else :
+                new_harakat += last_haraka
+                new_word += YEH
+
+        elif last_letter == vconst.ALEF_MAMDUDA :
+            if (last_haraka in(DAMMA, KASRA, vconst.WAW_HARAKA)) and \
+            previous_haraka == DAMMA :
+                new_harakat = new_harakat[:-1]+vconst.WAW_HARAKA
+            elif (last_haraka in(vconst.ALEF_HARAKA)) and \
+             previous_haraka == DAMMA:
+            ##                pass
+                new_harakat = new_harakat[:-1]+vconst.YEH_HARAKA
+            elif  (last_haraka == vconst.YEH_HARAKA):
+                new_harakat = new_harakat[:-1]+vconst.YEH_HARAKA
+                new_word += ''
+            elif (last_haraka == SUKUN) and previous_haraka == KASRA :
+                pass
+
+            elif (last_haraka == SUKUN):
+                new_harakat += ''
+                new_word += ''
+            elif (last_haraka == FATHA)and previous_haraka == FATHA:
+                new_harakat += vconst.NOT_DEF_HARAKA
+                new_word += vconst.ALEF_MAMDUDA
+            else :
+                new_harakat += last_haraka
+                new_word += WAW
+                #new_word += vconst.ALEF_MAMDUDA
+        elif  last_letter == WAW :
+            if  (last_haraka in(DAMMA, FATHA))  and previous_haraka == FATHA:
+                new_harakat += vconst.NOT_DEF_HARAKA
+                new_word += ALEF_MAKSURA
+            elif  (last_haraka in(FATHA,))  and previous_haraka == KASRA:
+                new_harakat += vconst.FATHA
+                new_word += YEH
+            elif  (last_haraka in (vconst.YEH_HARAKA,))  and previous_haraka in (KASRA, DAMMA):
+                new_harakat = new_harakat[:-1]+vconst.YEH_HARAKA
+                new_word += ''
+            elif (last_haraka in(SUKUN,))  and previous_haraka in (DAMMA, FATHA):
+                new_harakat += ""
+                new_word += ""
+            else:
+                new_harakat += harakat[i]
+                new_word += word_nm[i]
+        else:
+            new_harakat += harakat[i]
+            new_word += word_nm[i]
+        return (new_word, new_harakat)
+
+
+def is_triliteral_verb(verb):
+    """ Test if the verb is  triliteral, 
+    used in selectionof verbs from the triliteral verb dictionnary
+    @param verb: given verb.
+    @type verb: unicode.
+    @return: True if the verb is triliteral.
+    @rtype: Boolean.
+    """
+    verb_nm = araby.strip_harakat(verb)
+    verb_nm = verb_nm.replace(ALEF_MADDA, HAMZA+ALEF)
+    if len(verb_nm) == 3:
+        return True
+    else : return False
+
+
+
+
+

libqutrub/arabic_const.py

@@ -0,0 +1,113 @@
+#!/usr/bin/python
+# -*- coding=utf-8 -*-
+#---
+# $Id: arabic_const.py,v 1.6 2003/04/22 17:18:22 elzubeir Exp $
+#
+# ------------
+# Description:
+# ------------
+#
+# Arabic codes
+#
+# (C) Copyright 2003, Arabeyes, Mohammed Elzubeir
+# -----------------
+# Revision Details:    (Updated by Revision Control System)
+# -----------------
+#  $Date: 2003/04/22 17:18:22 $
+#  $Author: elzubeir $
+#  $Revision: 1.6 $
+#  $Source: /home/arabeyes/cvs/projects/duali/pyduali/pyduali/arabic.py,v $
+#
+#  This program is written under the BSD License.
+#---
+
+COMMA            = u'\u060C'
+SEMICOLON        = u'\u061B'
+QUESTION         = u'\u061F'
+HAMZA            = u'\u0621'
+ALEF_MADDA       = u'\u0622'
+ALEF_HAMZA_ABOVE = u'\u0623'
+WAW_HAMZA        = u'\u0624'
+ALEF_HAMZA_BELOW = u'\u0625'
+YEH_HAMZA        = u'\u0626'
+ALEF             = u'\u0627'
+BEH              = u'\u0628'
+TEH_MARBUTA      = u'\u0629'
+TEH              = u'\u062a'
+THEH             = u'\u062b'
+JEEM             = u'\u062c'
+HAH              = u'\u062d'
+KHAH             = u'\u062e'
+DAL              = u'\u062f'
+THAL             = u'\u0630'
+REH              = u'\u0631'
+ZAIN             = u'\u0632'
+SEEN             = u'\u0633'
+SHEEN            = u'\u0634'
+SAD              = u'\u0635'
+DAD              = u'\u0636'
+TAH              = u'\u0637'
+ZAH              = u'\u0638'
+AIN              = u'\u0639'
+GHAIN            = u'\u063a'
+TATWEEL          = u'\u0640'
+FEH              = u'\u0641'
+QAF              = u'\u0642'
+KAF              = u'\u0643'
+LAM              = u'\u0644'
+MEEM             = u'\u0645'
+NOON             = u'\u0646'
+HEH              = u'\u0647'
+WAW              = u'\u0648'
+ALEF_MAKSURA     = u'\u0649'
+YEH              = u'\u064a'
+MADDA_ABOVE      = u'\u0653'
+HAMZA_ABOVE      = u'\u0654'
+HAMZA_BELOW      = u'\u0655'
+ZERO             = u'\u0660'
+ONE              = u'\u0661'
+TWO              = u'\u0662'
+THREE            = u'\u0663'
+FOUR             = u'\u0664'
+FIVE             = u'\u0665'
+SIX              = u'\u0666'
+SEVEN            = u'\u0667'
+EIGHT            = u'\u0668'
+NINE             = u'\u0669'
+PERCENT          = u'\u066a'
+DECIMAL          = u'\u066b'
+THOUSANDS        = u'\u066c'
+STAR             = u'\u066d'
+MINI_ALEF        = u'\u0670'
+ALEF_WASLA       = u'\u0671'
+FULL_STOP        = u'\u06d4'
+BYTE_ORDER_MARK  = u'\ufeff'
+
+# Diacritics
+FATHATAN         = u'\u064b'
+DAMMATAN         = u'\u064c'
+KASRATAN         = u'\u064d'
+FATHA            = u'\u064e'
+DAMMA            = u'\u064f'
+KASRA            = u'\u0650'
+SHADDA           = u'\u0651'
+SUKUN            = u'\u0652'
+
+SMALL_ALEF=u"\u0670"
+SMALL_WAW=u"\u06E5"
+SMALL_YEH=u"\u06E6"
+
+#---------------------------------------------------------------------------
+# Arabic ligatures
+#---------------------------------------------------------------------------
+
+LAM_ALEF=u'\ufefb'
+LAM_ALEF_HAMZA_ABOVE=u'\ufef7'
+LAM_ALEF_HAMZA_BELOW=u'\ufef9'
+LAM_ALEF_MADDA_ABOVE=u'\ufef5'
+simple_LAM_ALEF=LAM+ALEF
+simple_LAM_ALEF_HAMZA_ABOVE=LAM+ALEF_HAMZA_ABOVE
+simple_LAM_ALEF_HAMZA_BELOW=LAM+ALEF_HAMZA_BELOW
+simple_LAM_ALEF_MADDA_ABOVE=LAM+HAMZA+FATHA+ALEF
+
+

libqutrub/classnoun.py

@@ -0,0 +1,368 @@
+#!/usr/bin/python
+# -*- coding=utf-8 -*-
+
+#************************************************************************
+# $Id: classnoun.py, v 0.1 2016/04/01 12:14:00 Taha Zerrouki $
+#
+# ------------
+# Description:
+# ------------
+#  Copyright (c) 2009, Arabtechies, Arabeyes Taha Zerrouki
+#
+#  The Main class to do the Noun derivation 
+#
+# -----------------
+# Revision Details:    (Updated by Revision Control System)
+# -----------------
+#  $Date: 2016/04/01 12:14:00 $
+#  $Author: Taha Zerrouki $
+#  $Revision: 0.1 $
+#  $Source: qutrub.sourceforge.net
+#
+#***********************************************************************/
+"""
+Noun Class for derivation
+@author: Taha Zerrouki
+@contact: taha dot zerrouki at gmail dot com
+@copyright: Arabtechies, Arabeyes, Taha Zerrouki
+@license: GPL
+@date:2016/04/01
+@version: 0.1
+"""
+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, DAMMATAN
+import libqutrub.classverb as classverb
+import  libqutrub.verb_const as vconst
+import libqutrub.ar_verb as ar_verb 
+
+#~ class ConjugStem:
+# Noun derivation 
+class NounClass(classverb.VerbClass):
+    """
+    Noun Class: represent a derived noun from a verb or a root
+    """
+    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).        
+        """    
+        # we make transitive as True, to force the cverb conjugator
+        # to generate passive voices
+        classverb.VerbClass.__init__(self, verb, True, future_type)
+        self._prepare_subject_stem()
+        self._prepare_object_stem()
+
+
+#####################################
+#{ Attributes functions
+#####################################
+#####################################
+#{ Extract information from verb functions
+#####################################
+
+    def _prepare_subject_stem(self):
+        """
+        Prepare the derivation stems 
+         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 nouns type:
+          - اسم الفاعل
+        """
+        #~ """
+        #~ اسم الفاعل /تعريفـه :
+#~ اسم مشتق من الفعل المبني للمعلوم للدلالة على وصف من فعل الفعل على وجه الحدوث .
+#~ مثل : كتب – كاتب ، جلس – جالس ، اجتهد – مُجتهد ، استمع – مُستمع .
+#~ صوغه : يصاغ اسم الفاعل على النحو التالي :
+#~ 1 ـ من الفعل الثلاثي على وزن فاعل :
+#~ نحو : ضرب - ضارب ، وقف - واقف ، أخذ - آخذ ، قال - قائل ، بغى - باغ ، أتى - آت ، رمى - رام ، وقى - واق .
+#~ فإن كان الفعل معتل الوسط بالألف " أجوف " تقلب ألفه همزة مثل : قال – قائل ، نام – نائم .
+#~ ومنه قوله تعالى : { وفي أموالهم حق للسائل والمحروم } 19 الذاريات .
+#~ أما إذا كان معتل الوسط بالواو أو بالياء فلا تتغير عينه في اسم الفاعل .
+#~ مثل : حول – حاول ، حيد – حايد .
+#~ وإن كان الفعل معتل الآخر " ناقصاً " فإن اسم الفاعل ينطبق عليه ما ينطبق على الاسم المنقوص . أي تحذف ياؤه الأخيرة في حالتي الرفع والجر ، وتبقى في حالة النصب .
+#~ 2 ـ من الفعل المزيد :
+#~ يصاغ اسم الفاعل من الفعل غير الثلاثي " المزيد " على وزن الفعل المضارع مع إبدال حرف المضارعة ميماً مضمومة وكسر ما قبل الآخر .
+#~ مثل : طمأن – مُطمئِن ، انكسر - مُنكسِر ، استعمل – مُستعمِل .
+#~ – الفعل المزيد الخماسي على وزن تفاعل هو ما تكون عينه مفتوحة في المضارع، لكنها تكون مكسورة في اسم الفاعل
+#~ 
+#~ 
+#~ الخوارزمية:
+#~ 1- إن كان ثلاثيا:
+    #~ - إن كان  أجوفا، نغير حرفه الأوسط إلى همزة، 
+#~ - نشتقه على وزن فاعل
+#~ 2- إن كان غير ثلاثي
+    #~ - إن كان خماسيا مبدوءا بتاء نأخذ مضارعه ونكسر ما قبل آخره
+    #~ - وإلا نأخذ مضارعه كما هو
+    #~ """
+    #~ 
+        letters = self.word_letters
+        marks = self.word_marks
+        # حركات مشتق اسم الفاعل
+        derivation_subject_marks = marks
+        derivation_subject_letters = letters
+        # حالة الفعل الثلاثي
+        if self.vlength == 3:
+            # الفعل الأجوف ممثل بحرفين باعتبار أنّ الألف هو حركة طويلة
+            # لذا نضع وسطه همزة
+            if len(letters) == 2:
+                # اسم الفاعل
+                derivation_subject_letters = letters[0] + HAMZA + letters[1]
+            elif letters.endswith(ALEF_MAKSURA) or letters.endswith(vconst.ALEF_MAMDUDA):
+                derivation_subject_letters = letters[0] + letters[1] + YEH
+
+
+            # اسم افاعل من الثلاثي جميعا
+            # حركاته
+            derivation_subject_marks = vconst.ALEF_HARAKA + KASRA + DAMMA 
+
+        # الفعل غير الثلاثي
+        else:
+        # الفعل الخماسي المبدوء بتاء
+        # هذا مضارعه عينه مفتوحة
+        # لذا نحتاج إلى عين مكسورة
+            if self.vlength == 5 and letters.startswith(TEH):
+                #~ if len(letters) == 4: # تفاعل 
+                    #~ # الألف تعتبر مدة وليست حرفا 
+                    #~ # لذا يظهر الاختلاف بين طول الطلمة وعدد الحروف الفعلي
+                    #~ # الفعل الخماسي المبدوء بتاء يختلف في حركة عين اسم الفاعل عن مضارعه
+                    #~ derivation_subject_marks = FATHA + vconst.ALEF_HARAKA + KASRA + DAMMA                    
+                #~ else:
+                    #~ # الفعل الخماسي المبدوء بتاء يختلف في حركة عين اسم الفاعل عن مضارعه
+                    #~ derivation_subject_marks = FATHA + FATHA + SUKUN + KASRA + DAMMA
+                derivation_subject_marks = FATHA + FATHA + SUKUN + KASRA + DAMMA
+
+                # add Damma for MEEM
+                #~ derivation_subject_marks = DAMMA + derivation_subject_marks
+            else :
+                # الفعل غير الثلاثي يصاغ على منوال مضارعه
+                derivation_subject_marks = self.tab_conjug_stem[vconst.TenseFuture].marks
+                #~ if derivation_subject_marks.startswith(FATHA):
+                   #~ derivation_subject_marks = DAMMA + derivation_subject_marks[1:] 
+                #~ derivation_subject_marks = DAMMA + derivation_subject_marks 
+                derivation_subject_letters = self.tab_conjug_stem[vconst.TenseFuture].letters
+
+    # معالجة الألفات في الفعل والحركات الطويلة
+        #  إذا كان طول الحركات ألأصلية للفعل 
+        # أقل من طول حركات الماضي المبني للمجهول
+        # هذا يعني وجود حركة طويلة
+        # نقوم بتحويل الحركة الطويلة إلى ما يوافقها
+        if len(marks) < len(derivation_subject_marks):
+            derivation_subject_marks = self._homogenize_harakat(marks, derivation_subject_marks)
+        # Add Meem Haraka
+        if self.vlength != 3:
+            if self.vlength == 5 and letters.startswith(TEH):
+                # add Damma for MEEM
+                derivation_subject_marks = DAMMA + derivation_subject_marks
+            else :
+                # الفعل غير الثلاثي يصاغ على منوال مضارعه
+                if derivation_subject_marks.startswith(FATHA):
+                   derivation_subject_marks = DAMMA + derivation_subject_marks[1:] 
+        ### اشتقاق اسم الفاعل 
+        self.tab_conjug_stem[vconst.SubjectNoun] = classverb.ConjugStem(
+        vconst.SubjectNoun, derivation_subject_letters, derivation_subject_marks)
+
+    def _prepare_object_stem(self):
+        """
+        Prepare the derivation stems 
+         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 nouns type:
+          - اسم المفعول
+          
+        """
+        letters = self.word_letters
+        marks = self.word_marks
+        # حركات مشتق اسم المفعول
+        derivation_object_marks = marks
+        derivation_object_letters = letters
+        # حالة الفعل الثلاثي
+    #~ """
+    #~ اسم المفعول تعريفـه :
+#~ اسم يشتق من الفعل المبني للمجهول للدلالة على وصف من يقع عليه الفعل .
+#~ مثل : ضُرب مضروب ، أُكل مأكول ، شُرب مشروب ، بُث مبثوث ، وُعد موعود ، أُتى مأتي ، رُجي مرجي ، مُلئ مملوء .
+#~ صوغـه :
+#~ لا يصاغ إلا من الأفعال المتعدية المتصرفة على النحو التالي :
+#~ 1 ـ من الثلاثي على وزن مفعول .
+#~ كما في الأمثلة السابقة . ومنه : الحق صوته مسموع .
+#~ والشاي مشروب لذيذ الطعم .
+#~ فإن كان الفعل معتل الوسط بالألف فإنه يحدث فيه إعلال تقتضيه القواعد الصرفية ، فيكون اسم المفعول من الفعل قال : مقول ، وباع : مبيع .
+#~ ومما سبق يتبع في أخذ اسم المفعول من الأفعال المعتلة الوسط الآتي :
+#~ نأخذ الفعل المضارع من الفعل المراد اشتقاق اسم المفعول منه ثم نحذف حرف المضارعة ونستبدلها بالميم .
+#~ مثل : قال يقول مقول ، باع يبيع مبيع .
+#~ فإن كان وسط المضارع ألفاً ترد في اسم المفعول إلى أصلها الواو أو الياء .
+#~ مثل : خاف يخاف مخوف ، فالألف أصلها الواو لأن مصدرها " الخوف " .
+#~ وهاب يهاب مهيب ، فالألف أصلها الياء لأن مصدرها " الهيبة " .
+#~ وإن كان الفعل معتل الآخر " ناقصاً " نأتي بالمضارع منه ثم نحذف حرف المضارعة ونضع مكانها ميماً مفتوحة ونضعف الحرف الأخير الذي هو حرف العلة سواء أكان أصله واواً أو ياءً أو ألفاً .
+#~ مثل : دعا يدعو مدعوّ ، رجا يرجو مرجوّ ، رمى يرمي مرميّ ، سعى يسعى مسعيّ .
+#~ 2 ـ ويصاغ من غير الثلاثي " المزيد " على وزن الفعل المضارع مع إبدال حرف المضارعة ميماً مضمومة وفتح ما قبل الآخر .
+#~ مثل : أنزل ينزل مُنزَل ، انطلق ينطلق مُنطلَق ، انحاز ينحاز مُنحاز ، استعمل يستعمل مُستعمَل .
+#~ ـ إذا كان الفعل لازماً يصح اشتقاق اسم المفعول منه حسب القواعد السابقة بشرط استعمال شبه الجملة " الجار والمجرور أو الظرف " مع الفعل ، وقد يصح المصدر أيضاً .
+#~ مثال : ذهب به – مذهوب به ، سافر يوم الخميس – ما مُسافَرٌ يوم الخميس .
+#~ ومثال استعمال المصدر مع اسم مفعول الفعل اللازم : العلم مُنتفَع انتفاع عظيم به .
+#~ 
+#~ 1- إن كان  ثلاثيا
+        #~ - غير معتل: على وزن مفعول
+#~ - معتل : 1- فعل مثال => كغير المعتل
+               #~ 2- الأجوف : من مضارعه      يقول => مقول
+                    #~ يسير => مسير
+                    #~ يخاف => مخوف
+                    #~ يهاب => يهيب
+    #~ 3- الناقص : من مضارعه مع تضعيف الحرف الأخير
+#~ 2- غير ثلاثي
+    #~ - على غرار المضارع المبني للمجهول
+#~ ل
+    #~ """
+        if self.vlength == 3:
+            # اسم المفعول
+            # حالة المعتل
+            # الأجوف
+            if len(letters) == 2:            
+                # اسم المفعول من الأجوف
+                # يشتق من المضارع المعلوم
+                derivation_object_marks = self.tab_conjug_stem[vconst.TenseFuture].marks
+                derivation_object_letters = self.tab_conjug_stem[vconst.TenseFuture].letters
+
+            elif (self.word_letters.endswith(ALEF_MAKSURA) or
+             self.word_letters.endswith(ALEF) or self.word_letters.endswith(YEH)):            
+                # والناقص
+                # يشتق من المضارع المعلوم
+                # يضاف إليه شدة في آخره 
+                derivation_object_marks = self.tab_conjug_stem[vconst.TenseFuture].marks
+                derivation_object_letters = self.tab_conjug_stem[vconst.TenseFuture].letters
+            else: # السالم والمضعف والمثال
+                if self.word_letters.endswith(SHADDA):
+                    # strip last letters which is Shadda, duplicate the second letters
+                    derivation_object_letters =  letters[0]+ letters[1]*2
+                else:
+                    derivation_object_letters =  letters
+                # الحروف
+                derivation_object_marks  = FATHA + SUKUN + vconst.WAW_HARAKA + DAMMA 
+        # الفعل غير الثلاثي
+        else:
+            # اسم المفعول من غير الثلاثي
+            derivation_object_marks = self.tab_conjug_stem[vconst.TensePassiveFuture].marks
+            derivation_object_letters = self.tab_conjug_stem[vconst.TensePassiveFuture].letters
+
+    # معالجة الألفات في الفعل والحركات الطويلة
+        #  إذا كان طول الحركات ألأصلية للفعل 
+        # أقل من طول حركات الماضي المبني للمجهول
+        # هذا يعني وجود حركة طويل��
+        # نقوم بتحويل الحركة الطويلة إلى ما يوافقها
+        #~ if len(marks) < len(derivation_object_marks):
+            #~ derivation_object_marks = self._homogenize_harakat(marks, 
+                     #~ derivation_object_marks)
+        ### اشتقاق اسم الفاعل والمفعول
+        self.tab_conjug_stem[vconst.ObjectNoun] = classverb.ConjugStem(
+        vconst.ObjectNoun, derivation_object_letters, derivation_object_marks)
+
+    def conjugate_noun(self, noun_type):
+        """
+        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;        
+        """
+
+        if noun_type == vconst.SubjectNoun :
+            if self.vlength == 3 :            
+                #prefix
+                pre_val = u""
+            else:
+                pre_val = MEEM                
+            #suffix
+            suf_val = DAMMA           
+        elif noun_type == vconst.ObjectNoun:
+            #prefix
+            pre_val = MEEM 
+            #suffix
+            suf_val = DAMMA 
+        else:
+            #prefix
+            pre_val = "" 
+            #suffix
+            suf_val = ""
+            
+        stem_l = self.tab_conjug_stem[noun_type].letters
+        stem_m = self.tab_conjug_stem[noun_type].marks
+        # _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 self.cache_standard['suffix'].has_key( suf_val): 
+            (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 self.cache_standard['sukun'].has_key(key_cache):
+            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 self.cache_standard['standard'].has_key(key_cache):
+            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 derivate(self):
+        """
+        Derivate a subject and object nouns from a verb
+        @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;        
+        """
+        subj = self.conjugate_noun(vconst.SubjectNoun)
+        obj  = self.conjugate_noun(vconst.ObjectNoun)
+
+        if subj.endswith(araby.DAMMA):
+            subj = subj[:-1]+araby.DAMMATAN
+        if self.vlength == 3 and obj.endswith(araby.YEH):
+            obj+= SHADDA + DAMMATAN 
+        #~ if self.verb == u"مَحَا":
+            #~ print self.verb.encode('utf8'), len(self.word_letters), obj.endswith(WAW*2+
+             #~ DAMMA)
+        if self.vlength == 3  and obj.endswith(WAW*2+DAMMA):
+            obj = obj[:-2] +SHADDA + DAMMATAN                        
+        if obj.endswith(araby.DAMMA):
+            obj = obj[:-1]+araby.DAMMATAN
+            
+        return u"\t".join([subj,obj])

libqutrub/classverb.py

@@ -0,0 +1,1101 @@
+#!/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)

libqutrub/conjugate.py

@@ -0,0 +1,166 @@
+#!/usr/bin/python
+# -*- coding=utf-8 -*-
+#************************************************************************
+# $Id: conjugate.py, v 0.7 2009/06/02 01:10:00 Taha Zerrouki $
+#
+# ------------
+# Description:
+# ------------
+#  Copyright (c) 2009, Arabtechies, Arabeyes Taha Zerrouki
+#
+#  This file is the main file to execute the application in the command line
+#
+# -----------------
+# Revision Details:    (Updated by Revision Control System)
+# -----------------
+#  $Date: 2009/06/02 01:10:00 $
+#  $Author: Taha Zerrouki $
+#  $Revision: 0.7 $
+#  $Source: arabtechies.sourceforge.net
+#
+#***********************************************************************/
+"""
+Conjugate console
+"""
+
+import sys
+import getopt
+import os
+sys.path.append('../')
+import libqutrub.mosaref_main as mosaref_main
+import libqutrub.ar_verb as ar_verb
+import libqutrub.verb_valid as verb_valid
+
+SCRIPT_NAME =  os.path.splitext(os.path.basename(sys.argv[0]))[0]
+SCRIPT_VERSION  =  '0.1'
+AUTHOR_NAME = "Taha Zerrouki"
+def usage():
+    """Display usage options"""
+    print "(C) CopyLeft 2009, %s" % AUTHOR_NAME
+    print "Usage: %s -f filename [OPTIONS]" % SCRIPT_NAME
+#"Display usage options"
+    print "\t[-h | --help]\toutputs this usage message"
+    print "\t[-V | --version]\tprogram version"
+    print "\t[-f | --file=filename]\tinput file to %s" % SCRIPT_NAME
+    print "\t[-d | --display=format]\tdisplay format as html, csv, tex, xml"
+    print "\t[-a | --all ] \tConjugate in all tenses"
+    print "\t[-i | --imperative]\tConjugate in imperative"
+    print "\t[-F | --future]\tconjugate in the present and the future"
+    print "\t[-p | --past]\t conjugate in the past"
+    print "\t[-c | --confirmed]  conjugate in confirmed (future or imperative)"
+    print """\t[-m | --moode]\tconjugate in future Subjunctive(mansoub) 
+    or Jussive (majzoom)"""
+    print " \t[-v | --passive] passive form"
+    print "\r\nN.B. FILE FORMAT is descripted in README"
+    print "\r\nThis program is licensed under the GPL License\n"
+
+
+def grabargs():
+    """Grab command-line arguments"""
+    alltense  =  False
+    future = False
+    past = False
+    passive = False
+    imperative = False
+    confirmed = False
+    future_moode = False
+    fname  =  ''
+    display_format  =  'csv'
+
+    if not sys.argv[1:]:
+        usage()
+        sys.exit(0)
+    try:
+        opts, args  =  getopt.getopt(sys.argv[1:], "hVvcmaiFpi:d:f:", 
+                               ["help", "version", "imperative", "passive",
+                               'confirmed', 'moode', "past", "all", 
+                                "future", "file = ", "display = "], )
+    except getopt.GetoptError:
+        usage()
+        sys.exit(0)
+    for opt, val in opts:
+        if opt in ("-h", "--help"):
+            usage()
+            sys.exit(0)
+        if opt in ("-V", "--version"):
+            print SCRIPT_VERSION
+            sys.exit(0)
+        if opt in ("-v", "--passive"):
+            passive  =  True
+        if opt in ("-f", "--file"):
+            fname  =  val
+        if opt in ("-d", "--display"):
+            display_format  =  val.upper()
+        if opt in ("-F", "--future"):
+            future  =  True
+        if opt in ("-a", "--all"):
+            alltense = True
+        if opt in ("-p", "--past"):
+            past  = True
+        if opt in ("-i", "--imperative"):
+            imperative = True
+        if opt in ("-c", "--confirmed"):
+            confirmed = True
+        if opt in ("-m", "--moode"):
+            future_moode = True
+
+    return (fname, alltense, future, past, passive, imperative, confirmed, 
+    future_moode, display_format)
+
+def main():
+    """Main function"""
+    filename, alltense, future, past, passive, imperative, confirmed, \
+     future_moode, display_format =  grabargs()
+    try:
+        fle = open(filename)
+    except IOError:
+        print " Error :No such file or directory: %s" % filename
+        sys.exit(0)
+
+    print filename, alltense, future, past, passive, imperative, \
+     confirmed, future_moode
+
+    line = fle.readline().decode("utf")
+    text = u""
+    verb_table = []
+    nb_field = 2
+    while line :
+        if not line.startswith("#"):
+
+            text = text+" "+ line.strip()
+            liste = line.split("\t")
+            if len(liste) >= nb_field:
+                verb_table.append(liste)
+
+        line = fle.readline().decode("utf8")
+    fle.close()
+
+    for tuple_verb in verb_table:
+        word = tuple_verb[0]
+
+        if not verb_valid.is_valid_infinitive_verb(word):
+            print u"is invalid verb ", 
+            print word.encode("utf8")
+        else:
+            future_type = u""+tuple_verb[1]
+            future_type = ar_verb.get_future_type_entree(future_type)
+            transitive = u""+tuple_verb[2]
+            if transitive in (u"متعدي", u"م", u"مشترك", u"ك", "t", 
+            "transitive"):
+                transitive = True
+            else :
+                transitive = False
+            text = mosaref_main.do_sarf(word, future_type, alltense, past, 
+            future, passive, imperative, future_moode, confirmed, 
+            transitive, display_format)
+            print text.encode("utf8")
+
+if __name__  ==  "__main__":
+    main()
+
+
+
+
+
+
+

libqutrub/conjugatedisplay.py

@@ -0,0 +1,568 @@
+#!/usr/bin/python
+# -*- coding=utf-8 -*-
+#************************************************************************
+# $Id: conjugateddisplay.py, v 0.7 2009/06/02 01:10:00 Taha Zerrouki $
+#
+# ------------
+# Description:
+# ------------
+#  Copyright (c) 2009, Arabtechies, Arabeyes Taha Zerrouki
+#
+#  The Class used to display information after conjugated
+#   All print and views and display are redirected to this class
+#
+# -----------------
+# Revision Details:    (Updated by Revision Control System)
+# -----------------
+#  $Date: 2009/06/02 01:10:00 $
+#  $Author: Taha Zerrouki $
+#  $Revision: 0.7 $
+#  $Source: arabtechies.sourceforge.net
+#
+#***********************************************************************/
+"""
+The conjugation display class to manage different display format.
+"""
+#~ from libqutrub.verb_const import *
+import libqutrub.verb_const as vconst
+import pyarabic.araby as araby
+
+# صف عرض التصريفات حسب الضمائر
+# جدول عرض التصريفات حسب الأزمنة
+# تعيينه متغيرا شاملا من أجل تقليل
+ #~ بناء جدول عرض التصريفات في كل عرض.
+ONE_TENSE_PRONOUN = {u"أنا":"" , u"أنت":"" , u"أنتِ":"" , u"هو":"" ,
+ u"هي":"" , u"أنتما":"" , u"أنتما مؤ":"" , u"هما":"" , 
+ u"هما مؤ":"" ,
+  u"نحن":"" , u"أنتم":"" , u"أنتن":"" , u"هم":"" , u"هن":""}
+
+# delete the global TableConj vvariable because  it causes problem
+TAB_DISPLAY = {
+vconst.PronounAna:u"1", 
+vconst.PronounNahnu:u"2", 
+vconst.PronounAnta:u"3", 
+vconst.PronounAnti:u"4ِ", 
+vconst.PronounAntuma:u"5", 
+vconst.PronounAntuma_f:u"6", 
+vconst.PronounAntum:u"7", 
+vconst.PronounAntunna:u"8", 
+vconst.PronounHuwa:u"9", 
+vconst.PronounHya:u"10", 
+vconst.PronounHuma:u"11", 
+vconst.PronounHuma_f:u"12", 
+vconst.PronounHum:u"13", 
+vconst.PronounHunna:u"14", 
+
+
+# const for Tense Name
+vconst.TensePast:u"20", 
+vconst.TenseFuture:u"21", 
+vconst.TenseImperative:u"22", 
+vconst.TenseConfirmedImperative:u"23", 
+vconst.TenseJussiveFuture:u"24", 
+vconst.TenseSubjunctiveFuture:u"25", 
+vconst.TenseConfirmedFuture:u"26", 
+
+
+vconst.TensePassivePast:u"27", 
+vconst.TensePassiveFuture:u"28", 
+vconst.TensePassiveJussiveFuture:u"29", 
+vconst.TensePassiveSubjunctiveFuture:u"30", 
+vconst.TensePassiveConfirmedFuture:u"31", 
+}
+
+class ConjugateDisplay:
+    """
+    conjugatedisplay class is used to display verb conjugation 
+    in different ways and uses.
+    """
+    tab_conjug = {}
+    pronouns = {}
+    verb = u""
+    mode = 'Text'
+    future_form = u""
+    text = {}
+    transitive = False
+    def __init__(self, verb):
+        """
+        Create the conjugedtdisplay instance for the verb.
+        @param verb: given verb.
+        @type verb unicode.
+        """
+# بناء جدول عرض التصريفات
+        self.tab_conjug = {
+    vconst.TensePast:ONE_TENSE_PRONOUN.copy(), 
+    vconst.TensePassivePast:ONE_TENSE_PRONOUN.copy(), 
+    vconst.TenseFuture:ONE_TENSE_PRONOUN.copy(), 
+    vconst.TensePassiveFuture:ONE_TENSE_PRONOUN.copy(), 
+    vconst.TenseJussiveFuture:ONE_TENSE_PRONOUN.copy(), 
+    vconst.TensePassiveJussiveFuture:ONE_TENSE_PRONOUN.copy(), 
+    vconst.TenseSubjunctiveFuture:ONE_TENSE_PRONOUN.copy(), 
+    vconst.TensePassiveSubjunctiveFuture:ONE_TENSE_PRONOUN.copy(), 
+    vconst.TenseImperative:ONE_TENSE_PRONOUN.copy(), 
+    vconst.TenseConfirmedFuture:ONE_TENSE_PRONOUN.copy(), 
+    vconst.TenseConfirmedImperative:ONE_TENSE_PRONOUN.copy()
+    }
+        self.verb = verb
+        self.text = {}
+        self.mode = 'Text'
+        self.future_form = u""
+        self.transitive = False
+        self.bab = "0"
+    def __del__(self):
+        self.tab_conjug = {}
+        self.verb = ""
+        self.text = {}
+        self.mode = 'Text'
+        self.future_form = u""
+        self.transitive = False
+        self.bab = "0"
+#####################################
+#{ Attributes functions
+#####################################
+    def setmode(self, mode):
+        """ 
+        Set the display mode as:
+            - 'Text':
+            - 'HTML':
+            - 'HTMLColoredDiacritics':
+            - 'DICT':
+            - 'CSV':
+            - 'GUI':
+            - 'TABLE':
+            - 'XML':
+            - 'TeX':
+            - 'ROWS':
+        @param mode: the given mode to display result
+        @type mode: unicode
+        """
+        self.mode = mode
+    def settransitive(self):
+        """ 
+        Set the transitivity value to True.
+        """    
+        self.transitive = True 
+    def setbab(self, bab):
+        """ 
+        Set the bab sarf value to bab
+        @param bab: the given sarf bab.
+        @type bab: integer (1-6)
+        """    
+        self.bab = bab
+#------------------------------------------------------------------
+    def set_future_form(self, future_form):
+        """ 
+        Set the future form of the verb value to future_form.
+        مثلا: صرب يصرب
+        @param future_form: the future form.
+        @type future_form: unicode
+        """        
+        self.future_form = future_form
+    def get_verb_attributs(self):
+        """
+        Get attributes as text
+        @return: Attributes as text.
+        @rtype: unicode
+        """    
+        return self.text
+
+    def add_attribut(self, title, value):
+        """
+        Add a new attribut to display, like the transitivity 
+        the root and the future form.
+        @param title: the title of the attribute to display.
+        @type title: unicode
+        @param value:the value if the attribute.
+        @type value: unicode
+        """    
+        if title != '' :
+            self.text[title] = value
+    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
+        
+        """
+        if  tense in self.tab_conjug:
+            if pronoun in self.tab_conjug[tense]:
+                return self.tab_conjug[tense][pronoun]
+        return u""
+
+    def add(self, tense, pronoun, verbconjugated):
+        """
+        Add a new conjugation to display.
+        @param tense: tense of the added conjuagtion.
+        @type tense: unicode
+        @param pronoun: pronoun of the added conjuagtion.
+        @type pronoun: unicode
+        @param verbconjugated:aded conjuagtion.
+        @type verbconjugated:unicode
+        
+        """
+        if  tense  not in self.tab_conjug:
+            self.tab_conjug[tense] = {}
+        self.tab_conjug[tense][pronoun] = verbconjugated
+#####################################
+#{ Display functions
+#####################################
+    def display(self, listtense = None):
+        """
+        Display The conjugation result for a list of tenses, 
+        with a display mode given by the class attribute.
+        Set the display mode as:
+            - 'Text':
+            - 'HTML':
+            - 'HTMLColoredDiacritics':
+            - 'DICT':
+            - 'CSV':
+            - 'GUI':
+            - 'TABLE':
+            - 'XML':
+            - 'TeX':
+            - 'ROWS':
+        @param listtense: the given tenses list to display result
+        @type listtense: list of unicode
+        @return: the result in a specified dispaly mode.
+        @rtype: according to display mode.
+        """        
+        return self.display(self.mode, listtense)
+    def display(self, mode, listtense = None):
+        """
+        Display The conjugation result for a list of tenses, 
+        with a display mode.
+        Set the display mode as:
+            - 'Text':
+            - 'HTML':
+            - 'HTMLColoredDiacritics':
+            - 'DICT':
+            - 'CSV':
+            - 'GUI':
+            - 'TABLE':
+            - 'XML':
+            - 'TeX':
+            - 'ROWS':
+        @param mode: the given mode to display result
+        @type mode: unicode
+        @param listtense: the given tenses list to display result
+        @type listtense: list of unicode
+        @return: the result in a specified dispaly mode.
+        @rtype: according to display mode.
+        """
+        if not listtense:
+            listtense = vconst.TABLE_TENSE
+        if mode == 'Text':
+            return self.display_text(listtense)
+        elif mode == 'HTML':
+            return self.display_html(listtense)
+        elif mode == 'HTMLColoredDiacritics':
+            return self.display_html_colored_diacritics(listtense)
+        elif mode == 'DICT':
+            return self.display_dict(listtense)
+        elif mode == 'CSV':
+            return self.display_csv(listtense)
+        elif mode == 'GUI':
+            return self.display_table(listtense)
+        elif mode == 'TABLE':
+            return self.display_table(listtense)
+        elif mode == 'XML':
+            return self.display_xml(listtense)
+        elif mode.upper() == 'TeX'.upper():
+            return self.display_tex(listtense)
+        elif mode == 'ROWS'.upper():
+            return self.display_rows(listtense)
+        else:
+            return self.display_text(listtense)
+
+    def display_text(self, listtense):
+        """
+        Display The conjugation result for a list of tenses, as text.
+        @param listtense: the given tenses list to display result
+        @type listtense: list of unicode
+        @return: the result as text.
+        @rtype: uunicode.
+        """    
+        text = u""
+        for title in self.text.keys():
+            text += u"%s: %s\n"  % (title, self.text[title])
+        text += u"\t"
+        text += u"\t".join(listtense)
+        for pronoun in vconst.PronounsTable:
+            text += u"\n%s"  % (pronoun)
+            for tense in listtense:
+                if pronoun  in self.tab_conjug[tense]:
+                    text += u"\t%s"  % (self.tab_conjug[tense][pronoun])
+        return text
+
+
+    def display_csv(self, listtense ):
+        """
+        Display The conjugation result for a list of tenses, 
+        as comma separeted value text.
+        every line contains:
+        example:
+            >>> اللزوم/التعدي: متعدي
+            الفعل: مَنَحَ
+            نوع الفعل: فعل ثلاثي
+            الماضي المعلومالمضارع المعلومالمضارع المجزومالمضارع المنصو
+            بالمضارع المؤكد الثقيلالأمرالأمر المؤكدالماضي المجهولالمضارع المجهولالمضارع المجهول المجزومالمضارع المجهول المنصوبالمضارع المؤكد الثقيل المجهول 
+            أنامَنَحْتُأَمْنَحُأَمْنَحْأَمْنَحَأَمْنَحَنَّمُنِحْتُأُمْنَحُأُمْنَحْأُمْنَحَأُمْنَحَنَّ
+            نحنمَنَحْنَانَمْنَحُنَمْنَحْنَمْنَحَنَمْنَحَنَّمُنِحْنَانُمْنَحُنُمْنَحْنُمْنَحَنُمْنَحَنَّ
+            أنتمَنَحْتَتَمْنَحُتَمْنَحْتَمْنَحَتَمْنَحَنَّاِمْنَحْاِمْنَحَنَّمُنِحْتَتُمْنَحُتُمْنَحْتُمْنَحَتُمْنَحَنَّ
+
+
+        @param listtense: the given tenses list to display result
+        @type listtense: list of unicode
+        @return: the result as text in row.
+        @rtype: unicode.
+        """        
+        text = u""
+        for title in self.text.keys():
+            text += u"%s: %s\n"  % (title, self.text[title])
+        text += u"".join(listtense)
+        text += u"\n"
+        for pronoun in vconst.PronounsTable:
+            text += u"%s"  % (pronoun)
+            for tense in listtense:
+#                print (self.verb).encode("utf-8"), 
+                if pronoun in self.tab_conjug[tense]:
+                    text += u"%s"  % (self.tab_conjug[tense][pronoun])
+            text += u"\n"
+        return text
+
+
+
+
+    def display_rows(self, listtense ):
+        """
+        Display The conjugation result for a list of tenses, as text in rows.
+        every row contains:
+            - unvocalized conjugation, 
+            - unvocalized conjugation, 
+            - pronoun
+            - tense, 
+            - transitive, 
+            - original verb
+            - tasrif bab
+
+        @param listtense: the given tenses list to display result
+        @type listtense: list of unicode
+        @return: the result as text in row.
+        @rtype: unicode.
+        """        
+        text = u""
+
+        transitive = "0"
+        if self.transitive:
+            transitive = '1'
+        for pronoun in vconst.PronounsTable:
+##            text += u"%s"  % (pronoun)
+            for tense in listtense:
+#                print (self.verb).encode("utf-8"), 
+                if  self.tab_conjug[tense][pronoun] != "":
+                    text += "\t".join([
+                        araby.strip_harakat(self.tab_conjug[tense][pronoun]), 
+                        self.tab_conjug[tense][pronoun], 
+                        TAB_DISPLAY[pronoun], 
+                        TAB_DISPLAY[tense], 
+                        transitive, 
+                        self.verb, 
+                        self.bab, 
+                        ])
+                    text += u"\n"
+        return text
+
+
+    def display_html(self, listtense):
+        """
+        Display The conjugation result for a list of tenses, as HTML.
+        @param listtense: the given tenses list to display result
+        @type listtense: list of unicode
+        # @return: the result as HTML.
+        @rtype: unicode.
+        """        
+        indicative_tenses = []
+        passive_tenses = []
+        for tense in listtense:
+            if tense in vconst.TableIndicativeTense:
+                indicative_tenses.append(tense)
+            else:
+                passive_tenses.append(tense)
+        text = u""
+        text += u"<h3>%s : %s - %s</h3>\n"  % (self.verb, self.verb, 
+        self.future_form)
+#        text += u"<h3>%s - %s</h3>\n\n"  % (self.verb, self.future_form)
+        # print spelcial attribut of the verb
+        text += u"<ul>\n"
+        for title in self.text.keys():
+            text += u"<li><b>%s:</b> %s</li>\n"  % (title, self.text[title])
+        text += u"</ul>\n\n"
+
+        for  mode in("indicative", "passive"):
+            if mode == "indicative":
+                listtense_to_display = indicative_tenses
+
+            else:
+                listtense_to_display = passive_tenses
+                text += "<br/>"
+            if len(listtense_to_display) >0:
+                text += u"""<table class = 'resultarea' border = 1
+                 cellspacing = 0>\n"""
+                text += u"<tr><th>&nbsp</th>"
+                for tense in listtense_to_display:
+                    text += u"<th>%s</th>"  % (tense)
+                text += u"</tr>\n"
+                for pronoun in vconst.PronounsTable:
+                    text += u"<tr>"
+                    text += u"<th>%s</th>"  % (pronoun)
+                    for tense in listtense_to_display:
+                        text += u"<td>&nbsp%s</td>"  % (
+                        self.tab_conjug[tense][pronoun])
+                    text += u"</tr>\n"
+                text += u"</table>\n"
+        return text
+
+    def display_html_colored_diacritics(self, listtense):
+        """
+        Display The conjugation result for a list of tenses, 
+        as HTML with colored vocalization.
+        @param listtense: the given tenses list to display result
+        @type listtense: list of unicode
+        @return: the result as HTML.
+        @rtype: unicode.
+        """        
+        text = self.display_html(listtense)
+##        text = "<div style = 'color:red'>"+text+"</div>"
+        text = self.highlight_diacritics_html(text)
+        return text
+
+    def highlight_diacritics_html(self, text):
+        """
+        Highlight dfiactitics in the HTML text.
+        @param text: the given text
+        @type text: unicode.
+        @return: the result as HTML.
+        @rtype: unicode.
+        """        
+        hight_text = u""
+        lefttag = u"<span class = 'tashkeel'>"
+        righttag = u"</span>"
+        for i in range(len(text)):
+            if text[i] in (araby.FATHA, araby.DAMMA, araby.KASRA, araby.SUKUN):
+                if (i>0 and text[i-1] not in (araby.ALEF, 
+                araby.ALEF_HAMZA_ABOVE, araby.WAW_HAMZA, araby.ALEF_MADDA,
+                 araby.DAL, araby.THAL, araby.WAW, araby.REH, araby.ZAIN,
+            araby.SHADDA)) and (i+1<len(text) and text[i+1] not in (" ", "<")):
+                    hight_text += u"".join([lefttag, araby.TATWEEL, 
+                    text[i], righttag])
+                else :
+##               hight_text += u"<span style = 'color:red'>%s</span>"%text[i]
+                    hight_text += u"".join([lefttag, " ", text[i], righttag])
+            else:
+                hight_text += text[i]
+        return hight_text
+
+    def display_table(self, listtense):
+        """Display The conjugation result for a list of tenses, as array.
+        @param listtense: the given tenses list to display result
+        @type listtense: list of unicode
+        @return: the result as table, the table[0] contains pronouns.
+        @rtype: dict with number indice.
+        """    
+        table = {}
+
+        j = 0
+        table[0] = {0:u"الضمائر"}
+        for j in range(len(listtense)):
+            table[0][j+1] = listtense[j]
+        i = 1
+        for pronoun in vconst.PronounsTable:
+            table[i] = {}
+            table[i][0] = pronoun
+            j = 1
+            for tense in listtense:
+                table[i][j] = self.tab_conjug[tense][pronoun]
+                j = j+1
+            i = i+1
+        return table
+
+    def display_dict(self, listtense):
+        """
+        Display The conjugation result for a list of tenses, as python dict.
+        @param listtense: the given tenses list to display result
+        @type listtense: list of unicode
+        @return: the result as python dict.
+        @rtype: dict.
+        """        
+        table = {}
+        for tense in listtense:
+            table[tense] = self.tab_conjug[tense]
+        #text = json.dumps(table, ensure_ascii = False)
+        return table
+
+    def display_xml(self, listtense):
+        """
+        Display The conjugation result for a list of tenses, as XML.
+        @param listtense: the given tenses list to display result
+        @type listtense: list of unicode
+        @return: the result as XML.
+        @rtype: unicode.
+        """        
+        text = u""
+        text += u"<verb_conjugation>\n"
+        text += u"\t<proprety name = 'verb' value = '%s'/>\n"  % (self.verb)
+        for title in self.text.keys():
+            text += u"\t<proprety name = '%s' value = '%s'/>\n"  % (title,
+             self.text[title])
+        for tense in listtense:
+            text += u"\t<tense name = '%s'>\n"  % (tense)
+            for pronoun in vconst.PronounsTable:
+                if self.tab_conjug[tense][pronoun] != "":
+                    text += u"""\t\t<conjugation pronoun = '%s' value = '%s'
+                    />\n"""  % (pronoun, self.tab_conjug[tense][pronoun])
+            text += u"\t</tense>\n"
+        text += u"</verb_conjugation>"
+        return text
+
+    def display_tex(self, listtense):
+        """
+        Display The conjugation result for a list of tenses, as TeX.
+        @param listtense: the given tenses list to display result
+        @type listtense: list of unicode
+        @return: the result as TeX format.
+        @rtype: unicode.
+        """        
+        text = u""
+        text += u"\\environment qutrub-layout\n"
+        text += u"\\starttext\n"
+
+        text += u"\\Title{%s}\n"  % (self.verb)
+
+        text += u"\\startitemize\n"
+        for title in self.text.keys():
+            if title == u" الكتابة الداخلية للفعل ":
+                text += u"\\item {\\bf %s} \\DeShape{%s}\n"  % (title,
+                 self.text[title])
+            else:
+                text += u"\\item {\\bf %s} %s\n"  % (title, self.text[title])
+        text += u"\\stopitemize\n"
+
+        text += u"\\starttable[|lB|l|l|l|l|l|]\n"
+        text += u"\\HL[3]\n\\NC"
+        for tense in listtense:
+            text += u"\\NC {\\bf %s}"  % (tense)
+        text += u"\\SR\n\\HL\n"
+        for pronoun in vconst.PronounsTable:
+            text += u"\\NC %s"  % (pronoun)
+            for tense in listtense:
+                text += u"\\NC %s"  % (self.tab_conjug[tense][pronoun])
+            text += u"\\AR\n"
+        text += u"\\LR\\HL[3]\n"
+        text += u"\\stoptable\n"
+
+        text += u"\\stoptext"
+        return text

libqutrub/mosaref_main.py

@@ -0,0 +1,140 @@
+#************************************************************************
+# $Id: mosaref_main.py, v 0.7 2009/06/02 01:10:00 Taha Zerrouki $
+#
+# ------------
+# Description:
+# ------------
+#  Copyright (c) 2009, Arabtechies, Arabeyes Taha Zerrouki
+#
+#  This file is used by the web interface to execute verb 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
+#
+#***********************************************************************/
+"""
+The main function to call qutrub conjugation from other programs.
+"""
+import libqutrub.classverb  as classverb
+import libqutrub.ar_verb  as ar_verb
+import libqutrub.verb_valid  as verb_valid
+import libqutrub.verb_const  as vconst
+import pyarabic.araby as araby
+import libqutrub.verb_db  as verb_db
+verb_db.create_index_triverbtable()
+#~ """ you need to create the trileteral verb dictionary  
+# index to search within triverbs."""
+
+def do_sarf(word, future_type, alltense = True, past = False, future = False, 
+passive = False, imperative = False, future_moode = False, confirmed = False,
+ transitive = False, display_format = "HTML"):
+    """
+    The main function to conjugate verbs.
+    You must specify all parameters.
+    Can be used as an example to call the conjugation class.
+    @param word: the givern verb. the given word must be vocalized, 
+    if it's 3 letters length only, else, the verb can be unvocalized, 
+     but the Shadda must be given, it' considered as letter.
+    @type word: unicode.
+    @param future_type: For Triliteral verbs, 
+    you must give the mark of Ain in the future, 
+    كة عين الفعل في المضارع. it's given as a name of haraka (فتحة، ضمة، كسرة).
+    @type future_type: unicode(فتحة، ضمة، كسرة).
+    @param all: conjugate in all arabic tenses.
+    @type all: Boolean, default(True)
+    @param past: conjugate in past tense ألماضي
+    @type past: Boolean, default(False)
+    @param future: conjugate in arabic present and future tenses المضارع
+    @type future: Boolean, default(False)
+    @param passive: conjugate in passive voice  المبني للمجهول
+    @type passive: Boolean, default(False)
+    @param imperative: conjugate in imperative tense الأمر
+    @type imperative: Boolean, default(False)
+    @param future_moode: conjugate in future moode tenses المضارع المنصوب والمجزوم
+    @type future_moode: Boolean, default(False)
+    @param confirmed: conjugate in confirmed cases tense المؤكّد
+    @type confirmed: Boolean, default(False)
+    @param transitive: the verb transitivity التعدي واللزوم
+    @type transitive: Boolean, default(False)
+    @param display_format: Choose the display format:
+        - 'Text':
+        - 'HTML':
+        - 'HTMLColoredDiacritics':
+        - 'DICT':
+        - 'CSV':
+        - 'GUI':
+        - 'TABLE':
+        - 'XML':
+        - 'TeX':
+        - 'ROWS':
+    @type display_format: string, default("HTML") 
+    @return: The conjugation result
+    @rtype: According to display_format.
+    """
+    valid = verb_valid.is_valid_infinitive_verb(word)
+    if valid:
+        future_type = ar_verb.get_future_type_by_name(future_type)
+        #~ bab_sarf = 0
+        #init the verb class to treat the verb
+        vbc = classverb.VerbClass(word, transitive, future_type)
+        vbc.set_display(display_format)
+
+        if alltense :
+            result =  vbc.conjugate_all_tenses()
+        else :
+            listetenses = []
+            if past :
+                listetenses.append(vconst.TensePast)
+            if (past and passive ) :
+                listetenses.append(vconst.TensePassivePast)
+            if future : 
+                listetenses.append(vconst.TenseFuture)
+            if (future and passive ) :
+                listetenses.append(vconst.TensePassiveFuture)
+            if (future_moode) :
+                listetenses.append(vconst.TenseSubjunctiveFuture)
+                listetenses.append(vconst.TenseJussiveFuture)
+            if (confirmed) :
+                if (future):
+                    listetenses.append(vconst.TenseConfirmedFuture)
+                if (imperative):
+                    listetenses.append(vconst.TenseConfirmedImperative)
+            if (future and transitive and confirmed) :
+                listetenses.append(vconst.TensePassiveConfirmedFuture)
+            if (passive and future_moode) :
+                listetenses.append(vconst.TensePassiveSubjunctiveFuture)
+                listetenses.append(vconst.TensePassiveJussiveFuture)
+            if imperative :
+                listetenses.append(vconst.TenseImperative)
+            result  = vbc.conjugate_all_tenses(listetenses)
+        return result
+    else: return None
+
+def get_future_form(verb_vocalised, haraka = araby.FATHA):
+    """
+    Get The future form of a verb. for example the future form of
+     qal with Damma as a Haraka of future verb, we get yqolu.
+    الحصول على صيغة الفعل في المضارع، فالفعل قال، وحركة عينه في المضارع صمة، نحصل على يقول.
+    @param verb_vocalised: given verb.
+    @type verb_vocalised:unicode.
+    @param haraka: the future mark for triverbs.
+    @type haraka: unicode.
+    @return: The conjugated form in the future tense.
+    @rtype: unicode.
+    """
+    word = verb_vocalised
+    transitive = True
+    future_type = haraka
+    if future_type not in (araby.FATHA, araby.DAMMA, araby.KASRA):
+        future_type = ar_verb.get_future_type_by_name(future_type)
+    vbc = classverb.VerbClass(word, transitive, future_type)
+    #vb.verb_class()
+    return vbc.conjugate_tense_pronoun(vconst.TenseFuture, vconst.PronounHuwa)
+
+
+

libqutrub/stack.py

@@ -0,0 +1,177 @@
+#!/usr/bin/python
+# -*- coding=utf-8 -*-
+#************************************************************************
+# from arabic_const import *
+from pyarabic.araby import *
+from verb_const import *
+class Stack :
+	def __init__(self,text="") :
+		self.items = list(text);
+
+	def push(self, item) :
+		self.items.append(item)
+
+	def pop(self) :
+		if not self.isEmpty():
+			return self.items.pop()
+		else:
+			return None;
+
+	def isEmpty(self) :
+		return (self.items == [])
+
+
+def separate(word):
+	"""
+	separate the letters from the vowels, in arabic word,
+	if a letter hasn't a haraka, the not definited haraka is attributed.
+	return ( letters,vowels);
+	"""
+	#debug=True;
+	stack1=Stack(word)
+	# the word is inversed in the stack
+	stack1.items.reverse();
+	letters=Stack()
+	marks=Stack()
+	vowels=('a','u')
+	last1=stack1.pop();
+	# if the last element must be a letter,
+	# the arabic word can't starts with a haraka
+	# in th stack the word is inversed
+	while last1 in vowels: last1=stack1.pop();
+	while  last1!=None:
+		if last1 in vowels:
+			# we can't have two harakats beside.
+			# the shadda is considered as a letter
+			marks.pop();
+			marks.push(last1);
+		elif last1==SHADDA:
+			# is the element is a Shadda,
+			# the previous letter must have a sukun as mark,
+			# and the shadda take the indefinate  mark
+			marks.pop();
+			marks.push(SUKUN);
+			marks.push(NOT_DEF_HARAKA);
+			letters.push(SHADDA);
+		else:
+			marks.push(NOT_DEF_HARAKA);
+			letters.push(last1);
+		last1=stack1.pop();
+	return (''.join(letters.items),''.join(marks.items))
+
+
+def joint(letters,marks):
+	"""
+	joint the letters with the marks
+	the length ot letters and marks must be equal
+	return word;
+	"""
+	#debug=True;
+	debug=False;
+	# The length ot letters and marks must be equal
+	if len(letters)!=len(marks): return "";
+
+	stackLetter=Stack(letters)
+	stackLetter.items.reverse();
+	stackMark=Stack(marks)
+	stackMark.items.reverse();
+	wordStack=Stack();
+	last1=stackLetter.pop();
+	last2=stackMark.pop();
+
+	vowels=('a','u','o','i',SUKUN)
+	while  last1!=None and  last2!=None:
+		if last1 == SHADDA:
+			top=wordStack.pop();
+			if top not in vowels:
+				wordStack.push(top);
+			wordStack.push(last1);
+			if last2!= NOT_DEF_HARAKA:
+				wordStack.push(last2);
+		else:
+			wordStack.push(last1);
+			if last2!= NOT_DEF_HARAKA:
+				wordStack.push(last2);
+
+		last1=stackLetter.pop();
+		last2=stackMark.pop();
+	if not (stackLetter.isEmpty() and stackMark.isEmpty()):
+		return False;
+	else:
+		#wordStack.items.reverse();
+		return ''.join(wordStack.items);
+
+def vocalizedlike(word1,word2):
+	"""
+	if the two words has the same letters and the same harakats, this fuction return True.
+	The two words can be full vocalized, or partial vocalized
+	"""
+	debug=False;
+	stack1=Stack(word1)
+	stack2=Stack(word2)
+	last1=stack1.pop();
+	last2=stack2.pop();
+	if debug: print "+0", stack1, stack2;
+	vowels=('a','u')
+	while  last1!=None and  last2!=None:
+		if last1==last2:
+			if debug: print "+2", stack1.items,last1, stack2.items,last2
+			last1=stack1.pop();
+			last2=stack2.pop();
+		elif last1 in vowels and last2 not in vowels:
+			if debug: print "+2", stack1.items,last1, stack2.items,last2
+			last1=stack1.pop();
+		elif last1 not in vowels and last2 in vowels:
+			if debug: print "+2", stack1.items,last1, stack2.items,last2
+			last2=stack2.pop();
+		else:
+			if debug: print "+2", stack1.items,last1, stack2.items,last2
+			break;
+	if not (stack1.isEmpty() and stack2.isEmpty()):
+		return False;
+	else: return True;
+#-------------------------
+# Function def vaznlike(word1,wazn):
+#-------------------------
+def waznlike(word1,wazn):
+	"""
+	if the  word1 is like a wazn (pattern),
+	the letters must be equal,
+	the wazn has FEH, AIN, LAM letters.
+	this are as generic letters.
+	The two words can be full vocalized, or partial vocalized
+	"""
+	debug=False;
+	stack1=Stack(word1)
+	stack2=Stack(wazn)
+	root=Stack()
+	last1=stack1.pop();
+	last2=stack2.pop();
+	if debug: print "+0", stack1, stack2;
+	vowels=('a','u')
+	while  last1!=None and  last2!=None:
+		if last1==last2 and last2 not in (FEH, AIN,LAM):
+			if debug: print "+2", stack1.items,last1, stack2.items,last2
+			last1=stack1.pop();
+			last2=stack2.pop();
+		elif last1 not in vowels and last2 in (FEH, AIN,LAM):
+			if debug: print "+2", stack1.items,last1, stack2.items,last2
+			root.push(last1);
+			print "t";
+			last1=stack1.pop();
+			last2=stack2.pop();
+		elif last1 in vowels and last2 not in vowels:
+			if debug: print "+2", stack1.items,last1, stack2.items,last2
+			last1=stack1.pop();
+		elif last1 not in vowels and last2 in vowels:
+			if debug: print "+2", stack1.items,last1, stack2.items,last2
+			last2=stack2.pop();
+		else:
+			if debug: print "+2", stack1.items,last1, stack2.items,last2
+			break;
+	# reverse the root letters
+	root.items.reverse();
+	print " the root is ", root.items#"".join(root.items);
+	if not (stack1.isEmpty() and stack2.isEmpty()):
+		return False;
+	else: return True;

libqutrub/verb_const.py

@@ -0,0 +1,613 @@
+#!/usr/bin/python
+# -*- coding=utf-8 -*-
+#---
+#************************************************************************
+# $Id: verb_const.py, v 0.7 2009/06/02 01:10:00 Taha Zerrouki $
+#
+# ------------
+# Description:
+# ------------
+#  Copyright (c) 2009, Arabtechies, Arabeyes Taha Zerrouki
+#
+#  List of constants used in the arabic verb conjugation
+#
+# -----------------
+# Revision Details:
+# -----------------
+#  $Date: 2009/06/02 01:10:00 $
+#  $Author: Taha Zerrouki $
+#  $Revision: 0.7 $
+#  $Source: arabtechies.sourceforge.net
+#
+#***********************************************************************/
+"""
+Arabic Qutrub verb conjugation, verb_const file
+"""
+from pyarabic.araby import FATHA, DAMMA, KASRA, SHADDA, SUKUN, HAMZA, ALEF, \
+ NOON, ALEF_WASLA, WAW, ALEF_HAMZA_ABOVE, ALEF_HAMZA_BELOW, ALEF_MADDA, \
+ YEH_HAMZA, WAW_HAMZA, TATWEEL, SMALL_ALEF, SMALL_YEH, SMALL_WAW, YEH, \
+ ALEF_MAKSURA
+
+import re
+
+PronounsTable = (u"أنا" , u"نحن" , u"أنت" , u"أنتِ" , u"أنتما" , 
+ u"أنتما مؤ" , u"أنتم" , u"أنتن" , u"هو" , u"هي" , u"هما" ,
+  u"هما مؤ" , u"هم" , u"هن")
+PronounsTableNotPassiveForUntransitive = (u"أنا" , u"نحن" , u"أنت" ,
+ u"أنتِ" , u"أنتما" , u"أنتما مؤ" , u"أنتم" , u"أنتن" , u"هما" ,
+  u"هما مؤ" , u"هم" , u"هن")
+PronounAna = u"أنا"
+PronounNahnu = u"نحن"
+PronounAnta = u"أنت"
+PronounAnti = u"أنتِ"
+PronounAntuma = u"أنتما"
+PronounAntuma_f = u"أنتما مؤ"
+PronounAntum = u"أنتم"
+PronounAntunna = u"أنتن"
+PronounHuwa = u"هو"
+PronounHya = u"هي"
+PronounHuma = u"هما"
+PronounHuma_f = u"هما مؤ"
+PronounHum = u"هم"
+PronounHunna = u"هن"
+PRONOUN_FEATURES = {
+ u"أنا" : {'person':u'متكلم', 'gender':u'', 'number': u'مفرد'} 
+, u"أنت" : {'person':u'مخاطب', 'gender':u'مذكر', 'number': u'مفرد'} 
+, u"أنتِ" : {'person':u'مخاطب', 'gender':u'مؤنث', 'number': u'مفرد'} 
+, u"هو" : {'person':u'غائب', 'gender':u'مذكر', 'number': u'مفرد'} 
+, u"هي" : {'person':u'غائب', 'gender':u'مؤنث', 'number': u'مفرد'} 
+, u"أنتما" : {'person':u'مخاطب', 'gender':u'مذكر', 'number': u'مثنى'} 
+, u"أنتما مؤ" : {'person':u'مخاطب', 'gender':u'مؤنث', 'number': u'مثنى'} 
+, u"هما" : {'person':u'غائب', 'gender':u'مذكر', 'number': u'مثنى'}
+, u"هما مؤ" : {'person':u'غائب', 'gender':u'مؤنث', 'number': u'مثنى'} 
+, u"نحن" : {'person':u'متكلم', 'gender':u'', 'number': u'جمع'}
+, u"أنتم" : {'person':u'مخاطب', 'gender':u'مذكر', 'number': u'جمع'}
+, u"أنتن" : {'person':u'مخاطب', 'gender':u'مؤنث', 'number': u'جمع'}
+, u"هم" : {'person':u'غائب', 'gender':u'مذكر', 'number': u'جمع'}
+, u"هن" : {'person':u'غائب', 'gender':u'مؤنث', 'number': u'جمع'}
+}
+
+ImperativePronouns = (u"أنت" , u"أنتِ" , u"أنتما" , u"أنتما مؤ" , u"أنتم" 
+             , u"أنتن" )
+# const for Tense Name
+TensePast = u"الماضي المعلوم"
+TenseFuture = u"المضارع المعلوم"
+TenseImperative = u"الأمر"
+TenseConfirmedImperative = u"الأمر المؤكد"
+TenseJussiveFuture = u"المضارع المجزوم"
+TenseSubjunctiveFuture = u"المضارع المنصوب"
+TenseConfirmedFuture = u"المضارع المؤكد الثقيل"
+
+
+TensePassivePast =  u"الماضي المجهول"
+TensePassiveFuture = u"المضارع المجهول"
+TensePassiveJussiveFuture = u"المضارع المجهول المجزوم"
+TensePassiveSubjunctiveFuture = u"المضارع المجهول المنصوب"
+TensePassiveConfirmedFuture = u"المضارع المؤكد الثقيل المجهول "
+
+
+TABLE_TENSE = [TensePast, TenseFuture, TenseJussiveFuture, 
+        TenseSubjunctiveFuture, TenseConfirmedFuture, TenseImperative, 
+        TenseConfirmedImperative, 
+        TensePassivePast, TensePassiveFuture, 
+        TensePassiveJussiveFuture, TensePassiveSubjunctiveFuture,
+         TensePassiveConfirmedFuture]
+TableIndicativeTense = [TensePast, TenseFuture, TenseJussiveFuture, 
+             TenseSubjunctiveFuture, TenseConfirmedFuture, TenseImperative, 
+        TenseConfirmedImperative]
+TablePassiveTense = [TensePassivePast, TensePassiveFuture, 
+        TensePassiveJussiveFuture, TensePassiveSubjunctiveFuture,
+        TensePassiveConfirmedFuture]
+
+TENSE_FEATURES = {
+TensePast : { 'tense':u'ماضي', 'voice':u'معلوم', 'mood':u'', 'confirmed':u'', },
+TenseFuture : { 'tense':u'مضارع', 'voice':u'معلوم', 'mood':u'مرفوع', 'confirmed':u'', },
+TenseImperative : { 'tense':u'أمر', 'voice':u'', 'mood':u'', 'confirmed':u'', },
+TenseConfirmedImperative : { 'tense':u'أمر', 'voice':u'', 'mood':u'', 'confirmed':u'مؤكذ', },
+TenseJussiveFuture : { 'tense':u'مضارع', 'voice':u'معلوم', 'mood':u'مجزوم', 'confirmed':u'', },
+TenseSubjunctiveFuture : { 'tense':u'مضارع', 'voice':u'معلوم', 'mood':u'منص��ب', 'confirmed':u'', },
+TenseConfirmedFuture : { 'tense':u'مضارع', 'voice':u'معلوم', 'mood':u'', 'confirmed':u'مؤكد', },
+
+
+TensePassivePast :  { 'tense':u'ماضي', 'voice':u'مجهول', 'mood':u'', 'confirmed':u'', },
+TensePassiveFuture : { 'tense':u'مضارع', 'voice':u'مجهول', 'mood':u'مرفوع', 'confirmed':u'', },
+TensePassiveJussiveFuture : { 'tense':u'مضارع', 'voice':u'مجهول', 'mood':u'مجزوم', 'confirmed':u'', },
+TensePassiveSubjunctiveFuture : { 'tense':u'مضارع', 'voice':u'مجهول', 'mood':u'منصوب', 'confirmed':u'', }, 
+TensePassiveConfirmedFuture : { 'tense':u'مضارع', 'voice':u'مجهول', 'mood':u'', 'confirmed':u'مؤكد', },
+}
+
+past = {
+ u"أنا" : [u"", u"ْتُ"]
+, u"أنت" : [u"", u"ْتَ"]
+, u"أنتِ" : [u"", u"ْتِ"]
+, u"هو" : [u"", u"َ"]
+, u"هي" : [u"", u"َتْ"]
+, u"أنتما" : [u"", u"ْتُما"]
+, u"أنتما مؤ" : [u"", u"ْتُما"]
+, u"هما" : [u"", u"َا"]
+, u"هما مؤ" : [u"", u"َتَا"]
+, u"نحن" : [u"", u"ْنَا"]
+, u"أنتم" : [u"", u"ْتُم"]
+, u"أنتن" : [u"", u"ْتُنَّ"]
+##, u"هم" : [u"", u"ُوا"]
+, u"هم" : [u"", DAMMA + WAW + ALEF_WASLA]
+, u"هن" : [u"", u"ْنَ"]
+}
+future = {
+u"أنا" : [u"أ", u"ُ"]
+, u"أنت" : [u"ت", u"ُ"]
+, u"أنتِ" : [u"ت", u"ِينَ"]
+, u"أنتم" : [u"ت", u"ُونَ"]
+, u"أنتما" : [u"ت", FATHA + ALEF + NOON + KASRA]
+, u"أنتما مؤ" : [u"ت", FATHA + ALEF + NOON + KASRA]
+, u"أنتن" : [u"ت", SUKUN + NOON + FATHA]
+, u"نحن" : [u"ن", u"ُ"]
+, u"هم" : [u"ي", u"ُونَ"]
+, u"هما" : [u"ي", u"َانِ"]
+, u"هما مؤ" : [u"ت", u"َانِ"]
+, u"هن" : [u"ي", u"ْنَ"]
+, u"هو" : [u"ي", u"ُ"]
+, u"هي" : [u"ت", u"ُ"]
+}
+future_majzoom = {
+u"أنا" : [u"أ", u"ْ"]
+, u"أنت" : [u"ت", u"ْ"]
+, u"أنتِ" : [u"ت", u"ِي"]
+, u"أنتم" : [u"ت", DAMMA + WAW + ALEF_WASLA]
+##, u"أنتم" : [u"ت", DAMMA+WAW+ALEF]
+, u"أنتما" : [u"ت", u"َا"]
+, u"أنتما مؤ" : [u"ت", u"َا"]
+, u"أنتن" : [u"ت", u"ْنَ"]
+, u"نحن" : [u"ن", u"ْ"]
+##, u"هم" : [u"ي", DAMMA+WAW+ALEF]
+, u"هم" : [u"ي", DAMMA+WAW+ALEF_WASLA]
+, u"هما" : [u"ي", u"َا"]
+, u"هما مؤ" : [u"ت", u"َا"]
+, u"هن" : [u"ي", u"ْنَ"]
+, u"هو" : [u"ي", u"ْ"]
+, u"هي" : [u"ت", u"ْ"]
+}
+future_mansoub = {
+u"أنا" : [u"أ", u"َ"]
+, u"أنت" : [u"ت", u"َ"]
+, u"أنتِ" : [u"ت", u"ِي"]
+, u"أنتم" : [u"ت", DAMMA+WAW+ALEF_WASLA]
+##, u"أنتم" : [u"ت", DAMMA+WAW+ALEF]
+, u"أنتما" : [u"ت", u"َا"]
+, u"أنتما مؤ" : [u"ت", u"َا"]
+, u"أنتن" : [u"ت", u"ْنَ"]
+, u"نحن" : [u"ن", u"َ"]
+##, u"هم" : [u"ي", DAMMA+WAW+ALEF]
+, u"هم" : [u"ي", DAMMA+WAW+ALEF_WASLA]
+, u"هما" : [u"ي", u"َا"]
+, u"هما مؤ" : [u"ت", u"َا"]
+, u"هن" : [u"ي", u"ْنَ"]
+, u"هو" : [u"ي", u"َ"]
+, u"هي" : [u"ت", u"َ"]
+}
+
+future_confirmed = {
+u"أنا" : [u"أ", FATHA+NOON+SHADDA+FATHA]
+, u"أنت" : [u"ت", FATHA+NOON+SHADDA+FATHA]
+, u"أنتِ" : [u"ت", KASRA+NOON+SHADDA+FATHA]
+, u"أنتما" : [u"ت", FATHA+ALEF+NOON+SHADDA+KASRA]
+, u"أنتما مؤ" : [u"ت", FATHA+ALEF+NOON+SHADDA+KASRA]
+, u"أنتم" : [u"ت", DAMMA+NOON+SHADDA+FATHA]
+, u"أنتن" : [u"ت", SUKUN+NOON+FATHA+ALEF+NOON+SHADDA+KASRA]
+, u"نحن" : [u"ن", FATHA+NOON+SHADDA+FATHA]
+, u"هم" : [u"ي", DAMMA+NOON+SHADDA+FATHA]
+, u"هما" : [u"ي", FATHA+ALEF+NOON+SHADDA+KASRA]
+, u"هما مؤ" : [u"ت", FATHA+ALEF+NOON+SHADDA+KASRA]
+, u"هن" : [u"ي", SUKUN+NOON+FATHA+ALEF+NOON+SHADDA+KASRA]
+, u"هو" : [u"ي", FATHA+NOON+SHADDA+FATHA]
+, u"هي" : [u"ت", FATHA+NOON+SHADDA+FATHA]
+}
+imperative = {
+u"أنت" : [u"", u"ْ"]
+, u"أنتِ" : [u"", u"ِي"]
+, u"أنتم" : [u"", DAMMA+WAW+ALEF_WASLA]
+, u"أنتما" : [u"", u"َا"]
+, u"أنتما مؤ" : [u"", u"َا"]
+, u"أنتن" : [u"", u"ْنَ"]
+}
+imperative_confirmed = {
+u"أنت" : [u"", FATHA+NOON+SHADDA+FATHA]
+, u"أنتِ" : [u"", KASRA+NOON+SHADDA+FATHA]
+, u"أنتم" : [u"", DAMMA+NOON+SHADDA+FATHA]
+, u"أنتما" : [u"", FATHA+ALEF+NOON+SHADDA+KASRA]
+, u"أنتما مؤ" : [u"", FATHA+ALEF+NOON+SHADDA+KASRA]
+, u"أنتن" : [u"", SUKUN+NOON+FATHA+ALEF+NOON+SHADDA+KASRA]
+}
+
+TableTensePronoun = {}
+TableTensePronoun[TensePast] = past
+TableTensePronoun[TenseFuture] = future
+TableTensePronoun[TenseImperative] = imperative
+TableTensePronoun[TenseJussiveFuture] = future_majzoom
+TableTensePronoun[TenseSubjunctiveFuture] = future_mansoub
+TableTensePronoun[TenseConfirmedFuture] = future_confirmed
+TableTensePronoun[TenseConfirmedImperative] = imperative_confirmed
+
+TableTensePronoun[TensePassivePast] = past
+TableTensePronoun[TensePassiveFuture] = future
+TableTensePronoun[TensePassiveJussiveFuture] = future_majzoom
+TableTensePronoun[TensePassiveSubjunctiveFuture] = future_mansoub
+TableTensePronoun[TensePassiveConfirmedFuture] = future_confirmed
+
+
+TAB_SARF = {
+#باب تصريف الفعل، الصفر لكل الأفعال عدا الثلاثي
+0: {"past":FATHA, "future":KASRA}, 
+# فَعَل يَفْعُل
+
+1: {"past":FATHA, "future":DAMMA}, 
+# فَعَل يَفْعِل
+2: {"past":FATHA, "future":KASRA}, 
+# فَعَل يَفْعَل
+3: {"past":FATHA, "future":FATHA}, 
+# فَعِل يَفْعَل
+4: {"past":KASRA, "future":FATHA}, 
+# فَعِل يَفْعِل
+5: {"past":KASRA, "future":KASRA}, 
+# فَعُل يَفْعُل
+6: {"past":DAMMA, "future":DAMMA}, 
+}
+
+NOT_DEF_HARAKA = TATWEEL
+##NOT_DEF_HARAKA = FATHA
+
+STRIP_HARAKA = u"i"
+ALEF_HARAKA = SMALL_ALEF
+ALEF4_HARAKA = u"y"
+ALEF_YEH_HARAKA = u"#"
+ALEF_WAW_HARAKA = u"*"
+
+YEH_HARAKA = SMALL_YEH
+
+ALTERNATIVE_YEH_HARAKA = u"t"
+ALEF_YEH_ALTERNATIVE = u"x"
+WAW_HARAKA = SMALL_WAW
+ALEF_MAMDUDA = "9"
+YEH_NAKISA = "5"
+
+WRITTEN_HARAKA = {
+ALEF_HARAKA:FATHA+ALEF, 
+ALEF_WAW_HARAKA:FATHA+ALEF, 
+ALEF_YEH_HARAKA:FATHA+ALEF, 
+WAW_HARAKA:DAMMA+WAW, 
+YEH_HARAKA:KASRA+YEH, 
+ALTERNATIVE_YEH_HARAKA:KASRA+YEH, 
+NOT_DEF_HARAKA:'', 
+FATHA: FATHA, 
+DAMMA:DAMMA, 
+KASRA:KASRA, 
+SUKUN:SUKUN, 
+SHADDA:SHADDA
+}
+
+# table of conversion if التقاء الساكنين
+CONVERSION_TABLE = {
+    ALEF_YEH_HARAKA:        KASRA, 
+    ALEF_WAW_HARAKA:         DAMMA, 
+    WAW_HARAKA:                DAMMA, 
+    YEH_HARAKA :            KASRA, 
+    ALTERNATIVE_YEH_HARAKA:    DAMMA, 
+}
+##WAW_MAKSURA = WAW
+
+#HARAKAT = u"%s%s%s%s%s"%(SUKUN, FATHA, DAMMA, KASRA, SHADDA)
+HARAKAT = (SUKUN, FATHA, DAMMA, KASRA)
+HARAKAT2 = u"".join([ALEF_HARAKA, WAW_HARAKA, YEH_HARAKA, SUKUN, 
+          FATHA, DAMMA, KASRA])
+HAMZAT_PATTERN = re.compile(u"[%s%s%s%s%s]"%(ALEF_HAMZA_ABOVE, WAW_HAMZA, 
+             YEH_HAMZA , HAMZA, ALEF_HAMZA_BELOW), re.UNICODE)
+HAMZAT = (ALEF_HAMZA_ABOVE, WAW_HAMZA, YEH_HAMZA , HAMZA, ALEF_HAMZA_BELOW)
+
+
+LAM_ALEF_PAT = re.compile(u'[\ufef7\ufef9\ufef5]', re.UNICODE)
+
+#uniformate harkat
+UNIFORMATE_MARKS_4 = FATHA+SUKUN+FATHA+FATHA
+UNIFORMATE_MARKS_5TEH = FATHA+FATHA+SUKUN+FATHA+FATHA
+UNIFORMATE_MARKS_5 = KASRA+SUKUN+FATHA+FATHA+FATHA
+UNIFORMATE_MARKS_6 = KASRA+SUKUN+FATHA+SUKUN+FATHA+FATHA
+
+BEGIN_WORD = u"^"
+END_WORD = u"$"
+
+LONG_HARAKAT = (ALEF_HARAKA, YEH_HARAKA, WAW_HARAKA, ALEF_YEH_HARAKA, 
+                  ALEF_WAW_HARAKA)
+_F = FATHA
+_D = DAMMA
+_K = KASRA
+_S = SUKUN
+_A = ALEF_HARAKA
+_W = WAW_HARAKA
+_Y = YEH_HARAKA
+
+_AH = ALEF_HARAKA
+_YH = YEH_HARAKA
+_WH = WAW_HARAKA
+_AYH = ALEF_YEH_HARAKA
+_AWH = ALEF_WAW_HARAKA
+_YHALT = ALTERNATIVE_YEH_HARAKA
+#HAMZAT
+_AHA = ALEF_HAMZA_ABOVE
+_AHB = ALEF_HAMZA_BELOW
+_AM = ALEF_MADDA
+_YHA = YEH_HAMZA
+_WHA = WAW_HAMZA
+_HZ = HAMZA
+
+
+INITIAL_TAHMEEZ_TABLE = {_S:_HZ, _F:_AHA, _D:_AHA, _K:_AHB, _AH:_AM , 
+            _WH:_AHA, _YH:_AHB, _YHALT:_AHB}
+
+
+MIDDLE_TAHMEEZ_TABLE = {
+_S: {_S:_HZ, _F:_AHA, _D:_WHA, _K:_YHA, _AH:_AHA, _WH:_WHA, _YH:_YHA }, 
+_F: {_S:_AHA, _F:_AHA, _D:_WHA, _K:_YHA, _AH:_AHA, _WH:_WHA, _YH:_YHA }, 
+_D: {_S:_WHA, _F:_WHA, _D:_WHA, _K:_YHA, _AH:_WHA, _WH:_WHA, _YH:_YHA }, 
+_K: {_S:_YHA, _F:_YHA, _D:_YHA, _K:_YHA, _AH:_YHA, _WH:_YHA, _YH:_YHA }, 
+#_AH: {_S:_HZ, _F:_HZ, _D:_WHA, _K:_YHA, _AH:_HZ, _WH:_WHA, _YH:_YHA }, 
+_AH: {_S:_HZ, _F:_HZ, _D:_WHA, _K:_YHA, _AH:_HZ, _WH:_WHA, _YH:_YHA }, 
+#_WH: {_S:_HZ, _F:_HZ, _D:_WHA, _K:_YHA, _AH:_HZ, _WH:_WHA, _YH:_YHA }, 
+_WH: {_S:_HZ, _F:_HZ, _D:_HZ, _K:_YHA, _AH:_HZ, _WH:_HZ, _YH:_YHA }, 
+_YH: {_S:_YHA, _F:_YHA, _D:_YHA, _K:_YHA, _AH:_YHA, _WH:_YHA, _YH:_YHA }, 
+}
+
+FINAL_TAHMEEZ_TABLE = {
+u"%s" % BEGIN_WORD :{_S:_HZ, _F:_AHA, _D:_AHA, _K:_YHA, _AH:_AM, _WH:_AHA, 
+ _YH:_AHA}, 
+#~ _S: {_S:_HZ, _F:_AHA, _D:_WHA, _K:_YHA, _AH:_AHA, _WH:_WHA, _YH:_YHA }, 
+_S: {_S:_HZ, _F:_AHA, _D:_WHA, _K:_YHA, _AH:_AHA, _WH:_WHA, _YH:_YHA }, 
+_F: {_S:_AHA, _F:_AHA, _D:_AHA, _K:_YHA, _AH:_AHA, _WH:_WHA, _YH:_YHA }, 
+_D: {_S:_WHA, _F:_WHA, _D:_WHA, _K:_YHA, _AH:_WHA, _WH:_WHA, _YH:_YHA }, 
+_K: {_S:_YHA, _F:_YHA, _D:_YHA, _K:_YHA, _AH:_WHA, _WH:_WHA, _YH:_YHA }, 
+_AH: {_S:_HZ, _F:_HZ, _D:_HZ, _K:_HZ, _AH:_HZ, _WH:_WHA, _YH:_YHA }, 
+_WH: {_S:_HZ, _F:_HZ, _D:_HZ, _K:_HZ, _AH:_WHA, _WH:_WHA, _YH:_YHA}, 
+_YH: {_S:_HZ, _F:_HZ, _D:_HZ, _K:_HZ, _AH:_WHA, _WH:_WHA, _YH:_YHA}
+}
+
+# جدول تحويل الألف الفتحة الطويلة إلى حركات أخرى حسب سياقها
+HOMOGENIZE_ALEF_HARAKA_TABLE = {
+_S:{_S:'*' , _F:ALEF_HARAKA, _D:WAW_HARAKA, _K:YEH_HARAKA }, 
+_F:{_S:ALEF_HARAKA, _F:ALEF_HARAKA, _D:ALEF_HARAKA, _K:ALEF_HARAKA }, 
+_D:{_S:WAW_HARAKA, _F:ALEF_HARAKA, _D:ALEF_HARAKA, _K:YEH_HARAKA }, 
+_K:{_S:YEH_HARAKA, _F:ALEF_HARAKA, _D:YEH_HARAKA,  _K:ALEF_HARAKA}, 
+}
+
+
+# Table of irregular verbs
+# irregular verbs have common forms
+# جدول الأفعال عربية الشاذة،
+# مثل الفعل رأى، أرى، أخذ أكل، سأل
+#الأفعال المثال
+# كل سطر يحتوي على جذوع تصريف الفعل
+# في زمن معين
+IRREGULAR_VERB_CONJUG = {}
+CONJUG_BAB = u"باب التصريف"
+
+#  في الحركات، الحركة الأولى هي لحركة حرف المضارعة
+IRREGULAR_VERB_CONJUG[u"رءى"+FATHA+FATHA] = {
+CONJUG_BAB:(FATHA, FATHA), 
+TenseFuture:(u"رى", FATHA+FATHA+FATHA), 
+TensePassiveFuture:(u"رى", DAMMA+FATHA+FATHA), 
+TenseImperative:(u"رى", FATHA+FATHA), 
+}
+#ToDO
+# الفعل أرى مشكلة كبيرة
+# لأنه الفعل الشاذ الوحيد الرباعي
+
+IRREGULAR_VERB_CONJUG[u"ءرى"+FATHA+KASRA] = {
+CONJUG_BAB:(KASRA, FATHA), 
+TenseFuture:(u"ري", DAMMA+KASRA+FATHA), 
+TensePassiveFuture:(u"ري", DAMMA+FATHA+FATHA), 
+TenseImperative:(u"ءري", FATHA+KASRA+FATHA), 
+}
+#~ ان يتصرف من باب (عَلِمَ يَعْلَمُ)، 
+#~ لا تحذف واوه؛ نحو: وَجِلَ، يَوْجَلُ، 
+#~ عدا ثلاثة أفعال هي: (وذر), و(وسع)، و(وطأ)،
+ #~ تحذف واوها؛ فنقول: وَذِرَ، يَذَرُ،
+# ونقول: وَسِعَ، يَسَعُ، ونقول: وَطِئَ، يَطَأُ.
+#إذا ك# الفعل وذر يذر
+# KASRA FATHA
+IRREGULAR_VERB_CONJUG[u"وذر"+KASRA+FATHA] = {
+    CONJUG_BAB:(KASRA, FATHA), 
+    TenseFuture:(u"ذر", FATHA+FATHA+DAMMA), 
+    TensePassiveFuture:(u"ذر", DAMMA+FATHA+DAMMA), 
+    TenseImperative:(u"ذر", FATHA+SUKUN), 
+}
+# الفعل وَسِعَ يسع
+# KASRA FATHA
+IRREGULAR_VERB_CONJUG[u"وسع"+KASRA+FATHA] = {
+    CONJUG_BAB:(KASRA, FATHA), 
+    TenseFuture:(u"سع", FATHA+FATHA+DAMMA), 
+    TensePassiveFuture:(u"سع", DAMMA+FATHA+DAMMA), 
+    TenseImperative:(u"سع", FATHA+SUKUN), 
+}
+# الفعل وطئ يطأ
+# KASRA FATHA
+IRREGULAR_VERB_CONJUG[u"وطء"+KASRA+FATHA] = {
+    CONJUG_BAB:(KASRA, FATHA), 
+    TenseFuture:(u"طء", FATHA+FATHA+DAMMA), 
+    TensePassiveFuture:(u"وطء", DAMMA+SUKUN+FATHA+DAMMA), 
+    TenseImperative:(u"طء", FATHA+SUKUN), 
+}
+
+
+
+# الأفعال التي يتغير أمرها بحذف الهمزة وجوبا، مثل أكل،  أخذ
+# أما ما لا تحذف همزته وجوبا مثل سأل وأمر، فلا تعتبر شاذة
+
+# الفعل أكَل يأكُل، كُل
+#FATHA, DAMMA
+IRREGULAR_VERB_CONJUG[u"ءكل"+FATHA+DAMMA] = {
+    CONJUG_BAB:(FATHA, DAMMA), 
+    TenseFuture:(u"ءكل", FATHA+SUKUN+DAMMA+DAMMA), 
+    TensePassiveFuture:(u"ءكل", DAMMA+SUKUN+FATHA+FATHA), 
+    TenseImperative:(u"كل", DAMMA+SUKUN), 
+}
+#الفعل أخَذَ يأخُذُ، خُذ
+#FATHA, DAMMA
+IRREGULAR_VERB_CONJUG[u"ءخذ"+FATHA+DAMMA] = {
+    CONJUG_BAB:(FATHA, DAMMA), 
+    TenseFuture:(u"ءخذ", FATHA+SUKUN+DAMMA+DAMMA), 
+    TensePassiveFuture:(u"ءخذ", DAMMA+SUKUN+FATHA+FATHA), 
+    TenseImperative:(u"خذ", DAMMA+SUKUN), 
+}
+#ج- إذا كان يتصرف من باب (مَنَعَ يَمْنَعُ)، 
+#~ تحذف واوه, نحو: وَضَعَ، يَضَعُ، وَجَأَ يَجَأُ، وَدَعَ يَدَعُ، وَزَعَ يَزَعُ،
+ #~ وَضَأَ يَضَأُ، وَطَأَ يَطَأُ، وَقَعَ يَقَعُ، وَلَغَ يَلَغُ، وَهَبَ يَهَبُ، 
+#~ عدا خمسة أفعال هي:
+ #~ (وَبَأ)، و(وَبَهَ)، و(وَجَعَ)، و(وَسَعَ)، و(وَهَلَ)، 
+#~ فلا تحذف منها الواو؛ فنقول: يَوْبَأُ، يَوْبَهُ، يَوْجَعُ، يَوْسَعُ، يَوْهَلُ.
+# الأفعال (وَبَأ)، و(وَبَهَ)، و(وَجَعَ)، و(وَسَعَ)، و(وَهَلَ)،#الفعل وبَأ يوبأ
+#FATHA FATHA
+IRREGULAR_VERB_CONJUG[u"وبء"+FATHA+FATHA] = {
+    CONJUG_BAB:(FATHA, FATHA), 
+    TenseFuture:(u"وبء", FATHA+SUKUN+FATHA+DAMMA), 
+    TensePassiveFuture:(u"وبء", DAMMA+SUKUN+FATHA+DAMMA), 
+    TenseImperative:(u"وبء", SUKUN+FATHA+SUKUN), 
+}
+# الفعل وبه يوبه
+#FATHA FATHA
+IRREGULAR_VERB_CONJUG[u"وبه"+FATHA+FATHA] = {
+    CONJUG_BAB:(FATHA, FATHA), 
+    TenseFuture:(u"وبه", FATHA+SUKUN+FATHA+DAMMA), 
+    TensePassiveFuture:(u"وبه", DAMMA+SUKUN+FATHA+DAMMA), 
+    TenseImperative:(u"وبه", SUKUN+FATHA+SUKUN), 
+}
+# الفعل وجع يوجع
+#FATHA FATHA
+IRREGULAR_VERB_CONJUG[u"وجع"+FATHA+FATHA] = {
+    CONJUG_BAB:         (FATHA, FATHA), 
+    TenseFuture:        (u"وجع", FATHA+SUKUN+FATHA+DAMMA), 
+    TensePassiveFuture: (u"وجع", DAMMA+SUKUN+FATHA+DAMMA), 
+    TenseImperative:    (u"وجع", SUKUN+FATHA+SUKUN), 
+}
+#الفعل وسع يوسع
+#FATHA FATHA
+IRREGULAR_VERB_CONJUG[u"وسع"+FATHA+FATHA] = {
+    CONJUG_BAB:         (FATHA, FATHA), 
+    TenseFuture:        (u"وسع", FATHA+SUKUN+FATHA+DAMMA), 
+    TensePassiveFuture: (u"وسع", DAMMA+SUKUN+FATHA+DAMMA), 
+    TenseImperative:    (u"وسع", SUKUN+FATHA+SUKUN), 
+}
+
+# الفعل وهل يوهل
+#FATHA FATHA
+IRREGULAR_VERB_CONJUG[u"وهل"+FATHA+FATHA] = {
+    CONJUG_BAB:         (FATHA, FATHA), 
+    TenseFuture:        (u"وهل", FATHA+SUKUN+FATHA+DAMMA), 
+    TensePassiveFuture: (u"وهل", DAMMA+SUKUN+FATHA+DAMMA), 
+    TenseImperative:    (u"وهل", SUKUN+FATHA+SUKUN), 
+}
+
+
+
+ALEF_MADDA_VERB_TABLE = {
+u'آبل':[u'أءبل'], 
+u'آبه':[u'أءبه'], 
+u'آبى':[u'أءبى'], 
+u'آتم':[u'أءتم'], 
+u'آتن':[u'أءتن'], 
+u'آتى':[u'أءتى'], 
+#~ u'آتى':[u'أءتى'], 
+u'آثر':[u'أءثر'], 
+u'آثف':[u'أءثف'], 
+u'آثم':[u'أءثم'], 
+u'آثى':[u'ءاثى'], 
+u'آجد':[u'أءجد'], 
+u'آجر':[u'أءجر', u'ءاجر'], 
+u'آجل':[u'أءجل'], 
+u'آجم':[u'أءجم'], 
+u'آحن':[u'ءاحن'], 
+u'آخذ':[u'ءاخذ'], 
+u'آخى':[u'أءخى', u'ءاخى'], 
+u'آدب':[u'أءدب'], 
+u'آدم':[u'أءدم'], 
+u'آدى':[u'أءدى'], 
+u'آذن':[u'أءذن'], 
+u'آذى':[u'أءذى'], 
+u'آرب':[u'أءرب', u'ءارب'], 
+u'آرخ':[u'أءرخ'], 
+u'آرس':[u'أءرس'], 
+u'آرض':[u'أءرض'], 
+u'آرط':[u'أءرط'], 
+u'آرف':[u'ءارف'], 
+u'آرق':[u'أءرق'], 
+u'آرك':[u'أءرك'], 
+u'آرم':[u'ءارم'], 
+u'آرن':[u'أءرن', u'ءارن'], 
+u'آرى':[u'أءرى'], 
+u'آزر':[u'ءازر'], 
+u'آزف':[u'أءزف'], 
+u'آزل':[u'أءزل'], 
+u'آزى':[u'أءزى', u'ءازى'], 
+u'آسب':[u'أءسب'], 
+u'آسد':[u'أءسد'], 
+u'آسف':[u'أءسف'], 
+u'آسن':[u'أءسن'], 
+#~ u'آسى':[u'ءاسى'], 
+u'آسى':[u'أءسى', u'ءاسى'], 
+u'آشى':[u'أءشى'], 
+u'آصد':[u'أءصد'], 
+u'آصر':[u'ءاصر'], 
+u'آصل':[u'أءصل'], 
+u'آضّ':[u'ءاضّ'],
+u'آض':[u'ءاضّ'],  
+u'آطم':[u'أءطم'], 
+u'آفك':[u'أءفك'], 
+u'آفى':[u'أءفى'], 
+u'آقط':[u'أءقط'], 
+u'آكد':[u'أءكد'], 
+u'آكر':[u'ءاكر'], 
+u'آكف':[u'أءكف'], 
+u'آكل':[u'أءكل', u'ءاكل'], 
+u'آلت':[u'أءلت'], 
+u'آلس':[u'ءالس'], 
+u'آلف':[u'أءلف', u'ءالف'], 
+u'آلم':[u'أءلم'], 
+u'آلى':[u'أءلى'], 
+u'آمر':[u'أءمر', u'ءامر'], 
+u'آمن':[u'أءمن'], 
+u'آنث':[u'أءنث'], 
+u'آنس':[u'أءنس', u'ءانس'], 
+u'آنض':[u'أءنض'], 
+u'آنف':[u'أءنف'], 
+u'آنق':[u'أءنق'], 
+u'آنى':[u'أءنى'], 
+u'آهل':[u'أءهل'], 
+u'آوب':[u'ءاوب'], 
+u'آوى':[u'أءوى'], 
+u'آيد':[u'ءايد'], 
+u'آيس':[u'أءيس'], 
+}
+
+STANDARD_REPLACEMENT=[
+    #-تحويل همزة القطع على الألف بعدها فتحة 
+#وهمزة القطع على الألف بعدها سكون إلى ألف ممدودة
+( u"".join([ALEF_HAMZA_ABOVE, FATHA, ALEF]), ALEF_MADDA)
+, ( u"".join([ALEF_MADDA, FATHA]), ALEF_MADDA)
+, ( u"".join([ALEF_MADDA, ALEF]), ALEF_MADDA)
+, ( u"".join([ALEF_HAMZA_ABOVE, FATHA, ALEF_HAMZA_ABOVE, SUKUN]), ALEF_MADDA)
+, ( u"".join([ALEF_HAMZA_ABOVE, FATHA, ALEF_HAMZA_ABOVE, FATHA]), ALEF_MADDA)
+, ( u"".join([ALEF_HAMZA_ABOVE, DAMMA, WAW_HAMZA, SUKUN]), ALEF_HAMZA_ABOVE+DAMMA+WAW)
+, ( u"".join([YEH, SHADDA, FATHA, ALEF_MAKSURA]), YEH+SHADDA+FATHA+ALEF)
+# إدغام النون الساكنة
+, ( u"".join([NOON, SUKUN, NOON]), NOON+SHADDA)
+# إذا كان الحرف الأول ساكنا وبعده شدة، ثم أضيفت إليه الألف
+, ( u"".join([SUKUN, SHADDA]), SHADDA)
+##  معالجة ألف التفريق
+, ( ALEF_WASLA, ALEF)
+##  معالجة ألف التفريق
+, ( ALEF_MAMDUDA, ALEF)
+
+##  معالجة ألف  الوصل الزائدة عند إضافتها إلى أول الفعل المثال
+##    word = word.replace( u"%s%s%s%s"%(ALEF, DAMMA, YEH, SUKUN), ALEF+DAMMA+WAW)
+
+
+
+
+]

libqutrub/verb_db.py

@@ -0,0 +1,149 @@
+#!/usr/bin/python
+# -*- coding = utf-8 -*-
+#************************************************************************
+# $Id: ar_verb.py, v 0.7 2009/06/02 01:10:00 Taha Zerrouki $
+#
+# ------------
+# Description:
+# ------------
+#  Copyright (c) 2009, Arabtechies, Arabeyes Taha Zerrouki
+#
+#  Elementary function to manipulate arabic texte
+#
+# -----------------
+# Revision Details:    (Updated by Revision Control System)
+# -----------------
+#  $Date: 2009/06/02 01:10:00 $
+#  $Author: Taha Zerrouki $
+#  $Revision: 0.7 $
+#  $Source: arabtechies.sourceforge.net
+#
+#***********************************************************************/
+"""
+Basic routines to treat verbs
+ar_verb
+"""
+import os
+# the db file
+db_path = os.path.join(os.path.dirname(__file__), "data/verbdict.db")
+
+import pyarabic.araby as araby
+import libqutrub.triverbtable as triverbtable
+TRIVERBTABLE_INDEX = {}
+
+def create_index_triverbtable():
+    """ Create index from the verb dictionary
+    to accelerate the search in the dictionary for verbs
+    @return: create the TRIVERBTABLE_INDEX
+    @rtype: None
+    """
+    # the key is the vocverb + the bab number
+    for key in triverbtable.TriVerbTable.keys():
+        vocverb = triverbtable.TriVerbTable[key]['verb']
+        unvverb = araby.strip_harakat(vocverb)
+        normverb = araby.normalize_hamza(unvverb)
+        if normverb in TRIVERBTABLE_INDEX:
+            TRIVERBTABLE_INDEX[normverb].append(key)
+        else:
+            TRIVERBTABLE_INDEX[normverb] = [key, ]
+
+
+
+def find_alltriverb(triverb, givenharaka = araby.FATHA, 
+vocalised_entree = False):
+    """
+    Find the triliteral verb in the dictionary (TriVerbTable)
+    return a list of possible verb forms
+    each item contains:
+        - 'root':
+        - 'haraka:
+        - 'bab':
+        - 'transitive':
+    @param triverb: given verb.
+    @type triverb: unicode.
+    @param givenharaka: given haraka of tuture type of the verb, 
+    default(FATHA).
+    @type givenharaka: unicode.
+    @param VocalisedEntree: True if the given verb is vocalized, 
+    default False.
+    @type VocalisedEntree: Boolean.
+    @return: list of triliteral verbs.
+    @rtype: list of dicts.
+    """
+    liste = []
+
+    if vocalised_entree:
+        verb_nm = araby.strip_harakat(triverb)
+    else:
+        verb_nm = triverb
+
+    normalized = araby.normalize_hamza(verb_nm)
+    if TRIVERBTABLE_INDEX.has_key(normalized):
+        for verb_voc_id in TRIVERBTABLE_INDEX[normalized]:
+            if triverb == triverbtable.TriVerbTable[verb_voc_id]['verb'] and \
+             givenharaka == triverbtable.TriVerbTable[verb_voc_id]['haraka']:
+                liste.insert(0, triverbtable.TriVerbTable[verb_voc_id])
+#            if VocalisedEntree:
+                #if verb_voc_id[:-1] == triverb:
+                #    liste.append(TriVerbTable[verb_voc_id])
+            else:
+                liste.append(triverbtable.TriVerbTable[verb_voc_id])
+    else:
+        print("triverb has no verb")
+    return liste
+
+
+
+def find_triliteral_verb(db_base_path, triliteralverb, givenharaka):
+    """
+    Find the triliteral verb in the dictionary, 
+    return a list of possible verb forms
+    @param db_base_path: the database path
+    @type db_base_path: path string.
+    @param triliteralverb: given verb.
+    @type triliteralverb: unicode.
+    @param givenharaka: given haraka of tuture type of the verb.
+    @type givenharaka: unicode.
+    @return: list of triliteral verbs.
+    @rtype: list of unicode.
+    """
+    liste = []
+    try:
+        import sqlite3 as sqlite
+        import os
+#     db_path = os.path.join(_base_directory(req), "data/verbdict.db")
+
+        #db_path = os.path.join(db_base_path, "data/verbdict.db")
+        conn  =  sqlite.connect(db_path)
+        cursor  =  conn.cursor()
+        verb_nm = araby.strip_harakat(triliteralverb)
+        tup = (verb_nm, )
+        cursor.execute("""select verb_vocalised, haraka, transitive 
+                    from verbdict
+                    where verb_unvocalised = ?""", tup)
+        for row in cursor:
+            verb_vocalised = row[0]
+            haraka = row[1]
+            transitive = row[2]
+            # Return the transitivity option
+            #MEEM is transitive
+            # KAF is commun ( transitive and intransitive)
+            # LAM is intransitive
+            if transitive in (araby.KAF, araby.MEEM):
+                transitive = True
+            else:
+                transitive = False
+# if the given verb is the list, 
+#it will be inserted in the top of the list, 
+#to be treated in prior
+            if triliteralverb == verb_vocalised and givenharaka == haraka:
+                liste.insert(0, {"verb":verb_vocalised, 
+                "haraka":haraka, "transitive":transitive})
+# else the verb is appended in the liste
+            else:
+                liste.append({"verb":verb_vocalised, 
+                "haraka":haraka, "transitive":transitive})
+        cursor.close()
+        return liste
+    except IOError:
+        return None

libqutrub/verb_valid.py

@@ -0,0 +1,359 @@
+#!/usr/bin/python
+# -*- coding = utf-8 -*-
+#************************************************************************
+# $Id: verb_valid.py, v 0.7 2009/06/02 01:10:00 Taha Zerrouki $
+#
+# ------------
+# Description:
+# ------------
+#  Copyright (c) 2009, Arabtechies, Arabeyes Taha Zerrouki
+#
+#  Elementary function to validate verbs 
+#
+# -----------------
+# Revision Details:    (Updated by Revision Control System)
+# -----------------
+#  $Date: 2009/06/02 01:10:00 $
+#  $Author: Taha Zerrouki $
+#  $Revision: 0.7 $
+#  $Source: arabtechies.sourceforge.net
+#
+#***********************************************************************/
+"""
+Basic routines to validate verbs
+ar_verb
+"""
+import re
+# import string
+# import sys
+# import os
+# import types
+# from arabic_const import *
+import libqutrub.verb_const as vconst #~ from verb_const import *
+# import ar_ctype 
+import pyarabic.araby as araby
+from pyarabic.araby import FATHA,   SHADDA,  HAMZA, ALEF, \
+ NOON,   ALEF_HAMZA_ABOVE, ALEF_HAMZA_BELOW, ALEF_MADDA, \
+  ALEF_MAKSURA, BEH, DAD, DAL, DAMMATAN, FATHATAN, FEH, GHAIN, HAH, \
+ HEH, JEEM, KAF, KASRATAN, KHAH, LAM, REH, SAD, SHEEN, TAH, TEH, \
+ TEH_MARBUTA, THAL, THEH, YEH, ZAH, ZAIN
+#used to
+VALID_INFINITIVE_VERB6_PATTERN = \
+re.compile(u"^است...|ا..ن..|ا..و..|ا..ا.ّ|ا....ّ|ا.ّ.ّ.|ا.ّا..$", re.UNICODE)
+
+VALID_INFINITIVE_VERB4_PATTERN = re.compile(\
+u"^([%s%s][^%s]{2}.|[^%s%s]%s[^%s%s].|[^%s%s]{2}%s[^%s]|[^%s%s]{4})$"\
+%(ALEF_HAMZA_ABOVE, HAMZA, SHADDA, ALEF, SHADDA, ALEF, ALEF, SHADDA, ALEF,
+ SHADDA, SHADDA, SHADDA, ALEF, SHADDA), re.UNICODE)
+
+VALID_INFINITIVE_VERB5_PATTERN = re.compile( u"|".join([
+                                    u"^ا...ّ$", 
+            # حالة اتخذ أو اذّكر أو اطّلع
+            u"^%s[%s%s%s]%s..$"%(ALEF, TEH, THAL, TAH, SHADDA), 
+            # حالة اتخذ أو اذّكر أو اطّلع
+           u"^ا[تذط]ّ[^اّ][^اّ]$", 
+            # انفعل
+            u"^ان...$", 
+            #افتعل
+            u"^(ازد|اصط|اضط)..$"
+            u"^ا[^صضطظد]ت..$", 
+            u"^ا...ّ$", 
+            # حالة اتخذ أو اذّكر أو اطّلع
+             u"^ا.ّ..$", 
+             u"^ا...ى$", 
+             ]) , re.UNICODE)
+
+#####################################
+#{validation functions
+#####################################
+def is_valid_infinitive_verb(word, vocalized = True):
+    """
+    Determine if the given word is a valid infinitive form of an arabic verb.
+    A word is not valid  infinitive if
+        - lenght < 3 letters.
+        - starts with : ALEF_MAKSURA, WAW_HAMZA, YEH_HAMZA, HARAKAT
+        - contains TEH_MARBUTA, Tanwin
+        - contains non arabic letters.
+        - contains ALEF_MAKSURA not in the end.
+        - contains double haraka : a warning
+    @param word: given word.
+    @type word: unicode.
+    @param is_vocalized: if the given word is vocalized.
+    @type is_vocalized:Boolean, default(True).
+    @return: True if the word is a valid infinitive form of verb.
+    @rtype: Boolean.
+    """
+    # test if the word is an arabic valid word, 
+    if not  araby.is_arabicword(word):
+        return False
+    if vocalized :
+        word_nm  =  araby.strip_harakat(word)
+    else:
+        word_nm = word
+    # the alef_madda is  considered as 2 letters
+
+    word_nm = word_nm.replace(ALEF_MADDA, HAMZA+ALEF)
+    length = len(word_nm)
+
+    # lenght with shadda must be between 3 and 6
+    if length < 3  or length >= 7:
+        return False
+    # a 3 length verb can't start by Alef or Shadda, 
+    #and the second letter can't be shadda
+    elif length == 3 and (word_nm[0] == ALEF or word_nm[0] == SHADDA \
+    or word_nm[1] == SHADDA):
+        return False
+
+    # a 5 length verb must start by ALEF or TEH
+    elif length == 5 and word_nm[0] not in (TEH, ALEF):
+        return False
+    # a 6 length verb must start by ALEF
+    elif length == 6 and word_nm[0] !=  ALEF:
+        return False
+
+    # contains some invalide letters in verb
+    elif re.search(u"[%s%s%s%s%s]"%(ALEF_HAMZA_BELOW, TEH_MARBUTA, 
+    DAMMATAN, KASRATAN, FATHATAN), word):
+        return False
+    # contains some SHADDA sequence letters in verb
+    # Like shadda shadda, shadda on alef, start  
+    # by shadda, shadda on alef_ maksura, 
+    # ALEF folowed by (ALEF, ALEF_MAKSURA)
+    # ALEF Folowed by a letter and ALEF
+    # end with ALEF folowed by (YEH, ALEF_MAKSURA)
+    # first letter is alef and ALLw alef and two letters aand shadda
+    elif re.search(u"([%s%s%s]%s|^%s|^%s..%s|^.%s|%s.%s|%s%s|%s[%s%s]$)"%(
+    ALEF, ALEF_MAKSURA, SHADDA, SHADDA, SHADDA, ALEF, SHADDA, SHADDA, 
+    ALEF, ALEF, ALEF, ALEF, ALEF, ALEF_MAKSURA, YEH), word_nm):
+        return False
+
+
+    # Invalid root form some letters :
+    #~ # initial YEH folowed by 
+    #~ ((THEH, JEEM, HAH, KHAH, THAL, ZAIN, SHEEN, SAD, DAD,
+     #~ TAH, ZAH, GHAIN, KAF, HEH, YEH))
+    elif re.search(u"^%s[%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s]"%(
+    YEH, THEH, JEEM, HAH, KHAH, THAL, ZAIN, SHEEN, SAD, DAD, 
+    TAH, ZAH, GHAIN, KAF, HEH, YEH), word_nm):
+        return False
+
+
+       # TEH After (DAL, THAL, TAH, ZAH, DAD)
+    elif re.search(u"[%s%s%s%s%s]%s"%(DAL, THAL, DAD, TAH, ZAH, TEH), word_nm):
+        return False
+    # Contains invalid root sequence in arabic, near in phonetic
+    # like BEH and FEH, LAM And REH
+    elif re.search(u"%s%s|%s%s|%s%s|%s%s|%s%s|%s%s|%s%s"%(
+    LAM, REH, REH, LAM, FEH, BEH, BEH, FEH, NOON,
+     LAM, HEH, HAH, HAH, HEH), word_nm):
+        return False
+
+
+    # in non 5 letters verbs :initial TEH followed by  
+    # (THEH, DAL, THAL, ZAIN, SHEEN, SAD, DAD, TAH, ZAH)
+    elif length !=  5 and word_nm.startswith(TEH) and word_nm[1] in (
+    TEH, THEH, DAL, THAL, ZAIN, SHEEN, SAD, DAD, TAH, ZAH):
+        return False
+    # if word start by the same letter doubled
+    elif word_nm[0] == word_nm[1] and word[0] !=  TEH:
+        return False
+
+    #verify the wazn of the verb
+    elif length == 3:
+        if re.match("^[^%s][^%s].$"%(ALEF, SHADDA), word_nm):
+            return True
+    # الأوزان المقبولة هي فعل، فعّ،
+    # الأوزان غير المقبولة
+    # اعل، فّل
+        else: return False
+    elif length == 4:
+    #1- أفعل، 2- فاعل، 3 فعّل 4 فعلل
+        if re.match(\
+        "^([%s%s][^%s]{2}.|[^%s%s]%s[^%s%s].|[^%s%s]{2}%s[^%s]|[^%s%s]{4})$"\
+        %(ALEF_HAMZA_ABOVE, HAMZA, SHADDA, ALEF, SHADDA, ALEF, ALEF, SHADDA,
+         ALEF, SHADDA, SHADDA, SHADDA, ALEF, SHADDA), word_nm):
+
+            return True
+    # الأوزان المقبولة هي فعل، فعّ،
+    # الأوزان غير المقبولة
+    #     افعل: يجب تثبيت همزة القطع
+    #فّعل، فعلّ: الشدة لها موضع خاص
+    # فعال، فعلا: للألف موضع خاص
+        else: return False
+    elif length == 5:
+
+        if  word_nm.startswith(ALEF):
+            if re.match(u"^ا...ّ$", word_nm):
+                return True
+            # حالة اتخذ أو اذّكر أو اطّلع
+            if re.match(u"^%s[%s%s%s]%s..$"%(ALEF, TEH, THAL, TAH, SHADDA), \
+             word_nm):
+                return True
+
+            # انفعل
+            elif re.match(u"^ان...$", word_nm):
+                return True
+            #افتعل
+            elif re.match(u"^(ازد|اصط|اضط)..$", word_nm):
+                return True
+            elif re.match(u"^ا[^صضطظد]ت..$", word_nm):
+                return True
+            elif re.match(u"^ا...ّ$", word_nm):
+                return True
+            # حالة اتخذ أو اذّكر أو اطّلع
+            elif re.match(u"^ا.ّ..$", word_nm):
+                return True
+            elif re.match(u"^ا...ى$", word_nm):
+                return True
+            else: return False
+        elif word_nm.startswith(TEH):
+            return True
+        else:
+            return False
+
+    # الأوزان المقبولة هي فعل، فعّ،
+    # الأوزان غير المقبولة
+    #للشدة موضع خاص: تفعّل، افتعّ
+    # للألف مواضع خاصة،
+    elif length == 6:
+        if not (word_nm.startswith(ALEF) or word_nm.startswith(TEH)):
+            return False
+        if VALID_INFINITIVE_VERB6_PATTERN.match(word_nm):
+            return True
+    # الأوزان المقبولة هي فعل، فعّ،
+    # الأوزان غير المقبولة
+    #للشدة موضع خاص: تفعّل، افتعّ
+    # للألف مواضع خاصة،
+        else: return False
+    return True
+
+
+def suggest_verb(verb):
+    """
+    Generate a list of valid infinitive verb for an invalid infinitive form.
+    @param verb: given verb, of invalid infinitive form.
+    @type verb: unicode.
+    @return: a list of suggested infinitive verb forms
+    @rtype: list of unicode.
+    """
+    # the verb is invalid
+    list_suggest = []
+    # first strip harakat, shadda is not striped
+    verb = araby.strip_harakat(verb)
+    # second strip all inacceptable letters in an infinivive form
+    verb = re.sub(u"[%s%s%s%s]"%( TEH_MARBUTA, DAMMATAN, KASRATAN, FATHATAN), \
+     '', verb)
+    # test the resulted verb if it's valid, if ok, 
+    # add it to the suggestion list.
+    if is_valid_infinitive_verb(verb):
+        list_suggest.append(verb)
+        return list_suggest
+    # if the verb starts by ALEF_HAMZA_BELOW like إستعمل, 
+    #replace if by an ALEF, because it's a common error.
+    # if the result is valid add it to the suggestions list
+    elif verb.startswith(ALEF_HAMZA_BELOW):
+        verb = re.sub(ALEF_HAMZA_BELOW, ALEF, verb)
+        if is_valid_infinitive_verb(verb):
+            list_suggest.append(verb)
+            return list_suggest
+    # if the verb starts by ALEF like اضرب, 
+    #replace if by an ALEF_HAMZA_ABOVE, because it's a common error.
+    # if the result is valid add it to the suggestions list
+    elif verb.startswith(ALEF):
+        verb_one = re.sub(ALEF, ALEF_HAMZA_ABOVE+FATHA, verb, 1)
+        if is_valid_infinitive_verb(verb_one):
+            list_suggest.append(verb_one)
+            return list_suggest
+    # if the verb is 2 letters length, 
+    # suggest to add the third letter as : 
+    # Shadda, Alef, Alef Maksura, Yeh at the end
+    # if the result is valid add it to the suggestions list
+    elif len(verb) == 2:
+        verb = re.sub(ALEF, ALEF_HAMZA_ABOVE, verb, 1)
+        #suggest to add the third letter as : Shadda at the end
+        verb_one = verb+SHADDA
+        if is_valid_infinitive_verb(verb_one):
+            list_suggest.append(verb_one)
+        #suggest to add the third letter as : Alef Maksura
+        verb_one = verb+ALEF_MAKSURA
+        if is_valid_infinitive_verb(verb_one):
+            list_suggest.append(verb_one)
+        #suggest to add the third letter as :Alef at the end
+        verb_one = verb+ALEF
+        if is_valid_infinitive_verb(verb_one):
+            list_suggest.append(verb_one)
+        #suggest to add the third letter as :Alef in middle
+        verb_one = verb[0]+ALEF+verb[1]
+        if is_valid_infinitive_verb(verb_one):
+            list_suggest.append(verb_one)
+        return list_suggest
+    elif len(verb) >= 6:
+    # if the verb is more than 6 letters length, 
+    #suggest to replace the over added letters by Alef
+    # if the result is valid add it to the suggestions list
+        for i in range(len(verb)-6):
+            verb_one = ALEF+verb[i:i+5]
+            if is_valid_infinitive_verb(verb_one):
+                list_suggest.append(verb_one)
+    elif len(verb) == 5:
+    # if the verb is 5 letters length, suggest
+    # if the result is valid add it to the suggestions list
+        # ToDo: review this part
+        for i in range(len(verb)-5):
+            verb_one = ALEF+verb[i:i+4]
+            if is_valid_infinitive_verb(verb_one):
+                list_suggest.append(verb_one)
+    elif len(verb) == 4:
+
+    # if the verb is 5 letters length, 
+    #suggest to replace the over added letters by Alef
+    # if the result is valid add it to the suggestions list
+    # فعال = > فاعل
+    #فّعل = > فعّل
+        if verb[2] == ALEF or verb[1] == SHADDA:
+            verb_one = verb[0]+verb[2]+verb[1]+verb[3]
+            if is_valid_infinitive_verb(verb_one):
+                list_suggest.append(verb_one)
+        if verb.endswith(SHADDA):
+    # if the verb is 4 letters length, 
+    #suggest to correct the alef and shadda position
+    # if the result is valid add it to the suggestions list
+    #فعلّ = > فعّل
+            verb_one = verb[0]+verb[1]+verb[3]+verb[2]
+            if is_valid_infinitive_verb(verb_one):
+                list_suggest.append(verb_one)
+        return list_suggest
+    else:
+    # else sugest to conjugate another verb
+        list_suggest.append(u"كتب")
+        return list_suggest
+    return list_suggest
+
+#####################################
+#{verb pretreatment functions
+#####################################
+def  normalize_alef_madda(word):
+    """
+    Convert Alef madda into two letters.
+    @param word: given word.
+    @type word: unicode.
+    @return: converted word.
+    @rtype: unicode.
+    """
+    if word.startswith(ALEF_MADDA):
+        word_nm = araby.strip_harakat(word)
+        if len(word_nm) == 2:
+            return word_nm.replace(ALEF_MADDA, HAMZA+ALEF)
+        elif len(word_nm) == 3:
+            if vconst.ALEF_MADDA_VERB_TABLE.has_key(word_nm):
+                #return the first one only
+                #mylist = ALEF_MADDA_VERB_TABLE[word_nm]
+                return vconst.ALEF_MADDA_VERB_TABLE[word_nm][0]
+            else:
+                return  word_nm.replace(ALEF_MADDA, HAMZA+ALEF)
+        else:
+            return word_nm.replace(ALEF_MADDA, HAMZA+ALEF)
+    else:
+        return word_nm
+
+

requirements.txt

@@ -0,0 +1,2 @@
+Flask==3.1.0
+PyArabic==0.6.15

templates/index.html

@@ -0,0 +1,94 @@
+<!DOCTYPE html>
+<html lang="ar">
+<head>
+<meta charset="UTF-8">
+<title>المصرّف</title>
+
+<style>
+body {
+    direction: rtl;
+    text-align: right;
+    font-family: Arial;
+    padding: 30px;
+    background: #f5f5f5;
+}
+
+.container {
+    background: white;
+    padding: 20px;
+    border-radius: 10px;
+}
+
+input, select, button {
+    padding: 10px;
+    margin: 10px 0;
+    width: 100%;
+    font-size: 16px;
+}
+
+button {
+    background: #2c7be5;
+    color: white;
+    border: none;
+    cursor: pointer;
+}
+
+#result {
+    margin-top: 20px;
+}
+</style>
+</head>
+
+<body>
+
+<div class="container">
+    <h1>المصرّف</h1>
+
+    <input id="word" placeholder="أدخل الفعل (مثال: كتب)">
+
+    <select id="tense">
+        <option value="past">الماضي</option>
+        <option value="future">المضارع</option>
+        <option value="jussive">المجزوم</option>
+        <option value="subjunctive">المنصوب</option>
+        <option value="confirmed">المؤكد</option>
+        <option value="imperative">الأمر</option>
+    </select>
+
+    <select id="future_type">
+        <option value="فتحة">فتحة</option>
+        <option value="ضمة">ضمة</option>
+        <option value="كسرة">كسرة</option>
+    </select>
+
+    <button onclick="generate()">توليد التصريف</button>
+
+    <div id="result"></div>
+</div>
+
+<script>
+async function generate() {
+    const word = document.getElementById("word").value;
+    const tense = document.getElementById("tense").value;
+    const future_type = document.getElementById("future_type").value;
+
+    const response = await fetch("http://127.0.0.1:5000/conjugate", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+            word,
+            tense,
+            future_type
+        })
+    });
+
+    const data = await response.json();
+
+    document.getElementById("result").innerHTML = data.result;
+}
+</script>
+
+</body>
+</html>