path: root/parentesis.activity/TODO.txt

#!/usr/bin/env python

# example-start buttons buttons.py

import pygtk
pygtk.require('2.0')
import gtk

# Crea un boton con un parentesis y le da comportamiento de alternar el 

def crear_label_boton_paren(str):
    boton = gtk.Button()
    etiqueta  = gtk.Label(str)
    boton.add(etiqueta)
    
    etiqueta.show()
    boton.show()
    
    return boton

# Crea una label y la empaca en un boton
# and pack it into a button
def crear_label_boton(str):
    button = gtk.Button();
    etiqueta = gtk.Label(str)    
    button.add(etiqueta)
    etiqueta.show()
    button.show()
    
    return button

def devolver_par():
    return (3,4)
# Create a new hbox with an image and a label packed into it
# and return the box.
def xpm_label_box(parent, xpm_filename, label_text):
    # Create box for xpm and label
    box1 = gtk.HBox(False, 0)
    box1.set_border_width(2)

    # Now on to the image stuff
    image = gtk.Image()
    image.set_from_file(xpm_filename)

    # Create a label for the button
    label = gtk.Label(label_text)

    # Pack the pixmap and label into the box
    box1.pack_start(image, False, False, 3)
    box1.pack_start(label, False, False, 3)

    image.show()
    label.show()
    return box1

class Controlador:
    self.indiceCasoActual = 0
    self.casoLista= generarCasos()
    self.listaBotones = []
    
    def generar_botones():
        casoActual = casoLista[indiceCasoActual]
        listaBotones = []
        primerBoton = crear_label_boton("")
        self.listaBotones.append(primerBoton)        
        
        for x in casoActual:
            botonChar = crear_label_boton(x)
            botonVacio = crear_label_boton("")
            self.listaBotones.append(botonChar)
            self.listaBotones.append(botonVacio)
        
        


class Buttons:
    # Our usual callback method
    def callback(self, widget, data=None):
        print "Hello again - %s was pressed" % data

    def __init__(self):
        # Create a new window
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)

        self.window.set_title("Image'd Buttons!")        
        self.window.connect("destroy", lambda wid: gtk.main_quit())
        self.window.connect("delete_event", lambda a1,a2:gtk.main_quit())
        self.window.set_border_width(10)

        cajaHorz = gtk.HBox(False, 0)
        
        etiqueta = gtk.Label("PARENTESIS")
        cajaVert = gtk.VBox(False, 0)
        cajaVert.pack_start(etiqueta, True, True, 0)

        cajaHor = gtk.HBox(False, 0)
        button = gtk.Button()    
        button.connect("clicked", self.callback, "cool button")

        self.listaBotones = []
        boton = crear_label_boton("(")
        
        
        cajaVert.pack_start(cajaHor, True, True, 0)
        # This calls our box creating function
        box1 = xpm_label_box(self.window, "info.xpm", "cool button")
        button.add(box1)
        cajaVert.pack_start(button, True, True, 0)
        cajaVert.show()

        box1.show()
        button.show()
        vscale = gtk.VScale(adjustment=None)
        hscale = gtk.HScale(adjustment=None)


        arrow = gtk.Arrow(gtk.ARROW_UP, gtk.SHADOW_IN)
        arrow.show()
        cajaVert.pack_start(arrow, True, True, 0)
        
        botonIgual = crear_label_boton("=")
        botonRes = crear_label_boton(str(eval("2+(3*4)+4") ) )
        #cajaHorz.pack_start(botonPar1, True, True, 0)
        #cajaHorz.pack_start(botonOprn1, True, True, 0)        
        #cajaHorz.pack_start(botonOprd1, True, True, 0)
        #cajaHorz.pack_start(botonOprn2, True, True, 0)
        #cajaHorz.pack_start(botonPar2, True, True, 0)
        print self.listaBotones
        cosita = botonRes.set_label("alfa")             
        print "la cista es", cosita

        
        for x in "2+(3*4)+4":           
            self.listaBotones.append(x)
            if x == "(" or x == ")":             
                boton = crear_label_boton(x)#crear_label_boton_paren(x)
                print x, "parentesis"
            else:
                boton = crear_label_boton(x)
                print x, "NO - parentesis"
            cajaHorz.pack_start(boton, True, True,0)    
        cajaHorz.pack_start(botonIgual, True, True, 0)
        cajaHorz.pack_start(botonRes, True, True, 0)


        cajaVert.pack_start(cajaHorz, True, True, 0)
        cajaHorz.show()
        cajaVert.show()
  #      self.window.add(hscale)
#        hscale.show()    
        

        etiqueta.show()
        self.window.add(cajaVert)
        self.window.show()

def main():  
    gtk.main()
    return 0     

if __name__ == "__main__":
    Buttons()
    main()  



--------------
import re
import random
import types

### Version 0.3
## modulo logico

## Definicion a manopla para formulas de nivel 1
pattern1 = "\S*\(\S*\+\S*\)\S*"      # ( ... + ... ) al menos un mas en el medio
pattern2 = "(\+\)|\*\)|\(\+|\(\*)"   # ni (+ ni (* ni +) ni *)
pattern3 = "^\(\w*\)$"               # parentesis al principio y parentesis al final

CANT_NUM = 6
def imprimirConfiguracion():
    """Usada para debug, muestra informacion del modulo"""
    print "CONSTANTES"
    print "CANT_NUM ", CANT_NUM
    print "OPERANDOS", CANT_NUM - 1

       
