PyZapv3

#PyZap
# -*- coding: utf-8 -*-

#TODO

#minor -> agregar boton de reset
#minor -> untogglear botones con clear
#minor -> self.line_edit.clear()agregar un nuevo shortcut en letras repetidas
#minor -> de-focusear botones después de oprimidos

import random
import csv
import sys
import unittest as u
from PySide import QtGui, QtCore

class MainWindow(QtGui.QMainWindow):

    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent)

        self.initUI()

    def initUI(self):
        """Inicia la Ventana del juego."""

        self.statusBar().showMessage('Listo.')

        self.widget = MainWidget()
        self.setCentralWidget(self.widget)

        self.setGeometry(300, 300, 300, 300)
        self.setWindowTitle('PyZap')
        self.setWindowIcon(QtGui.QIcon('icon.png'))
        self.show()

class MainWidget(QtGui.QWidget):

        def __init__(self, parent=None):
            super(MainWidget, self).__init__(parent)
            self.init_ui()

        def init_ui(self):
            #Aqui van las weas graficas

            self.grid= QtGui.QGridLayout()
            self.grid.setSpacing(10)

            self.letter_grid = QtGui.QGridLayout()
            self.letter_grid.setSpacing(10)

            pos = [(0,0), (0,1), (0,2), (1,0), (1,1), (1,2), (2,0), (2,1), (2,2)]
            j = 0

            for i in pyzap.letras_escogidas:
                button = QtGui.QPushButton(i)
                button.setShortcut(str(i))
                button.setCheckable(True)
                button.clicked[bool].connect(self.typea)
                self.letter_grid.addWidget(button, pos[j][0], pos[j][1])
                j = j + 1

            self.line_edit = QtGui.QTextEdit()
            self.line_edit.setReadOnly(True)
            self.line_edit.setMaximumHeight(25)

            self.grid.addLayout(self.letter_grid, 0, 0)

            self.clear_button = QtGui.QPushButton('Clear')
            self.clear_button.setShortcut("Ctrl + Q")
            self.clear_button.clicked.connect(self.line_edit.clear)

            self.ok_button = QtGui.QPushButton("OK")
            self.ok_button.setShortcut("Enter")
            self.ok_button.clicked.connect(self.send)

            self.grid.addWidget(self.clear_button, 0, 1)
            self.grid.addWidget(self.line_edit, 1, 0, 1, 1)
            self.grid.addWidget(self.ok_button, 2, 1)


            self.grid.addWidget(QtGui.QLabel("Tus Palabras"), 2,0)

            self.tus_palabras = QtGui.QTextEdit()
            self.tus_palabras.setReadOnly(True)

            self.grid.addWidget(self.tus_palabras, 3, 0, 1, 1)

            self.setLayout(self.grid)
            self.show()


        def typea(self, pressed):
            """Escribe el texto del boton."""

            source = self.sender()

            if pressed:
                 self.line_edit.insertPlainText(source.text())
            else:
                self.line_edit.clear()


        def send(self):
            """Envia word para ser validada. Regresa texto si succedea."""

            word = self.line_edit.toPlainText()
            print "La palabra enviada fue " + str(word) #debug

            self.line_edit.clear()

            valid = self.validate_word(word)

            if valid:
                repeated = self.check_repeated(word)
                if not repeated:
                    pyzap.your_words.append(word)
                    self.tus_palabras.append(word)
                    window.statusBar().showMessage("Correcto!")
                else:
                    self.line_edit.insertPlainText(
                    "Ya usaste esa palabra!")
                    window.statusBar().showMessage(
                    "Ya usaste esa palabra!")
            else:
                self.line_edit.insertPlainText(
                    "Esa palabra no se puede formar o no existe")
                window.statusBar().showMessage(
                    "Esa palabra no se puede formar o no existe!")

            if len(pyzap.your_words) == 10:
                #ShowDialogBox diciendo que ganaste
                msg = QtGui.QMessageBox.information(self, "Felicidades!",
                                                    "Has logrado formar 10 palabras!")

        def validate_word(self, word):
            """Valida que la palabra este presente en el diccionario."""
            return word in pyzap.palabras2

        def check_repeated(self, word):
            """Valida que la palabra no haya sido usada antes."""
            return word in pyzap.your_words



