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 do_transformacao():
seg.ChecarPerfil(seg.PERFIL_Analista)
nome = getattr(request.forms, 'nome')
sql = getattr(request.forms, 'sql')
persistir = getattr(request.forms, 'pers')
descricao = 'Gerado pela transformacao'
nome = '__' + nome
tabela = imp.ObterTabela('0')
tabela.nome = nome
tabela.descricao = descricao
tabela.sql_origem = sql
tabela.id_fonte_dados = fonte_dados_transformacao
if persistir == 'N':
tabela.sql_destino = sql
else:
tabela.sql_destino = None
imp.SalvarTabela(tabela)
if persistir == 'S':
imp.CriarTabelaDoSql(sql, nome)
imp.CriarIndices(nome)
imp.GerarColunas(nome)
else:
imp.GerarColunasComSQL(nome, sql)
tabela = imp.ObterTabelaPorNome(nome)
redirect('/colunas?id=' + str(tabela.id))
def mineracao_dados_cluster():
seg.ChecarPerfil(seg.PERFIL_Analista)
idTabela = request.params.get('idTabela')
id = request.params.get('id')
tabela = imp.ObterTabela(idTabela)
tabDesc = dm.ObterTabelaDescr(id)
#objModelo = {
# 'n_clusters': qtd_clusters,
# 'modeloDados': modeloDados,
# 'clusters': clusters.tolist(),
# 'labels' : labels.tolist()
# }
modelo = json.loads(tabDesc.modelo)
n_clusters = modelo['n_clusters']
modeloDados = modelo['modeloDados']
clusters = modelo['clusters']
labels = modelo['labels']
display = modelo['display']
lista = []
for itemCluster in clusters:
valores2 = []
for valor in itemCluster:
valores2.append(int(round(valor, 3)))
lista.append(valores2)
grf = comp.grfBolha('Clusters', lista, labels, '')
return dict(tabela=tabela, display=display, htmlGrf=grf.grf, jsGrf=grf.js)
def Association(idTabela, filtro, qtd_regras):
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.consultarSQL(sql)
regras = desc.Association(lista, int(qtd_regras))
dp_regras = json.dumps(regras)
session = db.getSession()
tabDesc = session.query(db.TabelaDescricao).filter_by(
id_tabela=idTabela).filter_by(id_alg=id_alg_rule_association).first()
if tabDesc == None:
tabDesc = db.TabelaDescricao(None, idTabela, id_alg_rule_association,
dp_regras, datetime.now())
session.add(tabDesc)
else:
tabDesc.modelo = dp_regras
tabDesc.dt_processo = datetime.now()
session.commit()
session.close()
return tabDesc
def ObterTotalRegistros(idTabela):
tabela = imp.ObterTabela(idTabela)
sql_table = tabela.nome
if not (tabela.sql_destino == None or tabela.sql_destino == ''):
sql_table = tabela.sql_destino
sql = 'SELECT COUNT(*) AS qtd FROM ' + sql_table
resultado = db.consultarSQL(sql)
return resultado[0]['qtd']
def edtTabela():
seg.ChecarPerfil(seg.PERFIL_Analista)
id = request.params.get('id')
tabela = imp.ObterTabela(id)
if tabela.descricao == None:
tabela.descricao = ''
if tabela.sql_destino == None:
tabela.sql_destino = ''
return dict(tabela=tabela)
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 mineracao_dados_rule_assoc():
seg.ChecarPerfil(seg.PERFIL_Analista)
idTabela = request.params.get('idTabela')
id = request.params.get('id')
tabela = imp.ObterTabela(idTabela)
tabDesc = dm.ObterTabelaDescr(id)
regras = json.loads(tabDesc.modelo)
regrasOrdenadas = sorted(regras, key=itemgetter('lift'), reverse=True)
objTree = comp.treeView(regrasOrdenadas, 'campos', 'lift', 'Regras')
return dict(tabela=tabela, treeView=objTree.grf, jsTree=objTree.js)
def mineracao_dados_outlier():
seg.ChecarPerfil(seg.PERFIL_Analista)
idTabela = request.params.get('idTabela')
id = request.params.get('id')
tabela = imp.ObterTabela(idTabela)
tabDesc = dm.ObterTabelaDescr(id)
modelo = json.loads(tabDesc.modelo)
grfOutlier = comp.grfOutliers(modelo['lista'], modelo['campoD'],
modelo['campoV'])
return dict(tabela=tabela, htmlGrf=grfOutlier.grf, jsGrf=grfOutlier.js)
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 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 Cluster(idTabela, filtro, qtd_clusters):
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)
modeloDados, listaCopy = ut.PrepararLista(lista)
kmeans = desc.Cluster(listaCopy, int(qtd_clusters))
clusters = kmeans.cluster_centers_
labels = kmeans.labels_
display = list()
for x in range(0, int(qtd_clusters)):
display.append('Cluster_' + str(x))
objModelo = {
'n_clusters': qtd_clusters,
'modeloDados': modeloDados,
'clusters': clusters.tolist(),
'labels': labels.tolist(),
'display': display
}
md_clusters = json.dumps(objModelo)
session = db.getSession()
tabDesc = session.query(db.TabelaDescricao).filter_by(
id_tabela=idTabela).filter_by(id_alg=id_alg_clusters).first()
if tabDesc == None:
tabDesc = db.TabelaDescricao(None, idTabela, id_alg_clusters,
md_clusters, datetime.now())
session.add(tabDesc)
else:
tabDesc.modelo = md_clusters
tabDesc.dt_processo = datetime.now()
session.commit()
session.close()
return None
def do_tabela_def():
id = getattr(request.forms, 'id')
descricao = getattr(request.forms, 'descricao')
sql_destino = getattr(request.forms, 'sql_destino')
sql_sem_hist = getattr(request.forms, 'sql_sem_hist')
pln = getattr(request.forms, 'pln')
tabela = imp.ObterTabela(id)
tabela.descricao = descricao
tabela.sql_destino = sql_destino
tabela.sql_sem_hist = sql_sem_hist
tabela.pln = "s" if pln == 'on' else "n"
imp.SalvarTabela(tabela)
redirect('/importacao')
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 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 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 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 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 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 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 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