repytex/notes_tools/tools/evaluation.py

#!/usr/bin/env python
# encoding: utf-8

import pandas as pd
import numpy as np
from notes_tools.tools.marks_plottings import (pie_pivot_table,
        parallel_on,
        radar_on,
        )

import seaborn as sns

class Student(object):

    """ 
    Informations on a student which can be use inside template.
    
    Those informations should not be modify or use for compute analysis otherwise they won't be spread over other POV.
    """

    def __init__(self, quest_df, exo_df, eval_df):
        """ 
        Description of a student from quest, exo and eval

        """

        name = {*quest_df["Eleve"].unique(),
                *exo_df["Eleve"].unique(),
                *eval_df["Eleve"].unique(),
                }

        if len(name) != 1:
            raise ValueError("Can't initiate Student: dfs contains different student names")

        self.name = name.pop()

        evalname = {*quest_df["Nom"].unique(),
                *exo_df["Nom"].unique(),
                *eval_df["Nom"].unique(),
                }

        if len(evalname) != 1:
            raise ValueError(f"Can't initiate Student: dfs contains different evaluation names ({'-'.join(evalname)})")

        self.quest_df = quest_df
        self.exo_df = exo_df
        self.eval = eval_df.to_dict('records')[0]

    @property
    def latex_exo_tabulars(self):
        """ Return list of latex tabulars. One by exercise of the evaluation """
        try:
            self._latex_exo_tabulars
        except AttributeError:
            self._latex_exo_tabulars = self.build_latex_exo_tabulars()
        return self._latex_exo_tabulars

    def build_latex_exo_tabulars(self):
        tabulars = []
        for t in self.exo_df["Exercice"]:
            tabulars.append(self.build_latex_exo_tabular(t))

        return tabulars

    def build_latex_exo_tabular(self, exo_name):
        exo = self.exo_df[self.exo_df["Exercice"] == exo_name]
        quest = self.quest_df[self.quest_df["Exercice"] == exo_name]

        tabular = [r"\begin{tabular}{|p{2cm}|p{1cm}|}"]
        tabular.append(r"\hline")
        tabular.append(r"\rowcolor{highlightbg}")

        if type(exo_name) == int:
            l = f"Exercice {exo_name} & {exo['Mark_barem'].all()}"
            tabular.append(l + r" \\")
        else:
            l = f"{exo_name} & {exo['Mark_barem'].all()}"
            tabular.append(l + r" \\")
        tabular.append(r"\hline")

        if len(quest) > 1:
            for _, q in quest.iterrows():
                line = ""
                if not pd.isnull(q["Question"]):
                    line += " "+str(q['Question'])
                if not pd.isnull(q["Commentaire"]):
                    line += " "+str(q['Commentaire'])

                line += " & "
                if q["Niveau"] == 1:
                    line += q['Latex_rep']
                else:
                    line += str(q['Mark'])
                line += r" \\"
                tabular.append(line)
                tabular.append(r"\hline")

        tabular.append(r"\end{tabular}")
        return '\n'.join(tabular)

    @property
    def pies_on_competence(self):
        """ Pies chart on competences """
        try:
            self._pies_on_competence
        except AttributeError:
            self._pies_on_competence = pie_pivot_table(self.quest_df,
                    index = "Level",
                    columns = "Competence",
                    values = "Eleve",
                    aggfunc = len,
                    fill_value = 0,
                    )
        return self._pies_on_competence

    @property
    def pies_on_domaine(self):
        """ Pies chart on domaines """
        try:
            self._pies_on_domaine
        except AttributeError:
            self._pies_on_domaine = pie_pivot_table(self.quest_df,
                    index = "Level",
                    columns = "Domaine",
                    values = "Eleve",
                    aggfunc = len,
                    fill_value = 0,
                    )
        return self._pies_on_domaine

    @property
    def radar_on_competence(self):
        """ Radar plot on competence """
        try:
            self._radar_on_competence
        except AttributeError:
            self._radar_on_competence = radar_on(self.quest_df,
                    "Competence")
        return self._radar_on_competence

    @property
    def radar_on_domaine(self):
        """ Radar plot on domaine """
        try:
            self._radar_on_domaine
        except AttributeError:
            self._radar_on_domaine = radar_on(self.quest_df,
                    "Domaine")
        return self._radar_on_domaine

    @property
    def heatmap_on_domain(self):
        """ Heatmap over evals on domains """
        try:
            self._heatmap_on_domain
        except AttributeError:
            comp = pd.pivot_table(self.quest_df,
                    index = "Competence",
                    columns = ["Exercice", "Question"],
                    values = ["Normalized"],
                    aggfunc = np.mean,
                    )
            comp.columns = [f"{i['Exercice']} {i['Question']}" for _,i in self.quest_df[["Exercice", "Question"]].drop_duplicates().iterrows()]
            self._heatmap_on_domain = sns.heatmap(comp)
        return self._heatmap_on_domain

