Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #PyZap v4
- # -*- coding: utf-8 -*-
- #TODO
- #MAJOR --> Agregar distintos diccionarios
- #minor -> untogglear botones con clear
- #minor -> agregar un nuevo shortcut en letras repetidas
- #minor -> de-focusear botones después de oprimidos
- #minor -> selector grafico de specs iniciales (dificultad, diccionario)
- 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 closeEvent(self, event):
- reply = QtGui.QMessageBox.question(self, "Aviso",
- "Seguro que quieres salir?",
- QtGui.QMessageBox.Yes | QtGui.QMessageBox.No,
- QtGui.QMessageBox.No)
- if reply == QtGui.QMessageBox.Yes:
- masusadas.seek(2)
- masusadas.writelines(most_used)
- else:
- event.ignore()
- 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), (3,0), (3,1), (3,2), (4,0), (4,1), (4,2), (5,0),
- (5,1), (5,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.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.reset_button = QtGui.QPushButton('Reset')
- self.reset_button.setShortcut("F2")
- self.reset_button.clicked.connect(self.reset)
- self.grid.addWidget(self.reset_button, 3, 1)
- 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)
- total_used.append(word)
- self.mark_as_most_used(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 reset(self):
- """Reinicia la corrida del programa."""
- global pyzap, window
- window.statusBar().showMessage("Reiniciando. Por favor espere...")
- pyzap = PyZap()
- window = MainWindow()
- 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
- def mark_as_most_used(self, word):
- """Registra una palabra comunmente usada."""
- if word in total_used:
- if total_used.count(word) > diff:
- most_used.append("\n" + word)
- def check_common(self, word):
- """Revisa que la palabra no sea comunmente usada."""
- if word in most_used:
- window.statusBar().showMessage("Usas esta palabra con frecuencia. Piensa en otra!")
- class PyZap(object):
- def __init__(self, parent=None):
- self.init_mind()
- def init_mind(self):
- """Inicia procesos de la aplicacion."""
- print "--------------------------------------------" #Debug
- print "Iniciando..." #Debug
- 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
- print "Coincidencias:"
- print self.palabras2
- self.your_words = []
- def create_alpha(self):
- """Regresa el alfabeto a utilizar en el PyZap."""
- zipo= []
- letters = list("abcdefghijklmnopqrstuvwxyz")
- archivo.seek(0)
- 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.
- """
- results = []
- for word in ram:
- 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
- #----------- PRUEBAS UNITARIAS -----------#
- class TestMainWidget(u.TestCase):
- def test_validate_word(self):
- """Revisa que el return type de validate_word sea un booleano."""
- self.assertEqual(type(window.widget.validate_word("prueba")), bool,
- "No es booleano!")
- def test_check_repeated(self):
- """Revisa que el return type de check_repeated sea un booleano."""
- self.assertEqual(type(window.widget.check_repeated("prueba")), bool,
- "No es booleano!")
- class TestPyZap(u.TestCase):
- def test_create_alpha(self):
- """Revisa haya al menos una vez cada letra en el alfabeto."""
- archivo.seek(0)
- alpha = pyzap.create_alpha()
- self.assertIn("a", alpha)
- self.assertIn("b", alpha)
- self.assertIn("c", alpha)
- self.assertIn("d", alpha)
- self.assertIn("e", alpha)
- self.assertIn("f", alpha)
- self.assertIn("g", alpha)
- self.assertIn("h", alpha)
- self.assertIn("i", alpha)
- self.assertIn("j", alpha)
- self.assertIn("k", alpha)
- self.assertIn("l", alpha)
- self.assertIn("m", alpha)
- self.assertIn("n", alpha)
- self.assertIn("o", alpha)
- self.assertIn("p", alpha)
- self.assertIn("q", alpha)
- self.assertIn("r", alpha)
- self.assertIn("s", alpha)
- self.assertIn("t", alpha)
- self.assertIn("u", alpha)
- self.assertIn("v", alpha)
- self.assertIn("w", alpha)
- self.assertIn("x", alpha)
- self.assertIn("y", alpha)
- self.assertIn("z", alpha)
- def test_get_sample(self):
- """Revisa que la muestra sea de el numero de letras especificado y
- tenga al menos una vocal.
- """
- sam = pyzap.get_sample()
- self.assertEqual(len(sam), LETRAS,
- "El numero de letras escogidas no coincide!")
- self.assertTrue(
- "a" in sam or "e" in sam or "i" in sam or "o" in sam or "u" in sam,
- "No hay vocales en las letras escogidas!")
- def test_first_search(self):
- """Revisa que la first search regrese al menos una palabra."""
- words = pyzap.palabras1
- self.assertGreater(len(words), 0, "No lanzo resultados!")
- def test_second_search(self):
- """Revisa que la second search regrese al menos una palabra."""
- words = pyzap.palabras2
- self.assertGreater(len(words), 0, "No lanzo resultados!")
- def main():
- app = QtGui.QApplication(sys.argv)
- global reader, diccionario, archivo, pyzap, window, LETRAS, ram
- global most_used, total_used, masusadas, diff
- diff = 1
- if diff == 2: #Easy
- LETRAS = 18
- elif diff == 1: #Normal
- LETRAS = 9
- else: #Hard
- LETRAS = 6
- FILE = "diccionario"
- archivo = open('probas.csv', 'r+')
- diccionario = open(FILE, 'r+')
- masusadas = open('mostusedwords', 'a+')
- reader = csv.reader(archivo, delimiter=',')
- ram = []
- most_used = []
- total_used = []
- for word in diccionario:
- word = word.rstrip()
- ram.append(word)
- for word in masusadas:
- word = word.rstrip()
- most_used.append(word)
- pyzap = PyZap()
- window = MainWindow()
- sys.exit(app.exec_())
- if __name__ == '__main__':
- main()
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement