PyZap 2

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

#TODO
#Cambiar MainWidget.send()
#Poner los botones de las letras como toggle
#Agregar validacion de palabras

import random
import csv
import sys
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.clicked.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.clicked.connect(self.line_edit.clear)

            self.ok_button = QtGui.QPushButton("OK")
            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):
            """Escribe el texto del boton"""

            source = self.sender()
            self.line_edit.insertPlainText(source.text())

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

            word = self.line_edit.toPlainText()
            self.line_edit.clear()

            #valida word
            valid = True #Hardcodeo MIENTRAS

            if valid:
                pyzap.your_words.append(word)
                self.tus_palabras.append(word)
            else:
                self.line_edit.insertPlainText(
                    "Esa palabra no se puede formar o no existe")



class PyZap(object):

    def __init__(self, parent=None):

        self.init_mind()
        self.init_skeleton()

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

        self.alpha = self.create_alpha()
        self.letras_escogidas = self.get_sample()

        self.palabras1 = self.first_search(
            self.letras_escogidas)
        self.palabras2 = self.second_search(
            self.palabras1, self.letras_escogidas)

        self.your_words = []

    def init_skeleton(self):
        """Inicia GUI de la aplicacion."""
        pass

    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 9 letras entre el alfabeto disponible."""

        chosen = random.sample(self.alpha,9)
        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)

        #toRAM
        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)

            sorted(actual_word)
            sorted(used_chars)
            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

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

    pyzap = PyZap()

    window = MainWindow()
    sys.exit(app.exec_())

if __name__ == '__main__':
    main()