def validar_palabra(palabra):
"""
Comprueba que el string que se pasa como palabra sea una palabra valida
retorna True si lo es, en caso contrario retorna False.
"""
palabra = parse(palabra).split('/')
existe = False
if palabra[1] in ('AO','JJ','AQ','DI','DT','VAG','VBG','VAI','VAN','MD',
'VAS','VMG','VMI','VB','VMM','VMN','VMP','VBN','VMS',
'VSG','VSI','VSN','VSP','VSS'): # VB:verbo, JJ:adjetivo
if palabra[0] not in (lexicon.keys() or spelling.keys()):
# si es adj o verbo y no esta en el lexicon
# ni el spelling comprueba con wiktionary
w = Wiktionary(language="es")
article = w.search(palabra[0])
if article is not None:
secciones = [x.title for x in article.sections]
if 'Español' in secciones:
existe = True
else:
existe = True
elif palabra[1] in ('NC','NN','NCS','NCP','NNS','NP','NNP','W'):
# sustantivo comprueba con wiktionary
w = Wiktionary(language="es")
article = w.search(palabra[0])
if article is not None:
secciones = [x.title for x in article.sections]
if 'Español' in secciones:
existe = True
return existe
def tipoPalabra(d):
"""
Depende de la libreria pattern. El mismo utiliza JJ , VB y NN.
IMPORTANTE: pattern considera sustantivo o NN todo loq no sea verbo o adjetivo.
Por el motivo de arriba seria necesario hacer una segunda comprobacion con lexicon o todo arrojaria sustantivo.
Aqui se hace la segunda comprobacion con lexicon para clasificar si el sustantivo es realmente una palabra o simplemente
entro en esa categoria y no existe.
"""
palabra = obtener_palabra(d)
analisis = parse(palabra, tags=True, chunks=False).split(' ')
tipo = clasificar(analisis)
if len(palabra) == 1: #SIRVE PARA TESTEAR POR AHORA
return 'no_existe'
if (tipo == 'sustantivos'):
if not palabra.lower() in verbs:
if not palabra.lower() in spelling:
if (not (palabra.lower() in lexicon)
and not (palabra.upper() in lexicon)
and not (palabra.capitalize() in lexicon)):
return 'no_existe'
else:
return clasificar(
tag(palabra, tokenize=True, encoding='utf-8')[0][1])
else:
return clasificar(
tag(palabra, tokenize=True, encoding='utf-8')[0][1])
else:
return clasificar(
tag(palabra, tokenize=True, encoding='utf-8')[0][1])
else:
return tipo
def contar(pal, frase):
s = parse(frase).split()
cont = 0
for palabra in s:
if palabra[1] == pal:
cont = cont + 1
return cont
def clasificar(palabra, clases_validas):
"""Verfica que la palabra pasada por parámetro pertenezca a una de las clases pasadas por parámetro
"""
aux = parse(palabra).split()[0][0][1]
if aux in clases_validas:
return True
else:
return False
def solo_los_verbos(frase):
lectura = frase.read()
s = parse(lectura).split()
for cada in s:
for c in cada:
if c[1] == 'VB':
verbos.append(c[0])
return(verbos)
def esValida(palabra, *dif):
palabra = parse(palabra).split('/')
if palabra[1] in dif:
if (palabra[1] == 'NN' or palabra[1] == 'NNS' or palabra[1] == 'NNP'):
if (not palabra[0] in spelling) and (not palabra[0] in lexicon):
return False
#print('existe'+ palabra[1])
return True
return False
def _verificarPalabra(self, palabra,clases_validas):
"""Verifica que la palabra sea correcta para la especificacion
de la dificultad en la que se esta jugando
"""
aux = parse(palabra).split()[0][0][1]
if aux in clases_validas:
return True
else:
return False
def clasificar(palabra, nivel):
'''clasifica si la palabra es valida para el nivel seleccionado'''
pal = parse(palabra).split()
if (nivel == 'facil'):
if (pal in sus or adj or verb):
return True
elif ((nivel == 'medio') or (nivel == 'dificil')):
if (pal in adj or verb):
return True
else:
return False
def solo_los_verbos(frase):
s = parse(frase).split()
dic = {}
lista = []
for cada in s:
for c in cada:
if c[1] == 'VB':
lista.append(c[0])
for i in lista:
if i not in dic.keys():
dic[i] = lista.count(i)
return dic
def __es_correcta_medio(self, palabra):
'''
Ver comentario en naranja de arriba
MOD: la catedra cambió, en medio sólo acepta adjetivos o verbos.
'''
ok = self.existe_en(palabra)
if ok:
palabra_split = parse(palabra).split('/')
return (palabra_split[1] in self.tupla_adj
or palabra_split[1] in self.tupla_verb)
return False
def __es_correcta_dificil(self, palabra):
'''
MOD: la catedra sólo acepta adjetivos o verbos, en difícil se toma aleatoriamente cualquiera de los dos.
'''
ok = self.existe_en(palabra)
if ok:
lista = ['verb', 'adj']
azar = lista[r.randint(0, 1)]
palabra_split = parse(palabra).split('/')
return palabra_split[
1] in self.tupla_verb if azar == 'verb' else ok and palabra_split[
1] in self.tupla_adj
return False
def es_palabra_valida(self, palabra):
from pattern.text.es import verbs, spelling, lexicon, parse
import string
if (palabra.lower() in verbs) or (palabra.lower() in spelling) or (
palabra.lower()
in lexicon) or (palabra.upper()
in lexicon) or (palabra.capitalize()
in lexicon):
tipo_palabra = parse(palabra).split(
'/'
)[1] # devuelve un string de tipo 'mario/NN/B-NP/O', nos quedamos con el elem 'NN'
return (tipo_palabra in self._tipo)
else:
return False
def buscar_pattern(x):
"""
clasifica el string recbido como paramentro(x) en pattern, analizando la palabra, devuleve su clasificacion
sustantivo, adjetivo o verbo.
"""
s = parse(x).split()
for cada in s:
for i in cada:
if i[1] == 'VB':
return 'VB'
elif i[1] == 'NN':
return 'NN'
elif i[1] == 'JJ':
return 'JJ'
def __corroboro_palabra(diccionario_trabajado, dificultad):
"""Transformo la estructura elegida previamente, y empiezo a corroborar con pattern"""
palabra = ""
palabra_lista = []
#Con el for, me quedo con las letras que ingresaron
for k, v in diccionario_trabajado.items():
palabra = palabra + v
palabra_lista.append(v)
#Hago el parse para que me identifique la palabra
pal = palabra.lower()
pal = parse(pal).split()
#parse = [[[zzz,zzz,zzz,zzz]]]
#Obtengo del parse la palabra para ir corroborando con el lexicon
pal_final = pal[0][0]
#Inicializo un booleano en false, esto es para saber si encontro o no la palabra
ok = False
for x in lexicon.keys():
if x in spelling.keys():
if (x == pal_final[0]):
ok = True
if (ok == True):
#Consulto si la palabra es sustantivo, adjetivo o verbo
for elemento in pal:
for elem in elemento:
if (dificultad == 1):
return (ok, palabra)
elif ((dificultad == 2) or (dificultad == 3)):
if ((elem[1] == 'VB') or (elem[1] == 'JJ')):
return (ok, palabra)
else:
ok = False
return (ok, palabra)
else:
ok = False
return (ok, palabra)
else:
ok = False
return (ok, palabra)
def validar_palabra(permutaciones, permutaciones_validas, dificultad):
"""
Valida palabras que esten dentro de las permutaciones
pasadas por parametro y las agrega a una lista de palabras
validas
"""
for pal in permutaciones:
if dificultad == 'Facil':
#if pal in lexicon and spelling or pal in verbs:
if pal in verbs or ((pal in lexicon) and (pal in spelling)):
permutaciones_validas.append(pal)
else:
palabra = parse(pal).split('/')
# si palabra es verbo o adjetivo es valida
if (pal in verbs) or (palabra[1] == 'JJ'):
permutaciones_validas.append(pal)
return permutaciones_validas
def verificar_palabra(palabra, dificultad):
"""
verificamos si la palabra es valida
"""
pal = palabra.lower()
if dificultad == 'Facil':
if pal in verbs or ((pal in lexicon) and (pal in spelling)):
return (True)
else:
return (False)
else:
pala = parse(pal).split('/')
# si palabra es verbo o adjetivo es valida
if (pal in verbs) or (pala[1] == 'JJ'):
return (True)
else:
return (False)
def PalabraPattern(pal):
'''Busca la palabra en el pattern y la califica segun su tipo, si no es un verbo, sustantivo o adjetivo, se debera ingresar otra.
TENER EN CUENTA QUE SI LA PALABRA NO EXISTE EL MODULO PATTERN LO TOMA COMO SUSTANTIVO'''
pal.lower()
palabra = patt.parse(pal)
correcto=False
#print(palabra)
if ('VB' in palabra):
tipo = '__verbos__'
correcto=True
elif ('NN' in palabra):
tipo = '__sustantivos__'
correcto=True
elif ('JJ' in palabra):
tipo = '__adjetivos__'
correcto=True
else:
tipo = ' '
return correcto, tipo
def identificador(palabra):
""""Retorno una lista con la palabra y que tipo es para mandarla a la tabla """
palabra = palabra.lower() #solo encuntra palabras en minuscula
engine = Wiktionary(license=None, throttle=5.0, language="es")
match = False
wik = False
patt = False
lis = []
try:
art = engine.search(palabra)
section = art.sections
except AttributeError:
section = "error"
if section != "error":
lis = section[3]
descr = section[3].string
descr = ((((
descr.split("2"))[0].split("1"))[1]).split("*")[0]).split("\n")[0]
if ("Sustantivo" in lis.title) or ("Adjetivo"
in lis.title) or ("Verbo"
in lis.title):
tag = lis.title.split(" ")[0]
lis = [palabra, tag, descr]
wik = True
try:
patt_es = parse(palabra, tokenize=False, tags=True,
chunks=False).split("/")[1]
patt = True
except AttributeError:
patt_es = "error"
if patt_es != "error":
print(patt_es)
if wik is False:
definicion = sg.PopupGetText(
"Palabra No Encontrada en wiki",
"Ingrese definicion") ## para guardar en archivo local
if "NN" in patt_es:
lis = [palabra, "Sustantivo", definicion]
elif "VB" in patt_es:
lis = [palabra, "Verbo", definicion]
elif "JJ" in patt_es:
lis = [palabra, "Adjetivo", definicion]
if wik is True:
if(("NN" in patt_es) and ("Sustantivo" in tag)) or (("VB" in patt_es) and ("Verbo" in tag)) or\
(("JJ" in patt_es) and ("Adjetivo" in tag)):
match = True
patt = True
if (wik is False) or (patt is False) or (match is False):
file = open("reporte.txt", "a+")
fechahora = datetime.now().strftime("%d/%m/%Y %H:%M:%S")
reporte = ""
if (wik is False) and (patt is True):
reporte = "La palabra " + palabra + " no fue encontrada en wiki. " + fechahora
elif (wik is True) and (patt is False):
reporte = "La palabra " + palabra + " no fue encontrada en pattern.es. " + fechahora
elif (wik is False) and (patt is False):
reporte = "La palabra " + palabra + " no fue encontrada en ninguno de los dos sitios. " + fechahora
elif (match is True):
reporte = "La clasificacion de la palabra " + palabra + " no conicide. " + fechahora
file.write(reporte)
file.write("\n")
file.close()
return lis