def do_md_coluna_def():
id = getattr(request.forms, 'id')
id_tabela = getattr(request.forms, 'id_tabela')
tipo = getattr(request.forms, 'tipo')
nome = getattr(request.forms, 'nome')
sql = getattr(request.forms, 'sql')
desabilitado = getattr(request.forms, 'desabilitado') != ''
titulo = getattr(request.forms, 'titulo')
descricao = getattr(request.forms, 'descricao')
classe = getattr(request.forms, 'classe') != ''
fl_aluno = getattr(request.forms, 'fl_aluno') != ''
chave_estrangeira = getattr(request.forms, 'chave_estrangeira') != ''
id_tabela_fk = getattr(request.forms, 'id_tabela_fk')
id_coluna_fk = getattr(request.forms, 'id_coluna_fk')
val_aluno_risco = getattr(request.forms, 'val_aluno_risco')
sinonimos = getattr(request.forms, 'sinonimos')
coluna = meta.ObterColuna(id)
coluna.id_tabela = id_tabela
coluna.tipo = tipo
coluna.nome = nome
coluna.sql = sql
coluna.desabilitado = desabilitado
coluna.titulo = titulo
coluna.descricao = descricao
coluna.classe = classe
coluna.fl_aluno = fl_aluno
coluna.chave_estrangeira = chave_estrangeira
coluna.id_tabela_fk = id_tabela_fk
coluna.id_coluna_fk = id_coluna_fk
coluna.val_aluno_risco = val_aluno_risco
coluna.sinonimos = sinonimos
meta.SalvarColuna(coluna)
redirect('/colunas?id=' + str(id_tabela))
def profAlunos():
seg.ChecarPerfil(seg.PERFIL_Professor)
colunaIdAluno = meta.ObterColunaIdAluno()
nomeColunaClasse, idColunaClasse = meta.ObterColunaClasse(
colunaIdAluno.id_tabela)
sql = dbTab.GerarSQL(colunaIdAluno.id_tabela, 'O',
[colunaIdAluno.id, idColunaClasse])
df = dm.db.consultarSQLDataFrame(sql)
lista = []
for index, row in df.iterrows():
login_aluno = row[colunaIdAluno.nome]
usuario = usu.ObterUsuarioPorLogin(login_aluno)
lista.append(usuario)
campos = ({
'campo': 'login',
'titulo': 'matricula'
}, {
'campo': 'nome',
'titulo': 'Nome'
})
grd = comp.grid('Lista de Alunos', lista, campos)
return dict(grid=grd)
def mineracao_dados_prever():
seg.ChecarPerfil(seg.PERFIL_Analista)
idTabela = request.params.get('id')
tabela = imp.ObterTabela(idTabela)
tabPrev = dm.ObterTabelaPredicao(idTabela)
tabPrevAlg = None
colunaClasse, id_coluna = meta.ObterColunaClasse(idTabela)
tabelaPrev = dm.ObterDadosPrevisao(idTabela)
colunas = []
for col in tabelaPrev.columns:
if col == "rowid":
continue
coluna = meta.ObterColunaPorTabNome(idTabela, col)
colunas.append({'campo': coluna.nome, 'titulo': coluna.titulo})
grid = comp.gridSP('Modelo DB para previsão', tabelaPrev, colunas, '')
for alg in tabPrev.Alg:
if alg.selecionado:
tabPrevAlg = alg
return dict(idTabela=idTabela,
tabela=tabela,
tabPrev=tabPrev,
tabPrevAlg=tabPrevAlg,
colunaClasse=colunaClasse,
grid=grid)
def ListarCampos(idTabela, edt = True, splColunas = []):
listaCampos = meta.ListarColunas(idTabela)
listaExibicao = dbTab.ListarExibicao(idTabela)
campos = [ ]
for col in listaCampos:
if col.desabilitado == True:
continue
if len(splColunas) != 0:
existeColunaFiltro = False
for idCol in splColunas:
if int(idCol) == int(col.id):
existeColunaFiltro = True
if existeColunaFiltro == False:
continue
if col.chave_estrangeira == False or edt == False:
c_campo = {'campo': col.nome, 'titulo': col.titulo }
else:
c_campo = {'campo': col.nome, 'titulo': '<a href="transformacao_sel?idTabela=' + str(idTabela) + '&idColuna=' + str(col.id) + '">' + col.titulo + '</a>' }
campos.append(c_campo)
conta_tb = 0
for colExib in listaExibicao:
col = meta.ObterColuna(colExib.id_coluna_fk)
if col.desabilitado == True:
continue
if len(splColunas) != 0:
existeColunaFiltro = False
for idCol in splColunas:
if int(idCol) == int(col.id):
existeColunaFiltro = True
if existeColunaFiltro == False:
continue
conta_tb = conta_tb + 1
if edt == True:
c_campo = {'campo': col.nome, 'titulo': '<a href="#" style="color: red;">' + col.titulo + '</a>' }
else:
c_campo = {'campo': col.nome, 'titulo': col.titulo }
campos.append(c_campo)
return campos
def ObterAlunosParaRecomendacoes(id_aluno):
listaMensanges = []
nomeAluno = ''
tx_acerto = 0
nomeColuna, id_colunaClasse = meta.ObterColunaClasse()
colunaClasse = meta.ObterColuna(id_colunaClasse)
tabela = imp.ObterTabela(colunaClasse.id_tabela)
colunaIdAluno = meta.ObterColunaIdAluno(colunaClasse.id_tabela)
listaAlunos = []
listaColunas = []
listaColunas.append(colunaIdAluno.id)
listaColunas.append(colunaClasse.id)
sql = dbTab.GerarSQL(tabela.id, 'O', listaColunas)
dfAlunos = db.consultarSQLDataFrame(sql)
session = db.getSession()
for index, row in dfAlunos.iterrows():
usuario = session.query(
db.Usuario).filter_by(login=row[colunaIdAluno.nome]).first()
usuario.selecionado = False
if id_aluno == usuario.id:
nomeAluno = usuario.nome
usuario.selecionado = True
listaAlunos.append(usuario)
session.close()
algPredicao = ObterTabelaPredicao(tabela.id)
for alg in algPredicao.Alg:
if alg.selecionado:
tx_acerto = alg.tx_acerto
if id_aluno != 0:
listaMensanges = ObterRecomendacoesPorAluno(id_aluno)
return dict(listaAlunos=listaAlunos,
listaMensanges=listaMensanges,
id_aluno=id_aluno,
nomeAluno=nomeAluno,
tx_acerto=tx_acerto)
def mineracao_dados_executar_tudo():
id_tabela = request.params.get('id')
id_coluna = meta.ObterColunaClasse(id_tabela)[1]
tam_tst = 20
dm.CalcularPreditivo(id_tabela, id_coluna, int(tam_tst))
dm.GerarRecomendacoes(id_tabela)
redirect('/mineracao_dados?id=' + str(id_tabela))
def mineracao_dados():
seg.ChecarPerfil(seg.PERFIL_Analista)
idTabela = request.params.get('id')
tam_tst = 15
id_coluna = 0
colunaClasse = ''
if idTabela == None:
idTabela = 0
listaTabelas = imp.ListarTabelas()
tabPred = None
listaTabelaDesc = []
listaColunaT = []
listaColunaN = []
if int(idTabela) != 0:
colunaClasse, id_coluna = meta.ObterColunaClasse(idTabela)
tabPred = dm.ObterTabelaPredicao(idTabela)
listaTabelaDesc = dm.ListarTabelaDescricao(idTabela)
listaColunaT = meta.ListarColunasPorTipo(idTabela, 'T')
listaColunaN = meta.ListarColunasPorTipo(idTabela, 'N')
if tabPred != None:
tam_tst = tabPred.reserva_treino
for tab in listaTabelas:
tab.selecionado = False
if int(tab.id) == int(idTabela):
tab.selecionado = True
return dict(idTabela=idTabela,
tam_tst=tam_tst,
listaTabelas=listaTabelas,
id_coluna=id_coluna,
colunaClasse=colunaClasse,
tabPred=tabPred,
listaTabelaDesc=listaTabelaDesc,
listaColunaT=listaColunaT,
listaColunaN=listaColunaN)
def DefColunas():
seg.ChecarPerfil(seg.PERFIL_Analista)
id = request.params.get('id')
if id == None:
id = 0
coluna = meta.ObterColuna(id)
listaTabelas = imp.ListarTabelas()
colunasFk = None
if coluna != None:
if coluna.val_aluno_risco == None:
coluna.val_aluno_risco = ''
if coluna.chave_estrangeira == True:
colunasFk = meta.ListarColunas(coluna.id_tabela_fk)
coluna.lstTipos = (
{
'id': 'T',
'nome': 'Texto',
'selecionado': False
},
{
'id': 'N',
'nome': 'Número',
'selecionado': False
},
{
'id': 'D',
'nome': 'Data (seq. temporal)',
'selecionado': False
},
)
for tp in coluna.lstTipos:
tp['selecionado'] = False
if tp['id'] == coluna.tipo:
tp['selecionado'] = True
return dict(listaTabelas=listaTabelas, colunasFk=colunasFk, coluna=coluna)
def Outlier(idTabela, filtro, campoD, campoV):
tabela = imp.ObterTabela(idTabela)
sql = dbTab.GerarSQL(idTabela, 'S')
if tabela.sql_sem_hist != None and tabela.sql_sem_hist != '':
if filtro == 'H':
sql = sql + ' WHERE NOT (' + tabela.sql_sem_hist + ')'
elif filtro == 'A':
sql = sql + ' WHERE (' + tabela.sql_sem_hist + ')'
lista = db.consultarSQLDataFrame(sql)
campoVal = meta.ObterColuna(campoV).nome
campoDesc = meta.ObterColuna(campoD).nome
existeOutlier, listaDf = desc.Outliers(lista, campoVal, campoDesc)
modelo = {
'campoV': campoVal,
'campoD': campoDesc,
'existe': existeOutlier,
'lista': listaDf
}
md_outlier = json.dumps(modelo)
session = db.getSession()
tabDesc = session.query(db.TabelaDescricao).filter_by(
id_tabela=idTabela).filter_by(id_alg=id_alg_outliers).first()
if tabDesc == None:
tabDesc = db.TabelaDescricao(None, idTabela, id_alg_outliers,
md_outlier, datetime.now())
session.add(tabDesc)
else:
tabDesc.modelo = md_outlier
tabDesc.dt_processo = datetime.now()
session.commit()
session.close()
return "OK"
def SalvarMensagens(tabela, msgs):
print(
'==============================================================================================='
)
print('Salvar Mensagens')
listaColunas = meta.ListarColunas(tabela.id)
sqlDelete = 'DELETE FROM mensagem WHERE id_tabela = ' + str(tabela.id)
print(sqlDelete)
session = db.getSession()
session.execute(sqlDelete)
coluna_identif_aluno = None
for col in listaColunas:
if (col.fl_aluno):
coluna_identif_aluno = col
break
dt_geracao = datetime.now()
for msg in msgs:
rowid = msg['Aluno']
sql_busca_usuario = 'SELECT U.id FROM "' + tabela.nome + '" AS T0 INNER JOIN usuario AS U ON "' + coluna_identif_aluno.nome + '" = U.login WHERE T0.rowid = ' + str(
rowid) + ' LIMIT 1'
print(sql_busca_usuario)
id_usuario_aluno = session.execute(
sql_busca_usuario).fetchall()[0]['id']
coluna = ObterColunaPorNomeLista(listaColunas, msg['Campo'])
print(coluna.titulo)
desc_mensagem = 'Na característica "' + coluna.titulo + '" esta informado: "' + msg[
'ValAtual'] + '".\nRecomendamos que seja modificado para "' + msg[
'ValSuger'] + '"'
print(desc_mensagem)
mensagem = db.Mensagem(None)
mensagem.id_tabela = tabela.id
mensagem.id_coluna = coluna.id
mensagem.id_usuario_aluno = id_usuario_aluno
mensagem.val_atual = msg['ValAtual']
mensagem.val_suger = msg['ValSuger']
mensagem.descartado = 'N'
mensagem.lido = 'N'
mensagem.dt_gerado = dt_geracao
mensagem.descricao = desc_mensagem
session.add(mensagem)
session.commit()
session.close()
def Obter():
seg.ChecarPerfil(seg.PERFIL_Analista)
id = request.params.get('id')
listaColunas = meta.ListarColunas(id)
lstCol = []
for col in listaColunas:
lstCol.append({'id': col.id, 'nome': col.nome})
return json.dumps(lstCol)
def RetornarValoresColuna(idTabela, idColuna):
tabela = imp.ObterTabela(idTabela)
coluna = meta.ObterColuna(idColuna)
sql_table = tabela.nome
if not (tabela.sql_destino == None or tabela.sql_destino == ''):
sql_table = tabela.sql_destino
sql = 'SELECT COUNT(*) AS qtd, ' + coluna.sql + ' as COL FROM "' + sql_table + '" GROUP BY COL'
#resultado = db.consultarSQL(sql)
resultado = db.consultarSQLDataFrame(sql)
return resultado
def pre_processamento():
seg.ChecarPerfil(seg.PERFIL_Analista)
listaTabelas = imp.ListarTabelas()
idTabela = request.params.get('idTabela')
idColuna = request.params.get('idColuna')
nomeColuna = ''
nomeTabela = ''
sql=''
for tab in listaTabelas:
tab.selecionado = False
if idTabela == None:
idTabela = 0
else:
for tab in listaTabelas:
if int(tab.id) == int(idTabela):
tab.selecionado = True
nomeTabela = tab.nome
listaColunas = meta.ListarColunas(idTabela)
for col in listaColunas:
col.selecionado = False
if idColuna == None:
idColuna = 0
else:
for col in listaColunas:
if int(col.id) == int(idColuna):
col.selecionado = True
nomeColuna = col.nome
sql = col.sql
resultado = None
if idColuna != 0 and idTabela != 0:
resultado = pre.RetornarValoresColuna(idTabela, idColuna)
grfPizza = comp.grfPizza('Valores Válidos', resultado, 'COL', 'qtd', 'Valores válidos para a coluna selecionada');
return dict(listaTabelas=listaTabelas,
listaColunas=listaColunas,
nomeTabela=nomeTabela,
nomeColuna=nomeColuna,
idTabela=idTabela,
idColuna=idColuna,
sql=sql,
grfPizza=grfPizza.grf,
scriptGrafico=grfPizza.js)
def PreverValores(idTabela):
tabela = imp.ObterTabela(idTabela)
colunaClasse, id_coluna = meta.ObterColunaClasse(idTabela)
coluna = meta.ObterColuna(id_coluna)
nomeTabela = tabela.nome
nomeColunaClasse = coluna.nome
LimparDadosColunaClasse(nomeTabela, nomeColunaClasse)
tabPredicao = ObterTabelaPredicao(tabela.id)
algPredicao = None
for alg in tabPredicao.Alg:
if alg.selecionado:
algPredicao = alg
modeloDb = json.loads(tabPredicao.modelo)
modeloDbColClasse = modeloDb[colunaClasse]
df = ObterDadosPrevisao(idTabela)
dfListaCopy = df.copy()
rowids = df['rowid']
del dfListaCopy[colunaClasse]
del dfListaCopy['rowid']
for index, row in dfListaCopy.iterrows():
rowPred = ut.VoltarModelo(dict(row), modeloDb)
val_prev = algPredicao.clf.predict([rowPred])
for key, value in modeloDbColClasse.items():
if int(key) == int(val_prev):
classe_prev = 'LA :: Prev :: ' + value
rowid = rowids[index]
AtualiarClasse(nomeTabela, nomeColunaClasse, classe_prev,
rowid)
break
def ObterColunaClasse(idTabela):
session = db.getSession()
obj = session.query(db.Coluna).filter_by(id_tabela=idTabela).filter_by(classe=True).first()
session.close()
if obj != None:
return obj.nome, obj.id
else:
listaExibicao = dbTab.ListarExibicao(idTabela)
for colExib in listaExibicao:
col = meta.ObterColuna(colExib.id_coluna_fk)
if col.classe:
return col.nome, col.id
return '', None
def def_visao():
seg.ChecarPerfil(seg.PERFIL_Analista)
id_tabela = request.params.get('id_tabela')
id = request.params.get('id')
nome = ''
modelo = ''
tipo = { }
tipo['1'] = ''
tipo['2'] = ''
tipo['3'] = ''
tipo['4'] = ''
tipo['5'] = ''
tabela = imp.ObterTabela(id_tabela)
listaColunas = meta.ListarColunas(id_tabela)
for col in listaColunas:
col.selecionado = False
visao = None
if id != '0':
visao = vis.ObterVisao(id)
nome = visao.nome
dTipo = visao.tipo
modelo = visao.modelo
tipo[dTipo] = 'selected'
objModelo = json.loads(modelo)
for col in listaColunas:
for mod in objModelo:
if int(mod['id_coluna']) == col.id:
col.selecionado = True
else:
tipo['1'] = 'checked'
return dict(id=id,
nome=nome,
tipo=tipo,
modelo=modelo,
idTabela=id_tabela,
nomeTabela=tabela.nome,
listaColunas=listaColunas,
visao=visao,
js='<script>ReconstruirGrid();</script>')
def CalcularPreditivo(idTabela, id_coluna, tam_tst):
sql = dbTab.GerarSQL(idTabela, 'S')
lista = db.consultarSQLDataFrame(sql)
del lista['rowid']
colunaClasse = meta.ObterColuna(id_coluna)
modeloDados, listaCopy = ut.PrepararLista(lista)
listaModeloPred = None
jsModeloDados = json.dumps(modeloDados, default=iDefault)
if colunaClasse.tipo == 'N':
listaCopy[colunaClasse.nome] = ut.TransformarNumeros(
lista[colunaClasse.nome].values())
listaModeloPred = pred.ModeloReg(listaCopy, colunaClasse.nome, tam_tst)
else:
listaModeloPred, clfTree = pred.ModeloClf(listaCopy, colunaClasse.nome,
tam_tst)
lstPesos = pred.ObterPesos(lista, clfTree, colunaClasse.nome,
colunaClasse.val_aluno_risco)
strPesos = json.dumps(lstPesos)
maiorTxAcerto = 0
id_alg_sel = 0
for modelo in listaModeloPred:
txAcerto = modelo['TxAcerto']
if maiorTxAcerto < txAcerto:
id_alg_sel = modelo['id_alg']
maiorTxAcerto = txAcerto
tabPred = db.TabelaPredicao(0, idTabela, jsModeloDados, None, tam_tst,
strPesos, id_alg_sel)
tabPred = SalvarTabelaPredicao(tabPred)
SalvarTabelaPredicaoAlg(tabPred.id, listaModeloPred, lstPesos)
#modelo2, listaCopy2 = ut.PrepararListaComModelo(modeloDados, lista)
ExportarDados(idTabela)
return listaModeloPred
def LstColunas():
seg.ChecarPerfil(seg.PERFIL_Analista)
listaTabelas = imp.ListarTabelas()
campos = ({
'campo': 'id_coluna_cid',
'titulo': 'ID'
}, {
'campo': 'comando',
'titulo': 'Nome'
}, {
'campo': 'tipo',
'titulo': 'Tipo'
}, {
'campo': 'titulo',
'titulo': 'Titulo'
}, {
'campo': 'desabilitado',
'titulo': 'Desabilitado'
})
idTabela = request.params.get('id')
listaColunas = meta.ListarColunas(idTabela)
for col in listaColunas:
col.comando = '<a href="/defcoluna?id=' + str(
col.id) + '">' + col.nome + '</a>'
for tab in listaTabelas:
tab.selecionado = False
if idTabela == None:
idTabela = 0
else:
for tab in listaTabelas:
if int(tab.id) == int(idTabela):
tab.selecionado = True
grid = comp.grid('Lista de Colunas', listaColunas, campos,
'dados atualizados em 26/01/2018')
return dict(listaTabelas=listaTabelas, grid=grid)
def ListarRecomendacoes(idTabela):
session = db.getSession()
listaMensagens = session.query(
db.Mensagem).filter_by(id_tabela=idTabela).all()
listaRetorno = []
listaColunas = meta.ListarColunas(idTabela)
for msg in listaMensagens:
existeAluno = False
edtRow = {}
msgsAluno = []
for rowRet in listaRetorno:
if rowRet['id_usuario_aluno'] == msg.id_usuario_aluno:
existeAluno = True
edtRow = rowRet
msgsAluno = edtRow['MsgsAluno']
break
if existeAluno == False:
edtRow['id_usuario_aluno'] = msg.id_usuario_aluno
usuario = session.query(
db.Usuario).filter_by(id=msg.id_usuario_aluno).first()
edtRow['nome'] = usuario.nome
listaRetorno.append(edtRow)
msgsAluno.append(msg)
edtRow['MsgsAluno'] = msgsAluno
session.close()
tabPredicao = ObterTabelaPredicao(idTabela)
tx_acerto = 0
for alg in tabPredicao.Alg:
if alg.selecionado:
tx_acerto = alg.tx_acerto
return dict(tabela=imp.ObterTabela(idTabela),
tx_acerto=tx_acerto,
lista=listaRetorno)
def ExportarDados(id_tabela):
tabela = imp.ObterTabela(id_tabela)
#-- Rede Gazeta
#path = "C:/Users/bstoll/source/repos/LA-Intervencao/LA-Intervencao/arquivosUpld"
#-- pythonanywhere
path = "/home/bstoll/mysite/arquivosUpld"
#-- Casa
#path = "C:/Users/Bruno Stoll/source/repos/LA-Intervencao/LA-Intervencao"
pathFile = "{path}/{file}".format(path=path, file=tabela.nome + ".csv")
listaColunas = meta.ListarColunas(id_tabela)
ar_lst_cols = []
for col in listaColunas:
ar_lst_cols.append(col.id)
sql = dbTab.GerarSQL(id_tabela, 'O', ar_lst_cols)
df = dbTab.db.consultarSQLDataFrame(sql)
if os.path.isfile(pathFile):
os.remove(pathFile)
df.to_csv(pathFile, index=False)
def ExibirMatrizConfusao(idTabela, idModPredAlg):
modeloPredAlg = ObterModeloPredicaoAlg(idModPredAlg)
tabPred = ObterTabelaPredicao(idTabela)
tabela = imp.ObterTabela(idTabela)
colunaClasse, id_coluna = meta.ObterColunaClasse(idTabela)
modeloBanco = json.loads(tabPred.modelo)
valoresCls = modeloBanco[colunaClasse]
for valor in valoresCls:
print(valor)
matriz_confusao = json.loads(modeloPredAlg.matriz_confusao)
return dict(idTabela=idTabela,
tabela=tabela.nome,
colunaClasse=colunaClasse,
dt_processo=tabPred.dt_processo,
algoritmo=modeloPredAlg.nome,
valoresCls=valoresCls,
matriz_confusao=matriz_confusao)
def GerarVisao(id):
visao = vis.ObterVisao(id)
tabela = imp.ObterTabela(visao.id_tabela)
modelo = json.loads(visao.modelo)
tipo = visao.tipo
listaColunas = []
listaTodasColunas = []
listaColunasExibGrd = []
defColunasAgrp = {}
campoCateg = None
campoSerie = None
campoValor = None
filtroClasse = ''
colunaClasse = ''
for mod in modelo:
id_coluna = int(mod['id_coluna'])
listaColunas.append(id_coluna)
coluna = meta.ObterColuna(id_coluna)
nomeCampo = coluna.nome
if coluna.classe:
filtroClasse = 'O'
colunaClasse = coluna.nome
if mod['agrupador'] != '':
nomeCampo = mod['agrupador'] + '_' + coluna.nome
if mod['grafico'] == 'S':
campoSerie = coluna
elif mod['grafico'] == 'C':
campoCateg = coluna
elif mod['grafico'] == 'V':
if mod['agrupador'] != '':
campoValor = mod['agrupador'] + '_' + coluna.nome
else:
campoValor = coluna.nome
defColunasAgrp[id_coluna] = mod['agrupador']
listaTodasColunas.append(nomeCampo)
listaColunasExibGrd.append({
'campo': coluna.nome,
'titulo': coluna.titulo
})
sql = GerarSQL(visao.id_tabela, filtroClasse, listaColunas, True,
defColunasAgrp)
df = db.consultarSQLDataFrame(sql)
if filtroClasse == 'O':
valoresClasse = df[colunaClasse]
for index, row in df.iterrows():
df[colunaClasse][index] = str(row[colunaClasse]).replace(
'LA :: Prev :: ', '')
obj = comp.defGrafico('', '')
if tipo == '1': # Gráfico de Pizza
print('Gráfico de Pizza')
obj = comp.grfPizza(visao.nome, df, campoSerie.nome, campoValor, '')
elif tipo == '2': # Gráfico Barras
print('Gráfico Barras')
obj = comp.grfBarras(visao.nome, df, campoCateg.nome, campoSerie.nome,
campoValor)
elif tipo == '3': # Gráfico Linha
print('Gráfico Linha')
obj = comp.grfLinhas(visao.nome, df, campoCateg.nome, campoSerie.nome,
campoValor)
elif tipo == '4': # Informação em Cards
print('Informação em Cards')
obj = comp.infCard(visao.nome, list(df.T.to_dict().values()),
listaTodasColunas)
elif tipo == '5': # Informação em Grid
print('Informação em Grid')
obj = comp.compGrid(visao.nome, list(df.T.to_dict().values()),
listaColunasExibGrd)
return obj
def GerarSQL(idTabela,
filtroClasse='',
somenteColunas=[],
agrupar=False,
defColunasAgrp={},
filtroSql=''):
""" filtroClasse
S = sem classe = para TREINAR
O = somente classe = para PREVER
"""
tabela = imp.ObterTabela(idTabela)
listaColunas = meta.ListarColunas(idTabela)
listaExibicao = ListarExibicao(idTabela)
conta_tb = 0
sql_table = '[' + tabela.nome + ']'
if not (tabela.sql_destino == None or tabela.sql_destino == ''):
sql_table = '(' + tabela.sql_destino + ')'
sql_table = sql_table
sql = ''
sql_coluna = ' rowid'
sql_coluna_classe = ''
sql_inner_join = ''
sql_where = '\n WHERE 0=0 \n'
sql_group = ''
if agrupar == True:
sql_group = ''
for col in listaColunas:
if col.desabilitado == True:
existeSomenteCol = False
for idCol in somenteColunas:
if int(idCol) == col.id:
existeSomenteCol = True
if existeSomenteCol == False:
continue
if len(somenteColunas) != 0:
existeFiltroColuna = False
for idCol in somenteColunas:
if int(idCol) == int(col.id):
existeFiltroColuna = True
if existeFiltroColuna == False:
continue
sql_coluna_tmp = col.sql.replace(col.nome, 't0.' + col.nome)
sql_coluna_one = sql_coluna_tmp + ' AS ' + col.nome
if agrupar == True:
if defColunasAgrp[col.id] != '':
sql_coluna_one = defColunasAgrp[
col.id] + '(' + sql_coluna_tmp + ') AS ' + defColunasAgrp[
col.id] + '_' + col.nome
elif defColunasAgrp[col.id] == '':
if sql_group == '':
sql_group = ' GROUP BY ' + sql_coluna_tmp
else:
sql_group = sql_group + ',' + sql_coluna_tmp
if col.classe:
sql_coluna_classe = sql_coluna_one
if filtroClasse == 'S':
sql_where += ' AND ' + sql_coluna_tmp + ' IS NOT NULL \n'
sql_where += ' AND ' + sql_coluna_tmp + ' <> \'\' \n'
sql_where += ' AND ' + sql_coluna_tmp + ' <> \'?\' \n'
sql_where += ' AND ' + sql_coluna_tmp + ' NOT LIKE \'LA :: Prev%\' \n'
elif filtroClasse == 'O':
sql_where += ' AND (' + sql_coluna_tmp + ' IS NULL \n'
sql_where += ' OR ' + sql_coluna_tmp + ' = \'\' \n'
sql_where += ' OR ' + sql_coluna_tmp + ' = \'?\' \n'
sql_where += ' OR ' + sql_coluna_tmp + ' LIKE \'LA :: Prev%\' ) \n'
elif sql_coluna == '':
sql_coluna = ' ' + sql_coluna_one
else:
sql_coluna = sql_coluna + ', \n ' + sql_coluna_one
tabelasJoin = {}
for colExib in listaExibicao:
col = meta.ObterColuna(colExib.id_coluna)
col_fk = meta.ObterColuna(col.id_coluna_fk)
col_lookup = meta.ObterColuna(colExib.id_coluna_fk)
tabela_fk = imp.ObterTabela(colExib.id_tabela_fk)
if col_lookup.desabilitado == True:
continue
if len(somenteColunas) != 0:
existeFiltroColuna = False
for idCol in somenteColunas:
if int(idCol) == int(col_lookup.id):
existeFiltroColuna = True
if existeFiltroColuna == False:
continue
sql_table_join = tabela_fk.nome
if (tabela_fk.sql_destino != None):
sql_table_join = tabela_fk.sql_destino
prefixo = ''
tb_corrente = -1
if tabela_fk.nome in tabelasJoin:
tb_corrente = tabelasJoin[tabela_fk.nome]
prefixo = 't' + str(tb_corrente)
else:
conta_tb = conta_tb + 1
tb_corrente = conta_tb
prefixo = 't' + str(tb_corrente)
tabelasJoin[tabela_fk.nome] = conta_tb
tb_corrente = conta_tb
sql_inner_join = sql_inner_join + ' INNER JOIN ' + sql_table_join + ' AS ' + prefixo + ' ON t0.' + col.nome + ' = ' + prefixo + '.' + col_fk.nome
sql_coluna_tmp = col_lookup.sql.replace(
col.nome, prefixo + '.' + col_lookup.nome)
sql_coluna_one = sql_coluna_tmp + ' AS ' + col_lookup.nome
if agrup == True:
if sql_group == '':
sql_group = ' GROUP BY ' + sql_coluna_tmp
else:
sql_group = sql_group + ',' + sql_coluna_tmp
if col_lookup.classe:
sql_coluna_classe = sql_coluna_one
if filtroClasse == 'S':
sql_where += ' AND ' + sql_coluna_tmp + ' IS NOT NULL'
sql_where += ' AND ' + sql_coluna_tmp + ' <> \'\' '
sql_where += ' AND ' + sql_coluna_tmp + ' <> \'?\' '
sql_where += ' AND ' + sql_coluna_tmp + ' NOT LIKE \'LA :: Prev%\' '
elif filtroClasse == 'O':
sql_where += ' AND (' + sql_coluna_tmp + ' IS NULL'
sql_where += ' OR ' + sql_coluna_tmp + ' = \'\' '
sql_where += ' OR ' + sql_coluna_tmp + ' = \'?\' '
sql_where += ' OR ' + sql_coluna_tmp + ' LIKE \'LA :: Prev%\' )'
else:
sql_coluna = sql_coluna + ', ' + sql_coluna_one
if sql_coluna_classe != '':
sql_coluna = sql_coluna + ', ' + sql_coluna_classe
if filtroSql != '':
sql_where += '\n and ' + filtroSql
sql = 'SELECT \n' + sql_coluna + ' FROM \n' + sql_table + ' as t0 ' + sql_inner_join + sql_where + '\n' + sql_group
print('GerarSQL:')
print(sql)
return sql
def ExibirPesos(id_tabela):
tabela = imp.ObterTabela(id_tabela)
nome_coluna, id_coluna = meta.ObterColunaClasse(tabela.id)
coluna = meta.ObterColuna(id_coluna)
tabPredicao = ObterTabelaPredicao(id_tabela)
listaColunas = meta.ListarColunas(id_tabela)
pesos = json.loads(tabPredicao.pesos)
pesosOrdenado = sorted(pesos, key=itemgetter('Peso'), reverse=True)
scriptGrafico = ''
for peso in pesosOrdenado:
df = pd.DataFrame(peso['Valores'])
print(peso)
print(df)
maxFalha = df[df['Classe'] ==
coluna.val_aluno_risco]['_percValor'].max()
maxSucesso = df[
df['Classe'] != coluna.val_aluno_risco]['_percValor'].max()
df['destaca'] = ''
df[df['Classe'] == coluna.val_aluno_risco][df['_percValor'] ==
maxFalha]['destaca'] = 'F'
df[df['Classe'] != coluna.val_aluno_risco][df['_percValor'] ==
maxSucesso]['destaca'] = 'S'
for item in peso['Valores']:
item['destaca'] = ''
if item['Classe'] == coluna.val_aluno_risco and item[
'_percValor'] == maxFalha:
item['destaca'] = 'F'
if item['Classe'] != coluna.val_aluno_risco and item[
'_percValor'] == maxSucesso:
item['destaca'] = 'S'
#df[dfClsFalha['_percRelativo'] == df['_percValor']] ['destaca'] = 'R'
#df[dfClsSucesso['_percRelativo'] == df['_percValor']]['destaca'] = 'B'
dfClsFalha = df[df['Classe'] == coluna.val_aluno_risco]
dfClsSucesso = df[df['Classe'] != coluna.val_aluno_risco]
legendaPadrao = ' Registros com o campo "' + coluna.titulo + '"'
legendaFalha = legendaPadrao + ' igual a "' + coluna.val_aluno_risco + '"'
legendaSucesso = legendaPadrao + ' diferente de "' + coluna.val_aluno_risco + '"'
grfFalha = comp.grfPizza(legendaFalha, dfClsFalha, 'Valor', '_qtd', '')
grfSucesso = comp.grfPizza(legendaSucesso, dfClsSucesso, 'Valor',
'_qtd', '')
scriptGrafico += grfFalha.js
scriptGrafico += grfSucesso.js
peso['grfFalha'] = grfFalha.grf
peso['grfSucesso'] = grfSucesso.grf
campo = ObterColunaPorNomeLista(listaColunas, peso['Campo'])
peso['Campo'] = campo.titulo
return dict(id_tabela=tabela.id,
nome=tabela.nome,
pesos=pesosOrdenado,
scriptGrafico=scriptGrafico)
def DiscretizarCampo(idColuna, nome, expressao):
colunaDiscr = meta.ObterColuna(idColuna)
colunaDiscr.sql = expressao
meta.SalvarColuna(colunaDiscr)
def GerarRecomendacoes(id_tabela):
print(
'==============================================================================================='
)
print('Gerar recomendações')
tabela = imp.ObterTabela(id_tabela)
nome_coluna, id_coluna = meta.ObterColunaClasse(tabela.id)
coluna = meta.ObterColuna(id_coluna)
tabPredicao = ObterTabelaPredicao(id_tabela)
tx_acerto = 0
for alg in tabPredicao.Alg:
if alg.selecionado:
tx_acerto = alg.tx_acerto
pesos = json.loads(tabPredicao.pesos)
pesosOrdenado = sorted(pesos, key=itemgetter('Peso'), reverse=True)
dfSoAlunosRisco = SoAlunosEmRisco(id_tabela, nome_coluna, coluna)
msgs = []
for index, row in dfSoAlunosRisco.iterrows():
i_conta_recomendacoes = 0
for peso in pesosOrdenado:
campo = peso['Campo']
print(
'==============================================================================================='
)
print('Campo: ' + campo)
print('Peso: ' + str(peso['Peso']))
print(peso)
dfValorePesos = pd.DataFrame(peso['Valores'])
print(dfValorePesos)
dfClsFalha = dfValorePesos[dfValorePesos['Classe'] ==
coluna.val_aluno_risco]
dfClsSucesso = dfValorePesos[
dfValorePesos['Classe'] != coluna.val_aluno_risco]
print('')
print('dfClsFalha')
print(dfClsFalha)
print('')
print('dfClsSucesso')
print(dfClsSucesso)
valorCol = row[campo]
rowFalha = dict(
next(
dfClsFalha[dfClsFalha['Valor'] == valorCol].iterrows())[1])
rowSucesso = dict(
next(dfClsSucesso[dfClsSucesso['Valor'] ==
valorCol].iterrows())[1])
qtdReg = len(dfClsFalha['Valor'])
falhaPerc = rowFalha['_perc']
falhaPercRel = rowFalha['_percRelativo']
sucesPerc = rowSucesso['_perc']
sucesPercRel = rowSucesso['_percRelativo']
valorPercSucessoMax = valorCol
percSucessoMax = dfClsSucesso[
dfClsSucesso['Valor'] != valorCol]['_percValor'].max()
auxDfvalorPercSucesso = dfClsSucesso[
dfClsSucesso['_percValor'] == percSucessoMax]['Valor'].values
if len(auxDfvalorPercSucesso) > 0:
valorPercSucessoMax = auxDfvalorPercSucesso[0]
if (falhaPercRel > sucesPercRel
or falhaPerc > 25) and valorCol != valorPercSucessoMax:
msg = dict()
msg['Aluno'] = row['rowid']
msg['Campo'] = campo
msg['ValAtual'] = valorCol
msg['ValSuger'] = valorPercSucessoMax
msgs.append(msg)
i_conta_recomendacoes += 1
if i_conta_recomendacoes == 5:
break
SalvarMensagens(tabela, msgs)
return dfSoAlunosRisco
def GerarSqlQuartil(tabela, coluna, tp):
tpDisc = ''
if tp == 'E':
tpDisc = 'DISTINCT'
sqlTexto = """
SELECT *,
CASE WHEN coluna <= Q1 THEN 'Q1'
WHEN coluna <= Q2 THEN 'Q2'
WHEN coluna <= Q3 THEN 'Q3'
ELSE 'Q4'
END AS QUARTIL
FROM (
SELECT *,
(SELECT COUNT(*) FROM (SELECT {{tpQuartil}} {{coluna}} FROM {{tabela}})) AS QTD,
(SELECT {{tpQuartil}} {{coluna}} FROM {{tabela}} ORDER BY 1 LIMIT (((SELECT COUNT(*) FROM (SELECT {{tpQuartil}} {{coluna}} FROM {{tabela}})) / 4) * 1), 1) Q1,
(SELECT {{tpQuartil}} {{coluna}} FROM {{tabela}} ORDER BY 1 LIMIT (((SELECT COUNT(*) FROM (SELECT {{tpQuartil}} {{coluna}} FROM {{tabela}})) / 4) * 2), 1) Q2,
(SELECT {{tpQuartil}} {{coluna}} FROM {{tabela}} ORDER BY 1 LIMIT (((SELECT COUNT(*) FROM (SELECT {{tpQuartil}} {{coluna}} FROM {{tabela}})) / 4) * 3), 1) Q3
FROM (
SELECT {{tpQuartil}} {{coluna}} AS coluna
FROM {{tabela}}) AS T
ORDER BY 1
) AS T
LIMIT 1"""
sqlNumero = """
SELECT *,
CASE WHEN coluna <= Q1 THEN 'Q1'
WHEN coluna <= Q2 THEN 'Q2'
WHEN coluna <= Q3 THEN 'Q3'
ELSE 'Q4'
END AS QUARTIL
FROM (
SELECT *,
(SELECT COUNT(*) FROM (SELECT {{tpQuartil}} {{coluna}} FROM {{tabela}})) AS QTD,
(SELECT {{tpQuartil}} CAST({{coluna}} AS FLOAT) FROM {{tabela}} ORDER BY 1 LIMIT (((SELECT COUNT(*) FROM (SELECT {{tpQuartil}} {{coluna}} FROM {{tabela}})) / 4) * 1), 1) Q1,
(SELECT {{tpQuartil}} CAST({{coluna}} AS FLOAT) FROM {{tabela}} ORDER BY 1 LIMIT (((SELECT COUNT(*) FROM (SELECT {{tpQuartil}} {{coluna}} FROM {{tabela}})) / 4) * 2), 1) Q2,
(SELECT {{tpQuartil}} CAST({{coluna}} AS FLOAT) FROM {{tabela}} ORDER BY 1 LIMIT (((SELECT COUNT(*) FROM (SELECT {{tpQuartil}} {{coluna}} FROM {{tabela}})) / 4) * 3), 1) Q3
FROM (
SELECT {{tpQuartil}} CAST({{coluna}} AS FLOAT) AS coluna
FROM {{tabela}}) AS T
ORDER BY 1
) AS T
LIMIT 1"""
objTabela = imp.ObterTabelaPorNome(tabela)
objColuna = meta.ObterColunaPorTabNome(objTabela.id, coluna)
if objColuna.tipo == 'N':
sql = sqlNumero.replace('{{tabela}}', tabela).replace(
'{{coluna}}', coluna).replace('{{tpQuartil}}', tpDisc)
else:
sql = sqlTexto.replace('{{tabela}}', tabela).replace(
'{{coluna}}', coluna).replace('{{tpQuartil}}', tpDisc)
resultado = db.consultarSQLDataFrame(sql)
if objColuna.tipo == 'N':
sqlResultado = 'CASE WHEN CAST(' + str(coluna) + ' AS FLOAT) <= ' + str(
resultado['Q1'][0]
) + ' THEN \'Q1\' WHEN CAST(' + str(coluna) + ' AS FLOAT) <= ' + str(
resultado['Q2'][0]) + ' THEN \'Q2\' WHEN CAST(' + str(
coluna) + ' AS FLOAT) <= ' + str(
resultado['Q3'][0]) + ' THEN \'Q3\' ELSE \'Q4\' END'
else:
sqlResultado = 'CASE WHEN ' + str(coluna) + ' <= ' + str(
resultado['Q1']
[0]) + ' THEN \'Q1\' WHEN ' + str(coluna) + ' <= ' + str(
resultado['Q2'][0]) + ' THEN \'Q2\' WHEN ' + str(
coluna) + ' <= ' + str(
resultado['Q3'][0]) + ' THEN \'Q3\' ELSE \'Q4\' END'
return sqlResultado
def explorar_dados():
seg.ChecarPerfil(seg.PERFIL_Analista)
idTabela = request.params.get('id')
idColunas = request.params.get('idColunas')
tipo = request.params.get('tipo')
listaTabelas = imp.ListarTabelas()
listaColunas = []
grid = ''
if tipo == None:
tipo = 'D'
if idTabela == None:
idTabela = 0
idColunas = ''
tipo = 'D'
else:
for col in meta.ListarColunas(idTabela):
listaColunas.append(col)
listaExibicao = dbTab.ListarExibicao(idTabela)
for colExib in listaExibicao:
col_lookup = meta.ObterColuna(colExib.id_coluna_fk)
listaColunas.append(col_lookup)
for col in listaColunas:
col.selecionado = False
if idColunas == None or idColunas == '':
idColunas = ''
else:
splColunas = idColunas.split(',')
for col in listaColunas:
for idCol in splColunas:
if int(idCol) == int(col.id):
col.selecionado = True
if len(splColunas) != 0:
campos = meta.ListarCampos(idTabela, False, splColunas)
if tipo == 'D':
resultado = dbTab.ListarDados(idTabela, splColunas)
grid = comp.grid('Registros', resultado, campos, '')
elif tipo == 'I':
resultado = dbTab.InformDados(idTabela, splColunas)
#grid = comp.grid('Registros', resultado, campos, '')
for tab in listaTabelas:
tab.selecionado = False
if int(tab.id) == int(idTabela):
tab.selecionado = True
return dict(idTabela=idTabela,
idColunas=idColunas,
tipo=tipo,
listaTabelas=listaTabelas,
listaColunas=listaColunas,
grid=grid)
def PainelDinamicoPln(expressao):
expressao, d_filtro = Parametros(expressao)
nlp = spacy.load('pt') # pt_core_news_sm
doc = nlp(expressao)
sents = [sent for sent in doc.sents]
#tokenCalculoMedidas = [token for token in nlp('soma,média,mínimo,máximo') if token.is_punct == False]
id_tabela = 53 # parte fixa no código
listaObjColunas = [coluna for coluna in meta.ListarColunas(id_tabela) if coluna.sinonimos != '']
html = ''
js = ''
conta=0
tokenFiltro = [token for token in nlp('onde')][0]
for sent in sents:
print(str(sent))
existeFiltro = False
sentencaTotal = str(sent)
sentencaBase = str(sent)
sentencaFiltro = ''
for token in sent:
d_similaridade = tokenFiltro.similarity(token)
print(str(token), d_similaridade)
if tokenFiltro.similarity(token) > 0.9:
sentencaFiltro = sentencaTotal[sentencaTotal.find(str(token)):]
sentencaBase = sentencaTotal[:sentencaTotal.find(str(token))-1]
print('existe filtro!')
print('sentenca base:', sentencaBase)
print('sentenca filtro:', sentencaFiltro)
existeFiltro = True
break
sentFiltro = None
if existeFiltro:
sent = nlp(sentencaBase)
sentFiltro = nlp(sentencaFiltro)
conta+= 1
caminho = "/static/images/sentence" + str(conta) + ".svg"
if not existeFiltro:
svg = displacy.render(sent, style="dep")
output_path = Path("." + caminho)
output_path.open("w", encoding="utf-8").write(svg)
html += '<div class="row"><div class="col-lg-5"><img src="' + caminho + '" style="max-width: 120%" /></div>'
else:
svg = displacy.render(sent, style="dep")
output_path = Path("." + caminho)
output_path.open("w", encoding="utf-8").write(svg)
caminhoFiltro = "/static/images/sentence" + str(conta) + "_filtro.svg"
svg = displacy.render(sentFiltro, style="dep")
output_path = Path("." + caminhoFiltro)
output_path.open("w", encoding="utf-8").write(svg)
html += '<div class="row"><div class="col-lg-5"><img src="' + caminho + '" style="max-width: 100%" /><br><img src="' + caminhoFiltro + '" style="max-width: 100%" /></div>'
tokens = [token for token in sent if not token.is_punct]
colunasMedidas, colunasDimensoes = ProcessarSentenca(nlp, tokens, listaObjColunas)
filtro = ' (final_result = \'\' or final_result LIKE \'LA :: Prev%\' )'
if existeFiltro:
tokensFiltros = [token for token in sentFiltro if not token.is_punct]
filtro_medidas, filtro_dimensoes = ProcessarSentenca(nlp, tokensFiltros, listaObjColunas, tokenFiltro)
print('filtro_ColMedida', filtro_medidas)
print('filtro_ColDimensoes', filtro_dimensoes)
conta=0
for col in filtro_dimensoes:
conta+= 1
nomeParam = 'param' + str(conta)
aux_filtro = col.nome+'= \'' + d_filtro[nomeParam] + '\''
if filtro != '':
filtro += ' and ' + aux_filtro
else:
filtro = aux_filtro
df = None
if len(colunasMedidas) == 0:
df = GerarDfVisaoPln(id_tabela, listaObjColunas, [], filtro)
else:
df = GerarDfVisaoPln(id_tabela, colunasDimensoes, colunasMedidas, filtro)
obj = GerarVisao(str(sent), df, colunasDimensoes, colunasMedidas)
if obj != None:
html += '<div class="col-lg-7">' + obj.grf + '</div>'
js += obj.js
html+= "</div>"
return html, js