xplia 1.0.1__py3-none-any.whl

xplia/visualizations/line_chart.py

@@ -0,0 +1,100 @@
+"""
+Implémentation des graphiques en ligne pour XPLIA
+"""
+
+def create_line_chart(data, config, library="plotly", **kwargs):
+    """
+    Crée un graphique en ligne avec la bibliothèque spécifiée.
+    
+    Args:
+        data: Données pour le graphique (dict, DataFrame, etc.)
+        config: Configuration du graphique
+        library: Bibliothèque à utiliser
+        **kwargs: Arguments spécifiques au type de graphique
+        
+    Returns:
+        Objet graphique selon la bibliothèque utilisée
+    """
+    if library == "plotly":
+        return _create_plotly_line_chart(data, config, **kwargs)
+    elif library == "matplotlib":
+        return _create_mpl_line_chart(data, config, **kwargs)
+    elif library == "bokeh":
+        return _create_bokeh_line_chart(data, config, **kwargs)
+    else:
+        raise ValueError(f"Bibliothèque {library} non supportée pour les graphiques en ligne")
+
+# Implémentations spécifiques
+def _create_plotly_line_chart(data, config, **kwargs):
+    """Implémentation Plotly des graphiques en ligne"""
+    import plotly.graph_objects as go
+    
+    # Extraction des paramètres
+    title = config.get('title', '')
+    x_label = config.get('x_label', '')
+    y_label = config.get('y_label', '')
+    width = config.get('width', 800)
+    height = config.get('height', 500)
+    
+    # Normalisation des données d'entrée
+    if isinstance(data, dict):
+        # Format {x: [...], y: [...], series: [...]}
+        x_data = data.get('x', [])
+        series = data.get('series', [{'name': '', 'y': data.get('y', [])}])
+    else:
+        # Format [[x], [y1], [y2], ...]
+        x_data = data[0]
+        series = [{'name': f'Série {i}', 'y': data[i]} for i in range(1, len(data))]
+    
+    # Création du graphique
+    fig = go.Figure()
+    
+    # Ajout de chaque série
+    for i, serie in enumerate(series):
+        color = kwargs.get('colors', config.get('color_palette', []))[i % len(config.get('color_palette', ['#1f77b4']))]
+        
+        fig.add_trace(go.Scatter(
+            x=x_data,
+            y=serie.get('y', []),
+            mode=kwargs.get('mode', 'lines+markers'),
+            name=serie.get('name', f'Série {i}'),
+            line=dict(
+                color=color,
+                width=kwargs.get('line_width', 2),
+                dash=kwargs.get('dash', None)
+            ),
+            marker=dict(
+                size=kwargs.get('marker_size', 6),
+                symbol=kwargs.get('marker_symbol', 'circle')
+            )
+        ))
+    
+    # Configuration du layout
+    fig.update_layout(
+        title=title,
+        xaxis_title=x_label,
+        yaxis_title=y_label,
+        width=width,
+        height=height,
+        hovermode=kwargs.get('hovermode', 'closest'),
+        legend=dict(
+            orientation=kwargs.get('legend_orientation', 'v'),
+            yanchor=kwargs.get('legend_yanchor', 'auto'),
+            xanchor=kwargs.get('legend_xanchor', 'auto'),
+            x=kwargs.get('legend_x', 1.02),
+            y=kwargs.get('legend_y', 1)
+        )
+    )
+    
+    # Si spécifié, ajouter des annotations
+    if 'annotations' in kwargs:
+        for annotation in kwargs['annotations']:
+            fig.add_annotation(**annotation)
+            
+    # Configuration des axes
+    if 'x_range' in kwargs:
+        fig.update_xaxes(range=kwargs['x_range'])
+    if 'y_range' in kwargs:
+        fig.update_yaxes(range=kwargs['y_range'])
+        
+    return fig

xplia/visualizations/pie_chart.py

