spellchecker.py~

import sys
from copy import copy
from time import time

from Engine.Classifier.QueryClassifier import QueryClassifier
from Engine.ErrorModel import ErrorModel
from Engine.Generators.GrammarGenerator import GrammarGenerator
from Engine.Generators.JoinGenerator import JoinGenerator
from Engine.Generators.LayoutGenerator import LayoutGenerator
from Engine.Generators.SplitGenerator import SplitGenerator
from Engine.TextFormatter import TextFormatter
from Engine.utils.utils import load_obj, print_error

if __name__ == "__main__":

    lm = load_obj("LanguageModel")
    em = ErrorModel(load_obj("Trie"))
    cl = load_obj("classifier")
    qc = QueryClassifier(cl, lm)

    layoutGenerator = LayoutGenerator()
    splitGenerator = SplitGenerator()
    joinGenerator = JoinGenerator()
    grammarGenerator = GrammarGenerator(em, lm)

    i = 0
    for s in sys.stdin:
        t1 = time()
        i+=1
        textFormatter = TextFormatter(s)
        words = textFormatter.get_query_list()
        query = textFormatter.text
        print query.encode("utf-8")
        print_error(s)
        """
        if qc.is_correct(query, words):
            print query.encode("utf-8")
            #print_error("CORRECT")#.format(query.encode("utf-8"), correction[probs.index(max(probs))]))
            #print_error("{} \t OK".format(s))
        else:
            correction = []
            probs = []

            # =============================== Layout
            keybordChangedWords = layoutGenerator.generate_correction(words)
            queryKeybord = textFormatter.format_text(keybordChangedWords)
            if qc.is_correct(queryKeybord, keybordChangedWords):
                correction.append(queryKeybord.encode("utf-8"))
                probs.append(lm.get_prob(keybordChangedWords))


            # ================================= Grammar
            grammas = grammarGenerator.generate_correction(words)
            for gramma in grammas:
                queryGramma = textFormatter.format_text(gramma)
                if qc.is_correct(queryGramma, gramma):
                    correction.append(queryGramma.encode("utf-8"))
                    probs.append(lm.get_prob(gramma))

            # ================================ Join
            joins = joinGenerator.generate_joins(words)
            for join in joins:
                queryJoin = u" ".join(join)
                if qc.is_correct(queryJoin, join):
                    correction.append(queryJoin.encode("utf-8"))
                    probs.append(lm.get_prob(join))


            # ================================ Split
            splits = splitGenerator.generate_splits(words)
            for split in splits:
                querySplit = u" ".join(split)
                if qc.is_correct(querySplit, split):
                    correction.append(querySplit.encode("utf-8"))
                    probs.append(lm.get_prob(split))

            if len(correction) == 0:
                print query.encode("utf-8")
                #print_error("{} \t {}".format(query.encode("utf-8"), "not found=("))
            else:
                print correction[probs.index(max(probs))]
                #print_error("{} \t {}".format(query.encode("utf-8"), correction[probs.index(max(probs))]))
        """