#Tal vez deba recibir un parametro NIVEL y en funcion de eso validar o no el string.    
def validarString(s):
    """Si el string s es valido segun las convenciones lo devuelve, sino da none

    Returns string"""
    if re.search(pattern2, s):
        return None
    if re.search(pattern3, s):
        return None
    if re.search(pattern1, s):
        return s
    return None # en caso contrario devuelve nada


##Funcion que testea las validaciones para todo el conjunto generado a mano de parentesis posibles
## en un conjunto de 6 numeros
def testearValidarStringNivelUno():
    print "COMIENZA TEST DE VALIDACION DE LECTOR DE STRING..."
    str1 = "(1*2+3)*4+5*6"
    str2 = "(1*2+3*4)+5*6"
    str3 = "(1*2+3*4+5)*6"
    str4 = "1*(2+3)*4+5*6"
    str5 = "1*(2+3*4)+5*6"
    str6 = "1*(2+3*4+5)*6"
    str7 = "1*(2+3*4+5*6)"
    str8 = "1*2+(3*4+5)*6"
    str9 = "1*2+(3*4+5*6)"
    str10= "1*2+3*(4+5)*6"
    str11= "1*2+3*(4+5*6)"
    listaStr = [str1, str2, str3, str4, str5, str6, str7, str8, str9, str10, str11]
    errores = [validarString(s) for s in listaStr]
    if errores.count(None):
        print "Hay errores de validacion!, verificar str1 .. str11"
    else:
        print "     TEST OK"
    print "FIN DEL TEST!"
    
#notar los parametros opcionales            ---remover---
def generarListaNum(cant_num = CANT_NUM, rango_max = 9):
    """genera  una lista de tamano cant_num, con numeros entre 2 y rango_max
    uqe no pueden estar repetidos"""
    if cant_num + 1 > rango_max:
        return None ### deberia de tirar una excepcion esto es MAL ESTILO TO DO
    lista = []
    while len(lista) < cant_num:
        num = random.randint(2,rango_max)
        if not lista.count(num):
            lista.append(num)
    return lista

def generarListaOp(cant_op = CANT_NUM - 1):
    """ genera una lista de largo cant_op alternando * y +, empezando por *"""
    i = 1
    lista = []
    while i <= cant_op:
        if i % 2:
            lista.append('*')
        else:
            lista.append('+')
        i += 1
    return lista

def alternarElementosLista(lst1, lst2):
    """ alterna los elementos de las listas, generando una lista nueva
        PRE: len(lst1) >= len(lst2)
    Retorna la lista con los elementos alternados"""
    lista = []
    largo = len(lst2)
    i = 0
    while i < largo:
        lista.append(lst1[i])
        lista.append(lst2[i])
        i += 1
    #si quedan elementos en la lista 1 los agrego
    largoNuevo = len(lst1)
    while i < largoNuevo:
        lista.append(lst1[i])
        i += 1
    return lista


### TO DO : Discriminar segun niveles
def generarCasos(cant_num = CANT_NUM, nivel = 1): ## TO DO!
    """Recibe un numero y devuelve una lista con todos los casos posibles y con
    los parentesis bien puestos"""
    listaNum = generarListaNum()
    listaOp   = generarListaOp()
    base = alternarElementosLista(listaNum, listaOp)
    i1 = buscarProxNum(base, 0)
    res = []
    while i1 < len(base) : ## mientras tenga sentido poner un '('
        lst = base[:]
        lst.insert(i1, '(')
        i2 = i1 + 6 # lo pongo en la posicion para insertar ')'
        lst2 = lst[:]
        lst2.insert(i2, ')')
        
        aux = listaToString(lst2)
        if validarString(aux) != None:
            res.append(aux)
            
        
        while i2 < len(base): ## chequear si es menor o menor e igual TO DO
            lst2 = lst[:]
            i2 += 2
            lst2.insert(i2, ')')
            aux = listaToString(lst2)
            if validarString(aux) != None:
                res.append(aux)

        i1 = buscarProxNum(base, i1 + 1)
        
        ## ( 1 * 2 + 3 * 4 + 5 * 6)
    return res

### Ejemplo de devolucion lista = ["(1*2+3)*4 + 5 * 6", "1*2+3 * (4+5)*6"]

def listaToString(lst):
    """Transforma una lista de cualquier cosa en un string conformado por la concatenacion de str de cada elemento """
    texto = ''
    for x in lst:
        texto += str(x)
    return texto

def intToChar(o):
    """Agarra un elemento, y si es un entero lo convierte a string, sino lo deja como esta"""
    if types(o) == types.IntType:
        return str(o)
    

def buscarProxNum(lista, start = 0):
    """Devuelve el proximo indice en la lista donde hay un numero
        PRE: len(lista) > start
    """
    
    lst = lista[start:]
    i = start
    while len(lst) > 0 and type(lst.pop(0)) != types.IntType:
        i += 1
    return i

    
### Pongo parentesis en el primer lugar que pueda --busco siguiente lugar con "numero a la derecha"
    ### Busco indice para el segundo lugar --recorro lista 
            ### Si encuentro pongo y mando a testear/agregar
            ### Si no encuentro indice, avanzo el primer indice
    ###

### [8, '*', 2, '+', 6, '*', 7, '+', 9, '*', 4]


listaNum = generarListaNum()
listaOp   = generarListaOp()
res = alternarElementosLista(listaNum, listaOp)
    
if __name__ == "__main__":
    testearValidarStringNivelUno()
    lst = generarCasos()
    for x in lst:
        print x