@@ -0,0 +1,134 @@
+"""
+Implémentation des graphiques circulaires (pie charts) pour XPLIA
+"""
+
+def create_pie_chart(data, config, library="plotly", **kwargs):
+    """
+    Crée un graphique circulaire avec la bibliothèque spécifiée.
+    
+    Args:
+        data: Données pour le graphique (dict, DataFrame, etc.)
+        config: Configuration du graphique
+        library: Bibliothèque à utiliser
+        **kwargs: Arguments spécifiques au type de graphique
+        
+    Returns:
+        Objet graphique selon la bibliothèque utilisée
+    """
+    if library == "plotly":
+        return _create_plotly_pie_chart(data, config, **kwargs)
+    elif library == "matplotlib":
+        return _create_mpl_pie_chart(data, config, **kwargs)
+    elif library == "bokeh":
+        return _create_bokeh_pie_chart(data, config, **kwargs)
+    else:
+        raise ValueError(f"Bibliothèque {library} non supportée pour les graphiques circulaires")
+
+# Implémentations spécifiques
+def _create_plotly_pie_chart(data, config, **kwargs):
+    """Implémentation Plotly des graphiques circulaires"""
+    import plotly.graph_objects as go
+    
+    # Extraction des paramètres
+    title = config.get('title', '')
+    width = config.get('width', 800)
+    height = config.get('height', 500)
+    
+    # Normalisation des données d'entrée
+    if isinstance(data, dict):
+        labels = data.get('labels', [])
+        values = data.get('values', [])
+    else:
+        # Format [labels, values]
+        labels = data[0]
+        values = data[1]
+    
+    # Récupération des options personnalisées
+    hole = kwargs.get('hole', 0)  # 0 pour pie, >0 pour donut
+    text_info = kwargs.get('text_info', 'percent')
+    pull = kwargs.get('pull', None)  # [0, 0, 0.2, 0] pour extraire une portion
+    
+    # Création du graphique
+    fig = go.Figure(data=[go.Pie(
+        labels=labels,
+        values=values,
+        hole=hole,
+        textinfo=text_info,
+        pull=pull,
+        marker_colors=kwargs.get('colors', config.get('color_palette', [])),
+        textfont=dict(size=kwargs.get('text_size', 12)),
+        hoverinfo=kwargs.get('hoverinfo', 'label+percent+value'),
+        rotation=kwargs.get('rotation', 0)
+    )])
+    
+    # Configuration du layout
+    fig.update_layout(
+        title=title,
+        width=width,
+        height=height,
+        showlegend=kwargs.get('show_legend', True),
+        legend=dict(
+            orientation=kwargs.get('legend_orientation', 'v'),
+            yanchor=kwargs.get('legend_yanchor', 'auto'),
+            xanchor=kwargs.get('legend_xanchor', 'auto'),
+            x=kwargs.get('legend_x', 1.02),
+            y=kwargs.get('legend_y', 1)
+        ),
+        annotations=kwargs.get('annotations', [])
+    )
+    
+    return fig
+
+def _create_mpl_pie_chart(data, config, **kwargs):
+    """Implémentation Matplotlib des graphiques circulaires"""
+    import matplotlib.pyplot as plt
+    
+    # Création d'une nouvelle figure
+    fig, ax = plt.subplots(figsize=(
+        config.get('width', 800)/100,
+        config.get('height', 500)/100
+    ))
+    
+    # Normalisation des données d'entrée
+    if isinstance(data, dict):
+        labels = data.get('labels', [])
+        values = data.get('values', [])
+    else:
+        # Format [labels, values]
+        labels = data[0]
+        values = data[1]
+    
+    # Récupération des options personnalisées
+    hole = kwargs.get('hole', 0)  # Pour donut, équivalent à Matplotlib wedgeprops
+    explode = kwargs.get('pull', None)  # [0, 0, 0.1, 0] pour extraire une portion
+    
+    # Options spécifiques pour Matplotlib
+    wedgeprops = {}
+    if hole > 0:
+        wedgeprops = {'width': hole}
+    
+    # Création du graphique
+    ax.pie(
+        values, 
+        labels=labels if kwargs.get('show_labels', True) else None,
+        autopct=kwargs.get('autopct', '%1.1f%%'),
+        startangle=kwargs.get('rotation', 0),
+        shadow=kwargs.get('shadow', False),
+        explode=explode,
+        colors=kwargs.get('colors', config.get('color_palette', [])),
+        textprops={'fontsize': kwargs.get('text_size', 12)},
+        wedgeprops=wedgeprops
+    )
+    
+    # Titre
+    if config.get('title'):
+        ax.set_title(config.get('title'))
+    
+    # Égaliser les axes pour un cercle parfait
+    ax.axis('equal')
+    
+    # Légende
+    if kwargs.get('show_legend', True):
+        ax.legend(loc=kwargs.get('legend_loc', 'best'))
+        
+    return fig

