callbacks.py

import dash
import pandas as pd
from dash import Input, Output, State
from dash.dependencies import Input, Output, State
from dash.exceptions import PreventUpdate

from utils import parse_contents_graph, parse_contents_instance, parse_contents_data


def register_callbacks(page_home, page_course, page_application, app):
    page_list = ['home', 'course', 'application']

    @app.callback(
        Output('page-content', 'children'),
        Input('url', 'pathname'))
    def display_page(pathname):
        if pathname == '/':
            return page_home
        if pathname == '/application':
            return page_application.view.layout        
        if pathname == '/course':
            return page_course

    @app.callback(Output('home-link', 'active'),
                Output('course-link', 'active'),
                Output('application-link', 'active'),
                Input('url', 'pathname'))
    def navbar_state(pathname):
        active_link = ([pathname == f'/{i}' for i in page_list])
        return active_link[0], active_link[1], active_link[2]

    @app.callback(
        Output('pretrained_model_filename', 'children'),
        Output('instance_filename', 'children'),
        Output('graph', 'children'),
        Output('explanation', 'children'),
        Input('ml_model_choice', 'value'),
        Input('ml_pretrained_model_choice', 'contents'),
        State('ml_pretrained_model_choice', 'filename'),
        Input('model_dataset_choice', 'contents'),
        State('model_dataset_choice', 'filename'),
        Input('ml_instance_choice', 'contents'),
        State('ml_instance_choice', 'filename'),
        Input('number_explanations', 'value'),
        Input('explanation_type', 'value'),
        Input('solver_sat', 'value'),
        Input('expl_choice', 'value'),
        prevent_initial_call=True
    )
    def update_ml_type(value_ml_model, pretrained_model_contents, pretrained_model_filename, model_dataset, model_dataset_filename, instance_contents, instance_filename, enum, xtype, solver, expl_choice):
        ctx = dash.callback_context
        if ctx.triggered:
            ihm_id = ctx.triggered[0]['prop_id'].split('.')[0]
            model_application = page_application.model
            if ihm_id == 'ml_model_choice' :
                    model_application.update_ml_model(value_ml_model)
                    return None, None, None, None

            elif ihm_id == 'ml_pretrained_model_choice':
                if model_application.ml_model is None :
                    raise PreventUpdate
                graph = parse_contents_graph(pretrained_model_contents, pretrained_model_filename)
                model_application.update_pretrained_model(graph)
                return pretrained_model_filename, None, None, None

            elif ihm_id == 'model_dataset_choice':
                if model_application.ml_model is None :
                    raise PreventUpdate
                model_dataset = parse_contents_data(model_dataset, model_dataset_filename)
                model_application.update_pretrained_model_dataset(model_dataset)
                return pretrained_model_filename, None, model_application.component.network, None

            elif ihm_id == 'ml_instance_choice' :
                if model_application.ml_model is None or model_application.pretrained_model is None :
                    raise PreventUpdate
                instance = parse_contents_instance(instance_contents, instance_filename)
                model_application.update_instance(instance, enum, xtype)
                return pretrained_model_filename, instance_filename, model_application.component.network, model_application.component.explanation   

            elif ihm_id == 'number_explanations' :
                if model_application.ml_model is None or model_application.pretrained_model is None or model_application.instance is None:
                    raise PreventUpdate
                instance = parse_contents_instance(model_application.instance, instance_filename)
                model_application.update_instance(instance, enum, xtype)
                return pretrained_model_filename, instance_filename, model_application.component.network, model_application.component.explanation   

            elif ihm_id == 'explanation_type' :
                if model_application.ml_model is None or model_application.pretrained_model is None or model_application.instance is None:
                    raise PreventUpdate
                instance = parse_contents_instance(model_application.instance, instance_filename)
                model_application.update_instance(instance, enum, xtype)
                return pretrained_model_filename, instance_filename, model_application.component.network, model_application.component.explanation
            
            elif ihm_id == 'solver_sat' :
                if model_application.ml_model is None or model_application.pretrained_model is None or model_application.instance is None:
                    raise PreventUpdate
                instance = parse_contents_instance(model_application.instance, instance_filename)
                model_application.update_instance(instance, enum, xtype, solver=solver)
                return pretrained_model_filename, instance_filename, model_application.component.network, model_application.component.explanation             
            
            elif ihm_id == 'expl_choice' :
                if instance_contents is None :
                    raise PreventUpdate
                model_application.update_expl(expl_choice)
                return pretrained_model_filename, instance_filename, model_application.component.network, model_application.component.explanation             


    @app.callback(
        Output('explanation', 'hidden'),
        Output('navigate_label', 'hidden'),    
        Output('navigate_dropdown', 'hidden'),
        Output('expl_choice', 'options'),
        Input('explanation', 'children'),
        Input('explanation_type', 'value'),
        prevent_initial_call=True
    )
    def layout_buttons_navigate_expls(explanation, explanation_type):
        if explanation is None or len(explanation_type)==0:
            return True, True, True, {}
        elif "AXp" not in explanation_type and "CXp" in explanation_type:
            return False, True, True, {}
        else : 
            options = {}
            model_application = page_application.model
            for i in range (len(model_application.list_expls)):
                options[str(model_application.list_expls[i])] = model_application.list_expls[i]
            return False, False, False, options