opsci-toolbox 0.0.2__py3-none-any.whl → 0.0.6__py3-none-any.whl

opsci_toolbox/helpers/dataviz.py

@@ -15,55 +15,115 @@ import math
 import pandas as pd
 from opsci_toolbox.helpers.nlp import sample_most_engaging_posts, create_frequency_table
 from matplotlib.colors import to_hex
+import networkx as nx
 
 
 
-def upload_chart_studio(username,api_key,fig, title):
+def upload_chart_studio(
+    username: str, 
+    api_key: str, 
+    fig, 
+    title: str
+) -> tuple:
     """
-    Upload Plotly viz to chart studio
+    Upload a Plotly visualization to Chart Studio.
+
+    Args:
+        username (str): The Chart Studio username.
+        api_key (str): The Chart Studio API key.
+        fig: The Plotly figure object to be uploaded.
+        title (str): The title for the uploaded visualization.
+
+    Returns:
+        tuple: A tuple containing the URL of the uploaded visualization and the embed code.
     """
     URL = ""
     EMBED = ""
 
-    try:    
+    try:
+        # Set Chart Studio credentials
         tls.set_credentials_file(username=username, api_key=api_key)
-        URL = py.plot(fig, filename = title, auto_open=True)
+        
+        # Upload the figure to Chart Studio
+        URL = py.plot(fig, filename=title, auto_open=True)
+        
+        # Get the embed code for the uploaded figure
         EMBED = tls.get_embed(URL)
-        print("* URL DE LA VIZ >> ",URL)
-        print("\n*CODE EMBED A COLLER \n",EMBED)
+        
+        # Print the URL and embed code
+        print("* URL DE LA VIZ >> ", URL)
+        print("\n*CODE EMBED A COLLER \n", EMBED)
         
     except Exception as e:
-        pass
+        # Print the exception message and a suggestion to reduce the visualization size
         print(e, "try to reduce the dataviz size by printing less data")
 
-    return URL,EMBED
+    return URL, EMBED
+
+def scale_to_0_10(x: pd.Series) -> pd.Series:
+    """
+    Scale a pandas Series to the range [0, 10].
 
+    Args:
+        x (pd.Series): The input pandas Series to be scaled.
 
-def scale_to_0_10(x):
+    Returns:
+        pd.Series: The scaled pandas Series with values in the range [0, 10].
+    """
     return ((x - x.min()) / (x.max() - x.min()) * 10).astype(int)
 
-def normalize_data_size(df, col:str, coef = 20, constant = 5):
+def normalize_data_size(df: pd.DataFrame, col: str, coef: int = 20, constant: int = 5) -> pd.DataFrame:
     """
-    Function to normalize the sizes of dots 
+    Normalize the sizes of dots based on a specified column in a DataFrame.
+
+    Args:
+        df (pd.DataFrame): The input DataFrame.
+        col (str): The column name to be normalized.
+        coef (int, optional): The coefficient to scale the normalized values. Defaults to 20.
+        constant (int, optional): The constant to add to the scaled normalized values. Defaults to 5.
+
+    Returns:
+        pd.DataFrame: The DataFrame with an additional column for the normalized sizes.
     """
-    df['normalized_'+col]=((df[col]-df[col].max())/(df[col]+df[col].max())+1) * coef + constant
+    df['normalized_' + col] = ((df[col] - df[col].max()) / (df[col] + df[col].max()) + 1) * coef + constant
     return df
 
-def generate_color_palette(lst, transparency=1):
+def generate_color_palette(lst: list, transparency: float = 1) -> dict:
     """
-    Function to generate a random color palette of RGBa codes
+    Generate a random color palette of RGBA codes.
+
+    Args:
+        lst (List[str]): List of color names or identifiers.
+        transparency (float, optional): Transparency value for RGBA colors (0 to 1). Defaults to 1.
+
+    Returns:
+        dict: Dictionary containing color names or identifiers as keys and corresponding RGBA codes as values.
     """
-    color_palette = {color: 'rgba({}, {}, {}, {})'.format(
-                        random.randrange(0, 255),
-                        random.randrange(0, 255),
-                        random.randrange(0, 255),
-                        transparency
-                    ) for color in lst}
+    color_palette = {
+        color: 'rgba({}, {}, {}, {})'.format(
+            random.randrange(0, 255),
+            random.randrange(0, 255),
+            random.randrange(0, 255),
+            transparency
+        )
+        for color in lst
+    }
     return color_palette
 
-def generate_color_palette_with_colormap(lst, colormap = "viridis"):
+def generate_color_palette_with_colormap(lst: list, colormap: str = "viridis") -> dict:
+    """
+    Generate a color palette with hexadecimal codes using a specified colormap.
+
+    Args:
+        lst (List[str]): List of color names or identifiers.
+        colormap (str, optional): Name of the colormap to use. Defaults to "viridis".
+
+    Returns:
+        Dict[str, str]: Dictionary containing color names or identifiers as keys and corresponding hexadecimal codes as values.
+    """
     num_colors = len(lst)
-    # Generate some example data
+
+    # Generate example data
     data = np.linspace(0, 1, num_colors)
 
     # Choose the colormap
@@ -76,38 +136,69 @@ def generate_color_palette_with_colormap(lst, colormap = "viridis"):
     colors = cmap(norm(data))
 
     # Convert colors to hexadecimal codes
-    hex_colors = {item : to_hex(colors[i]) for i, item in enumerate(lst)}
+    hex_colors = {item: to_hex(colors[i]) for i, item in enumerate(lst)}
 
     return hex_colors
 
-def generate_hexadecimal_color_palette(lst, add_transparency=False, transparency=0.5):
+def generate_hexadecimal_color_palette(lst: list, add_transparency: bool = False, transparency: float = 0.5) -> dict:
     """
-    Function to generate a random color palette with hexadecimal codes and transparency
+    Generate a random color palette with hexadecimal codes and optional transparency.
+
+    Args:
+        lst (List[str]): List of color names or identifiers.
+        add_transparency (bool, optional): Whether to add transparency to the colors. Defaults to False.
+        transparency (float, optional): Transparency value for the colors (0 to 1). Defaults to 0.5.
+
+    Returns:
+        Dict[str, str]: Dictionary containing color names or identifiers as keys and corresponding hexadecimal codes as values.
     """
     if add_transparency:
         alpha_hex = int(transparency * 255)  # Convert transparency to integer (0-255 range)
-        color_palette = {color: "#{:02x}{:02x}{:02x}{:02x}".format(
-                            random.randint(0, 255),
-                            random.randint(0, 255),
-                            random.randint(0, 255),
-                            alpha_hex
-                        ) for color in lst}
+        color_palette = {
+            color: "#{:02x}{:02x}{:02x}{:02x}".format(
+                random.randint(0, 255),
+                random.randint(0, 255),
+                random.randint(0, 255),
+                alpha_hex
+            )
+            for color in lst
+        }
     else:
-        color_palette = {color: "#{:02x}{:02x}{:02x}".format(
-                            random.randint(0, 255),
-                            random.randint(0, 255),
-                            random.randint(0, 255)
-                        ) for color in lst}
+        color_palette = {
+            color: "#{:02x}{:02x}{:02x}".format(
+                random.randint(0, 255),
+                random.randint(0, 255),
+                random.randint(0, 255)
+            )
+            for color in lst
+        }
     return color_palette
 
