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
Exemplo n.º 2
0
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 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
Exemplo n.º 4
0
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
Exemplo n.º 5
0
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)
Exemplo n.º 6
0
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 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 DiscretizarCampo(idColuna, nome, expressao):
    colunaDiscr = meta.ObterColuna(idColuna)
    colunaDiscr.sql = expressao

    meta.SalvarColuna(colunaDiscr)
Exemplo n.º 9
0
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
Exemplo n.º 10
0
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)
Exemplo n.º 11
0
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
Exemplo n.º 12
0
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