playing with HTMLParser and SGLMParser

----------------------
----------------------

''' ENERO 15/16 '''

Y no parsing, muy complicado, jajaja

{{{
#import HTMLParser
from sgmllib import SGMLParser

html=open('index.html','r')
abrir=html.read()
...
}}}

Lo pienso usar para un proyecto que tengo, pero todavia me toca leer mucho, jajaja, Quien me enseña a programar en pythooooonnnnnnn????????

Tambien estuve jugando un poco con el WING y el ERIC, me ayudaron a resolver unos problemas mediante el debuggin, fácil, puro F6, F7, F8, esto me recuerda muchas cosas, jajaja, un ENTER mas para obtener un EAX mas.

Pd:
me parecio que hay poca doc oficial sobre estos temas :s, faltan mas ejemplos!!!!

Pd:
ya se, ya se, si no estan los ejemplos, que espero para hacerlos :p, bueno asi es la vida.

''' ENERO 16 '''

Me aburrí con esos parceros (parsers), jaja, busque otra forma de hacer el match que queria y fue bastante simple.
un split, jeje sobre todo un string, eso me daba para generar los bloques.

Explico mi problema y lo que llevo de codigo:

''
En OpenBSD el sistema de traduccion de documentación es como en casi todos los BSD, no usan archivos .po o algo parecido, lo que hacen es coordinar a traves del CVS los cambios de los archivos. Todo el mundo debe tener como referencia los archivos maestros, que son los cambios que se hacen en el CVS oficial. Luego esos archivos se bajan a otro servidor de traducciones y ahi empieza el problema.

Las personas que se encargan de traducir en los diferentes idiomas, lo que hacen es mirar las fuentes en ingles (EN) y verificar cuales han sido los cambios y entonces hacer los respectivos cambios en los archivos de la lengua traducida.
Basicamente hay que estar mirando los cambios que ocurren en una (diff) y traducir esos cambios en la otra (i.e ES).

Bueno, entonces que es lo que quiero hacer?, quiero montar una aplicacion en web, que permita a varios usuarios acceder a los diferentes archivos que se deben traducir y que cada uno pueda elegir "bloques" de cada archivo y hacer la respectiva traduccion.
de esta forma muchas personas podrian trabajar sincronizadamente, algo que no se hace actualmente.

El software deberia:

*Encargarse del manejo interno de CVS (update, commits)

*Presentarle los "bloques de texto" de la manera mas simple posible, ojala con resaltado de texto, indicando donde estan los cambios, permitiendo que el proceso de traduccion sea inmediato. Una vez traducido, debe llevar estos bloques a un archivo comun, hasta que el archivo completo este listo y se pueda hacer commit del mismo.

*Chequear constantemente (dia/semana), los cambios en las fuentes en ingles e informar de los archivos que se requieren actualizar.

*Etc.

Como ven, no es un problema fácil de resolver y como llevo 2 días aprendiendo python, quize aprender trabajando en este "proyecto".

La idea de "bloques" la estoy haciendo separando el archivo .html en strings separados por los tags ''

''. Parece algo tonto, pero me parece que es viable. Luego intento organizar los bloques y puedo manipularlos individualmente y luego construir el archivo con los bloques ordenados."

CUALQUIER AYUDA, IDEAS, COMENTARIOS, me sirven, aún no tengo muy claro como hacer todo eso ...

Aqui dejo lo que llevo de código. proximamente organizo un CVS para trabajarlo desde ahí.

Hasta ahora lo que he logrado es que se guarden los bloques, que se guarde una "base de datos" con la informacion del orden de los bloques y los MD5 para luego chequear si hay cambios en ellos y logre hacer la comparacion entre dos bloques...

{{{
root@debian:/home/nando/python/open# cat parser.py
#!/usr/bin/env python
#Basicas y MD5
import string,sys,md5
#Libreria para hacer el pickle
import pickle, string
#Libreria para hacer el diff de los bloques
from difflib import unified_diff

#Funcion que almacena el archivo .html en un .dat como diccionario [MD5,'TEXTOBLOQUE'] y ademas genera los bloques .txt

#Funcion que lee los archivo .txt (los bloques) y devuelve el archivo en memoria
def lee_bloques(archivo):
bloque=1
abierto=""
while True:
try:
file=open((archivo+"-"+"[porciento]d.txt" % bloque),'r')
abierto=abierto+file.read()
bloque=bloque+1
except IOError:
break
return abierto

#Funcion que lee el archivo en .DAT (pickle) y regresa la estructura de MD5,TEXTO
def lee_dat(archivo):
filedat= open(archivo+".dat","r")
db=""
db=pickle.load(filedat)
return db

#Funcion que lee un archivo y crea en memoria el diccionario, devuelve el texto parseado y el diccionario
def lee_archivo(archivo):
losp=parsea_archivo(archivo)
bloques=[]
indices=[]
#Crear diccionario del archivo: archivo, ahora puedo usar como keys, los MD5.
#SOn dos diccionarios, indices, tiene los numeros de bloques (1,2,3...) enlazados a los MD5
#y diccionario tiene los MD5 enlazados a los textos, esto para darle orden en la lectura con el pickle
#diccionario=dict([(md5.new(i).hexdigest(), i) for i in losp])
#indices=dict([(h,md5.new(losp[h]).hexdigest()) for h in range(long) ])
for i in range(len(losp)):
bloques.append(losp[i])
indices.append(md5.new(losp[i]).hexdigest())
bd=[indices,bloques]
return bd


#Funcion que graba los bloques, de memoria a archivos de texto .txt
def graba_bloques(archivo):
bloque=1
for i in parsea_archivo(archivo):
file=open((archivo+"-"+"[porciento]d.txt" % bloque),'w')
file.write(i);
file.close
bloque=bloque+1
return 0

#Funcion que graba el archivo .dat (pickle), basandose en un diccionario y nombre de archivo
def graba_dat(archivo,bd):
filedat= open(archivo+".dat","w")
pickle.dump(bd, filedat)
return 0

def parsea_archivo(archivo):
html=open(archivo,'r')
abrir=html.read()
losp=abrir.split("

")
return losp

#Funcion que me permite mirar los cambios de los bloques de un archivo nuevo, con uno almacenado en DAT, osea la referencia
def cambios(archivo,ref):
bd=lee_archivo(archivo)
bdref=lee_dat(ref)
indices=bd[0]
datos=bd[1]
indices_ref=bdref[0]
datos_ref=bdref[1]
if bd==bdref:
print "El archivo no ha cambiado"
else:
for i in range(len(indices)):
if indices[i]!=indices_ref[i]:
print "El bloque ",i,"cambio!"
print "\n"
print "###########################################################"
for line in unified_diff(datos_ref[i].split(),datos[i].split()):
print line


#datos[i], datos_ref[i]
archivo="index.html"
archivo2="index2.html"
graba_dat(archivo,lee_archivo(archivo))
graba_bloques(archivo)
cambios(archivo2,archivo)

}}}
----------------------
----------------------