class Classe(object):

    """ 
    Informations on a class which can be use inside template.
    
    Those informations should not be modify or use for compute analysis otherwise they won't be spread over other POV.
    """
    def __init__(self, quest_df, exo_df, eval_df):
        """ Init of a class from quest, exo and eval """
        names = {*quest_df["Nom"].unique(),
                *exo_df["Nom"].unique(),
                *eval_df["Nom"].unique(),
                }

        if len(names) != 1:
            raise ValueError("Can't initiate Classe: dfs contains different evaluation names")

        self.name = names.pop()

        self.quest_df = quest_df
        self.exo_df = exo_df
        self.eval_df = eval_df

    @property
    def marks_tabular(self):
        """ Latex tabular with marks of students"""
        try:
            self._marks_tabular
        except AttributeError:
            self._marks_tabular = self.eval_df[["Eleve", "Mark_barem"]]
            self._marks_tabular.columns = ["Élèves", "Note"]
        return self._marks_tabular.to_latex()

    @property
    def level_heatmap(self):
        """ Heapmap on acheivement level """
        try:
            self._level_heatmap
        except AttributeError:
            pv = pd.pivot_table(self.quest_df,
                    index = "Eleve",
                    columns = ["Exercice", "Question", "Commentaire"],
                    values = ["Normalized"],
                    aggfunc = "mean",
                    )

            def lines_4_heatmap(c):
                lines = []
                ini = ''
                for k,v in enumerate(c.labels[1][::-1]):
                    if v != ini:
                        lines.append(k)
                        ini = v
                return lines[1:]
            exercice_sep = lines_4_heatmap(pv.columns)

            pv.columns = [f"{i[1]} {i[2]} {i[3]:.15}" for i in pv.columns.get_values()]
            
            self._level_heatmap = sns.heatmap(pv.T)

            self._level_heatmap.hlines(exercice_sep, 
                    *self._level_heatmap.get_xlim(),
                    colors = "orange",
                    )

        return self._level_heatmap


    

# TODO: à factoriser Il y a la même dans term.py |jeu. mars 23 19:36:28 EAT 2017
def select(quest_df, exo_df, eval_df, index, value):
    """ Return quest, exo and eval rows which correspond index == value

    :param quest_df: TODO
    :param exo_df: TODO
    :param eval_df: TODO

    """
    qu = quest_df[quest_df[index] == value]
    exo = exo_df[exo_df[index] == value]
    ev = eval_df[eval_df[index] == value]
    return qu, exo, ev

def select_contains(quest_df, exo_df, eval_df, index, name_part):
    """ Return quest, exo and eval rows which contains name_part

    :param quest_df: TODO
    :param exo_df: TODO
    :param eval_df: TODO

    """
    qu = quest_df[quest_df[index].str.contains(name_part)]
    exo = exo_df[exo_df[index].str.contains(name_part)]
    ev = eval_df[eval_df[index].str.contains(name_part)]
    return qu, exo, ev

def students_pov(quest_df, exo_df, eval_df):
    es = []
    for e in eval_df["Eleve"].unique():
        d = select(quest_df, exo_df, eval_df, "Eleve", e)
        eleve = Student(*d)
        es.append(eleve)
    return es

def class_pov(quest_df, exo_df, eval_df):
    return Classe(quest_df, exo_df, eval_df)



# -----------------------------
# Reglages pour 'vim'
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
# cursor: 16 del