-def generate_random_hexadecimal_color():
-    return "#{:02x}{:02x}{:02x}".format(random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
+def generate_random_hexadecimal_color() -> str:
+    """
+    Generate a random hexadecimal color code.
 
-def wrap_text(txt, lenght=50):
+    Returns:
+        str: Hexadecimal color code.
     """
-    Function to wrap text (for hover)
+    return "#{:02x}{:02x}{:02x}".format(
+        random.randint(0, 255),
+        random.randint(0, 255),
+        random.randint(0, 255)
+    )
+
+def wrap_text(txt: str, length: int = 50) -> str:
     """
-    txt = '<br>'.join(textwrap.wrap(str(txt), width=lenght))
+    Wrap text to a specified length.
+
+    Args:
+        txt (str): The text to wrap.
+        length (int, optional): The maximum length of each line. Defaults to 50.
+
+    Returns:
+        str: The wrapped text.
+    """
+    txt = '<br>'.join(textwrap.wrap(str(txt), width=length))
     return txt
 
 def get_convex_hull_coord(points: np.array, interpolate_curve: bool = True) -> tuple:
@@ -282,31 +373,45 @@ def get_convex_hull_coord(points: np.array, interpolate_curve: bool = True) -> t
 
 #     return fig
 
-def create_scatter_plot(df, col_x, col_y, col_category, color_palette, col_color, col_size, col_text, title="Scatter Plot", x_axis_label="X-axis", y_axis_label="Y-axis", width=1000, height=1000, xaxis_range=None, yaxis_range=None, 
-    size_value =4, opacity=0.8, maxdisplayed=0, mode = "markers", textposition="bottom center", plot_bgcolor=None, paper_bgcolor=None, yaxis_showgrid = False, xaxis_showgrid = False, color="indianred", line_width=0.5, line_color="white", colorscale='Viridis', showscale=True, template="plotly"):
+def create_scatter_plot(df: pd.DataFrame, col_x: str, col_y: str, col_category: str, color_palette: dict, col_color: str, col_size: str, col_text: str, col_legend: list = [], title: str = "Scatter Plot", x_axis_label: str = "X-axis", y_axis_label: str = "Y-axis", width: int = 1000, height: int = 1000, xaxis_range: list =None, yaxis_range: list =None, size_value: int = 4, opacity: float = 0.8, maxdisplayed: int = 0, mode: str = "markers", textposition: str = "bottom center", plot_bgcolor: str = None, paper_bgcolor: str = None, yaxis_showgrid: bool = False, xaxis_showgrid: bool = False, color: str = "indianred", line_width: float = 0.5, line_color: str = "white", colorscale: str = 'Viridis', showscale: bool = True, template: str = "plotly") -> go.Figure:
     """
-    Create a scatter plot : 
-    - df contains all data : X / Y values, category for colorization, sizes and text for hover.
-    - col_x : name of the column containing X values
-    - col_y : name of the column containing Y values
-    - col_category : name of the column for colorization
-    - color_palette : a dict mapping category with color value
-    - col_color : name of the column for color ==> to be used only for continuous scale
-    - col_size : name of the column for dot sizes
-    - col_text : name of the column containing text for legend on hover
-    - title : graph title
-    - x_axis_label : label for X
-    - y_axis_label : label for Y
-    - width / height : size of the graphe
-    - xaxis_range / y_axis_range : range values for axis. None for auto values.
-    - size_value =  minimun size (or constant) for dots 
-    - opacity : dots transparency
-    - maxdisplayed : maximum number of dots to display. 0 = infinite
-    - plot_bgcolor : background color for plot
-    - paper_bgcolor : background color for the area around the plot 
-    - color : color code for dots if col_category is None
-    - line_width : width of dots contours
-    - line_color : color of dots contours
+    Create a scatter plot.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing all data.
+        col_x (str): Name of the column containing X values.
+        col_y (str): Name of the column containing Y values.
+        col_category (str): Name of the column for colorization.
+        color_palette (dict): A dictionary mapping category with color value.
+        col_color (str): Name of the column for color. Only used for continuous scale.
+        col_size (str): Name of the column for dot sizes.
+        col_text (str): Name of the column containing text for legend on hover.
+        col_legend (List[str], optional): List of column names for legend. Defaults to [].
+        title (str, optional): Graph title. Defaults to "Scatter Plot".
+        x_axis_label (str, optional): Label for X-axis. Defaults to "X-axis".
+        y_axis_label (str, optional): Label for Y-axis. Defaults to "Y-axis".
+        width (int, optional): Size of the graph. Defaults to 1000.
+        height (int, optional): Size of the graph. Defaults to 1000.
+        xaxis_range (list, optional): Range values for X-axis. Defaults to None.
+        yaxis_range (list, optional): Range values for Y-axis. Defaults to None.
+        size_value (int, optional): Minimum size (or constant) for dots. Defaults to 4.
+        opacity (float, optional): Dots transparency. Defaults to 0.8.
+        maxdisplayed (int, optional): Maximum number of dots to display. 0 = infinite. Defaults to 0.
+        mode (str, optional): Mode for the scatter plot. Defaults to "markers".
+        textposition (str, optional): Text position for hover. Defaults to "bottom center".
+        plot_bgcolor (str, optional): Background color for plot. Defaults to None.
+        paper_bgcolor (str, optional): Background color for the area around the plot. Defaults to None.
+        yaxis_showgrid (bool, optional): Whether to show grid on Y-axis. Defaults to False.
+        xaxis_showgrid (bool, optional): Whether to show grid on X-axis. Defaults to False.
+        color (str, optional): Color code for dots if col_category is None. Defaults to "indianred".
+        line_width (float, optional): Width of dots contours. Defaults to 0.5.
+        line_color (str, optional): Color of dots contours. Defaults to "white".
+        colorscale (str, optional): Color scale for continuous color mapping. Defaults to 'Viridis'.
+        showscale (bool, optional): Whether to show color scale. Defaults to True.
+        template (str, optional): Plotly template. Defaults to "plotly".
+
+    Returns:
+        go.Figure: Plotly scatter plot figure.
     """
 
     if line_color is None :
@@ -327,8 +432,9 @@ def create_scatter_plot(df, col_x, col_y, col_category, color_palette, col_color
                 size = df[df[col_category] == category][col_size]
                 hovertemplate += '<br><b>'+col_size+'</b>:'+size.astype(str)
 
-            if col_text is not None:
-                hovertemplate +='<br><b>'+col_text+'</b>:'+ df[df[col_category]==category][col_text].apply(wrap_text)
+            if len(col_legend)>0:
+                for c in col_legend:
+                    hovertemplate +='<br><b>'+str(c)+'</b>:'+ df[df[col_category]==category][c].astype(str).apply(wrap_text)
 
             fig.add_trace(
                 go.Scatter(
@@ -365,13 +471,16 @@ def create_scatter_plot(df, col_x, col_y, col_category, color_palette, col_color
         else :
             if color is None:
                 color = generate_random_hexadecimal_color()
-        if col_text is not None:
-            hovertemplate +='<br><b>'+col_text+'</b>:'+ df[col_text].apply(wrap_text)
+        if len(col_legend)>0:
+            for c in col_legend:
+                hovertemplate +='<br><b>'+str(c)+'</b>:'+ df[c].astype(str).apply(wrap_text)
 
         fig = go.Figure( go.Scatter(
                     x=df[col_x], 
                     y=df[col_y], 
                     mode=mode, 
+                    text = df[col_text],
+                    textposition=textposition,
                     marker=dict(color=color,                #dots color
                                 size=size,                  #dots size
                                 opacity=opacity,            #dots opacity
@@ -418,52 +527,83 @@ def create_scatter_plot(df, col_x, col_y, col_category, color_palette, col_color
     )
     return fig
 
-def add_annotations(fig, df, col_x, col_y, col_txt, width=1000, label_size_ratio=100, bordercolor = "#C7C7C7", arrowcolor = "SlateGray", bgcolor ="#FFFFFF", font_color = "SlateGray"):
-    df[col_txt]=df[col_txt].fillna("").astype(str)
+def add_annotations(fig: go.Figure, df: pd.DataFrame, col_x: str, col_y: str, col_txt: str, width: int = 1000, label_size_ratio: int = 100, bordercolor: str = "#C7C7C7", arrowcolor: str = "SlateGray", bgcolor: str = "#FFFFFF", font_color: str = "SlateGray") -> go.Figure:
+    """
+    Add annotations to a Plotly figure.
+
+    Args:
+        fig (go.Figure): Plotly figure object.
+        df (pd.DataFrame): DataFrame containing annotation data.
+        col_x (str): Name of the column containing X values.
+        col_y (str): Name of the column containing Y values.
+        col_txt (str): Name of the column containing text for annotations.
+        width (int, optional): Width of the figure. Defaults to 1000.
+        label_size_ratio (int, optional): Ratio of label size to figure width. Defaults to 100.
+        bordercolor (str, optional): Color of annotation borders. Defaults to "#C7C7C7".
+        arrowcolor (str, optional): Color of annotation arrows. Defaults to "SlateGray".
+        bgcolor (str, optional): Background color of annotations. Defaults to "#FFFFFF".
+        font_color (str, optional): Color of annotation text. Defaults to "SlateGray".
+
+    Returns:
+        go.Figure: Plotly figure object with annotations added.
+    """
+    df[col_txt] = df[col_txt].fillna("").astype(str)
+
     for i, row in df.iterrows():
-        fig.add_annotation(x=row[col_x], 
-                           y=row[col_y], 
-                           text='<b>'+wrap_text(row[col_txt])+'</b>', 
-                           showarrow=True, 
-                           arrowhead=1, 
-                           font=dict(
-                               family="Helvetica, Sans-serif",
-                               size=width / label_size_ratio,
-                               color=font_color
-                               ),
-                            bordercolor=bordercolor, 
-                            borderwidth=width / 1000, 
-                            borderpad=width / 500, 
-                            bgcolor=bgcolor, 
-                            opacity=1, 
-                            arrowcolor=arrowcolor
-                        )
+        fig.add_annotation(
+            x=row[col_x],
+            y=row[col_y],
+            text='<b>'+wrap_text(row[col_txt])+'</b>',
+            showarrow=True,
+            arrowhead=1,
+            font=dict(
+                family="Helvetica, Sans-serif",
+                size=width / label_size_ratio,
+                color=font_color
+            ),
+            bordercolor=bordercolor,
+            borderwidth=width / 1000,
+            borderpad=width / 500,
+            bgcolor=bgcolor,
+            opacity=1,
+            arrowcolor=arrowcolor
+        )
 
     return fig
 
-def scatter3D(df, col_x, col_y, col_z, col_category, color_palette, col_size, col_text, title="3D Scatter Plot", x_axis_label="X-axis", y_axis_label="Y-axis", z_axis_label="Z-axis", width=1000, height=1000, xaxis_range=None, yaxis_range=None, 
-              zaxis_range=None, size_value =4, opacity=0.8, plot_bgcolor=None, paper_bgcolor=None, color="indianred", line_width=0.5, line_color="white", template = "plotly"):
+def scatter3D(df: pd.DataFrame, col_x: str, col_y: str, col_z: str, col_category: str, color_palette: dict, col_size: str, col_text: str, title: str = "3D Scatter Plot", x_axis_label: str = "X-axis", y_axis_label: str = "Y-axis", z_axis_label: str = "Z-axis", width: int = 1000, height: int = 1000, xaxis_range: list = None, yaxis_range: list = None, zaxis_range: list = None, size_value: int = 4, opacity: float = 0.8, plot_bgcolor: str = None, paper_bgcolor: str = None, color: str = "indianred", line_width: float = 0.5, line_color: str = "white", template: str = "plotly") -> go.Figure:
     """
-    Create a 3D scatter plot : 
-    - df contains all data : X / Y values, category for colorization, sizes and text for hover.
-    - col_x : name of the column containing X values
-    - col_y : name of the column containing Y values
-    - col_z : name of the column containing Z values
-    - col_category : name of the column for colorization
-    - color_palette : a dict mapping category with color value
-    - col_size : name of the column for dot sizes
-    - col_text : name of the column containing text for legend on hover
-    - title : graph title
-    - x_axis_label / y_axis_label / z_axis_label : label for X, Y, Z axis
-    - width / height : size of the graphe
-    - xaxis_range / y_axis_range / z_axis_range : range values for axis. None for auto values.
-    - size_value =  minimun size (or constant) for dots 
-    - opacity : dots transparency
-    - plot_bgcolor : background color for plot
-    - paper_bgcolor : background color for the area around the plot 
-    - color : color code for dots if col_category is None
-    - line_width : width of dots contours
-    - line_color : color of dots contours
+    Create a 3D scatter plot.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing all data.
+        col_x (str): Name of the column containing X values.
+        col_y (str): Name of the column containing Y values.
+        col_z (str): Name of the column containing Z values.
+        col_category (str): Name of the column for colorization.
+        color_palette (dict): A dictionary mapping categories with color values.
+        col_size (str): Name of the column for dot sizes.
+        col_text (str): Name of the column containing text for legend on hover.
+        title (str, optional): Graph title. Defaults to "3D Scatter Plot".
+        x_axis_label (str, optional): Label for X-axis. Defaults to "X-axis".
+        y_axis_label (str, optional): Label for Y-axis. Defaults to "Y-axis".
+        z_axis_label (str, optional): Label for Z-axis. Defaults to "Z-axis".
+        width (int, optional): Width of the graph. Defaults to 1000.
+        height (int, optional): Height of the graph. Defaults to 1000.
+        xaxis_range (list, optional): Range values for the X-axis. Defaults to None.
+        yaxis_range (list, optional): Range values for the Y-axis. Defaults to None.
+        zaxis_range (list, optional): Range values for the Z-axis. Defaults to None.
+        size_value (int, optional): Minimum size (or constant) for dots. Defaults to 4.
+        opacity (float, optional): Dots transparency. Defaults to 0.8.
+        plot_bgcolor (str, optional): Background color for the plot. Defaults to None.
+        paper_bgcolor (str, optional): Background color for the area around the plot. Defaults to None.
+        color (str, optional): Color code for dots if col_category is None. Defaults to "indianred".
+        line_width (float, optional): Width of dots contours. Defaults to 0.5.
+        line_color (str, optional): Color of dots contours. Defaults to "white".
+        template (str, optional): Plotly template. Defaults to "plotly".
+
+    Returns:
+        go.Figure: Plotly figure object.
     """
     fig=go.Figure()
     if col_category is not None:
@@ -582,57 +722,71 @@ def scatter3D(df, col_x, col_y, col_z, col_category, color_palette, col_size, co
 
     return fig
     
-def fig_bar_trend(x, bar_measure, trend_measure, x_name="X", bar_name ="metric1", trend_name = "metric2", marker_color='lightpink', line_color='indianred', title_text="Couverture & Résonance", width=1500, height=700, xaxis_tickangle=0, opacity=0.8, plot_bgcolor=None, paper_bgcolor=None, template = "plotly"):
+
+def fig_bar_trend(df: pd.DataFrame, col_x: str, bar_measure: str, trend_measure: str, x_name: str = "X", bar_name: str = "metric1", trend_name: str = "metric2", marker_color: str = 'lightpink', line_color: str = 'indianred', title_text: str = "Couverture & Résonance", width: int = 1500, height: int = 700, xaxis_tickangle: int = 0, opacity: float = 0.8, plot_bgcolor: str = None, paper_bgcolor: str = None, template: str = "plotly") -> go.Figure:
     """
-    Display a graph that combine bar and trend chart to compare 2 metrics :
-    - x = x axis data
-    - bar_measure = data represented as bar diagram
-    - trend_measure = data represented as trend line
-    - x_name / bar_name / trend_name : axis labels
-    - marker_color = color code for bars
-    - line_color = color code for trend line
-    - title_text = graph title
-    - width / height = size of plot
-    - xaxis_tickangle =  angle for x ticks
-    - opacity = opacity of bars
+    Display a graph that combines bar and trend chart to compare 2 metrics.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing all data.
+        col_x (str): Name of the column containing X values.
+        bar_measure (str): Data represented as bar diagram.
+        trend_measure (str): Data represented as trend line.
+        x_name (str, optional): Label for X-axis. Defaults to "X".
+        bar_name (str, optional): Label for the bar measure. Defaults to "metric1".
+        trend_name (str, optional): Label for the trend measure. Defaults to "metric2".
+        marker_color (str, optional): Color code for bars. Defaults to 'lightpink'.
+        line_color (str, optional): Color code for trend line. Defaults to 'indianred'.
+        title_text (str, optional): Graph title. Defaults to "Couverture & Résonance".
+        width (int, optional): Width of the graph. Defaults to 1500.
+        height (int, optional): Height of the graph. Defaults to 700.
+        xaxis_tickangle (int, optional): Angle for x ticks. Defaults to 0.
+        opacity (float, optional): Opacity of bars. Defaults to 0.8.
+        plot_bgcolor (str, optional): Background color for the plot. Defaults to None.
+        paper_bgcolor (str, optional): Background color for the area around the plot. Defaults to None.
+        template (str, optional): Plotly template. Defaults to "plotly".
+
+    Returns:
+        go.Figure: Plotly figure object.
     """
 
-    nk = np.empty(shape=(len(x), 3, 1), dtype="object")
-    nk[:, 0] = np.array(x.apply(lambda txt: '<br>'.join(textwrap.wrap(str(txt), width=50)))).reshape(-1, 1)
-    nk[:, 1] = np.array(bar_measure).reshape(-1, 1)
-    nk[:, 2] = np.array(trend_measure).reshape(-1, 1)
+    # nk = np.empty(shape=(len(x), 3, 1), dtype="object")
+    # nk[:, 0] = np.array(x.apply(lambda txt: '<br>'.join(textwrap.wrap(str(txt), width=50)))).reshape(-1, 1)
+    # nk[:, 1] = np.array(bar_measure).reshape(-1, 1)
+    # nk[:, 2] = np.array(trend_measure).reshape(-1, 1)
 
     fig = make_subplots(specs=[[{"secondary_y": True}]])
 
     fig.add_trace(
         go.Scatter(
-            x=x, 
-            y=trend_measure, 
+            x=df[col_x].apply(wrap_text), 
+            y=df[trend_measure], 
             name=trend_name,
             mode='lines', 
             line_color=line_color, 
             line_width=4,
             textfont=dict(size=8),
-            customdata=nk,
-            hovertemplate=("<br>"+x_name+" :%{customdata[0]}<br>"+bar_name+" - %{customdata[1]}<br>"+trend_name+":%{customdata[2]}"+"<extra></extra>"),
+            # customdata=nk,
+            hovertemplate=("<br>"+x_name+" :"+df[col_x].astype(str)+"<br>"+bar_name+" - "+df[bar_measure].astype(str)+"<br>"+trend_name+" : "+df[trend_measure].astype(str)+"<extra></extra>"),
         ),
         secondary_y=True,
     )
     # Add traces
     fig.add_trace(
         go.Bar(
-            x=x, 
-            y = bar_measure, 
+            x=df[col_x].apply(wrap_text), 
+            y = df[bar_measure], 
             name=bar_name, 
             marker_color=marker_color, 
             opacity=opacity,
-            hovertemplate=("<br>"+x_name+" :%{customdata[0]}<br>"+bar_name+" - %{customdata[1]}<br>"+trend_name+":%{customdata[2]}"+"<extra></extra>"),
+            # customdata=nk,
+            hovertemplate=("<br>"+x_name+" :"+df[col_x].astype(str)+"<br>"+bar_name+" - "+df[bar_measure].astype(str)+"<br>"+trend_name+" : "+df[trend_measure].astype(str)+"<extra></extra>"),
         ),
         secondary_y=False,
 
     )
-    first_axis_range=[-0.5,bar_measure.max()*1.01]
-    secondary_axis_range=[-0.5,trend_measure.max()*1.01]
+    first_axis_range=[-0.5,df[bar_measure].max()*1.01]
+    secondary_axis_range=[-0.5,df[trend_measure].max()*1.01]
 
     # Add figure title
     fig.update_layout(
@@ -668,54 +822,150 @@ def fig_bar_trend(x, bar_measure, trend_measure, x_name="X", bar_name ="metric1"
     return fig
 
 
-def density_map(df_posts, 
-              df_dots, 
-              df_topics,
-              col_topic, 
-              col_engagement, 
-              col_text,
-              col_text_dots,
-              colorscale = "Portland", 
-              marker_color = "#ff7f0e",
-              arrow_color = "#ff7f0e",
-              width=1000, 
-              height=1000, 
-              show_text=True, 
-              show_topics=True,
-              show_halo=False,
-              show_histogram =True,
-              label_size_ratio=100, 
-              n_words = 3,
-              title_text = "Clustering",
-              max_dots_displayed=0,
-              max_topics_displayed=20,
-              opacity=0.3,
-              plot_bgcolor=None, 
-              paper_bgcolor=None, 
-              template = "plotly"):
+# def fig_bar_trend(x, bar_measure, trend_measure, x_name="X", bar_name ="metric1", trend_name = "metric2", marker_color='lightpink', line_color='indianred', title_text="Couverture & Résonance", width=1500, height=700, xaxis_tickangle=0, opacity=0.8, plot_bgcolor=None, paper_bgcolor=None, template = "plotly"):
+#     """
+#     Display a graph that combine bar and trend chart to compare 2 metrics :
+#     - x = x axis data
+#     - bar_measure = data represented as bar diagram
+#     - trend_measure = data represented as trend line
+#     - x_name / bar_name / trend_name : axis labels
+#     - marker_color = color code for bars
+#     - line_color = color code for trend line
+#     - title_text = graph title
+#     - width / height = size of plot
+#     - xaxis_tickangle =  angle for x ticks
+#     - opacity = opacity of bars
+#     """
+
+#     nk = np.empty(shape=(len(x), 3, 1), dtype="object")
+#     nk[:, 0] = np.array(x.apply(lambda txt: '<br>'.join(textwrap.wrap(str(txt), width=50)))).reshape(-1, 1)
+#     nk[:, 1] = np.array(bar_measure).reshape(-1, 1)
+#     nk[:, 2] = np.array(trend_measure).reshape(-1, 1)
+
+#     fig = make_subplots(specs=[[{"secondary_y": True}]])
+
+#     fig.add_trace(
+#         go.Scatter(
+#             x=x, 
+#             y=trend_measure, 
+#             name=trend_name,
+#             mode='lines', 
+#             line_color=line_color, 
+#             line_width=4,
+#             textfont=dict(size=8),
+#             customdata=nk,
+#             hovertemplate=("<br>"+x_name+" :%{customdata[0]}<br>"+bar_name+" - %{customdata[1]}<br>"+trend_name+":%{customdata[2]}"+"<extra></extra>"),
+#         ),
+#         secondary_y=True,
+#     )
+#     # Add traces
+#     fig.add_trace(
+#         go.Bar(
+#             x=x, 
+#             y = bar_measure, 
+#             name=bar_name, 
+#             marker_color=marker_color, 
+#             opacity=opacity,
+#             hovertemplate=("<br>"+x_name+" :%{customdata[0]}<br>"+bar_name+" - %{customdata[1]}<br>"+trend_name+":%{customdata[2]}"+"<extra></extra>"),
+#         ),
+#         secondary_y=False,
+
+#     )
+#     first_axis_range=[-0.5,bar_measure.max()*1.01]
+#     secondary_axis_range=[-0.5,trend_measure.max()*1.01]
+
+#     # Add figure title
+#     fig.update_layout(
+        
+#         title_text=title_text, 
+#         showlegend=True,
+#         width = width,
+#         height= height,
+#         xaxis_tickangle=xaxis_tickangle,
+#         xaxis_showline=False,
+#         xaxis_showgrid=False,
+#         yaxis_showline=False,
+#         yaxis_showgrid=False,
+#         font_family="Segoe UI Semibold",
+#         template=template,
+#         plot_bgcolor=plot_bgcolor,    #background color (plot)
+#         paper_bgcolor=paper_bgcolor,   #background color (around plot)
+#         margin=dict(
+#                     t=width / 15,
+#                     b=width / 20,
+#                     r=width / 20,
+#                     l=width / 20,
+#                 ),
+#     )
+
+#     # # Set x-axis title
+#     fig.update_xaxes(title_text=x_name)
+
+#     # Set y-axes titles
+#     fig.update_yaxes(title_text=bar_name, range = first_axis_range, secondary_y=False)
+#     fig.update_yaxes(title_text=trend_name, range = secondary_axis_range, secondary_y=True)  
+    
+#     return fig
+
+
+def density_map(df_posts: pd.DataFrame,
+                df_dots: pd.DataFrame,
+                df_topics: pd.DataFrame,
+                col_topic: str,
+                col_engagement: str,
+                col_text: str,
+                col_text_dots: str,
+                colorscale: str = "Portland",
+                marker_color: str = "#ff7f0e",
+                arrow_color: str = "#ff7f0e",
+                width: int = 1000,
+                height: int = 1000,
+                show_text: bool = True,
+                show_topics: bool = True,
+                show_halo: bool = False,
+                show_histogram: bool = True,
+                label_size_ratio: int = 100,
+                n_words: int = 3,
+                title_text: str = "Clustering",
+                max_dots_displayed: int = 0,
+                max_topics_displayed: int = 20,
+                opacity: float = 0.3,
+                plot_bgcolor: str = None,
+                paper_bgcolor: str = None,
+                template: str = "plotly") -> go.Figure:
+    """
+    Display a 2D histogram with contours and scattered dots.
+
+    Args:
+        df_posts (pd.DataFrame): DataFrame containing all data points to plot (corresponding to contours).
+        df_dots (pd.DataFrame): DataFrame containing a sample of points to plot as dots.
+        df_topics (pd.DataFrame): DataFrame containing topics representations.
+        col_topic (str): Column name corresponding to category.
+        col_engagement (str): Column name corresponding to a metric.
+        col_text (str): Column name corresponding to a text separated by |.
+        col_text_dots (str): Column name corresponding to the text for dots.
+        colorscale (str, optional): Possible values are https://plotly.com/python/builtin-colorscales/. Defaults to "Portland".
+        marker_color (str, optional): Dots color value. Defaults to "#ff7f0e".
+        arrow_color (str, optional): Arrow pointing to topic centroid color value. Defaults to "#ff7f0e".
+        width (int, optional): Width of the plot. Defaults to 1000.
+        height (int, optional): Height of the plot. Defaults to 1000.
+        show_text (bool, optional): Show dots. Defaults to True.
+        show_topics (bool, optional): Show topics labels. Defaults to True.
+        show_halo (bool, optional): Show circles around topics. Defaults to False.
+        show_histogram (bool, optional): Show 2D histogram with contours. Defaults to True.
+        label_size_ratio (int, optional): Influence the size of the topics labels. Higher value means smaller topics labels. Defaults to 100.
+        n_words (int, optional): Number of words to display. Defaults to 3.
+        title_text (str, optional): Graph title. Defaults to "Clustering".
+        max_dots_displayed (int, optional): Number of dots to display. Defaults to 0.
+        max_topics_displayed (int, optional): Number of topics to display. Defaults to 20.
+        opacity (float, optional): Opacity of dots. Defaults to 0.3.
+        plot_bgcolor (str, optional): Background color for the plot. Defaults to None.
+        paper_bgcolor (str, optional): Background color for the area around the plot. Defaults to None.
+        template (str, optional): Plotly template. Defaults to "plotly".
+
+    Returns:
+        go.Figure: Plotly figure object.
     """
-    Display a 2Dhistogram with contours :
-    - df_posts : dataframe containing all data points to plot (corresponding to contours)
-    - df_dots : dataframe containing a sample of points to plot as dots
-    - df_topics : dataframe containing topics representations
-    - col_topic : column name corresponding to category
-    - col_engagement : column name corresponding to a metric
-    - col_text : column name corresponding to a text separated by | 
-    - colorscale : possible values are https://plotly.com/python/builtin-colorscales/
-    - marker_color : dots color value
-    - arrow_color : arrow pointing to topic centroid color value
-    - width / height = size of plot
-    - show_text : show dots
-    - show_topic : show topics labels
-    - show_halo : show circles around topics
-    - show_histogram : show 2Dhistogram with contours
-    - label_size_ratio : influence the size of the topics labels, higher value means smaller topics labels
-    - n_words : number of words to display (words should be separated by | in col_text)
-    - title_text = graph title
-    - max_dots_displayed : number of dots to display,
-    - max_topics_displayed : number of topics to display
-    - opacity : opacity of dots
-    """  
 
     # df_topics = df_distrib_sample.copy()
     df_topics= df_topics.dropna(subset=col_text)
@@ -834,9 +1084,25 @@ def density_map(df_posts,
 
 
 
-def topic_heatmap(df, col_x = "topic_x", col_y = "topic_y", col_topic = "soft_topic", color_continuous_scale='GnBu', title ="Similarity between topics"):
+def topic_heatmap(df: pd.DataFrame,
+                  col_x: str = "topic_x",
+                  col_y: str = "topic_y",
+                  col_topic: str = "soft_topic",
+                  color_continuous_scale: str = 'GnBu',
+                  title: str = "Similarity between topics") -> go.Figure:
     """
-    
+    Display a heatmap representing the similarity between topics.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing the topic data.
+        col_x (str, optional): Column name for x-axis coordinates. Defaults to "topic_x".
+        col_y (str, optional): Column name for y-axis coordinates. Defaults to "topic_y".
+        col_topic (str, optional): Column name for the topic labels. Defaults to "soft_topic".
+        color_continuous_scale (str, optional): Plotly color scale. Defaults to 'GnBu'.
+        title (str, optional): Title of the heatmap. Defaults to "Similarity between topics".
+
+    Returns:
+        go.Figure: Plotly figure object representing the heatmap.
     """
 
     distance_matrix = cosine_similarity(np.array(df[[col_x,col_y]]))
@@ -871,7 +1137,34 @@ def topic_heatmap(df, col_x = "topic_x", col_y = "topic_y", col_topic = "soft_to
     fig.update_layout(legend_title_text='Trend')
     return fig
 
-def generate_wordcloud(df, col_word, col_metric, width=3000, height=1500, dpi=300, background_color='white', font_path = "font/SEGUIEMJ.TTF", colormap="Viridis", show=False):
+def generate_wordcloud(df: pd.DataFrame,
+                       col_word: str,
+                       col_metric: str,
+                       width: int = 3000,
+                       height: int = 1500,
+                       dpi: int = 300,
+                       background_color: str = 'white',
+                       font_path: str = "font/SEGUIEMJ.TTF",
+                       colormap: str = "Viridis",
+                       show: bool = False) -> WordCloud:
+    """
+    Generate a word cloud from a DataFrame.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing word frequency data.
+        col_word (str): Column name containing words.
+        col_metric (str): Column name containing frequency metrics for each word.
+        width (int, optional): Width of the word cloud image. Defaults to 3000.
+        height (int, optional): Height of the word cloud image. Defaults to 1500.
+        dpi (int, optional): Dots per inch for image resolution. Defaults to 300.
+        background_color (str, optional): Background color of the word cloud image. Defaults to 'white'.
+        font_path (str, optional): Path to the font file to be used in the word cloud. Defaults to "font/SEGUIEMJ.TTF".
+        colormap (str, optional): Colormap for the word cloud image. Defaults to "Viridis".
+        show (bool, optional): Whether to display the word cloud image. Defaults to False.
+
+    Returns:
+        WordCloud: WordCloud object representing the generated word cloud.
+    """
     
     top_n_words={row[col_word]:row[col_metric] for i,row in df.iterrows()}
     
@@ -882,12 +1175,36 @@ def generate_wordcloud(df, col_word, col_metric, width=3000, height=1500, dpi=30
         plt.imshow(wordcloud, interpolation='bilinear')
         plt.axis('off')
         plt.show()
-
     return wordcloud
 
+def create_radar(df: pd.DataFrame,
+                 col_topic: str,
+                 col_metrics: list,
+                 title: str = "Radar",
+                 opacity: float = 0.6,
+                 width: int = 1000,
+                 height: int = 1000,
+                 template: str = "ggplot2",
+                 plot_bgcolor: str = None,
+                 paper_bgcolor: str = None) -> go.Figure:
+    """
+    Create a radar chart.
 
+    Args:
+        df (pd.DataFrame): DataFrame containing data for radar chart.
+        col_topic (str): Column name containing topics.
+        col_metrics (List[str]): List of column names containing metric values.
+        title (str, optional): Title of the radar chart. Defaults to "Radar".
+        opacity (float, optional): Opacity of radar area. Defaults to 0.6.
+        width (int, optional): Width of the radar chart. Defaults to 1000.
+        height (int, optional): Height of the radar chart. Defaults to 1000.
+        template (str, optional): Plotly template to use. Defaults to "ggplot2".
+        plot_bgcolor (Optional[str], optional): Background color of the plot. Defaults to None.
+        paper_bgcolor (Optional[str], optional): Background color of the paper. Defaults to None.
 
-def create_radar(df, col_topic, col_metrics, title="Radar", opacity=0.6, width = 1000, height= 1000, template = "ggplot2" , plot_bgcolor=None, paper_bgcolor=None):
+    Returns:
+        go.Figure: Plotly Figure object representing the radar chart.
+    """
 
     df = df[[col_topic] + col_metrics]
     col_metrics.append(col_metrics[0])
@@ -934,12 +1251,54 @@ def create_radar(df, col_topic, col_metrics, title="Radar", opacity=0.6, width =
         template=template,
         margin=dict(l=100, r=100, t=100, b=100)
     )
+    return fig
 
+def bar_subplots(df: pd.DataFrame,
+                 col_x: str,
+                 col_y: str,
+                 col_cat: str,
+                 color_palette: dict = None,
+                 n_cols: int = 4,
+                 n_top_words: int = 20,
+                 horizontal_spacing: float = 0.2,
+                 vertical_spacing: float = 0.08,
+                 textposition: str = None,
+                 color: str = None,
+                 title: str = "Top words per topic",
+                 template: str = "plotly",
+                 bargap: float = 0.4,
+                 width: int = 500,
+                 height: int = 35,
+                 plot_bgcolor: str = None,
+                 paper_bgcolor: str = None,
+                 showlegend: bool = True) -> go.Figure:
+    """
+    Create subplots of horizontal bar charts.
 
-    return fig
+    Args:
+        df (pd.DataFrame): DataFrame containing data for bar charts.
+        col_x (str): Name of the column containing x-axis values.
+        col_y (str): Name of the column containing y-axis values.
+        col_cat (str): Name of the column containing categories.
+        color_palette (Optional[Dict[str, str]], optional): Dictionary mapping categories to colors. Defaults to None.
+        n_cols (int, optional): Number of columns in the subplot grid. Defaults to 4.
+        n_top_words (int, optional): Number of top words to display in each bar chart. Defaults to 20.
+        horizontal_spacing (float, optional): Spacing between subplots horizontally. Defaults to 0.2.
+        vertical_spacing (float, optional): Spacing between subplots vertically. Defaults to 0.08.
+        textposition (Optional[str], optional): Position of the text relative to the bars ('inside', 'outside', or None). Defaults to None.
+        color (Optional[str], optional): Color of the bars. Defaults to None.
+        title (str, optional): Title of the subplot. Defaults to "Top words per topic".
+        template (str, optional): Plotly template to use. Defaults to "plotly".
+        bargap (float, optional): Space between bars in the same cluster. Defaults to 0.4.
+        width (int, optional): Width of each subplot. Defaults to 500.
+        height (int, optional): Height of each bar in the subplot. Defaults to 35.
+        plot_bgcolor (Optional[str], optional): Background color of the plot. Defaults to None.
+        paper_bgcolor (Optional[str], optional): Background color of the paper. Defaults to None.
+        showlegend (bool, optional): Whether to display the legend. Defaults to True.
 
-def bar_subplots(df, col_x, col_y, col_cat, color_palette, n_cols=4, n_top_words = 20, horizontal_spacing = 0.2, vertical_spacing = 0.08, textposition=None, color = None, title =  "Top words per topic", template = "plotly", bargap = 0.4,  width = 500, height = 35, plot_bgcolor=None, paper_bgcolor=None, showlegend = True):
-    
+    Returns:
+        go.Figure: Plotly Figure object representing the subplots of horizontal bar charts.
+    """
     categories = df[col_cat].unique()
 
     # user define a number of columns, we compute the number of rows requires
@@ -947,16 +1306,16 @@ def bar_subplots(df, col_x, col_y, col_cat, color_palette, n_cols=4, n_top_words
 
     # fine tune parameter according to the text position provided
     if textposition == 'inside':
-        horizontal_spacing = (horizontal_spacing / n_rows)/2
+        horizontal_spacing = (horizontal_spacing / n_cols)/2
     else:
-        horizontal_spacing = (horizontal_spacing / n_rows)
+        horizontal_spacing = (horizontal_spacing / n_cols)
         
     # create subplots
     fig = make_subplots(
         rows = n_rows,                           # number of rows
         cols = n_cols,                           # number of columns
         subplot_titles = list(categories),       # title for each subplot
-        vertical_spacing = vertical_spacing / n_cols,     # space between subplots
+        vertical_spacing = vertical_spacing / n_rows,     # space between subplots
         horizontal_spacing = horizontal_spacing  # space between subplots
         )
 
@@ -1034,14 +1393,48 @@ def bar_subplots(df, col_x, col_y, col_cat, color_palette, n_cols=4, n_top_words
         )
     return fig
 
-def pie_subplots(df, col_x, col_y, col_cat, col_color, n_cols=4, horizontal_spacing = 0.2, vertical_spacing = 0.08, title =  "Top words per topic", template = "plotly",  width = 500, height = 150, plot_bgcolor=None, paper_bgcolor=None, showlegend = True):
-    
+def pie_subplots(df: pd.DataFrame,
+                 col_x: str,
+                 col_y: str,
+                 col_cat: str,
+                 col_color: str,
+                 n_cols: int = 4,
+                 horizontal_spacing: float = 0.2,
+                 vertical_spacing: float = 0.08,
+                 title: str = "Top words per topic",
+                 template: str = "plotly",
+                 width: int = 500,
+                 height: int = 150,
+                 plot_bgcolor: str = None,
+                 paper_bgcolor: str = None,
+                 showlegend: bool = True) -> go.Figure:
+    """
+    Create subplots of pie charts.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing data for pie charts.
+        col_x (str): Name of the column containing labels.
+        col_y (str): Name of the column containing values.
+        col_cat (str): Name of the column containing categories.
+        col_color (str): Name of the column containing colors.
+        n_cols (int, optional): Number of columns in the subplot grid. Defaults to 4.
+        horizontal_spacing (float, optional): Spacing between subplots horizontally. Defaults to 0.2.
+        vertical_spacing (float, optional): Spacing between subplots vertically. Defaults to 0.08.
+        title (str, optional): Title of the subplot. Defaults to "Top words per topic".
+        template (str, optional): Plotly template to use. Defaults to "plotly".
+        width (int, optional): Width of each subplot. Defaults to 500.
+        height (int, optional): Height of each subplot. Defaults to 150.
+        plot_bgcolor (Optional[str], optional): Background color of the plot. Defaults to None.
+        paper_bgcolor (Optional[str], optional): Background color of the paper. Defaults to None.
+        showlegend (bool, optional): Whether to display the legend. Defaults to True.
+
+    Returns:
+        go.Figure: Plotly Figure object representing the subplots of pie charts.
+    """    
     categories = df[col_cat].unique()
 
     # user define a number of columns, we compute the number of rows requires
     n_rows =  math.ceil(len(categories) / n_cols)
-
-    horizontal_spacing = (horizontal_spacing / n_rows)
         
     specs = [[{'type':'domain'}] * n_cols] * n_rows
     # create subplots
@@ -1049,8 +1442,8 @@ def pie_subplots(df, col_x, col_y, col_cat, col_color, n_cols=4, horizontal_spac
         rows=n_rows,
         cols=n_cols,
         subplot_titles=list(categories),
-        horizontal_spacing=horizontal_spacing,
-        vertical_spacing=vertical_spacing,
+        horizontal_spacing=horizontal_spacing / n_cols,
+        vertical_spacing=vertical_spacing / n_rows,
         specs=specs
     )
 
@@ -1103,8 +1496,44 @@ def pie_subplots(df, col_x, col_y, col_cat, col_color, n_cols=4, horizontal_spac
     return fig
 
 
-def horizontal_stacked_bars(df, col_x, col_y, col_percentage, col_cat, col_color, title_text = "Sentiment per topic", width=1200, height=1200, xaxis_tickangle=0, horizontal_spacing = 0.2, vertical_spacing = 0.08, plot_bgcolor=None, paper_bgcolor=None, template = "plotly"):
+def horizontal_stacked_bars(df: pd.DataFrame,
+                             col_x: str,
+                             col_y: str,
+                             col_percentage: str,
+                             col_cat: str,
+                             col_color: str,
+                             title_text: str = "Sentiment per topic",
+                             width: int = 1200,
+                             height: int = 1200,
+                             xaxis_tickangle: int = 0,
+                             horizontal_spacing: float = 0,
+                             vertical_spacing: float = 0.08,
+                             plot_bgcolor: str = None,
+                             paper_bgcolor: str = None,
+                             template: str = "plotly") -> go.Figure:
+    """
+    Create horizontal stacked bar plots.
 
+    Args:
+        df (pd.DataFrame): DataFrame containing data for the bar plots.
+        col_x (str): Name of the column containing x-axis values.
+        col_y (str): Name of the column containing y-axis values.
+        col_percentage (str): Name of the column containing percentage values.
+        col_cat (str): Name of the column containing categories.
+        col_color (str): Name of the column containing colors.
+        title_text (str, optional): Title of the plot. Defaults to "Sentiment per topic".
+        width (int, optional): Width of the plot. Defaults to 1200.
+        height (int, optional): Height of the plot. Defaults to 1200.
+        xaxis_tickangle (int, optional): Angle for x-axis ticks. Defaults to 0.
+        horizontal_spacing (float, optional): Spacing between subplots horizontally. Defaults to 0.
+        vertical_spacing (float, optional): Spacing between subplots vertically. Defaults to 0.08.
+        plot_bgcolor (Optional[str], optional): Background color of the plot. Defaults to None.
+        paper_bgcolor (Optional[str], optional): Background color of the paper. Defaults to None.
+        template (str, optional): Plotly template to use. Defaults to "plotly".
+
+    Returns:
+        go.Figure: Plotly Figure object representing the horizontal stacked bar plots.
+    """
     categories = df[col_cat].unique()
 
     n_cols=2
@@ -1112,8 +1541,8 @@ def horizontal_stacked_bars(df, col_x, col_y, col_percentage, col_cat, col_color
         rows = 1,                           # number of rows
         cols = 2,                           # number of columns
         # subplot_titles = list(categories),       # title for each subplot
-        vertical_spacing = vertical_spacing / n_cols,     # space between subplots
-        horizontal_spacing = 0  # space between subplots
+        vertical_spacing = vertical_spacing,     # space between subplots
+        horizontal_spacing = horizontal_spacing / n_cols # space between subplots
         )
     
     for cat in categories:
@@ -1181,8 +1610,44 @@ def horizontal_stacked_bars(df, col_x, col_y, col_percentage, col_cat, col_color
     
     return fig
 
-def bar_trend_per_day(df, col_date, col_metric1, col_metric2,  xaxis_title = "Date", y1_axis_title = "Verbatims", y2_axis_title = "Engagements", title_text = "Trend - couverture & résonance", width = 1500, height = 700, marker_color = "indianred", line_color = "#273746", plot_bgcolor=None, paper_bgcolor=None, template = "plotly"):
+def bar_trend_per_day(df: pd.DataFrame, 
+                      col_date: str, 
+                      col_metric1: str, 
+                      col_metric2: str, 
+                      xaxis_title: str = "Date", 
+                      y1_axis_title: str = "Verbatims", 
+                      y2_axis_title: str = "Engagements", 
+                      title_text: str = "Trend - couverture & résonance", 
+                      width: int = 1500, 
+                      height: int = 700, 
+                      marker_color: str = "indianred", 
+                      line_color: str = "#273746", 
+                      plot_bgcolor: str = None, 
+                      paper_bgcolor: str = None, 
+                      template: str = "plotly") -> go.Figure:
+    """
+    Creates a Plotly stacked bar chart with a secondary line plot for two metrics over time.
+
+    Parameters:
+    - df (pd.DataFrame): The DataFrame containing the data.
+    - col_date (str): The name of the column containing dates.
+    - col_metric1 (str): The name of the column containing the first metric values.
+    - col_metric2 (str): The name of the column containing the second metric values.
+    - xaxis_title (str, optional): The title for the x-axis. Defaults to "Date".
+    - y1_axis_title (str, optional): The title for the primary y-axis. Defaults to "Verbatims".
+    - y2_axis_title (str, optional): The title for the secondary y-axis. Defaults to "Engagements".
+    - title_text (str, optional): The title text for the chart. Defaults to "Trend - couverture & résonance".
+    - width (int, optional): The width of the chart. Defaults to 1500.
+    - height (int, optional): The height of the chart. Defaults to 700.
+    - marker_color (str, optional): The color of the bars. Defaults to "indianred".
+    - line_color (str, optional): The color of the line plot. Defaults to "#273746".
+    - plot_bgcolor (str, optional): The background color of the plot area. Defaults to None.
+    - paper_bgcolor (str, optional): The background color of the paper area. Defaults to None.
+    - template (str, optional): The template of the chart. Defaults to "plotly".
 
+    Returns:
+    - fig (go.Figure): The Plotly Figure object representing the stacked bar chart with line plot.
+    """
     # Plotly Stacked Bar Chart
     fig = make_subplots(specs=[[{"secondary_y": True}]])
     hovertemplate='<b>Date :</b>'+ df[col_date].astype(str) + '<br><b>'+y1_axis_title+'</b>:'+ df[col_metric1].astype(str)+ '<br><b>'+y2_axis_title+'</b>:'+ df[col_metric2].astype(int).astype(str)
@@ -1251,8 +1716,46 @@ def bar_trend_per_day(df, col_date, col_metric1, col_metric2,  xaxis_title = "Da
 
     return fig
 
-def bar_trend_per_day_per_cat(df, col_date, col_cat, col_metric1, col_metric2, col_color, xaxis_title = "Date", y1_axis_title = "Verbatims", y2_axis_title = "Engagements", title_text = "Trend - couverture & résonance", vertical_spacing = 0.1, width = 1500, height = 700, marker_color = "indianred", line_color = "#273746", plot_bgcolor=None, paper_bgcolor=None, template = "plotly"):
+def bar_trend_per_day_per_cat(df: pd.DataFrame, 
+                              col_date: str, 
+                              col_cat: str, 
+                              col_metric1: str, 
+                              col_metric2: str, 
+                              col_color: str, 
+                              xaxis_title: str = "Date", 
+                              y1_axis_title: str = "Verbatims", 
+                              y2_axis_title: str = "Engagements", 
+                              title_text: str = "Trend - couverture & résonance", 
+                              vertical_spacing: float = 0.1, 
+                              width: int = 1500, 
+                              height: int = 700, 
+                              plot_bgcolor: str = None, 
+                              paper_bgcolor: str = None, 
+                              template: str = "plotly") -> go.Figure:
+    """
+    Creates a Plotly stacked bar chart with multiple categories, each represented as a separate subplot.
+
+    Parameters:
+    - df (pd.DataFrame): The DataFrame containing the data.
+    - col_date (str): The name of the column containing dates.
+    - col_cat (str): The name of the column containing categories.
+    - col_metric1 (str): The name of the column containing the first metric values.
+    - col_metric2 (str): The name of the column containing the second metric values.
+    - col_color (str): The name of the column containing the color codes for each category.
+    - xaxis_title (str, optional): The title for the x-axis. Defaults to "Date".
+    - y1_axis_title (str, optional): The title for the primary y-axis. Defaults to "Verbatims".
+    - y2_axis_title (str, optional): The title for the secondary y-axis. Defaults to "Engagements".
+    - title_text (str, optional): The title text for the chart. Defaults to "Trend - couverture & résonance".
+    - vertical_spacing (float, optional): The space between subplots. Defaults to 0.1.
+    - width (int, optional): The width of the chart. Defaults to 1500.
+    - height (int, optional): The height of the chart. Defaults to 700.
+    - plot_bgcolor (str, optional): The background color of the plot area. Defaults to None.
+    - paper_bgcolor (str, optional): The background color of the paper area. Defaults to None.
+    - template (str, optional): The template of the chart. Defaults to "plotly".
 
+    Returns:
+    - fig (go.Figure): The Plotly Figure object representing the stacked bar chart with subplots for each category.
+    """
     fig = make_subplots(
         rows = 2,                           # number of rows
         cols = 1,                           # number of columns
@@ -1333,8 +1836,36 @@ def bar_trend_per_day_per_cat(df, col_date, col_cat, col_metric1, col_metric2, c
 
     return fig
 
-def pie(df, col_x, col_y, col_color, title =  "Sentiment", template = "plotly",  width = 1000, height = 1000, plot_bgcolor=None, paper_bgcolor=None, showlegend = True):
-    
+def pie(df: pd.DataFrame, 
+        col_x: str, 
+        col_y: str, 
+        col_color: str, 
+        title: str = "Sentiment", 
+        template: str = "plotly",  
+        width: int = 1000, 
+        height: int = 1000, 
+        plot_bgcolor: str = None, 
+        paper_bgcolor: str = None, 
+        showlegend: bool = True) -> go.Figure:
+    """
+    Creates a Plotly pie chart.
+
+    Parameters:
+    - df (pd.DataFrame): The DataFrame containing the data.
+    - col_x (str): The name of the column containing the labels for the pie chart slices.
+    - col_y (str): The name of the column containing the values for the pie chart slices.
+    - col_color (str): The name of the column containing the colors for the pie chart slices.
+    - title (str, optional): The title for the pie chart. Defaults to "Sentiment".
+    - template (str, optional): The template of the chart. Defaults to "plotly".
+    - width (int, optional): The width of the chart. Defaults to 1000.
+    - height (int, optional): The height of the chart. Defaults to 1000.
+    - plot_bgcolor (str, optional): The background color of the plot area. Defaults to None.
+    - paper_bgcolor (str, optional): The background color of the paper area. Defaults to None.
+    - showlegend (bool, optional): Whether to show the legend. Defaults to True.
+
+    Returns:
+    - fig (go.Figure): The Plotly Figure object representing the pie chart.
+    """    
     fig = go.Figure()
     fig.add_trace(go.Pie(
         labels=df[col_x],
@@ -1373,8 +1904,40 @@ def pie(df, col_x, col_y, col_color, title =  "Sentiment", template = "plotly",
     )
     return fig
 
-def bar(df, x, y, color="indianred", xaxis_title="x", yaxis_title="y", width=1200, height = 700, title_text="", plot_bgcolor=None, paper_bgcolor=None, template = "plotly", showlegend=True):
+def bar(df: pd.DataFrame, 
+        x: str, 
+        y: str, 
+        color: str = "indianred", 
+        xaxis_title: str = "x", 
+        yaxis_title: str = "y", 
+        width: int = 1200, 
+        height: int = 700, 
+        title_text: str = "", 
+        plot_bgcolor: str = None, 
+        paper_bgcolor: str = None, 
+        template: str = "plotly", 
+        showlegend: bool = True) -> go.Figure:
+    """
+    Creates a Plotly vertical bar chart.
+
+    Parameters:
+    - df (pd.DataFrame): The DataFrame containing the data.
+    - x (str): The name of the column containing the x-axis values.
+    - y (str): The name of the column containing the y-axis values.
+    - color (str, optional): The color of the bars. Defaults to "indianred".
+    - xaxis_title (str, optional): The title for the x-axis. Defaults to "x".
+    - yaxis_title (str, optional): The title for the y-axis. Defaults to "y".
+    - width (int, optional): The width of the chart. Defaults to 1200.
+    - height (int, optional): The height of the chart. Defaults to 700.
+    - title_text (str, optional): The title text for the chart. Defaults to "".
+    - plot_bgcolor (str, optional): The background color of the plot area. Defaults to None.
+    - paper_bgcolor (str, optional): The background color of the paper area. Defaults to None.
+    - template (str, optional): The template of the chart. Defaults to "plotly".
+    - showlegend (bool, optional): Whether to show the legend. Defaults to True.
 
+    Returns:
+    - fig (go.Figure): The Plotly Figure object representing the vertical bar chart.
+    """
     fig = go.Figure()
     fig.add_trace(
         go.Bar(
@@ -1411,7 +1974,28 @@ def bar(df, x, y, color="indianred", xaxis_title="x", yaxis_title="y", width=120
     return fig
 
 
-def add_horizontal_line(fig, y, line_color = "gray", line_width = 1.5, line_dash = "dash", annotation_text = "Longueur moyenne des textes", annotation_position = "top right"):
+def add_horizontal_line(fig: go.Figure, 
+                         y: float, 
+                         line_color: str = "gray", 
+                         line_width: float = 1.5, 
+                         line_dash: str = "dash", 
+                         annotation_text: str = "Longueur moyenne des textes", 
+                         annotation_position: str = "top right") -> go.Figure:
+    """
+    Adds a horizontal line to a Plotly Figure object.
+
+    Parameters:
+    - fig (go.Figure): The Plotly Figure object to which the horizontal line will be added.
+    - y (float): The y-coordinate of the horizontal line.
+    - line_color (str, optional): The color of the horizontal line. Defaults to "gray".
+    - line_width (float, optional): The width of the horizontal line. Defaults to 1.5.
+    - line_dash (str, optional): The dash style of the horizontal line. Defaults to "dash".
+    - annotation_text (str, optional): The text annotation associated with the horizontal line. Defaults to "Longueur moyenne des textes".
+    - annotation_position (str, optional): The position of the annotation relative to the horizontal line. Defaults to "top right".
+
+    Returns:
+    - fig (go.Figure): The Plotly Figure object with the horizontal line added.
+    """    
     fig.add_hline(
         y=y, 
         line_width=line_width, 
@@ -1422,7 +2006,28 @@ def add_horizontal_line(fig, y, line_color = "gray", line_width = 1.5, line_dash
         )
     return fig
 
-def add_vertical_line(fig, x, line_color = "gray", line_width = 1.5, line_dash = "dash", annotation_text = "Longueur moyenne des textes", annotation_position = "top right"):
+def add_vertical_line(fig: go.Figure, 
+                      x: float, 
+                      line_color: str = "gray", 
+                      line_width: float = 1.5, 
+                      line_dash: str = "dash", 
+                      annotation_text: str = "Longueur moyenne des textes", 
+                      annotation_position: str = "top right") -> go.Figure:
+    """
+    Adds a vertical line to a Plotly Figure object.
+
+    Parameters:
+    - fig (go.Figure): The Plotly Figure object to which the vertical line will be added.
+    - x (float): The x-coordinate of the vertical line.
+    - line_color (str, optional): The color of the vertical line. Defaults to "gray".
+    - line_width (float, optional): The width of the vertical line. Defaults to 1.5.
+    - line_dash (str, optional): The dash style of the vertical line. Defaults to "dash".
+    - annotation_text (str, optional): The text annotation associated with the vertical line. Defaults to "Longueur moyenne des textes".
+    - annotation_position (str, optional): The position of the annotation relative to the vertical line. Defaults to "top right".
+
+    Returns:
+    - fig (go.Figure): The Plotly Figure object with the vertical line added.
+    """
     fig.add_vline(
         x=x, 
         line_width=line_width, 
@@ -1433,9 +2038,50 @@ def add_vertical_line(fig, x, line_color = "gray", line_width = 1.5, line_dash =
         )
     return fig
 
-def network_graph(T, col_size="scaled_size", col_color="modularity_color",  title_text = "Analyse de similitudes", sample_nodes = 0.15, show_edges=True, show_halo=False, textposition=None, line_color = "#B7B7B7", line_dash="dot", edge_mode = "lines+markers", node_mode="markers+text", opacity=0.2, width=1600, height=1200, plot_bgcolor=None, paper_bgcolor=None, template="plotly"):
-    
-    
+def network_graph(T: nx.Graph, 
+                  col_size: str = "scaled_size", 
+                  col_color: str = "modularity_color",  
+                  title_text: str = "Analyse de similitudes", 
+                  sample_nodes: float = 0.15, 
+                  show_edges: bool = True, 
+                  show_halo: bool = False, 
+                  textposition: str = None, 
+                  line_color: str = "#B7B7B7", 
+                  line_dash: str = "dot", 
+                  edge_mode: str = "lines+markers", 
+                  node_mode: str = "markers+text", 
+                  opacity: float = 0.2, 
+                  width: int = 1600, 
+                  height: int = 1200, 
+                  plot_bgcolor: str = None, 
+                  paper_bgcolor: str = None, 
+                  template: str = "plotly") -> go.Figure:
+    """
+    Creates a network graph visualization using Plotly.
+
+    Parameters:
+    - T (nx.Graph): The NetworkX graph object.
+    - col_size (str, optional): The column name for node size. Defaults to "scaled_size".
+    - col_color (str, optional): The column name for node color. Defaults to "modularity_color".
+    - title_text (str, optional): The title for the graph. Defaults to "Analyse de similitudes".
+    - sample_nodes (float, optional): The proportion of nodes to sample for displaying labels. Defaults to 0.15.
+    - show_edges (bool, optional): Whether to display edges. Defaults to True.
+    - show_halo (bool, optional): Whether to display halo around nodes. Defaults to False.
+    - textposition (str, optional): The position of node labels. Defaults to None.
+    - line_color (str, optional): The color of edges. Defaults to "#B7B7B7".
+    - line_dash (str, optional): The dash style of edges. Defaults to "dot".
+    - edge_mode (str, optional): The mode for displaying edges. Defaults to "lines+markers".
+    - node_mode (str, optional): The mode for displaying nodes. Defaults to "markers+text".
+    - opacity (float, optional): The opacity of nodes. Defaults to 0.2.
+    - width (int, optional): The width of the plot. Defaults to 1600.
+    - height (int, optional): The height of the plot. Defaults to 1200.
+    - plot_bgcolor (str, optional): The background color of the plot area. Defaults to None.
+    - paper_bgcolor (str, optional): The background color of the paper area. Defaults to None.
+    - template (str, optional): The template of the plot. Defaults to "plotly".
+
+    Returns:
+    - fig (go.Figure): The Plotly Figure object representing the network graph visualization.
+    """    
     # on construit un dataframe des noeuds à partir des données du graphe pour plus de simplicité
     df_nodes=pd.DataFrame()
     for node in T.nodes(data=True):
@@ -1548,7 +2194,24 @@ def network_graph(T, col_size="scaled_size", col_color="modularity_color",  titl
     
     return fig
 
-def richesse_lexicale(df, title= "Richesse lexicale", width=1200, height=1000, template="plotly"):
+def richesse_lexicale(df: pd.DataFrame, 
+                      title: str = "Richesse lexicale", 
+                      width: int = 1200, 
+                      height: int = 1000, 
+                      template: str = "plotly") -> go.Figure:
+    """
+    Creates a lexical richness visualization using Plotly.
+
+    Parameters:
+    - df (pd.DataFrame): The DataFrame containing word frequency data.
+    - title (str, optional): The title for the plot. Defaults to "Richesse lexicale".
+    - width (int, optional): The width of the plot. Defaults to 1200.
+    - height (int, optional): The height of the plot. Defaults to 1000.
+    - template (str, optional): The template of the plot. Defaults to "plotly".
+
+    Returns:
+    - fig_richesse (go.Figure): The Plotly Figure object representing the lexical richness visualization.
+    """
     df = create_frequency_table(df, "freq")
     fig_richesse = go.Figure()
     fig_richesse.add_trace(
@@ -1569,7 +2232,26 @@ def richesse_lexicale(df, title= "Richesse lexicale", width=1200, height=1000, t
     fig_richesse.update_yaxes(tickformat=".0f", title_text="Freq", type="log")
     return fig_richesse
 
-def richesse_lexicale_per_topic(df, col_topic, title= "Richesse lexicale par topic", width=1200, height=1000, template="plotly"):
+def richesse_lexicale_per_topic(df: pd.DataFrame, 
+                                col_topic: str, 
+                                title: str = "Richesse lexicale par topic", 
+                                width: int = 1200, 
+                                height: int = 1000, 
+                                template: str = "plotly") -> go.Figure:
+    """
+    Creates a lexical richness visualization per topic using Plotly.
+
+    Parameters:
+    - df (pd.DataFrame): The DataFrame containing word frequency data.
+    - col_topic (str): The name of the column representing topics.
+    - title (str, optional): The title for the plot. Defaults to "Richesse lexicale par topic".
+    - width (int, optional): The width of the plot. Defaults to 1200.
+    - height (int, optional): The height of the plot. Defaults to 1000.
+    - template (str, optional): The template of the plot. Defaults to "plotly".
+
+    Returns:
+    - fig_richesse (go.Figure): The Plotly Figure object representing the lexical richness visualization per topic.
+    """
     fig_richesse = go.Figure()
     for topic in list(df[col_topic].unique()):
         df_tmp = create_frequency_table(df[df[col_topic]==topic], "freq")
@@ -1591,8 +2273,42 @@ def richesse_lexicale_per_topic(df, col_topic, title= "Richesse lexicale par top
         fig_richesse.update_yaxes(tickformat=".0f", title_text="Freq", type="log")
     return fig_richesse
 
-def subplots_bar_per_day_per_cat(df, col_date, col_cat, metrics, col_color, y_axis_titles, xaxis_title = "Date",title_text = "Trend - couverture & résonance", vertical_spacing = 0.1, width = 1500, height = 700, marker_color = "indianred", line_color = "#273746", plot_bgcolor=None, paper_bgcolor=None, template = "plotly"):
+def subplots_bar_per_day_per_cat(df: pd.DataFrame, 
+                                 col_date: str, 
+                                 col_cat: str, 
+                                 metrics: list, 
+                                 col_color: str, 
+                                 y_axis_titles: list, 
+                                 xaxis_title: str = "Date", 
+                                 title_text: str = "Trend - couverture & résonance", 
+                                 vertical_spacing: float = 0.1, 
+                                 width: int = 1500, 
+                                 height: int = 700, 
+                                 plot_bgcolor: str = None, 
+                                 paper_bgcolor: str = None, 
+                                 template: str = "plotly") -> go.Figure:
+    """
+    Creates subplots of stacked bar charts per day and category using Plotly.
+
+    Parameters:
+    - df (pd.DataFrame): The DataFrame containing the data.
+    - col_date (str): The name of the column representing dates.
+    - col_cat (str): The name of the column representing categories.
+    - metrics (List[str]): A list of column names representing metrics to be plotted.
+    - col_color (str): The name of the column representing colors for bars.
+    - y_axis_titles (List[str]): A list of titles for the y-axes of subplots.
+    - xaxis_title (str, optional): The title for the x-axis. Defaults to "Date".
+    - title_text (str, optional): The title for the entire plot. Defaults to "Trend - couverture & résonance".
+    - vertical_spacing (float, optional): The space between subplots. Defaults to 0.1.
+    - width (int, optional): The width of the entire plot. Defaults to 1500.
+    - height (int, optional): The height of each subplot. Defaults to 700.
+    - plot_bgcolor (str, optional): The background color for the plot area. Defaults to None.
+    - paper_bgcolor (str, optional): The background color for the paper area. Defaults to None.
+    - template (str, optional): The template of the plot. Defaults to "plotly".
 
+    Returns:
+    - fig (go.Figure): The Plotly Figure object representing the subplots of stacked bar charts.
+    """
     fig = make_subplots(
         rows = len(metrics),                           # number of rows
         cols = 1,                           # number of columns
@@ -1668,7 +2384,38 @@ def subplots_bar_per_day_per_cat(df, col_date, col_cat, metrics, col_color, y_ax
     return fig
 
     
-def add_shape(fig, shape_type = "rect", x0= -1, y0= -1, x1 = 0, y1=0, fillcolor= 'Silver', opacity = 0.1, line_width = 0, line_color = 'white', dash = None, layer = "below"):
+def add_shape(fig: go.Figure, 
+              shape_type: str = "rect", 
+              x0: float = -1, 
+              y0: float = -1, 
+              x1: float = 0, 
+              y1: float = 0, 
+              fillcolor: str = 'Silver', 
+              opacity: float = 0.1, 
+              line_width: float = 0, 
+              line_color: str = 'white', 
+              dash: str = None, 
+              layer: str = "below") -> go.Figure:
+    """
+    Adds a shape to a Plotly figure.
+
+    Parameters:
+    - fig (go.Figure): The Plotly Figure object.
+    - shape_type (str, optional): The type of shape to add. Defaults to "rect".
+    - x0 (float, optional): The x-coordinate of the lower left corner of the shape. Defaults to -1.
+    - y0 (float, optional): The y-coordinate of the lower left corner of the shape. Defaults to -1.
+    - x1 (float, optional): The x-coordinate of the upper right corner of the shape. Defaults to 0.
+    - y1 (float, optional): The y-coordinate of the upper right corner of the shape. Defaults to 0.
+    - fillcolor (str, optional): The fill color of the shape. Defaults to 'Silver'.
+    - opacity (float, optional): The opacity of the shape. Defaults to 0.1.
+    - line_width (float, optional): The width of the shape's outline. Defaults to 0.
+    - line_color (str, optional): The color of the shape's outline. Defaults to 'white'.
+    - dash (str, optional): The dash style of the shape's outline. Defaults to None.
+    - layer (str, optional): The layer on which the shape is added, either 'below' or 'above' the data. Defaults to "below".
+
+    Returns:
+    - fig (go.Figure): The modified Plotly Figure object with the added shape.
+    """
     fig.add_shape(
             # Shape for the area between (-1, 0)
             {
@@ -1688,4 +2435,46 @@ def add_shape(fig, shape_type = "rect", x0= -1, y0= -1, x1 = 0, y1=0, fillcolor=
                 
             }
         )
+    return fig
+
+def add_image(fig: go.Figure, 
+              xref: str = "paper", 
+              yref: str = "paper", 
+              x: float = 0, 
+              y: float = 0, 
+              sizex: float = 0.08, 
+              sizey: float = 0.08, 
+              xanchor: str = "right", 
+              yanchor: str = "bottom", 
+              source: str = "data:image/svg+xml;base64,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") -> go.Figure:
+    """
+    Adds an image to a Plotly figure.
+
+    Parameters:
+    - fig (go.Figure): The Plotly Figure object.
+    - xref (str, optional): The x-coordinate reference point. Defaults to "paper".
+    - yref (str, optional): The y-coordinate reference point. Defaults to "paper".
+    - x (float, optional): The x-coordinate of the image position. Defaults to 0.
+    - y (float, optional): The y-coordinate of the image position. Defaults to 0.
+    - sizex (float, optional): The size of the image in the x-direction. Defaults to 0.08.
+    - sizey (float, optional): The size of the image in the y-direction. Defaults to 0.08.
+    - xanchor (str, optional): The x-coordinate anchor point. Defaults to "right".
+    - yanchor (str, optional): The y-coordinate anchor point. Defaults to "bottom".
+    - source (str, optional): The URL source of the image. Defaults to "https://www.example.com/image.jpg".
+
+    Returns:
+    - fig (go.Figure): The modified Plotly Figure object with the added image.
+    """
+    fig.add_layout_image(
+    dict(
+        source=source,
+        xref=xref, 
+        yref=yref,
+        x=x, y=y,
+        sizex=sizex, 
+        sizey=sizey,
+        xanchor=xanchor,
+        yanchor=yanchor
+        )
+    )
     return fig