class PyZap(object):

    def __init__(self, parent=None):

        self.init_mind()

    def init_mind(self):
        """Inicia procesos de la aplicacion."""

        self.alpha = self.create_alpha()
        print "Alfabeto creado correctamente" #Debug
        print "--------------------------------------------" #Debug

        self.letras_escogidas = self.get_sample()
        print "Letras de la corrida: " + str(self.letras_escogidas)
        print "--------------------------------------------" #Debug

        print "Comenzando busqueda lv1 en diccionario seleccionado..." #debug
        self.palabras1 = self.first_search(
            self.letras_escogidas)

        print "Busqueda lv1 concluida.\nComenzando busqueda lv2..." #debug
        self.palabras2 = self.second_search(
            self.palabras1, self.letras_escogidas)
        print "Hecho." #Debug
        print "--------------------------------------------" #Debug

        self.your_words = []

    def create_alpha(self):
        """Regresa el alfabeto a utilizar en el PyZap."""
        zipo= []
        letters = list("abcdefghijklmnopqrstuvwxyz")

        for row in reader:
            zipo.append(tuple(row))

        for (char,proba) in zipo:
            for i in range(int(proba)):
                letters.append(char)

        return letters

    def get_sample(self):
        """Regresa una muestra de LETRAS letras entre el alfabeto disponible.
        LETRAS es una constante definida en el main().

        """

        chosen = random.sample(self.alpha,LETRAS)

        for el in chosen:
            if el is "a" or el is "e"or el is "i" or el is "o" or el is "u":
                check = True
                break
            else:
                check = False

        if check is False:
            self.get_sample()
        else:
            return chosen

    def first_search(self, search_terms):
        """Realiza la primera busqueda de palabras dentro de 'diccionario' que
        contengan cualquier elemento de search_terms.

        Los search_terms son una sola lista de caracteres. Cada elemento de la
        lista es una letra.

        Tras haber encontrado las palabras, las copia a un diccionario a RAM
        en el siguiente formato:

        'palabra' : num_de_coincidencias, num_de_caracteres

        Regresa el diccionario antes mencionado.

        """

        diccionario.seek(0)
        results = []

        for word in diccionario:
            word = word.rstrip()
            for term in search_terms:
                if word.find(term) != -1:
                    results.append(word)

        first_search_words = {}

        for word in results:
            if word not in first_search_words:
                first_search_words[word] = [results.count(word), len(word)]

        return first_search_words

    def second_search(self, first_search_words, search_terms):
        """Recibe el diccionario en ram con las first_search_words para refinar
        la busqueda.

        Primero se eliminan los resultados que tengan menos coincidencias que
        numero de caracteres. Posteriormente, cada palabra es separada en
        caracteres, y se comparan uno a uno con las letras escogidas en el run.

        Regresa una lista de palabras.

        """

        flagged_for_deletion = []

        for word in first_search_words:
            if first_search_words.get(word)[0] < first_search_words.get(word)[1]:
                flagged_for_deletion.append(word)

        for word in flagged_for_deletion:
            del first_search_words[word]

        used_chars = []
        final_words = []
        keys = first_search_words.keys()

        for word in keys:

            available = list(search_terms)
            used_chars[:] = []
            actual_word = list(word)

            for current_char in actual_word:
                if current_char in available:
                    used_chars.append(current_char)
                    available.remove(current_char)

            actual_word.sort()
            used_chars.sort()
            available[:] = []

            if actual_word == used_chars:
                final_words.append(word)

        return final_words


def main():

    app = QtGui.QApplication(sys.argv)
    global reader, diccionario, archivo, pyzap, window, LETRAS

    LETRAS = 9
    FILE = "diccionario"

    archivo = open('probas.csv', 'r+')
    diccionario = open(FILE, 'r+')
    reader = csv.reader(archivo, delimiter=',')

    print "Iniciando..." #Debug

    pyzap = PyZap()
    window = MainWindow()

    print "Las coincidencias en el diccionario son las siguientes:" #Debug
    print pyzap.palabras2 #Debug

    sys.exit(app.exec_())

if __name__ == '__main__':
    main()