def do_ABRIR(self, archivo):
self.archivo = Archivo(archivo)
self.archivo.leer()
self.archivo.conversion()
self.archivo.agregar_objeto()
self.editor = Editor(self.archivo)
self.editor.representar_cancion()
def do_REPRODUCIR(self, archivo):
'''Toma como parametro un archivo y lo reproduce'''
self.archivo = Archivo(archivo)
self.archivo.leer()
self.archivo.conversion()
self.archivo.agregar_objeto()
self.archivo.reproducir()
def hacer_algo(self):
lista_valores = []
lista_final = []
for val in range(len(self.__Inecuaciones)):
for j in range(4):
lista_valores.append(self.__Inecuaciones[val][j].get())
lista_separada = [
lista_valores[x:x + 4]
for x in range(0, len(lista_valores), 4)
]
lista_final = lista_separada
#
lista_strings = []
for lista in (lista_final):
linea = ""
for x in range(len(lista)):
if x != len(lista) - 1:
linea = linea + lista[x] + ","
else:
linea = linea + lista[x]
lista_strings.append(linea)
Archivo.crear_modelo(lista_strings)
root = tk.Tk()
VentanaSolucion(root).pack(expand=True, fill=tk.BOTH)
iniciar("planta_termo_electrica.txt")
root.mainloop()
def do_REPRODUCIR(self, archivo):
self.archivo = Archivo(archivo)
self.archivo.leer()
self.archivo.conversion()
self.archivo.agregar_objeto()
self.archivo.reproducir()
def do_ABRIR(self, archivo):
'''Toma como parametro un archivo y lo abre en consola'''
self.archivo = Archivo(archivo)
self.archivo.leer()
self.archivo.conversion()
self.archivo.agregar_objeto()
self.editor = Editor(self.archivo)
self.editor.representar_cancion()
def abrirArchivo(self):
options = QFileDialog.Options()
ruta_de_archivo, _ = QFileDialog.getOpenFileName(
self,
"Abrir Dataset",
"",
"Archivos de texto (*.txt);; Archivos CSV (*.CSV)",
options=options)
if ruta_de_archivo:
self.label_2.setText(ruta_de_archivo)
self.archivo = Archivo(ruta_de_archivo)
try:
self.archivo.abrir(
self.separadores[self.comboSeparador.currentText()])
except:
self.label_2.setText("Separadores no válidos")
self.groupBox.setEnabled(False)
self.barraProgreso.setEnabled(False)
tipo = 'Critical'
titulo = 'No se ha podido cargar el archivo'
mensaje = 'Los separadores de datos escogidos no son válidos para este archivo, pruebe con otro/s'
detalles = ''
self.mostrarError(tipo, titulo, mensaje, detalles)
else:
self.groupBox.setEnabled(True)
self.barraProgreso.setEnabled(True)
self.txtTest.clear()
self.txtMejorK.clear()
self.valorDeK = 7
#print("datos del archivo")
#print(self.archivo.datos)
self.datos = Datos()
self.datos.atributos = self.archivo.columnas
self.datos.generar(deepcopy(self.archivo.datos))
#print("datos del archivo")
#print(self.archivo.datos)
self.tableWidget.setColumnCount(self.archivo.numcolumnas)
self.tableWidget.setRowCount(self.archivo.numfilas)
self.tableWidget.setHorizontalHeaderLabels(
self.archivo.columnas)
self.lineClases.setText(str(
self.datos.obtenerNumeroDeClases()))
self.lineElementos.setText(str(self.datos.obtenerCantidad()))
for fila in range(self.archivo.numfilas):
for columna in range(self.archivo.numcolumnas):
self.tableWidget.setItem(
fila, columna,
QTableWidgetItem(
(self.archivo.datos[fila][columna])))
else:
self.label_2.setText("No se ha seleccionado ningún archivo")
self.groupBox.setEnabled(False)
self.barraProgreso.setEnabled(False)
def main(argv):
start = time.time()
nombre_sol = Archivo.crearNombre(argv[0])
#mochila = MochilaPD(argv[0])
#print(mochila.mochila(mochila.items, mochila.pesomaximo))
alineamiento = AlineamientoDinamico(argv[0])
Archivo.crearArchivo(
nombre_sol,
alineamiento.needleman_wunsch(alineamiento.seq1, alineamiento.seq2))
#mochila = MochilaFB(argv[0])
#Archivo.crearArchivo(nombre_sol,mochila.mochila(mochila.items, mochila.pesomaximo))
end = time.time()
print(end - start)
def imprimir_tabla(self,recursion):
x = Archivo.crearNombre(self.archivo)
with open(x, 'a') as archivo:
print('-' * (12 * (len(self.fila_objetivo) + 1)), file=archivo)
print(' ' * (3 * (len(self.fila_objetivo) + 1)) + "T A B L A "+recursion, file=archivo)
print('-' * (12 * (len(self.fila_objetivo) + 1)), file=archivo)
for value in self.fila_objetivo:
print('%10.2f,' % value, end='', file=archivo)
print('%10.2f' % self.resultados[0], file=archivo)
for i, row in enumerate(self.restricciones):
for j, value in enumerate(row):
print('%10.2f,' % value, end='', file=archivo)
print('%10.2f' % self.resultados[i + 1], file=archivo)
print('-' * (12 * (len(self.fila_objetivo) + 1)), file=archivo)
print("\nLISTA PIVOTES: " + str(self.pivotes)+"\n", file=archivo)
print('-' * (12 * (len(self.fila_objetivo) + 1))+"\n", file=archivo)
def abrirArchivo(self):
options = QFileDialog.Options()
ruta_de_archivo, _ = QFileDialog.getOpenFileName(
self,
"Abrir Dataset",
"",
"Archivos de texto (*.txt);; Archivos CSV (*.CSV)",
options=options)
if ruta_de_archivo:
self.label_2.setText(ruta_de_archivo)
self.archivo = Archivo(ruta_de_archivo)
self.archivo.abrir(
self.separadores[self.comboSeparador.currentText()])
self.groupBox.setEnabled(True)
self.btnDetener.setEnabled(True)
self.barraProgreso.setEnabled(True)
self.txtTest.clear()
self.txtMejorK.clear()
self.valorDeK = 7
#print("datos del archivo")
#print(self.archivo.datos)
self.datos = Datos()
self.datos.generar(deepcopy(self.archivo.datos))
#print("datos del archivo")
#print(self.archivo.datos)
self.tableWidget.setColumnCount(self.archivo.numcolumnas)
self.tableWidget.setRowCount(self.archivo.numfilas)
self.tableWidget.setHorizontalHeaderLabels(self.archivo.columnas)
self.lineClases.setText(str(self.datos.obtenerNumeroDeClases()))
self.lineElementos.setText(str(self.datos.obtenerCantidad()))
for fila in range(self.archivo.numfilas):
for columna in range(self.archivo.numcolumnas):
self.tableWidget.setItem(
fila, columna,
QTableWidgetItem((self.archivo.datos[fila][columna])))
else:
self.label_2.setText("No se ha seleccionado ningún archivo")
self.groupBox.setEnabled(False)
self.btnDetener.setEnabled(False)
self.barraProgreso.setEnabled(False)
def clicked():
# ARCHIVO
tanda = Archivo().leer(window.filename)
# MEMORIA
tamañoMemoria = txtMemoria.get()
#ESTRATEGIA
estrategia = selected.get()
# TIEMPO DE SELECCION
tiempoSelecion = txtTseleccion.get()
# TIEMPO DE CARGA
tiempoCarga = txtTcarga.get()
# TIEMPO DE LIBERACION
tiempoLiberacion = txtTliberacion.get()
# Simular CPU
logs = simular(tanda, int(tamañoMemoria), estrategia, int(tiempoSelecion),
int(tiempoCarga), int(tiempoLiberacion))
Archivo().escribir('logs', logs)
def __init__(self, nombre_archivo):
info = Archivo.leer_archivo_alineamiento(nombre_archivo)
self.match = info[0]
self.missmatch = info[1]
self.gap = info[2]
self.seq1 = info[3]
self.seq2 = info[4]
self.nombre_archivo = nombre_archivo
def main(argv):
if len(sys.argv) == 1:
print("No se recibieron argumentos")
exit(0)
elif sys.argv[1] == "-h":
print("Formato de argumentos inválido")
print("Formato válido: python3 main.py file.txt")
else:
num = -1
for arg in sys.argv:
num = num + 1
if num == 0:
print("Los archivos a procesar son:" + str(sys.argv[1:]))
elif num > 0 and arg.endswith('.txt'):
try:
print("Archivo" + str(num) + ":" + str(arg))
problem = Archivo.leer_archivo(arg)
# 0=Simplex, 1=GranM, 2=DosFases
if problem.metodo == 0 or problem.metodo == "simplex":
try:
simplex = Simplex(problem, arg)
simplex.setup()
simplex.solucion()
except:
return "Error al ejecutar simplex"
elif problem.metodo == 1 or problem.metodo == "granm":
try:
big_m = GranM(problem, arg)
big_m.setup()
big_m.solucion()
except:
return "Error al ejecutar Gran M"
elif problem.metodo == 2 or problem.metodo == "dosfases":
try:
two_phases = DosFases(problem, arg)
two_phases.solve()
two_phases.solucion()
except:
print("error")
return "Error al ejecutar Dos fases"
except:
print("El archivo presenta un problema")
def Cur_Ton_Ley(self):
ventana = Tk()
ventana.title("Curva Tonelaje Ley | Erick Tocasca")
#ventana.geometry("600x600")
#ventana.resizable(0,0)
ventana.iconbitmap("../Imagenes/lobo.ico")
#imagen = Image.open("../Imagenes/BIENVENIDO.jpg")
#render = ImageTk.PhotoImage(imagen)
#Label(ventana, image = render).grid(row=0, column=0)
mi_menu = Menu(ventana)
ventana.config(menu=mi_menu, bg="lightblue")
archivo = Menu(mi_menu, tearoff=0)
archivo.add_command(label="Nuevo Archivo")
archivo.add_separator()
archivo.add_command(label="Abrir")
archivo.add_command(label="Abrir el ultimo cerrado")
archivo.add_command(label="Abierto recientemente")
archivo.add_separator()
archivo.add_command(label="Salir", command=ventana.destroy)
mi_menu.add_cascade(label="Archivo", menu=archivo)
mi_menu.add_command(label="Editar")
mi_menu.add_command(label="Buscar")
mi_menu.add_command(label="Ayuda")
archivo1 = Archivo()
label = Label(ventana, text="INICIO")
label.config(fg="white",
bg="black",
font=("Arial", 30),
padx=200,
pady=15)
label.grid(row=0, column=0, columnspan=15)
label1 = Label(ventana, text="Abrir el archivo")
label1.grid(row=1, column=2)
Button(ventana, text="Open", command=archivo1.openFile).grid(row=1,
column=8)
label2 = Label(ventana, text="Procesar el archivo")
label2.grid(row=2, column=2)
Button(ventana, text="Process", command=archivo1.curva).grid(row=2,
column=8)
label3 = Label(ventana, text="Crear grafico")
label3.grid(row=3, column=2)
Button(ventana, text="Graph", command=archivo1.graph).grid(row=3,
column=8)
ventana.mainloop()
def iniciar(archivo):
try:
problem = Archivo.leer_archivo(archivo)
# 0=Simplex, 1=GranM, 2=DosFases
if problem.metodo == 0 or problem.metodo == "simplex":
try:
print("simplex")
simplex = Simplex(problem, archivo)
simplex.setup()
simplex.solucion()
except:
return "Error al ejecutar simplex"
elif problem.metodo == 1 or problem.metodo == "granm":
try:
print("gran m")
big_m = GranM(problem, archivo)
big_m.setup()
big_m.solucion()
except:
return "Error al ejecutar Gran M"
elif problem.metodo == 2 or problem.metodo == "dosfases":
try:
print("Metodo de las dos fases")
two_phases = DosFases(problem, archivo)
two_phases.solve()
two_phases.solucion()
except:
print("error")
return "Error al ejecutar Dos fases"
except:
print("El archivo presenta un problema")
from archivo import Archivo
arch = Archivo("data.txt")
arch.escribir()
arch.leer()
def setupUi(self, venPrincipal):
venPrincipal.setObjectName("venPrincipal")
venPrincipal.resize(797, 471)
self.centralwidget = QtWidgets.QWidget(venPrincipal)
self.centralwidget.setObjectName("centralwidget")
self.label = QtWidgets.QLabel(self.centralwidget)
self.label.setGeometry(QtCore.QRect(320, 30, 191, 41))
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.label.setFont(font)
self.label.setStyleSheet(
"background-color: rgb(170, 255, 255);\n"
"background-color: qlineargradient(spread:pad, x1:0.483, y1:0, x2:0.506, y2:0.625, stop:0 rgba(170, 255, 255, 255), stop:1 rgba(255, 255, 255, 255));"
)
self.label.setObjectName("label")
self.lblDni_2 = QtWidgets.QLabel(self.centralwidget)
self.lblDni_2.setGeometry(QtCore.QRect(60, 120, 31, 21))
font = QtGui.QFont()
font.setPointSize(8)
font.setBold(True)
font.setWeight(75)
self.lblDni_2.setFont(font)
self.lblDni_2.setObjectName("lblDni_2")
self.line = QtWidgets.QFrame(self.centralwidget)
self.line.setGeometry(QtCore.QRect(40, 80, 751, 20))
self.line.setFrameShape(QtWidgets.QFrame.HLine)
self.line.setFrameShadow(QtWidgets.QFrame.Sunken)
self.line.setObjectName("line")
self.editDni = QtWidgets.QTextEdit(self.centralwidget)
self.editDni.setGeometry(QtCore.QRect(120, 120, 171, 21))
self.editDni.setObjectName("editDni")
self.lblapel = QtWidgets.QLabel(self.centralwidget)
self.lblapel.setGeometry(QtCore.QRect(60, 160, 71, 16))
font = QtGui.QFont()
font.setPointSize(8)
font.setBold(True)
font.setWeight(75)
self.lblapel.setFont(font)
self.lblapel.setObjectName("lblapel")
self.editApel = QtWidgets.QTextEdit(self.centralwidget)
self.editApel.setGeometry(QtCore.QRect(120, 160, 251, 21))
self.editApel.setObjectName("editApel")
self.line_2 = QtWidgets.QFrame(self.centralwidget)
self.line_2.setGeometry(QtCore.QRect(30, 270, 761, 16))
self.line_2.setFrameShape(QtWidgets.QFrame.HLine)
self.line_2.setFrameShadow(QtWidgets.QFrame.Sunken)
self.line_2.setObjectName("line_2")
self.lblNome = QtWidgets.QLabel(self.centralwidget)
self.lblNome.setGeometry(QtCore.QRect(420, 160, 47, 13))
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.lblNome.setFont(font)
self.lblNome.setObjectName("lblNome")
self.editNome = QtWidgets.QTextEdit(self.centralwidget)
self.editNome.setGeometry(QtCore.QRect(490, 160, 211, 21))
self.editNome.setObjectName("editNome")
self.btnAceptar = QtWidgets.QPushButton(self.centralwidget)
self.btnAceptar.setGeometry(QtCore.QRect(310, 290, 75, 23))
self.btnAceptar.setObjectName("btnAceptar")
self.btnSalir = QtWidgets.QPushButton(self.centralwidget)
self.btnSalir.setGeometry(QtCore.QRect(450, 290, 75, 23))
self.btnSalir.setObjectName("btnSalir")
self.lblSexo = QtWidgets.QLabel(self.centralwidget)
self.lblSexo.setGeometry(QtCore.QRect(60, 250, 47, 13))
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.lblSexo.setFont(font)
self.lblSexo.setObjectName("lblSexo")
self.rbtFem = QtWidgets.QRadioButton(self.centralwidget)
self.rbtFem.setGeometry(QtCore.QRect(110, 250, 82, 17))
self.rbtFem.setObjectName("rbtFem")
self.rbtMasc = QtWidgets.QRadioButton(self.centralwidget)
self.rbtMasc.setGeometry(QtCore.QRect(200, 250, 82, 17))
self.rbtMasc.setObjectName("rbtMasc")
self.lblSexo_2 = QtWidgets.QLabel(self.centralwidget)
self.lblSexo_2.setGeometry(QtCore.QRect(320, 250, 111, 16))
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.lblSexo_2.setFont(font)
self.lblSexo_2.setObjectName("lblSexo_2")
self.chkEfec = QtWidgets.QCheckBox(self.centralwidget)
self.chkEfec.setGeometry(QtCore.QRect(440, 250, 61, 17))
self.chkEfec.setObjectName("chkEfec")
self.chkTar = QtWidgets.QCheckBox(self.centralwidget)
self.chkTar.setGeometry(QtCore.QRect(520, 250, 61, 17))
self.chkTar.setObjectName("chkTar")
self.chkTrans = QtWidgets.QCheckBox(self.centralwidget)
self.chkTrans.setGeometry(QtCore.QRect(600, 250, 91, 17))
self.chkTrans.setObjectName("chkTrans")
self.lblapel_2 = QtWidgets.QLabel(self.centralwidget)
self.lblapel_2.setGeometry(QtCore.QRect(60, 200, 71, 16))
font = QtGui.QFont()
font.setPointSize(8)
font.setBold(True)
font.setWeight(75)
self.lblapel_2.setFont(font)
self.lblapel_2.setObjectName("lblapel_2")
self.editApel_2 = QtWidgets.QTextEdit(self.centralwidget)
self.editApel_2.setGeometry(QtCore.QRect(120, 200, 271, 21))
self.editApel_2.setObjectName("editApel_2")
self.lblProv = QtWidgets.QLabel(self.centralwidget)
self.lblProv.setGeometry(QtCore.QRect(420, 200, 61, 16))
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.lblProv.setFont(font)
self.lblProv.setObjectName("lblProv")
self.cmbProv = QtWidgets.QComboBox(self.centralwidget)
self.cmbProv.setGeometry(QtCore.QRect(490, 200, 181, 22))
self.cmbProv.setObjectName("cmbProv")
venPrincipal.setCentralWidget(self.centralwidget)
self.menuBar = Archivo(venPrincipal)
self.menuBar.setGeometry(QtCore.QRect(0, 0, 797, 21))
self.menuBar.setObjectName("menuBar")
self.menuArchivo = QtWidgets.QMenu(self.menuBar)
self.menuArchivo.setObjectName("menuArchivo")
venPrincipal.setMenuBar(self.menuBar)
self.statusbar = QtWidgets.QStatusBar(venPrincipal)
self.statusbar.setObjectName("statusbar")
venPrincipal.setStatusBar(self.statusbar)
self.menuBar.addAction(self.menuArchivo.menuAction())
self.retranslateUi(venPrincipal)
QtCore.QMetaObject.connectSlotsByName(venPrincipal)
def setupUi(self, venPrincipal):
venPrincipal.setObjectName("venPrincipal")
venPrincipal.resize(861, 644)
self.centralwidget = QtWidgets.QWidget(venPrincipal)
self.centralwidget.setObjectName("centralwidget")
self.label = QtWidgets.QLabel(self.centralwidget)
self.label.setGeometry(QtCore.QRect(340, 110, 171, 41))
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.label.setFont(font)
self.label.setStyleSheet("background-color: rgb(170, 255, 255);\n"
"background-color: qlineargradient(spread:pad, x1:0.483, y1:0, x2:0.506, y2:0.625, stop:0 rgba(170, 255, 255, 255), stop:1 rgba(255, 255, 255, 255));")
self.label.setObjectName("label")
self.lblDni_2 = QtWidgets.QLabel(self.centralwidget)
self.lblDni_2.setGeometry(QtCore.QRect(110, 200, 31, 21))
font = QtGui.QFont()
font.setPointSize(8)
font.setBold(True)
font.setWeight(75)
self.lblDni_2.setFont(font)
self.lblDni_2.setObjectName("lblDni_2")
self.line = QtWidgets.QFrame(self.centralwidget)
self.line.setGeometry(QtCore.QRect(40, 170, 751, 20))
self.line.setFrameShape(QtWidgets.QFrame.HLine)
self.line.setFrameShadow(QtWidgets.QFrame.Sunken)
self.line.setObjectName("line")
self.editDni = QtWidgets.QTextEdit(self.centralwidget)
self.editDni.setGeometry(QtCore.QRect(150, 200, 171, 21))
self.editDni.setObjectName("editDni")
self.lblapel = QtWidgets.QLabel(self.centralwidget)
self.lblapel.setGeometry(QtCore.QRect(80, 270, 71, 16))
font = QtGui.QFont()
font.setPointSize(8)
font.setBold(True)
font.setWeight(75)
self.lblapel.setFont(font)
self.lblapel.setObjectName("lblapel")
self.editApel = QtWidgets.QTextEdit(self.centralwidget)
self.editApel.setGeometry(QtCore.QRect(160, 270, 221, 21))
self.editApel.setObjectName("editApel")
self.line_2 = QtWidgets.QFrame(self.centralwidget)
self.line_2.setGeometry(QtCore.QRect(40, 320, 761, 16))
self.line_2.setFrameShape(QtWidgets.QFrame.HLine)
self.line_2.setFrameShadow(QtWidgets.QFrame.Sunken)
self.line_2.setObjectName("line_2")
self.lblNome = QtWidgets.QLabel(self.centralwidget)
self.lblNome.setGeometry(QtCore.QRect(460, 270, 47, 13))
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.lblNome.setFont(font)
self.lblNome.setObjectName("lblNome")
self.editNome = QtWidgets.QTextEdit(self.centralwidget)
self.editNome.setGeometry(QtCore.QRect(520, 270, 211, 21))
self.editNome.setObjectName("editNome")
self.btnAceptar = QtWidgets.QPushButton(self.centralwidget)
self.btnAceptar.setGeometry(QtCore.QRect(320, 380, 75, 23))
self.btnAceptar.setObjectName("btnAceptar")
self.btnSalir = QtWidgets.QPushButton(self.centralwidget)
self.btnSalir.setGeometry(QtCore.QRect(480, 380, 75, 23))
self.btnSalir.setObjectName("btnSalir")
self.lblValidar = QtWidgets.QLabel(self.centralwidget)
self.lblValidar.setGeometry(QtCore.QRect(340, 200, 41, 31))
font = QtGui.QFont()
font.setFamily("Comic Sans MS")
font.setPointSize(10)
font.setBold(True)
font.setItalic(True)
font.setWeight(75)
self.lblValidar.setFont(font)
self.lblValidar.setText("")
self.lblValidar.setObjectName("lblValidar")
venPrincipal.setCentralWidget(self.centralwidget)
self.menuBar = Archivo(venPrincipal)
self.menuBar.setGeometry(QtCore.QRect(0, 0, 861, 21))
self.menuBar.setObjectName("menuBar")
self.menuArchivo = QtWidgets.QMenu(self.menuBar)
self.menuArchivo.setObjectName("menuArchivo")
venPrincipal.setMenuBar(self.menuBar)
self.statusbar = QtWidgets.QStatusBar(venPrincipal)
self.statusbar.setObjectName("statusbar")
venPrincipal.setStatusBar(self.statusbar)
self.menuBar.addAction(self.menuArchivo.menuAction())
self.retranslateUi(venPrincipal)
QtCore.QMetaObject.connectSlotsByName(venPrincipal)
class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
def __init__(self, *args, **kwargs):
QtWidgets.QMainWindow.__init__(self, *args, **kwargs)
self.setupUi(self)
#Inicializando botones y esas weas
self.threadpool = QThreadPool()
self.txtTest.setReadOnly(True)
self.txtMejorK.setReadOnly(True)
self.lineElementos.setReadOnly(True)
self.lineClases.setReadOnly(True)
self.labelTest_2.setText(str(30))
self.spinEntrenamiento.setValue(70)
self.spinKUsuario.setValue(10)
self.groupBox.setEnabled(False)
self.radioCuadrado.setChecked(True)
self.radioElbow.setChecked(True)
self.btnDetener.setEnabled(False)
self.barraProgreso.setEnabled(False)
self.comboSeparador.addItems([';', ',', 'Tab', 'Espacio'])
self.separadores = {',': ',', ';': ';', 'Tab': '\t', 'Espacio': ' '}
self.porcentajeEntrenamiento = 70
self.porcentajeTest = 30
self.diccionario = {}
self.datos = None
self.resultadosTestMetodo = list()
self.resultadosTestUsuario = list()
#fecha = datetime.datetime.now().strftime("%m/%d/%Y, %H:%M:%S")
self.colores = list()
self.ladoDeUnCuadrado = 0.5
self.numero_de_divisiones = 70 #El video mostraba ~68
self.kDeTest = 1
self.label_2.setText('No se ha seleccionado ningún archivo')
self.abrirDataset.clicked.connect(self.abrirArchivo)
self.btnTestUsuario.clicked.connect(self.testearModeloUsuario)
self.btnGraficoUsuario.clicked.connect(self.graficarUsuario)
self.btnTestMetodo.clicked.connect(self.testearModeloMetodo)
self.btnGraficoMetodo.clicked.connect(self.graficarMetodo)
self.btnPredecirPunto.clicked.connect(self.predecirPunto)
self.spinEntrenamiento.valueChanged.connect(self.cambiarPorcentajes)
#Inicializar widgets
def progress_fn(self, n):
self.barraProgreso.setValue(n)
def execute_this_fn(self, progress_callback):
for n in range(0, 5):
time.sleep(1)
progress_callback.emit(n * 100 / 4)
return "Done."
def print_output(self, s):
print('')
def finTestMetodo(self):
for resultado in self.resultadosTestMetodo:
self.txtMejorK.insertPlainText("Con K = " + str(resultado[0]) +
", la eficacia fue de " +
"{:.2f}".format(resultado[1]) +
"% \n")
def finTestUsuario(self):
for resultado in self.resultadosTestUsuario:
self.txtTest.insertPlainText("Con K = " + str(resultado[0]) +
", la eficacia fue de " +
"{:.2f}".format(resultado[1]) +
"% \n")
#☺def recurring_timer(self):
#self.counter +=1
#self.l.setText("Counter: %d" % self.counter)
def hiloTestearModeloMetodo(self, progress_callback):
puntosDeEntrenamiento = self.datos.obtenerDatosEntrenamiento(
self.porcentajeEntrenamiento)
puntosDeTest = self.datos.obtenerDatosTest(
self.porcentajeEntrenamiento)
self.resultadosTestMetodo = list()
aciertos = 0
totalElementos = 0
k = self.kDeTest
total = len(puntosDeTest)
for puntoDeTest in puntosDeTest:
loskvecinos = vecinos(puntosDeEntrenamiento, puntoDeTest, k)
claseDelPunto = prediccion(puntoDeTest, loskvecinos)
totalElementos = totalElementos + 1
if (claseDelPunto == puntoDeTest[-1]):
aciertos = aciertos + 1
progreso = totalElementos
n = int((progreso * 100) / total)
progress_callback.emit(n)
porcentajeDeAciertos = (aciertos / totalElementos) * 100
self.resultadosTestMetodo.append((k, porcentajeDeAciertos))
def testearModeloMetodo(self):
self.txtMejorK.clear()
self.barraProgreso.setValue(0)
self.kDeTest = self.obtenerMejorK()
worker = Worker(
self.hiloTestearModeloMetodo
) # Any other args, kwargs are passed to the run function
worker.signals.result.connect(self.print_output)
worker.signals.finished.connect(self.finTestMetodo)
worker.signals.progress.connect(self.progress_fn)
# Execute
self.threadpool.start(worker)
def hiloTestearModeloUsuario(self, progress_callback):
puntosDeEntrenamiento = self.datos.obtenerDatosEntrenamiento(
self.porcentajeEntrenamiento)
puntosDeTest = self.datos.obtenerDatosTest(
self.porcentajeEntrenamiento)
self.resultadosTestUsuario = list()
k = self.obtenerValorDeK() + 1
for i in range(1, k + 1):
aciertos = 0
totalElementos = 0
#TODO: mostrar en una tabla los resultados, por ejemplo
#clasesPredichas = list()
#clasesReales = list()
for puntoDeTest in puntosDeTest:
loskvecinos = vecinos(puntosDeEntrenamiento, puntoDeTest, i)
claseDelPunto = prediccion(puntoDeTest, loskvecinos)
totalElementos = totalElementos + 1
if (claseDelPunto == puntoDeTest[-1]):
aciertos = aciertos + 1
porcentajeDeAciertos = (aciertos / totalElementos) * 100
self.resultadosTestUsuario.append((i, porcentajeDeAciertos))
#self.progress_fn(i,k)
n = int((i * 100) / k)
progress_callback.emit(n)
#for resultado in resultados:
#self.txtTest.insertPlainText("Con K = " + str(resultado[0]) + ", la eficacia fue de " + "{:.2f}".format(resultado[1]) + "% \n")
#TODO: esto no debería pasar porque están en hilos distintos
#self.archivo.datosDeEntrenamiento(self.porcentajeEntrenamiento)
#pyplot.plot(self.archivo.datosEntrenamientoX,self.archivo.datosEntrenamientoY,'go')
#pyplot.show()
def testearModeloUsuario(self):
self.txtTest.clear()
self.barraProgreso.setValue(0)
worker = Worker(
self.hiloTestearModeloUsuario
) # Any other args, kwargs are passed to the run function
worker.signals.result.connect(self.print_output)
worker.signals.finished.connect(self.finTestUsuario)
worker.signals.progress.connect(self.progress_fn)
# Execute
self.threadpool.start(worker)
def predecirPunto(self):
self.txtTest.clear()
mipunto = list()
mipunto.append(float(self.linePuntoX.text()))
mipunto.append(float(self.linePuntoY.text()))
#puntosDeEntrenamiento = self.datos.obtenerDatosEntrenamiento(self.porcentajeEntrenamiento)
#puntosDeTest = self.datos.obtenerDatosTest(self.porcentajeEntrenamiento)
for i in range(1, 11):
loskvecinos = vecinos(self.datos.datosCompletos, mipunto, i)
#print("Para " + str(i) + " vecinos sus vecinos más cercanos son:")
#print(loskvecinos)
claseDelPunto = prediccion(mipunto, loskvecinos)
#print("La clase predicha fue " + claseDelPunto)
self.txtTest.insertPlainText("Con " + str(i) +
" vecinos, la clase predicha fue " +
claseDelPunto + "\n")
#self.archivo.datosDeEntrenamiento(self.porcentajeEntrenamiento)
#pyplot.plot(self.archivo.datosEntrenamientoX,self.archivo.datosEntrenamientoY,'go')
#pyplot.show()
def cambiarPorcentajes(self):
self.porcentajeEntrenamiento = self.spinEntrenamiento.value()
self.porcentajeTest = 100 - self.spinEntrenamiento.value()
self.labelTest_2.setText(str(self.porcentajeTest))
def cambiarKUsuario(self):
self.valorDeK = self.spinKUsuario.value()
def abrirArchivo(self):
options = QFileDialog.Options()
ruta_de_archivo, _ = QFileDialog.getOpenFileName(
self,
"Abrir Dataset",
"",
"Archivos de texto (*.txt);; Archivos CSV (*.CSV)",
options=options)
if ruta_de_archivo:
self.label_2.setText(ruta_de_archivo)
self.archivo = Archivo(ruta_de_archivo)
self.archivo.abrir(
self.separadores[self.comboSeparador.currentText()])
self.groupBox.setEnabled(True)
self.btnDetener.setEnabled(True)
self.barraProgreso.setEnabled(True)
self.txtTest.clear()
self.txtMejorK.clear()
self.valorDeK = 7
#print("datos del archivo")
#print(self.archivo.datos)
self.datos = Datos()
self.datos.generar(deepcopy(self.archivo.datos))
#print("datos del archivo")
#print(self.archivo.datos)
self.tableWidget.setColumnCount(self.archivo.numcolumnas)
self.tableWidget.setRowCount(self.archivo.numfilas)
self.tableWidget.setHorizontalHeaderLabels(self.archivo.columnas)
self.lineClases.setText(str(self.datos.obtenerNumeroDeClases()))
self.lineElementos.setText(str(self.datos.obtenerCantidad()))
for fila in range(self.archivo.numfilas):
for columna in range(self.archivo.numcolumnas):
self.tableWidget.setItem(
fila, columna,
QTableWidgetItem((self.archivo.datos[fila][columna])))
else:
self.label_2.setText("No se ha seleccionado ningún archivo")
self.groupBox.setEnabled(False)
self.btnDetener.setEnabled(False)
self.barraProgreso.setEnabled(False)
def obtenerValorDeK(self):
return int(self.spinKUsuario.value())
def obtenerMejorK(self):
if (self.radioRaiz.isChecked()):
return self.calcularKRaiz()
else:
return self.calcularKElbow()
def calcularKRaiz(self):
k = int(sqrt(self.datos.obtenerCantidad()))
if (((k % 2) == 0)
and (((self.datos.obtenerNumeroDeClases()) % 2) == 0)):
k = k + 1
return k
def finCalcularKElbow(self):
self.txtMejorK.insertPlainText("Se ha detectado un k óptimo igual a " +
str(self.kDeTest) +
"\n ------------- \n")
def progresoCalcularKElbow(self, n):
self.txtMejorK.insertPlainText('Analizando K = ' + str(n) + "\n")
def calcularKElbow(self):
self.txtMejorK.clear()
worker = Worker(
self.hiloCalcularKElbow
) # Any other args, kwargs are passed to the run function
worker.signals.result.connect(self.print_output)
worker.signals.finished.connect(self.finCalcularKElbow)
worker.signals.progress.connect(self.progresoCalcularKElbow)
# Execute
self.threadpool.start(worker)
def hiloCalcularKElbow(self, progress_callback):
puntosDeEntrenamiento = self.datos.obtenerDatosEntrenamiento(
self.porcentajeEntrenamiento)
puntosDeTest = self.datos.obtenerDatosTest(
self.porcentajeEntrenamiento)
self.resultadosTestMetodo = list()
aciertos = 0
totalElementos = 0
k = 1
mejorK = 1
fin = False
mejorValor = 0
j = 0
while (not fin):
progress_callback.emit(k)
aciertos = 0
totalElementos = 0
for puntoDeTest in puntosDeTest:
loskvecinos = vecinos(puntosDeEntrenamiento, puntoDeTest, k)
claseDelPunto = prediccion(puntoDeTest, loskvecinos)
totalElementos = totalElementos + 1
if (claseDelPunto == puntoDeTest[-1]):
aciertos = aciertos + 1
porcentajeDeAciertos = (aciertos / totalElementos) * 100
self.resultadosTestMetodo.append((k, porcentajeDeAciertos))
if (porcentajeDeAciertos > mejorValor):
mejorValor = porcentajeDeAciertos
mejorK = k
j = 0
else:
j = j + 1
if ((j > 10) or (porcentajeDeAciertos == 100) or (k > 30)):
fin = True
else:
k = k + 1
#for resultado in resultados:
#self.txtMejorK.insertPlainText("Con K = " + str(resultado[0]) + ", la eficacia fue de " + "{:.2f}".format(resultado[1]) + "% \n")
self.kDeTest = mejorK
return mejorK
def obtenerRejilla(self):
return (self.checkRejilla.isChecked())
def insertarGrid(self, grafico, ejes, limiteInferiorX, limiteSuperiorX,
limiteInferiorY, limiteSuperiorY, k, salto):
#¶coordenadas = list()
cuadrados = []
x = limiteInferiorX
y = limiteInferiorY
random.seed(datetime.datetime.now())
xDePrueba = x + self.ladoDeUnCuadrado / 2
yDePrueba = y + self.ladoDeUnCuadrado / 2
while (y < limiteSuperiorY):
x = limiteInferiorX
xDePrueba = x + self.ladoDeUnCuadrado / 2
while (x < limiteSuperiorX):
clase = predecirClase(self.datos.datosCompletos,
(xDePrueba, yDePrueba), k)
color = self.diccionario[clase]
cuadrado = mpatches.Rectangle((x, y),
self.ladoDeUnCuadrado,
self.ladoDeUnCuadrado,
angle=0.0,
color=color,
alpha=0.4,
linewidth=0)
#grafico.patches.extend([pyplot.Rectangle((x,y),saltoDelCuadrado,saltoDelCuadrado,
#fill=True, color=color, alpha=0.5, zorder=1000,
#transform=grafico.transFigure, figure=grafico)])
cuadrados.append(cuadrado)
ejes.add_patch(cuadrado)
x = x + self.ladoDeUnCuadrado
xDePrueba = x + self.ladoDeUnCuadrado / 2
y = y + self.ladoDeUnCuadrado
yDePrueba = y + self.ladoDeUnCuadrado / 2
#for c in cuadrados:
#print(str(c) + "/n")
def insertarCirculos(self, grafico, ejes, limiteInferiorX, limiteSuperiorX,
limiteInferiorY, limiteSuperiorY, k, salto):
#coordenadas = list()
cuadrados = []
x = limiteInferiorX
y = limiteInferiorY
random.seed(datetime.datetime.now())
xDePrueba = x + self.ladoDeUnCuadrado / 2
yDePrueba = y + self.ladoDeUnCuadrado / 2
while (y < limiteSuperiorY):
x = limiteInferiorX
xDePrueba = x + self.ladoDeUnCuadrado / 2
while (x < limiteSuperiorX):
clase = (predecirClaseConCalidad(self.datos.datosCompletos,
(xDePrueba, yDePrueba), k))[0]
calidad = (predecirClaseConCalidad(self.datos.datosCompletos,
(xDePrueba, yDePrueba),
k))[1]
calidad = ((self.ladoDeUnCuadrado / 2) * (calidad))
color = self.diccionario[clase]
cuadrado = mpatches.Circle(
(x + (self.ladoDeUnCuadrado / 2), y +
(self.ladoDeUnCuadrado / 2)),
radius=calidad,
color=color,
alpha=0.4,
linewidth=0)
#grafico.patches.extend([pyplot.Rectangle((x,y),saltoDelCuadrado,saltoDelCuadrado,
#fill=True, color=color, alpha=0.5, zorder=1000,
#transform=grafico.transFigure, figure=grafico)])
cuadrados.append(cuadrado)
ejes.add_patch(cuadrado)
x = x + self.ladoDeUnCuadrado
xDePrueba = x + self.ladoDeUnCuadrado / 2
y = y + self.ladoDeUnCuadrado
yDePrueba = y + self.ladoDeUnCuadrado / 2
#for c in cuadrados:
#print(str(c) + "/n")
def graficarMetodo(self):
k = self.obtenerMejorK()
self.graficarDataset(k)
def graficarUsuario(self):
k = self.obtenerValorDeK()
self.graficarDataset(k)
def graficarDataset(self, k):
valorDeSeparacionX = (self.datos.maxX() - self.datos.minX()) * 0.1
valorDeSeparacionY = (self.datos.maxY() - self.datos.minY()) * 0.1
limiteInferiorX = self.datos.minX() - valorDeSeparacionX
limiteSuperiorX = self.datos.maxX() + valorDeSeparacionX
limiteInferiorY = self.datos.minY() - valorDeSeparacionY
limiteSuperiorY = self.datos.maxY() + valorDeSeparacionY
pyplot.clf()
grafico = pyplot.figure(figsize=(8, 8))
ax = grafico.add_subplot()
ax.plot(limiteInferiorX, limiteInferiorY)
ax.set_aspect(1)
if (len(self.datos.clases) > 9):
self.colores = colors.CSS4_COLORS
else:
self.colores = colors.TABLEAU_COLORS
#divisionX = (self.datos.maxX() + valorDeSeparacionX - self.datos.minX() + valorDeSeparacionY) / (self.numero_de_divisiones)
#divisionY = (self.datos.maxY() + valorDeSeparacionY - self.datos.minY() + valorDeSeparacionY) / (self.numero_de_divisiones)
#print(divisionX)
pyplot.xlim(limiteInferiorX, limiteSuperiorX)
pyplot.ylim(limiteInferiorY, limiteSuperiorY)
xDelBucle = limiteInferiorX
yDelBucle = limiteInferiorY
if (self.obtenerRejilla()):
while (xDelBucle < limiteSuperiorX):
pyplot.axvline(x=xDelBucle,
linestyle='-',
marker=",",
linewidth=0.2)
xDelBucle = xDelBucle + self.ladoDeUnCuadrado
while (yDelBucle < limiteSuperiorY):
pyplot.axhline(y=yDelBucle,
linestyle='-',
marker=",",
linewidth=0.2)
yDelBucle = yDelBucle + self.ladoDeUnCuadrado
self.diccionario = {}
i = 0
lista = list(self.colores.items())
for clase in self.datos.clases:
self.diccionario[clase] = lista[i][0]
i = i + 1
for punto in self.datos.datosCompletos:
pyplot.plot(punto[0],
punto[1],
marker='.',
color=self.diccionario[punto[2]])
if (self.radioCuadrado.isChecked() == True):
self.insertarGrid(grafico, ax, limiteInferiorX, limiteSuperiorX,
limiteInferiorY, limiteSuperiorY, k,
self.ladoDeUnCuadrado)
else:
self.insertarCirculos(grafico, ax, limiteInferiorX,
limiteSuperiorX, limiteInferiorY,
limiteSuperiorY, k, self.ladoDeUnCuadrado)
#Crear cuadrados
grafico.show()
from cifrar import *
from tkinter import filedialog
from tkinter import ttk
import os
from tkinter import ttk
#----Variables del sistema----
window = Tk()
password = StringVar()
mostrarDato = StringVar()
estadoArchivo = StringVar()
estadoArchivo.set("Cargar archivo")
archivoLeer = Archivo()
#Variables Desencriptador
passwordD = StringVar()
mostrarDatoD = StringVar()
estadoArchivoD = StringVar()
estadoArchivoD.set("Cargar archivo")
archivoLeerD = Archivo()
#-----Lógica del programa-----
#Lógica del Botón Encriptar
def setDato():
if archivoLeer.getOk() & (len(password.get()) > 0):
class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
def __init__(self, *args, **kwargs):
QtWidgets.QMainWindow.__init__(self, *args, **kwargs)
self.setupUi(self)
#Inicializando botones y esas weas
self.threadpool = QThreadPool()
self.txtTest.setReadOnly(True)
self.txtMejorK.setReadOnly(True)
self.lineElementos.setReadOnly(True)
self.lineClases.setReadOnly(True)
self.labelTest_2.setText(str(30))
self.spinEntrenamiento.setValue(70)
self.spinKUsuario.setValue(10)
self.groupBox.setEnabled(False)
self.radioCirculo.setChecked(True)
self.radioCuadrado.setEnabled(False)
self.radioElbow.setChecked(True)
self.barraProgreso.setEnabled(False)
self.btnGraficoMetodo.setEnabled(False)
self.checkRejilla.setChecked(True)
self.checkRA.setChecked(True)
self.checkCelda.setChecked(False)
self.lineCelda.setEnabled(False)
self.linePuntoX.setText('0')
self.linePuntoY.setText('0')
self.lineCelda.setText('0.5')
self.btnComparacion.setEnabled(False)
self.btnComparacion.setText(
'Debe calcular un k óptimo para comparar gráficos')
self.lblCargaTexto.hide()
rx = QRegExp("[0-9]\.?[0-9]*")
validator = QRegExpValidator(rx, self)
self.lineCelda.setValidator(validator)
rx2 = QRegExp("[+-]?[0-9]*\.[0-9]*")
validator2 = QRegExpValidator(rx2, self)
self.linePuntoX.setValidator(validator2)
self.linePuntoY.setValidator(validator2)
self.comboSeparador.addItems([';', ',', 'Tab', 'Espacio'])
self.separadores = {',': ',', ';': ';', 'Tab': '\t', 'Espacio': ' '}
self.porcentajeEntrenamiento = 70
self.porcentajeTest = 30
self.diccionario = {}
self.datos = None
self.resultadosTestMetodo = list()
self.resultadosTestUsuario = list()
#fecha = datetime.datetime.now().strftime("%m/%d/%Y, %H:%M:%S")
self.colores = list()
self.ladoDeUnCuadrado = 0.5
self.numero_de_divisiones = 70 #El video mostraba ~68
self.kRaiz = 1
self.kMetodo = 1
self.laRaiz = False
self.elMetodo = True
self.label_2.setText('No se ha seleccionado ningún archivo')
self.abrirDataset.clicked.connect(self.abrirArchivo)
self.btnTestUsuario.clicked.connect(self.testearModeloUsuario)
self.btnGraficoUsuario.clicked.connect(self.graficarUsuario)
self.btnTestMetodo.clicked.connect(self.testearModeloMetodo)
self.btnGraficoMetodo.clicked.connect(self.graficarMetodo)
self.btnPredecirPunto.clicked.connect(self.predecirPunto)
self.spinEntrenamiento.valueChanged.connect(self.cambiarPorcentajes)
self.radioRaiz.toggled.connect(self.activarRaiz)
self.radioElbow.toggled.connect(self.activarMetodo)
self.checkCelda.stateChanged.connect(self.verCelda)
self.btnComparacion.clicked.connect(self.realizarComparacion)
def verCelda(self):
self.lineCelda.setEnabled(self.checkCelda.isChecked())
if self.checkCelda.isChecked():
self.lineCelda.setText("0.5")
def activarMetodo(self):
self.laRaiz = False
self.elMetodo = True
def activarRaiz(self):
self.laRaiz = True
self.elMetodo = False
def progress_fn(self, n):
self.barraProgreso.setValue(n)
def execute_this_fn(self, progress_callback):
for n in range(0, 5):
time.sleep(1)
progress_callback.emit(n * 100 / 4)
return "Done."
def print_output(self, s):
print('')
def finTestMetodo(self):
for resultado in self.resultadosTestMetodo:
self.txtMejorK.insertPlainText("Con k = " + str(resultado[0]) +
", la precisión fue de " +
"{:.2f}".format(resultado[1]) +
"% \n")
def finTestUsuario(self):
for resultado in self.resultadosTestUsuario:
self.txtTest.insertPlainText("Con k = " + str(resultado[0]) +
", la precisión fue de " +
"{:.2f}".format(resultado[1]) +
"% \n")
#☺def recurring_timer(self):
#self.counter +=1
#self.l.setText("Counter: %d" % self.counter)
def hiloTestearModeloMetodo(self, progress_callback):
self.resultadosTestMetodo = list()
aciertos = 0
totalElementos = 0
totalDeTests = 10
if self.laRaiz:
k = self.kRaiz
else:
k = self.kMetodo
total = len(self.datos.obtenerDatosTest(
self.porcentajeEntrenamiento)) * totalDeTests
for i in range(1, totalDeTests + 1):
self.datos.aleatorizar()
puntosDeEntrenamiento = self.datos.obtenerDatosEntrenamiento(
self.porcentajeEntrenamiento)
puntosDeTest = self.datos.obtenerDatosTest(
self.porcentajeEntrenamiento)
for puntoDeTest in puntosDeTest:
loskvecinos = vecinos(puntosDeEntrenamiento, puntoDeTest, k)
claseDelPunto = prediccion(puntoDeTest, loskvecinos)
totalElementos = totalElementos + 1
if (claseDelPunto == puntoDeTest[-1]):
aciertos = aciertos + 1
progreso = totalElementos
n = int((progreso * 100) / total)
progress_callback.emit(n)
porcentajeDeAciertos = (aciertos / totalElementos) * 100
self.resultadosTestMetodo.append((k, porcentajeDeAciertos))
def testearModeloMetodo(self):
self.txtMejorK.clear()
self.txtMejorK.insertPlainText(
'Ordenando aleatoriamente los datos...\n')
self.datos.aleatorizar()
self.barraProgreso.setValue(0)
if self.laRaiz:
self.kRaiz = self.calcularKRaiz()
self.continuar()
else:
worker1 = Worker(
self.hiloCalcularKElbow
) # Any other args, kwargs are passed to the run function
worker1.signals.result.connect(self.print_output)
worker1.signals.finished.connect(self.finCalcularKElbow)
worker1.signals.finished.connect(self.continuar)
worker1.signals.progress.connect(self.progresoCalcularKElbow)
self.threadpool.start(worker1)
def continuar(self):
self.btnGraficoMetodo.setEnabled(True)
self.btnComparacion.setEnabled(True)
self.btnComparacion.setText('Comparar gráficos')
worker = Worker(
self.hiloTestearModeloMetodo
) # Any other args, kwargs are passed to the run function
worker.signals.result.connect(self.print_output)
worker.signals.finished.connect(self.finTestMetodo)
worker.signals.progress.connect(self.progress_fn)
# Execute
self.threadpool.start(worker)
def hiloTestearModeloUsuario(self, progress_callback):
self.resultadosTestUsuario = list()
k = self.obtenerValorDeK()
total = k * 10 * len(
self.datos.obtenerDatosTest(self.porcentajeEntrenamiento))
progreso = 0
listadedatos = []
for i in range(1, k + 1):
listadedatos.append(0)
for i in range(1, 11):
self.datos.aleatorizar()
puntosDeEntrenamiento = self.datos.obtenerDatosEntrenamiento(
self.porcentajeEntrenamiento)
puntosDeTest = self.datos.obtenerDatosTest(
self.porcentajeEntrenamiento)
for puntoDeTest in puntosDeTest:
loskvecinos = vecinos(puntosDeEntrenamiento, puntoDeTest, k)
for j in range(1, k + 1):
progreso = progreso + 1
claseDelPunto = prediccion(puntoDeTest, loskvecinos[0:j])
if (claseDelPunto == puntoDeTest[-1]):
listadedatos[j - 1] = listadedatos[j - 1] + 1
n = int((progreso * 100) / total)
progress_callback.emit(n)
puntosDeTest = self.datos.obtenerDatosTest(
self.porcentajeEntrenamiento)
for i in range(0, k):
listadedatos[i] = (listadedatos[i] /
(10 * len(puntosDeTest))) * 100
for i in range(1, k + 1):
self.resultadosTestUsuario.append((i, listadedatos[i - 1]))
#for resultado in resultados:
#self.txtTest.insertPlainText("Con K = " + str(resultado[0]) + ", la eficacia fue de " + "{:.2f}".format(resultado[1]) + "% \n")
#TODO: esto no debería pasar porque están en hilos distintos
#self.archivo.datosDeEntrenamiento(self.porcentajeEntrenamiento)
#pyplot.plot(self.archivo.datosEntrenamientoX,self.archivo.datosEntrenamientoY,'go')
#pyplot.show()
def testearModeloUsuario(self):
self.txtTest.clear()
self.barraProgreso.setValue(0)
worker = Worker(
self.hiloTestearModeloUsuario
) # Any other args, kwargs are passed to the run function
worker.signals.result.connect(self.print_output)
worker.signals.finished.connect(self.finTestUsuario)
worker.signals.progress.connect(self.progress_fn)
# Execute
self.threadpool.start(worker)
def hayUnNumero(self):
try:
float(self.linePuntoX.text())
float(self.linePuntoY.text())
return True
except ValueError:
return False
def mostrarError(self, tipo, titulo, mensaje, detalles):
coso = QMessageBox()
if tipo == 'Critical':
coso.setIcon(QMessageBox.Critical)
else:
if tipo == 'Information':
coso.setIcon(QMessageBox.Information)
coso.setText(mensaje)
coso.setInformativeText('')
coso.setWindowTitle(titulo)
if detalles != '':
coso.setDetailedText(detalles)
coso.setStandardButtons(QMessageBox.Ok)
#coso.buttonClicked.connect(msgbtn)
retval = coso.exec_()
def predecirPunto(self):
self.txtTest.clear()
mipunto = list()
if self.hayUnNumero():
mipunto.append(float(self.linePuntoX.text()))
mipunto.append(float(self.linePuntoY.text()))
#puntosDeEntrenamiento = self.datos.obtenerDatosEntrenamiento(self.porcentajeEntrenamiento)
#puntosDeTest = self.datos.obtenerDatosTest(self.porcentajeEntrenamiento)
for i in range(1, 11):
loskvecinos = vecinos(self.datos.datosCompletos, mipunto, i)
#print("Para " + str(i) + " vecinos sus vecinos más cercanos son:")
#print(loskvecinos)
claseDelPunto = prediccion(mipunto, loskvecinos)
#print("La clase predicha fue " + claseDelPunto)
self.txtTest.insertPlainText(
"Con " + str(i) + " vecinos, la clase predicha fue " +
claseDelPunto + "\n")
#self.archivo.datosDeEntrenamiento(self.porcentajeEntrenamiento)
#pyplot.plot(self.archivo.datosEntrenamientoX,self.archivo.datosEntrenamientoY,'go')
#pyplot.show()
else:
tipo = 'Critical'
titulo = 'Error'
mensaje = 'No has ingresado un punto válido'
detalles = 'Las coordenadas ingresadas no son válidas'
self.mostrarError(tipo, titulo, mensaje, detalles)
def cambiarPorcentajes(self):
self.porcentajeEntrenamiento = self.spinEntrenamiento.value()
self.porcentajeTest = 100 - self.spinEntrenamiento.value()
self.labelTest_2.setText(str(self.porcentajeTest))
self.btnGraficoMetodo.setEnabled(False)
self.btnComparacion.setEnabled(False)
self.btnComparacion.setText(
'Debe calcular un k óptimo para comparar gráficos')
def cambiarKUsuario(self):
self.valorDeK = self.spinKUsuario.value()
def abrirArchivo(self):
options = QFileDialog.Options()
ruta_de_archivo, _ = QFileDialog.getOpenFileName(
self,
"Abrir Dataset",
"",
"Archivos de texto (*.txt);; Archivos CSV (*.CSV)",
options=options)
if ruta_de_archivo:
self.label_2.setText(ruta_de_archivo)
self.archivo = Archivo(ruta_de_archivo)
try:
self.archivo.abrir(
self.separadores[self.comboSeparador.currentText()])
except:
self.label_2.setText("Separadores no válidos")
self.groupBox.setEnabled(False)
self.barraProgreso.setEnabled(False)
tipo = 'Critical'
titulo = 'No se ha podido cargar el archivo'
mensaje = 'Los separadores de datos escogidos no son válidos para este archivo, pruebe con otro/s'
detalles = ''
self.mostrarError(tipo, titulo, mensaje, detalles)
else:
self.groupBox.setEnabled(True)
self.barraProgreso.setEnabled(True)
self.txtTest.clear()
self.txtMejorK.clear()
self.valorDeK = 7
#print("datos del archivo")
#print(self.archivo.datos)
self.datos = Datos()
self.datos.atributos = self.archivo.columnas
self.datos.generar(deepcopy(self.archivo.datos))
#print("datos del archivo")
#print(self.archivo.datos)
self.tableWidget.setColumnCount(self.archivo.numcolumnas)
self.tableWidget.setRowCount(self.archivo.numfilas)
self.tableWidget.setHorizontalHeaderLabels(
self.archivo.columnas)
self.lineClases.setText(str(
self.datos.obtenerNumeroDeClases()))
self.lineElementos.setText(str(self.datos.obtenerCantidad()))
for fila in range(self.archivo.numfilas):
for columna in range(self.archivo.numcolumnas):
self.tableWidget.setItem(
fila, columna,
QTableWidgetItem(
(self.archivo.datos[fila][columna])))
else:
self.label_2.setText("No se ha seleccionado ningún archivo")
self.groupBox.setEnabled(False)
self.barraProgreso.setEnabled(False)
def obtenerValorDeK(self):
return int(self.spinKUsuario.value())
def obtenerMejorK(self):
if (self.radioRaiz.isChecked()):
return self.calcularKRaiz()
else:
return self.calcularKElbow()
def calcularKRaiz(self):
k = int(sqrt(self.datos.obtenerCantidad()))
if (((k % 2) == 0)
and (((self.datos.obtenerNumeroDeClases()) % 2) == 0)):
k = k + 1
return k
def finCalcularKElbow(self):
self.txtMejorK.insertPlainText("Se ha detectado un k óptimo igual a " +
str(self.kMetodo) +
"\n ------------- \n")
def progresoCalcularKElbow(self, n):
self.txtMejorK.insertPlainText('Analizando k = ' + str(n) + "\n")
def hiloCalcularKElbow(self, progress_callback):
puntosDeEntrenamiento = self.datos.obtenerDatosEntrenamiento(
self.porcentajeEntrenamiento)
puntosDeTest = self.datos.obtenerDatosTest(
self.porcentajeEntrenamiento)
raiz = self.calcularKRaiz()
self.resultadosTestMetodo = list()
aciertos = 0
totalElementos = 0
k = 1
mejorK = 1
fin = False
mejorValor = 0
j = 0
while (not fin):
progress_callback.emit(k)
aciertos = 0
totalElementos = 0
for puntoDeTest in puntosDeTest:
loskvecinos = vecinos(puntosDeEntrenamiento, puntoDeTest, k)
claseDelPunto = prediccion(puntoDeTest, loskvecinos)
totalElementos = totalElementos + 1
if (claseDelPunto == puntoDeTest[-1]):
aciertos = aciertos + 1
porcentajeDeAciertos = (aciertos / totalElementos) * 100
self.resultadosTestMetodo.append((k, porcentajeDeAciertos))
#¹print('k' + str(k) + 'j' + str(j) + 'raiz' + str(raiz))
if (porcentajeDeAciertos > mejorValor):
mejorValor = porcentajeDeAciertos
mejorK = k
j = 0
else:
j = j + 1
if ((j > (raiz / 2)) or (k > raiz)):
fin = True
else:
k = k + 1
#for resultado in resultados:
#self.txtMejorK.insertPlainText("Con K = " + str(resultado[0]) + ", la eficacia fue de " + "{:.2f}".format(resultado[1]) + "% \n")
self.kMetodo = mejorK
def obtenerRejilla(self):
return (self.checkRejilla.isChecked())
def obtenerRA(self):
if self.checkRA.isChecked():
return True
else:
return False
return (self.checkRejilla.isChecked())
def obtenerCelda(self):
if (self.checkCelda.isChecked()
and (0 < float(self.lineCelda.text()))):
return float(self.lineCelda.text())
else:
return 0.5
def insertarCirculos(self, grafico, ejes, limiteInferiorX, limiteSuperiorX,
limiteInferiorY, limiteSuperiorY, k, salto):
cuadrados = []
x = limiteInferiorX
y = limiteInferiorY
xDePrueba = x + salto / 2
yDePrueba = y + salto / 2
while (y < limiteSuperiorY):
x = limiteInferiorX
xDePrueba = x + salto / 2
while (x < limiteSuperiorX):
clase = (predecirClaseConCalidad(self.datos.datosCompletos,
(xDePrueba, yDePrueba), k))[0]
calidad = (predecirClaseConCalidad(self.datos.datosCompletos,
(xDePrueba, yDePrueba),
k))[1]
calidad = ((salto / 2) * (calidad))
color = self.diccionario[clase]
cuadrado = mpatches.Circle((x + (salto / 2), y + (salto / 2)),
radius=calidad,
color=color,
alpha=0.4,
linewidth=0)
#grafico.patches.extend([pyplot.Rectangle((x,y),saltoDelCuadrado,saltoDelCuadrado,
#fill=True, color=color, alpha=0.5, zorder=1000,
#transform=grafico.transFigure, figure=grafico)])
cuadrados.append(cuadrado)
ejes.add_patch(cuadrado)
x = x + salto
xDePrueba = x + salto / 2
y = y + salto
yDePrueba = y + salto / 2
#for c in cuadrados:
#print(str(c) + "/n")
def graficarMetodo(self):
if self.laRaiz:
k = self.kRaiz
mensaje = 'Raiz'
else:
k = self.kMetodo
mensaje = 'Codo'
self.graficarDataset(k, mensaje, False)
def graficarUsuario(self):
k = self.obtenerValorDeK()
self.graficarDataset(k, 'Usuario', False)
def realizarComparacion(self):
self.lblCargaTexto.show()
tipo = 'Information'
titulo = 'Aviso'
mensaje = 'Esta operación podría tardar. Por favor espere...'
detalles = ''
self.mostrarError(tipo, titulo, mensaje, detalles)
kUsuario = self.obtenerValorDeK()
if self.laRaiz:
kMetodo = self.kRaiz
metodo = 'Raiz'
else:
kMetodo = self.kMetodo
metodo = 'Codo'
for k in range(1, kUsuario + 1):
self.graficarDataset(k, 'Usuario', True)
self.graficarDataset(kMetodo, metodo, True)
self.ventanaComparacion = Grids(kUsuario, kMetodo)
self.ventanaComparacion.show()
self.lblCargaTexto.hide()
def graficarDataset(self, k, tipoDeGrafico, imprimir):
valorDeSeparacionX = (self.datos.maxX() - self.datos.minX()) * 0.1
valorDeSeparacionY = (self.datos.maxY() - self.datos.minY()) * 0.1
limiteInferiorX = self.datos.minX() - valorDeSeparacionX
limiteSuperiorX = self.datos.maxX() + valorDeSeparacionX
limiteInferiorY = self.datos.minY() - valorDeSeparacionY
limiteSuperiorY = self.datos.maxY() + valorDeSeparacionY
pyplot.clf()
grafico = pyplot.figure(figsize=(8, 8))
ax = grafico.add_subplot()
ax.plot(limiteInferiorX, limiteInferiorY)
if self.obtenerRA():
ax.set_aspect(1)
#if(len(self.datos.clases)>9):
#self.colores = colors.CSS4_COLORS
#else:
#self.colores = colors.TABLEAU_COLORS
self.colores = colors.TABLEAU_COLORS
#divisionX = (self.datos.maxX() + valorDeSeparacionX - self.datos.minX() + valorDeSeparacionY) / (self.numero_de_divisiones)
#divisionY = (self.datos.maxY() + valorDeSeparacionY - self.datos.minY() + valorDeSeparacionY) / (self.numero_de_divisiones)
#print(divisionX)
limiteCeldaX = (trunc(
((limiteSuperiorX - limiteInferiorX) / self.obtenerCelda())) +
1) * self.obtenerCelda() + limiteInferiorX
limiteCeldaY = (trunc(
((limiteSuperiorY - limiteInferiorY) / self.obtenerCelda())) +
1) * self.obtenerCelda() + limiteInferiorY
pyplot.xlim(limiteInferiorX, limiteCeldaX)
pyplot.ylim(limiteInferiorY, limiteCeldaY)
pyplot.xlabel(self.datos.atributos[0])
pyplot.ylabel(self.datos.atributos[1])
xDelBucle = limiteInferiorX
yDelBucle = limiteInferiorY
if (self.obtenerRejilla()):
while (xDelBucle < limiteSuperiorX):
pyplot.axvline(x=xDelBucle,
linestyle='-',
marker=",",
linewidth=0.2)
xDelBucle = xDelBucle + self.obtenerCelda()
while (yDelBucle < limiteSuperiorY):
pyplot.axhline(y=yDelBucle,
linestyle='-',
marker=",",
linewidth=0.2)
yDelBucle = yDelBucle + self.obtenerCelda()
self.diccionario = {}
i = 0
lista = list(self.colores.items())
for clase in self.datos.clases:
self.diccionario[clase] = lista[i][0]
i = i + 1
puntos = self.datos.datosCompletos #ËpuntosEntrenamiento = self.datos.obtenerDatosEntrenamiento(self.porcentajeEntrenamiento)
for punto in puntos: #puntosEntrenamiento:
pyplot.plot(punto[0],
punto[1],
marker='o',
color=self.diccionario[punto[2]])
leyendas = []
for clase in self.datos.clases:
leyendas.append(
Line2D([0], [0],
lw=4,
marker='o',
color=self.diccionario[clase]))
pyplot.legend(leyendas, self.datos.clases, loc='upper left')
#print(self.colores)
#print(lista)
#print(self.diccionario)
self.gridcolores = []
self.gridclases = {}
self.gridcolores.append('#FFFFFF')
i = 1
for clase in self.datos.clases:
self.gridclases[clase] = i
self.gridcolores.append(self.diccionario[clase])
i = i + 1
#print(self.gridclases)
#print(self.gridcolores)
inicio = time.time()
if (self.radioCuadrado.isChecked() == True):
self.insertarGridV2(grafico, ax, limiteInferiorX, limiteSuperiorX,
limiteInferiorY, limiteSuperiorY, k,
self.obtenerCelda())
else:
self.insertarArray(pyplot, grafico, ax, limiteInferiorX,
limiteSuperiorX, limiteInferiorY,
limiteSuperiorY, k, self.obtenerCelda())
#self.insertarCirculos(grafico,ax,limiteInferiorX,limiteSuperiorX,limiteInferiorY,limiteSuperiorY,k,self.obtenerCelda())
fin = time.time()
#print(fin-inicio)
if tipoDeGrafico == 'Usuario':
nombre = tipoDeGrafico + str(k)
else:
nombre = 'Metodo'
if tipoDeGrafico == 'Raiz':
mensaje = 'Utilizando método de la Raíz con k = '
else:
if tipoDeGrafico == 'Codo':
mensaje = 'Utilizando método del codo con k = '
else:
mensaje = 'Rango de K ingresado por el usuario, k = '
mensaje = mensaje + str(k)
pyplot.title(mensaje)
if imprimir:
grafico.savefig(nombre)
else:
grafico.show()
def insertarArray(self, elpyplot, grafico, ejes, limiteInferiorX,
limiteSuperiorX, limiteInferiorY, limiteSuperiorY, k,
salto):
cuadrados = []
x = limiteInferiorX
y = limiteInferiorY
yDePrueba = y + salto / 2
arreglo = []
while (y < limiteSuperiorY):
fila = []
x = limiteInferiorX
xDePrueba = x + salto / 2
while (x < limiteSuperiorX):
clases = []
clase1 = predecirClase(self.datos.datosCompletos,
(xDePrueba - (salto / 2), yDePrueba -
(salto / 2)), k)
clases.append(clase1)
clase2 = predecirClase(self.datos.datosCompletos,
(xDePrueba - (salto / 2), yDePrueba +
(salto / 2)), k)
clases.append(clase2)
clase3 = predecirClase(self.datos.datosCompletos,
(xDePrueba + (salto / 2), yDePrueba -
(salto / 2)), k)
clases.append(clase3)
clase4 = predecirClase(self.datos.datosCompletos,
(xDePrueba + (salto / 2), yDePrueba +
(salto / 2)), k)
clases.append(clase4)
contadores = Counter(clases)
clase = masFrecuente(clases)
calidad = contadores[clase]
if calidad < 3:
fila.append(0)
else:
fila.append(self.gridclases[clase])
#cuadrado = mpatches.Rectangle((x,y),salto,salto,angle = 0.0,color=color, alpha=(0.5*proporcion),linewidth=0)
#cuadrados.append(cuadrado)
#ejes.add_patch(cuadrado)
x = x + salto
xDePrueba = x + salto / 2
arreglo.append(fila)
y = y + salto
yDePrueba = y + salto / 2
nuevoarreglo = np.array(arreglo)
#print(len(nuevoarreglo)*len(nuevoarreglo[0]))
#print(len(arreglo))
#print(len(nuevoarreglo))
# Setup a mesh grid and values
step = salto # mesh step size
xx, yy = np.meshgrid(
np.arange(limiteInferiorX, limiteSuperiorX + salto, step),
np.arange(limiteInferiorY, limiteSuperiorY + salto, step))
z = nuevoarreglo #np.random.randint(0, 3, xx.shape) # random integers in [0, 2]
lista = list(self.colores.items())
cmap = ListedColormap(self.gridcolores) # color map for [0, 2]
elpyplot.pcolormesh(xx, yy, z, cmap=cmap, alpha=0.33)
# Plot colorbar for color mesh
#cbar = elpyplot.colorbar()
#cbar.set_ticks([0.33, 1., 1.67])
def insertarGridV2(self, grafico, ejes, limiteInferiorX, limiteSuperiorX,
limiteInferiorY, limiteSuperiorY, k, salto):
cuadrados = []
x = limiteInferiorX
y = limiteInferiorY
#xDePrueba = x + salto/2
yDePrueba = y + salto / 2
while (y < limiteSuperiorY):
x = limiteInferiorX
xDePrueba = x + salto / 2
while (x < limiteSuperiorX):
clases = []
clase1 = predecirClase(self.datos.datosCompletos,
(xDePrueba - (salto / 2), yDePrueba -
(salto / 2)), k)
clases.append(clase1)
clase2 = predecirClase(self.datos.datosCompletos,
(xDePrueba - (salto / 2), yDePrueba +
(salto / 2)), k)
clases.append(clase2)
clase3 = predecirClase(self.datos.datosCompletos,
(xDePrueba + (salto / 2), yDePrueba -
(salto / 2)), k)
clases.append(clase3)
clase4 = predecirClase(self.datos.datosCompletos,
(xDePrueba + (salto / 2), yDePrueba +
(salto / 2)), k)
clases.append(clase4)
contadores = Counter(clases)
clase = masFrecuente(clases)
calidad = contadores[clase]
if calidad == 1:
proporcion = 0.0
else:
if calidad == 2:
proporcion = 0.1
else:
if calidad == 3:
proporcion = 0.5
else:
proporcion = 1
color = self.diccionario[clase]
cuadrado = mpatches.Rectangle((x, y),
salto,
salto,
angle=0.0,
color=color,
alpha=(0.5 * proporcion),
linewidth=0)
cuadrados.append(cuadrado)
ejes.add_patch(cuadrado)
x = x + salto
xDePrueba = x + salto / 2
y = y + salto
yDePrueba = y + salto / 2
def __init__(self, nombre_archivo):
info = Archivo.leer_archivo_mochila(nombre_archivo)
self.pesomaximo = info[0]
self.items = info[1]
self.nombre_archivo = nombre_archivo
def do_ABRIR(self, archivo):
a = Archivo(archivo)
a.leer()
editor = Editor(a)
editor.representar_cancion()
from archivo import Archivo
from juego_ahorcado import JuegoAhoracado
archivo = Archivo()
juego = JuegoAhoracado()
opcion = -1
print("==========JUEGO AHORCADO==========")
print("==========BIENBENIDO==========")
while opcion != 0:
print("\n")
print("************************")
print("** MENU DEL JUEGOUEGO **")
print("************************")
print("1) Verificar archivo")
print("2) Llenar archivo con palabras")
print("3) Borrar archivo")
print("4) Jugar")
print("0) SALIR")
print("-------------------------")
opcion_string = input("Selecciona una opcion: ")
if opcion_string.isdigit():
opcion = int(opcion_string)
else:
opcion = -1
print("\n")
if opcion == 1:
palabras_verificadas = archivo.verificar_archivo()
print("Palabras cargadas: {}".format(palabras_verificadas))
elif opcion == 2:
num_palabras = int(input("Numero de palabras a ingresar: "))
from __future__ import print_function
import os
from archivo import Archivo
print("Bienvenido al manejador de archivos: \nIngrese el nombre del archivo")
r1 = raw_input()
archivo = Archivo(r1)
if archivo.existe(archivo):
print("Archivo encontrado, desea visualizarlo? [Y/N]")
r2 = raw_input()
if r2 == 'Y' or r2 == 'y':
archivo.leer(archivo)
print("Que desea hacer:\n1 - Sobreescribir\n 2 - Anexar")
rmodo = raw_input()
if rmodo == 1:
print("Ingrese el contenido")
msj = raw_input()
archivo.modo(nombre, msj, rmodo)
elif rmodo == 2:
print("Ingrese el contenido")
msj = raw_input()
archivo.modo(nombre, nombre, rmodo)
else:
print("Archivo no encontrado, desea generarlo? [Y/N]")
r3 = raw_input()
if r3 == 'Y' or r3 == 'y':
print("Ingrese el contenido")
msj = raw_input()
modo2 = 'w'
##!/usr/bin/python3
# -*- coding: utf-8 -*-
from archivo import Archivo
from pelicula import Pelicula
from imagen import Imagen
pelicula = Pelicula()
imagen = Imagen()
archivo = Archivo(pelicula)
archivo2 = Archivo(imagen)
descarados = []
encontrados2 = []
encontrados = archivo.buscar('Duro de matar')
descargados2 = archivo2.buscar('hola')
print(archivo.descargar(encontrados), archivo2.descargar(encontrados2))
def activasms1():
if e1.get()== '':
print 'error'
tkMessageBox._show('Error', 'No ingreso el nombre del audio a grabar.')
elif e2.get()== '':
print 'error'
tkMessageBox._show('Error', 'No ingreso la nota del metronomo.')
elif e3.get()== '':
print 'error'
tkMessageBox._show('Error', 'No ingreso el bpm del metronomo.')
elif e4.get()== '':
print 'error'
tkMessageBox._show('Error', 'No ingreso la metrica del metronomo.')
else:
d.set(True)
g=e2.get()
if g=="do":
frecFundamental=261.63
print("La nota escogida es: do")
if g=="re":
frecFundamental=293.66
print("La nota escogida es: re")
if g=="mi":
frecFundamental=329.63
print("La nota escogida es: mi")
if g=="fa":
frecFundamental=349.23
print("La nota escogida es: fa")
if g=="sol":
frecFundamental=392.00
print("La nota escogida es: sol")
if g=="la":
frecFundamental=440.00
print("La nota escogida es: la")
if g=="si":
frecFundamental=493.88
print("La nota escogida es: si")
t=float(e3.get())
tiempo=(60/t)
negra=tiempo/2
corchea=tiempo/4
print("El bpm es:")
print(t)
m=float(e4.get())
if m == 1:
onda = Seno(RATE, MaxBits, frecFundamental, m,negra)
print("Metrica de: 4/4")
if m == 2:
onda = Seno(RATE, MaxBits, frecFundamental, m,negra)
print("Metrica de: 3/4")
if m == 3:
onda = Seno(RATE, MaxBits, frecFundamental, m,negra)
print("Metrica de: 2/4")
if m == 4:
onda = Seno(RATE, MaxBits, frecFundamental, m,corchea)
print("Metrica de: 6/8")
e1.configure(state='disabled')
e2.configure(state='disabled')
e3.configure(state='disabled')
e4.configure(state='disabled')
datos = onda.generar()
datosAjustados = onda.leveladjust(datos,MaxBits,level)
archivo = Archivo(RATE, MaxBits,Nombre)
archivo.archivar(datosAjustados)
audio = Audio(buffer)
Datos = audio.abrir(Nombre)
audio.inicio(Datos[0],Datos[1],Datos[2])
audio.reproducir(Datos[3])
audio1.inicio()
mensaje1.pack(side=BOTTOM)
print("G R A B A N D O...")
while d.get():
audio1.grabacion()
ventana.update()
if d.get() is False:
break
audio.cerrar()
choice = ''
display_tittle_bar()
while choice != 'q':
choice = get_user_choice()
display_tittle_bar()
if choice == "1":
print ("")
nombre_archivo = input("Ingres el nombre del archivo\n>>")
archivo = Archivo()
archivo.cargar_archivo("./tablas_transicion_estados/" + nombre_archivo,"r")
tabla_de_transiciones = archivo.obtener_lista_tabla_transicion()
archivo_adaptador = ArchivoAdaptador()
automata_finito = archivo_adaptador.pasar_a_automata_finito(archivo)
input("Has pulsado la opción 1...\npulsa una tecla para continuar")
elif choice == "2":
print ("")
if automata_finito is None:
print("Cargue el automata a validar (Opción 1)")
class Shell(cmd.Cmd, object):
intro = 'Bienvenido al reproductor, ? para ver comandos, help COMANDO para obtener ayuda'
prompt = '*>>'
def __init__(self):
cmd.Cmd.__init__(self)
self.archivo = None
self.editor = None
#-----------------------MANEJO DE ARCHIVOS---------------------------#
def do_REPRODUCIR(self, archivo):
self.archivo = Archivo(archivo)
self.archivo.leer()
self.archivo.conversion()
self.archivo.agregar_objeto()
self.archivo.reproducir()
def do_ABRIR(self, archivo):
self.archivo = Archivo(archivo)
self.archivo.leer()
self.archivo.conversion()
self.archivo.agregar_objeto()
self.editor = Editor(self.archivo)
self.editor.representar_cancion()
def do_STORE(self, archivo):
self.editor.guardar(archivo)
#-----------------------MOVIMIENTO SOBRE TIEMPOS---------------------------#
def do_STEP(self, x):
self.editor.avanzar()
self.editor.representar_cancion()
def do_BACK(self, x):
self.editor.retroceder()
self.editor.representar_cancion()
def do_STEPM(self, x):
self.editor.avanzar(x)
self.editor.representar_cancion()
def do_BACKM(self, x):
self.editor.retroceder(x)
self.editor.representar_cancion()
#-----------------------ADICION Y REMOCION DE SONIDOS------------------------#
def do_TRACKADD(self, parametros):
linea = parametros.split()
tipo = linea[0]
frecuencia = linea[1]
volumen = linea[2]
self.editor.agregar_nota(tipo, frecuencia, volumen)
self.editor.representar_cancion()
def do_TRACKDEL(self, pos):
self.editor.quitar_nota(int(pos))
self.editor.representar_cancion()
#----------------------ACTIVAR Y DESACTIVAR SONIDOS--------------------------#
def do_TRACKON(self, pos):
self.editor.activar_nota(int(pos))
self.editor.representar_cancion()
def do_TRACKOFF(self, pos):
self.editor.desactivar_nota(int(pos))
self.editor.representar_cancion()
#-----------------------------REPRODUCCION---------------------------------#
def do_PLAYALL(self, x):
self.editor.reproducir()
def do_PLAY(self, x):
self.editor.reproducir_tiempos(1)
def do_PLAYMARKS(self, x):
self.editor.reproducir_tiempos(int(x))
def do_PLAYSECONDS(self, segundos):
self.editor.reproducir_tiempos(False, float(segundos))
def do_MARKADD(self, duracion):
self.editor.anadir_marca(float(duracion))
self.editor.representar_cancion()
return
def do_MARCKADDNEXT(self, duracion):
self.editor.anadir_marca_next(float(duracion))
self.editor.representar_cancion()
return
def do_MARCKADDPREV(self, duracion):
self.editor.anadir_marca_prev(float(duracion))
self.editor.representar_cancion()
return
def do_SALIR(self):
return 2 // 0
##!/usr/bin/python3
# -*- coding: utf-8 -*-
from archivo import Archivo
from pelicula import Pelicula
from imagen import Imagen
pelicula = Pelicula()
imagen=Imagen()
archivo = Archivo(imagen)
archivo2 = Archivo(pelicula)
encontrados = []
encontrados2 = []
encontrados = archivo.buscar("hola")
encontrados2 = archivo2.buscar("duro de matar")
print (archivo.descargar(encontrados),archivo2.descargar(encontrados2))
class Shell(cmd.Cmd, object):
'''Crea la interfaz del programa la cual manejara el usuario y va mostrando el progreso
de la edicion del archivo.'''
intro = 'Bienvenido al reproductor, ? para ver comandos, help COMANDO para obtener ayuda'
prompt = '*>>'
def __init__(self):
cmd.Cmd.__init__(self)
self.archivo = None
self.editor = None
#-----------------------MANEJO DE ARCHIVOS---------------------------#
def do_REPRODUCIR(self, archivo):
'''Toma como parametro un archivo y lo reproduce'''
self.archivo = Archivo(archivo)
self.archivo.leer()
self.archivo.conversion()
self.archivo.agregar_objeto()
self.archivo.reproducir()
def do_ABRIR(self, archivo):
'''Toma como parametro un archivo y lo abre en consola'''
self.archivo = Archivo(archivo)
self.archivo.leer()
self.archivo.conversion()
self.archivo.agregar_objeto()
self.editor = Editor(self.archivo)
self.editor.representar_cancion()
def do_STORE(self, archivo):
'''Toma como parametro un archivo y lo guarda'''
self.editor.guardar(archivo)
#-----------------------MOVIMIENTO SOBRE TIEMPOS---------------------------#
def do_STEP(self, x):
'''Avanza una marca de tiempo'''
self.editor.avanzar()
self.editor.representar_cancion()
def do_BACK(self, x):
'''Retrodece una marca de tiempo'''
self.editor.retroceder()
self.editor.representar_cancion()
def do_STEPM(self, x):
'''Toma como parametro un numero 'x' y avanza 'x' marcas de tiempo.
Pre: 'x' en un numero int'''
self.editor.avanzar(x)
self.editor.representar_cancion()
def do_BACKM(self, x):
'''Toma como parametro un numero 'x' y retrocede 'x' marcas de tiempo.
Pre: 'x' en un numero int'''
editor.retroceder(x)
editor.representar_cancion()
#-----------------------ADICION Y REMOCION DE SONIDOS---------------------------#
def do_TRACKADD(self, parametros
): #te parece mas descriptivo ponerle sonido al parametro?
'''Toma como parametro 'parametros' y agrega un nuevo track.
Pre: -'parametros' debe ser una lista que contenga tres partes
-'parametros' debe estar compuesta por digitos'''
linea = parametros.split()
tipo = linea[0]
frecuencia = linea[1]
volumen = linea[2]
self.editor.agregar_nota(tipo, volumen, frecuencia)
self.editor.representar_cancion()
def do_TRACKDEL(self, pos):
'''Dada una posicion 'pos' elimina el track en dicha posicion'''
self.editor.quitar_nota(int(pos))
self.editor.representar_cancion()
#-----------------------------REPRODUCCION---------------------------------#
def do_PLAYALL(self, x):
'''Reproduce todo el archivo desde el comienzo'''
self.editor.reproducir()
def do_PLAY(self, x):
'''Reproduce la marca en la que se encuentra el cursor actualmente''' #chequear desp
self.editor.reproducir_tiempos(1)
def do_PLAYMARKS(self, x):
'''Reproduce las marcas de tiempo dadas'''
self.editor.reproducir_tiempos(int(x))
def do_PLAYSECONDS(self, segundos):
'''Toma como parmetro una cantidad de segundos y los reproduce.
Pre: -'segundos' debe ser un numero'''
self.editor.reproducir_tiempos(False, float(segundos))
def do_SALIR(self):
'''Demasiado dificil de explicar en tan solo unas lineas. Para entender
el funcionamiento de esto metodo se requiere aprobar las materias: 67.01/68.09/61.23/64.05
y tener la tesis de ingenieria nuclear'''
return 2 // 0
def do_ABRIR(self, archivo):
a = Archivo(archivo)
tiempos, sonidos, canales, escena = a.leer().obtener_datos()
editor = Editor(tiempos, sonidos, canales, escena)
editor.representar_cancion()
class Shell(cmd.Cmd, object):
intro = 'Bienvenido al reproductor, ? para ver comandos, help COMANDO para obtener ayuda'
prompt = '*>>'
def __init__(self):
cmd.Cmd.__init__(self)
self.archivo = None
self.editor = None
#-----------------------MANEJO DE ARCHIVOS---------------------------#
def do_REPRODUCIR(self, archivo):
self.archivo = Archivo(archivo)
self.archivo.leer()
self.archivo.conversion()
self.archivo.agregar_objeto()
self.archivo.reproducir()
def do_ABRIR(self, archivo):
self.archivo = Archivo(archivo)
self.archivo.leer()
self.archivo.conversion()
self.archivo.agregar_objeto()
self.editor = Editor(self.archivo)
self.editor.representar_cancion()
def do_STORE(self, archivo):
self.editor.guardar(archivo)
#-----------------------MOVIMIENTO SOBRE TIEMPOS---------------------------#
def do_STEP(self, x):
self.editor.avanzar()
self.editor.representar_cancion()
def do_BACK(self, x):
self.editor.retroceder()
self.editor.representar_cancion()
def do_STEPM(self, x):
self.editor.avanzar(x)
self.editor.representar_cancion()
def do_BACKM(self, x):
editor.retroceder(x)
editor.representar_cancion()
#-----------------------ADICION Y REMOCION DE SONIDOS---------------------------#
def do_TRACKADD(self, parametros):
linea = parametros.split()
tipo = linea[0]
frecuencia = linea[1]
volumen = linea[2]
self.editor.agregar_nota(tipo, volumen, frecuencia)
self.editor.representar_cancion()
def do_TRACKDEL(self, pos):
self.editor.quitar_nota(int(pos))
self.editor.representar_cancion()
#-----------------------------REPRODUCCION---------------------------------#
def do_PLAYALL(self):
self.editor.reproducir()
def do_SALIR(self):
return 2 // 0
from __future__ import print_function
import os
from archivo import Archivo
print("Bienvenido al manejador de archivos: \nIngrese el nombre del archivo")
r1 = raw_input()
archivo = Archivo(r1)
if archivo.existe(archivo):
print("Archivo encontrado, desea visualizarlo? [Y/N]")
r2 = raw_input()
if r2 == 'Y' or r2 == 'y':
archivo.leer(archivo)
print("Que desea hacer:\n1 - Sobreescribir\n 2 - Anexar")
rmodo = raw_input()
if rmodo == 1:
print("Ingrese el contenido")
msj = raw_input()
archivo.modo(nombre, msj, rmodo)
elif rmodo == 2:
print("Ingrese el contenido")
msj = raw_input()
archivo.modo(nombre, nombre, rmodo)
else:
print("Archivo no encontrado, desea generarlo? [Y/N]")
r3 = raw_input()
if r3 == 'Y' or r3 == 'y':
print("Ingrese el contenido")