xplia/visualizations/radar_chart.py

@@ -0,0 +1,154 @@
+"""
+Implémentation des graphiques radar (diagrammes en toile d'araignée) pour XPLIA
+"""
+
+def create_radar_chart(data, config, library="plotly", **kwargs):
+    """
+    Crée un graphique radar avec la bibliothèque spécifiée.
+    
+    Args:
+        data: Données pour le graphique 
+        config: Configuration du graphique
+        library: Bibliothèque à utiliser
+        **kwargs: Arguments spécifiques au type de graphique
+        
+    Returns:
+        Objet graphique selon la bibliothèque utilisée
+    """
+    if library == "plotly":
+        return _create_plotly_radar_chart(data, config, **kwargs)
+    elif library == "matplotlib":
+        return _create_mpl_radar_chart(data, config, **kwargs)
+    elif library == "bokeh":
+        return _create_bokeh_radar_chart(data, config, **kwargs)
+    else:
+        raise ValueError(f"Bibliothèque {library} non supportée pour les graphiques radar")
+
+# Implémentations spécifiques
+def _create_plotly_radar_chart(data, config, **kwargs):
+    """Implémentation Plotly des graphiques radar"""
+    import plotly.graph_objects as go
+    
+    # Extraction des paramètres
+    title = config.get('title', '')
+    width = config.get('width', 800)
+    height = config.get('height', 600)
+    
+    # Normalisation des données d'entrée
+    if isinstance(data, dict):
+        # Format {categories: [...], series: [{name: "...", values: [...]}, ...]}
+        categories = data.get('categories', [])
+        series = data.get('series', [])
+    else:
+        # Format [categories, [values_series1, values_series2, ...], [names]]
+        categories = data[0]
+        values_series = data[1]
+        names = data[2] if len(data) > 2 else [f"Série {i+1}" for i in range(len(values_series))]
+        series = [{"name": names[i], "values": values} for i, values in enumerate(values_series)]
+    
+    # Création du graphique
+    fig = go.Figure()
+    
+    # Ajout de chaque série
+    for i, serie in enumerate(series):
+        color = serie.get('color', config.get('color_palette', [])[i % len(config.get('color_palette', ['#1f77b4']))])
+        
+        fig.add_trace(go.Scatterpolar(
+            r=serie.get('values', []),
+            theta=categories,
+            fill=kwargs.get('fill', 'toself'),
+            name=serie.get('name', f'Série {i}'),
+            line=dict(color=color, width=serie.get('line_width', 2)),
+            marker=dict(
+                size=serie.get('marker_size', 6),
+                symbol=serie.get('marker_symbol', 'circle'),
+                color=color,
+                opacity=serie.get('opacity', 0.8)
+            ),
+            opacity=serie.get('fill_opacity', 0.6),
+            hoverinfo=kwargs.get('hoverinfo', 'all')
+        ))
+    
+    # Configuration du layout
+    fig.update_layout(
+        title=title,
+        width=width,
+        height=height,
+        polar=dict(
+            radialaxis=dict(
+                visible=True,
+                range=kwargs.get('range', [0, max([max(s.get('values', [0])) for s in series]) * 1.1])
+            )
+        ),
+        showlegend=kwargs.get('show_legend', True)
+    )
+    
+    return fig
+
+def _create_mpl_radar_chart(data, config, **kwargs):
+    """Implémentation Matplotlib des graphiques radar"""
+    import matplotlib.pyplot as plt
+    import numpy as np
+    
+    # Extraction des paramètres
+    title = config.get('title', '')
+    
+    # Normalisation des données d'entrée
+    if isinstance(data, dict):
+        categories = data.get('categories', [])
+        series = data.get('series', [])
+    else:
+        # Format [categories, [values_series1, values_series2, ...], [names]]
+        categories = data[0]
+        values_series = data[1]
+        names = data[2] if len(data) > 2 else [f"Série {i+1}" for i in range(len(values_series))]
+        series = [{"name": names[i], "values": values} for i, values in enumerate(values_series)]
+    
+    # Nombre de variables
+    N = len(categories)
+    
+    # Création d'un angle pour chaque variable
+    angles = [n / float(N) * 2 * np.pi for n in range(N)]
+    angles += angles[:1]  # Fermer le cercle
+    
+    # Création de la figure
+    fig, ax = plt.subplots(figsize=(
+        config.get('width', 800) / 100,
+        config.get('height', 600) / 100
+    ), subplot_kw=dict(polar=True))
+    
+    # Calculer la plage de valeurs pour toutes les séries
+    max_value = max([max(s.get('values', [0])) for s in series])
+    if kwargs.get('range'):
+        ax.set_ylim(kwargs.get('range'))
+    else:
+        ax.set_ylim([0, max_value * 1.1])
+    
+    # Placer les axes à la bonne position
+    ax.set_xticks(angles[:-1])
+    ax.set_xticklabels(categories)
+    
+    # Tracer chaque série
+    for i, serie in enumerate(series):
+        values = serie.get('values', [])
+        values += values[:1]  # Fermer le cercle
+        
+        color = serie.get('color', config.get('color_palette', [])[i % len(config.get('color_palette', ['#1f77b4']))])
+        
+        ax.plot(angles, values, 'o-', linewidth=serie.get('line_width', 2), 
+                label=serie.get('name', f'Série {i}'), color=color)
+        
+        if kwargs.get('fill', True):
+            ax.fill(angles, values, color=color, alpha=serie.get('fill_opacity', 0.4))
+    
+    # Ajout du titre et de la légende
+    ax.set_title(title)
+    
+    if kwargs.get('show_legend', True):
+        ax.legend(loc=kwargs.get('legend_loc', 'best'))
+    
+    # Option pour personnaliser les grilles
+    if kwargs.get('grid', True):
+        ax.grid(True)
+    
+    return fig

xplia/visualizations/registry.py

@@ -0,0 +1,76 @@
+"""
+Registre des visualiseurs XPLIA
+==============================
+
+Ce module fournit un registre pour les visualiseurs XPLIA, permettant
+l'enregistrement et la récupération des différentes classes de visualisation.
+"""
+
+import logging
+from typing import Dict, Type, Any, Optional
+from functools import wraps
+
+from ..core.enums import ExplainabilityMethod
+from .base import VisualizerBase
+
+# Registre global des visualiseurs
+_VISUALIZER_REGISTRY: Dict[str, Type[VisualizerBase]] = {}
+logger = logging.getLogger(__name__)
+
+
+def register_visualizer(explainability_method: ExplainabilityMethod):
+    """
+    Décorateur pour enregistrer un visualiseur dans le registre global.
+    
+    Args:
+        explainability_method: Méthode d'explicabilité associée au visualiseur
+        
+    Returns:
+        Fonction décorateur
+    """
+    def decorator(cls):
+        if not issubclass(cls, VisualizerBase):
+            raise TypeError(f"La classe {cls.__name__} doit hériter de VisualizerBase")
+        
+        method_name = explainability_method.value
+        _VISUALIZER_REGISTRY[method_name] = cls
+        logger.info(f"Visxplialiseur {cls.__name__} enregistré pour la méthode {method_name}")
+        
+        @wraps(cls)
+        def wrapper(*args, **kwargs):
+            return cls(*args, **kwargs)
+        
+        return wrapper
+    
+    return decorator
+
+
+def get_visualizer(explainability_method: ExplainabilityMethod, **kwargs) -> Optional[VisualizerBase]:
+    """
+    Récupère une instance de visualiseur pour la méthode d'explicabilité spécifiée.
+    
+    Args:
+        explainability_method: Méthode d'explicabilité pour laquelle récupérer un visualiseur
+        **kwargs: Paramètres à passer au constructeur du visualiseur
+        
+    Returns:
+        Instance de visualiseur ou None si aucun visualiseur n'est enregistré
+    """
+    method_name = explainability_method.value
+    
+    if method_name in _VISUALIZER_REGISTRY:
+        visxplializer_cls = _VISUALIZER_REGISTRY[method_name]
+        return visxplializer_cls(**kwargs)
+    else:
+        logger.warning(f"Aucun visualiseur enregistré pour la méthode {method_name}")
+        return None
+
+
+def list_available_visualizers() -> Dict[str, str]:
+    """
+    Liste tous les visualiseurs disponibles.
+    
+    Returns:
+        Dictionnaire des méthodes d'explicabilité et noms de classes de visualiseurs
+    """
+    return {method: cls.__name__ for method, cls in _VISUALIZER_REGISTRY.items()}

xplia/visualizations/sankey_chart.py

@@ -0,0 +1,190 @@
+"""
+Implémentation des diagrammes de flux Sankey pour XPLIA
+"""
+
+def create_sankey_chart(data, config, library="plotly", **kwargs):
+    """
+    Crée un diagramme de flux Sankey avec la bibliothèque spécifiée.
+    
+    Args:
+        data: Données pour le diagramme (sources, cibles, valeurs)
+        config: Configuration du graphique
+        library: Bibliothèque à utiliser
+        **kwargs: Arguments spécifiques au type de graphique
+        
+    Returns:
+        Objet graphique selon la bibliothèque utilisée
+    """
+    if library == "plotly":
+        return _create_plotly_sankey_chart(data, config, **kwargs)
+    elif library == "matplotlib":
+        return _create_mpl_sankey_chart(data, config, **kwargs)
+    elif library == "bokeh":
+        return _create_bokeh_sankey_chart(data, config, **kwargs)
+    else:
+        raise ValueError(f"Bibliothèque {library} non supportée pour les diagrammes Sankey")
+
+# Implémentations spécifiques
+def _create_plotly_sankey_chart(data, config, **kwargs):
+    """Implémentation Plotly des diagrammes Sankey"""
+    import plotly.graph_objects as go
+    
+    # Extraction des paramètres
+    title = config.get('title', '')
+    width = config.get('width', 1000)
+    height = config.get('height', 600)
+    
+    # Normalisation des données d'entrée
+    if isinstance(data, dict):
+        # Format {source: [...], target: [...], value: [...], node: {label: [...]}}
+        source = data.get('source', [])
+        target = data.get('target', [])
+        value = data.get('value', [])
+        node_labels = data.get('node', {}).get('label', [])
+        link_colors = data.get('link', {}).get('color', [])
+        node_colors = data.get('node', {}).get('color', [])
+    else:
+        # Format [sources, targets, values, node_labels]
+        source = data[0] if len(data) > 0 else []
+        target = data[1] if len(data) > 1 else []
+        value = data[2] if len(data) > 2 else [1] * len(source)
+        node_labels = data[3] if len(data) > 3 else []
+        link_colors = []
+        node_colors = []
+    
+    # Configuration du diagramme Sankey
+    sankey_config = dict(
+        node=dict(
+            pad=kwargs.get('node_pad', 15),
+            thickness=kwargs.get('node_thickness', 20),
+            line=dict(
+                color=kwargs.get('node_line_color', "black"),
+                width=kwargs.get('node_line_width', 0.5)
+            ),
+            label=node_labels if node_labels else None
+        ),
+        link=dict(
+            source=source,
+            target=target,
+            value=value,
+            hovertemplate=kwargs.get('hovertemplate', 'Source: %{source.label}<br>Target: %{target.label}<br>Value: %{value}<extra></extra>')
+        )
+    )
+    
+    # Ajout des couleurs personnalisées pour les nœuds si disponibles
+    if node_colors:
+        sankey_config['node']['color'] = node_colors
+        
+    # Ajout des couleurs personnalisées pour les liens si disponibles
+    if link_colors:
+        sankey_config['link']['color'] = link_colors
+    elif 'link_colorscale' in kwargs:
+        # Utiliser une échelle de couleurs pour les liens en fonction de leur valeur
+        import numpy as np
+        import plotly.colors as pc
+        
+        # Normaliser les valeurs entre 0 et 1
+        norm_values = [(v - min(value)) / (max(value) - min(value) + 0.0001) for v in value]
+        
+        # Générer les couleurs à partir de l'échelle
+        colorscale = kwargs.get('link_colorscale', 'Viridis')
+        if isinstance(colorscale, str):
+            colors = [pc.sample_colorscale(pc.get_colorscale(colorscale), v)[0] for v in norm_values]
+        else:
+            colors = [pc.sample_colorscale(colorscale, v)[0] for v in norm_values]
+            
+        sankey_config['link']['color'] = colors
+    
+    # Création du graphique
+    fig = go.Figure(data=[go.Sankey(**sankey_config)])
+    
+    # Configuration du layout
+    fig.update_layout(
+        title=title,
+        width=width,
+        height=height,
+        font=dict(
+            size=kwargs.get('font_size', 12)
+        ),
+        margin=dict(t=50, b=25, l=25, r=25)
+    )
+            
+    return fig
+
+def _create_mpl_sankey_chart(data, config, **kwargs):
+    """Implémentation Matplotlib des diagrammes Sankey"""
+    import matplotlib.pyplot as plt
+    from matplotlib.sankey import Sankey
+    
+    # Extraction des paramètres
+    title = config.get('title', '')
+    
+    # Note: La fonction Sankey de Matplotlib est limitée comparée à Plotly
+    # Elle nécessite un format spécifique qui diffère du format Plotly
+    # On va donc convertir les données
+    
+    # Normalisation des données d'entrée
+    if isinstance(data, dict):
+        source = data.get('source', [])
+        target = data.get('target', [])
+        value = data.get('value', [])
+        node_labels = data.get('node', {}).get('label', [])
+    else:
+        source = data[0] if len(data) > 0 else []
+        target = data[1] if len(data) > 1 else []
+        value = data[2] if len(data) > 2 else [1] * len(source)
+        node_labels = data[3] if len(data) > 3 else []
+    
+    # Création de la figure
+    fig, ax = plt.subplots(figsize=(
+        config.get('width', 1000) / 100,
+        config.get('height', 600) / 100
+    ))
+    
+    # Configuration des flux (adapté pour le format Matplotlib Sankey)
+    # Note: Le format Matplotlib Sankey est assez différent et plus limité que celui de Plotly
+    # Cette implémentation est simplifiée et ne prend en compte que le premier flux
+    # Pour des diagrammes Sankey plus complexes, il est recommandé d'utiliser Plotly
+
+    # Nous allons organiser les nœuds et les flux pour créer un diagramme simple
+    # Identifier les nœuds uniques
+    all_nodes = set()
+    for s, t in zip(source, target):
+        all_nodes.add(s)
+        all_nodes.add(t)
+    
+    # Mappez les indices de nœuds vers des entiers consécutifs
+    node_map = {node: i for i, node in enumerate(all_nodes)}
+    
+    # Créer des dictionnaires pour suivre les flux entrants et sortants
+    flows = {}
+    for i, (s, t, v) in enumerate(zip(source, target, value)):
+        if node_map[s] not in flows:
+            flows[node_map[s]] = []
+        flows[node_map[s]].append((node_map[t], v))
+    
+    # Créer un objet Sankey
+    sankey = Sankey(ax=ax, unit='', scale=0.01 * kwargs.get('scale', 1.0),
+                   format='%.0f', gap=kwargs.get('gap', 0.25))
+    
+    # Ajouter les flux pour chaque nœud
+    for node_idx, outflows in flows.items():
+        # Calculer les flux entrants et sortants
+        targets = [t for t, _ in outflows]
+        values = [v for _, v in outflows]
+        
+        # Ajouter le diagramme au sankey
+        sankey.add(flows=[values], labels=[node_labels[node_idx] if node_idx < len(node_labels) else f'Node {node_idx}'],
+                 orientations=[0])  # 0 for horizontal
+    
+    # Mettre à jour le diagramme
+    sankey.finish()
+    
+    # Ajouter le titre
+    plt.title(title)
+    
+    # Ajuster les limites des axes
+    plt.axis('equal')
+    plt.axis('off')
+    
+    return fig