Upload 5 files

src/AutoVisualizer/categorical_viz.py

@@ -0,0 +1,283 @@
+# Module that will handle plots like bar chart, count plot, pie chart, etc.
+import plotly.express as px
+import streamlit as st
+import numpy as np
+import pandas as pd
+from plotly.subplots import make_subplots
+import plotly.graph_objs as go
+
+# Subplotting Function
+def combine_figures_as_subplots(figures: list, rows_per_column: int = 2):
+    """
+    Combines a list of Plotly figures into a single subplot layout.
+
+    Args:
+        figures (list): A list of individual Plotly figure objects to be arranged as subplots.
+        rows_per_column (int, optional): The number of subplot rows per column. Defaults to 2.
+
+    Returns:
+        plotly.graph_objects.Figure: A single Plotly figure containing all input figures as subplots.
+    """
+    total = len(figures)
+    cols = 1 if total <= rows_per_column else 2
+    rows = (total + cols - 1) // cols           # Ceiling division to compute total rows
+
+    # Determine subplot types for each cell
+    specs = []
+    for i in range(rows):
+        row_specs = []
+        for j in range(cols):
+            idx = i * cols + j
+            if idx < total and figures[idx].data and figures[idx].data[0].type == "pie":
+                row_specs.append({"type": "domain"})
+            else:
+                row_specs.append({"type": "xy"})
+        specs.append(row_specs)
+
+    # Create subplots with correct specs
+    subplot_fig = make_subplots(
+        rows=rows, cols=cols,
+        subplot_titles=[fig.layout.title.text for fig in figures],
+        specs=specs
+    )
+
+    # Add each figure's traces to the corresponding subplot cell
+    for idx, fig in enumerate(figures):
+        row = (idx // cols) + 1
+        col = (idx % cols) + 1
+
+        for trace in fig.data:
+            subplot_fig.add_trace(trace, row=row, col=col)
+
+        # Only update axes for non-pie charts
+        if fig.data[0].type != "pie":
+            xaxis_title = fig.layout.xaxis.title.text
+            yaxis_title = fig.layout.yaxis.title.text
+            subplot_fig.update_xaxes(title_text=xaxis_title, row=row, col=col)
+            subplot_fig.update_yaxes(title_text=yaxis_title, row=row, col=col)
+    
+    # Final layout adjustments
+    subplot_fig.update_layout(height=350 * rows, showlegend=False)
+    return subplot_fig
+
+# Count Plots Function
+def generate_count_plots(df: pd.DataFrame, categorical_column: str, max_label_len: int = 10):
+    """
+    Generates a count plot (bar chart) for a given categorical column in a DataFrame.
+
+    Args:
+        df (pd.DataFrame): The input dataset.
+        categorical_column (str): The name of the categorical column to plot.
+        max_label_len (int, optional): Maximum number of characters to display on x-axis labels. 
+                                       Longer labels are truncated with an ellipsis. Defaults to 10.
+
+    Returns:
+        list: A list containing a single Plotly bar chart figure.
+    """
+    plots = []
+    # Compute value counts for the selected column
+    value_counts = df[categorical_column].value_counts().reset_index()
+    value_counts.columns = [categorical_column, "Count"]
+
+    # Add truncated label column
+    value_counts["Truncated"] = value_counts[categorical_column].apply(
+        lambda x: x if len(str(x)) <= max_label_len else str(x)[:max_label_len] + "…"
+    )
+
+    # Create a bar plot
+    fig = px.bar(
+        value_counts, x="Truncated", y="Count", color="Truncated",
+        title=f"Count Plot for '{categorical_column}'",
+        labels={categorical_column: "Truncated", "Count": "Frequency"},
+        custom_data=[value_counts[categorical_column]]
+    )
+
+    # Use full label in hover template
+    fig.update_traces(
+        hovertemplate=f"{categorical_column}=%{{customdata}}<br>Count=%{{y}}<extra></extra>"
+    )
+
+    fig.update_layout(showlegend=False, xaxis_title=categorical_column)
+    plots.append(fig)
+    return plots
+
+# Bar Plot Function
+def generate_bar_plots(df: pd.DataFrame, x_col: str, y_columns: list, max_label_len: int = 10):
+    """
+    Generates bar plots showing the average of continuous features grouped by a categorical column.
+
+    Args:
+        df (pd.DataFrame): The input dataset.
+        x_col (str): The categorical column to group by (x-axis).
+        y_columns (list): List of continuous columns to aggregate and plot (y-axis).
+        max_label_len (int, optional): Maximum number of characters for x-axis labels. 
+                                       Labels longer than this are truncated. Defaults to 10.
+
+    Returns:
+        list: A list of Plotly bar chart figures.
+    """
+    plots = []
+
+    for y_col in y_columns:
+        # Compute mean aggregation
+        agg_func = df.groupby(x_col)[y_col].mean().reset_index()
+
+        # Add truncated label for x-axis ticks
+        agg_func["Truncated"] = agg_func[x_col].apply(
+            lambda x: x if len(str(x)) <= max_label_len else str(x)[:max_label_len] + "…"
+        )
+
+        fig = px.bar(
+            agg_func, x="Truncated", y=y_col, color="Truncated",  # color by original to retain legend info
+            title=f"{x_col} vs {y_col} (Average)",
+            labels={"Truncated": "", y_col: y_col},
+            custom_data=[agg_func[x_col]],
+        )
+
+        # Format hover values
+        if (df[y_col].dropna() % 1 == 0).all():
+            hover_format = ".0f"
+        else:
+            hover_format = ".2f"
+
+        # Show full x value on hover instead of truncated
+        fig.update_traces(
+            hovertemplate=f"{x_col}=%{{customdata[0]}}<br>Average {y_col}=%{{y:{hover_format}}}<extra></extra>",
+        )
+
+        fig.update_layout(showlegend=False, xaxis_title=x_col)
+        plots.append(fig)
+
+    return plots
+
+# Grouped Bar Plot Function
+def generate_grouped_bar_plots(df: pd.DataFrame, x_columns: list, y_columns: list, max_label_len: int = 10):
+    """
+    Generates grouped bar plots showing the average of continuous features 
+    grouped by a categorical feature and further separated by a binary hue column.
+
+    Args:
+        df (pd.DataFrame): The input dataset.
+        x_columns (list): Categorical columns to consider for x-axis and hue roles.
+        y_columns (list): Continuous columns to be averaged and plotted.
+        max_label_len (int, optional): Maximum length of x-axis labels before truncation. Defaults to 10.
+
+    Returns:
+        list: A list of Plotly grouped bar chart figures.
+    """
+    plots = []
+    
+    # Split categorical columns
+    hue_candidates = [col for col in x_columns if df[col].nunique() <= 2]
+    x_candidates = [col for col in x_columns if df[col].nunique() > 2 and df[col].nunique() <= 10]
+    
+    for x_col in x_candidates:
+        for y_col in y_columns:
+            for hue_col in hue_candidates:
+                # Group and aggregate
+                agg_func = df.groupby([x_col, hue_col])[y_col].mean().reset_index()
+
+                # Add truncated label for x-axis ticks
+                agg_func["Truncated"] = agg_func[x_col].apply(
+                    lambda x: x if len(str(x)) <= max_label_len else str(x)[:max_label_len] + "…"
+                )
+
+                fig = px.bar(
+                    agg_func,
+                    x="Truncated",
+                    y=y_col,
+                    color=hue_col,
+                    barmode="group",
+                    title=f"{x_col} vs {y_col} grouped by {hue_col}",
+                    labels={x_col: x_col, y_col: f"Average {y_col}", hue_col: hue_col},
+                    custom_data=[agg_func[x_col], agg_func[hue_col]]
+                )
+
+                # Formatting hover text
+                if (df[y_col].dropna() % 1 == 0).all():
+                    hover_format = ".0f"
+                else:
+                    hover_format = ".2f"
+            
+                # Show full x value on hover instead of truncated
+                fig.update_traces(
+                    hovertemplate=f"{x_col}=%{{customdata[0]}}<br>{hue_col}=%{{customdata[1]}}<br>Average {y_col}=%{{y:{hover_format}}}<extra></extra>",
+                )
+                fig.update_layout(showlegend=False, xaxis_title=x_col)
+                plots.append(fig)
+
+    return plots
+
+# Pie Charts Function
+def generate_pie_plots(df: pd.DataFrame, categorical_column: str, max_label_len: int = 10):
+    """
+    Generates a pie chart showing the distribution of values for a given categorical column.
+
+    Args:
+        df (pd.DataFrame): The input dataset.
+        categorical_column (str): The categorical column for which to create a pie chart.
+        max_label_len (int, optional): Maximum length of labels (currently unused here but reserved for consistency). Defaults to 10.
+
+    Returns:
+        list: A list containing one Plotly pie chart figure.
+    """
+    plots = []
+    # Count occurrences of each category
+    value_counts = df[categorical_column].value_counts().reset_index()
+    value_counts.columns = [categorical_column, "Count"]
+
+    fig = px.pie(
+        value_counts, names=categorical_column, values="Count",
+        hole=0.3, 
+        title=f"Pie Plot for '{categorical_column}'",
+    )
+    # Use full label in hover template
+    fig.update_traces(
+        textinfo='value',
+        hovertemplate=f"{categorical_column}=%{{label}}<br>Percentage=%{{percent}}<extra></extra>"
+    )
+
+    fig.update_layout(showlegend=False)
+    plots.append(fig)
+    return plots
+
+# HeatMap Function
+# Heatmap showing correlated categorical features based on a numerical target column
+def generate_categorical_correlation_heatmap(df: pd.DataFrame, numerical_col: str, categorical_columns: list):
+    """
+    Generates a heatmap showing correlations between categorical features based on a numeric target column.
+
+    This function encodes each categorical feature by replacing its categories with the mean value
+    of the numeric column for that category. Then it computes the Pearson correlation between the
+    encoded categorical features.
+
+    Args:
+        df (pd.DataFrame): The input DataFrame.
+        numerical_col (str): The target numeric column to base encoding on.
+        categorical_columns (list): List of categorical feature names to analyze.
+
+    Returns:
+        list: A list containing one Plotly heatmap figure visualizing the correlation matrix.
+    """
+    plots = []
+    encoded_df = pd.DataFrame()
+
+    # Encode categorical features using mean of numeric target per category
+    for col in categorical_columns:
+        temp = df[[col, numerical_col]].dropna()
+        means = temp.groupby(col)[numerical_col].mean()
+        encoded_df[col] = temp[col].map(means)
+    
+    # Compute correlation matrix on the encoded values
+    corr_matrix = encoded_df.corr(method="pearson")
+
+    fig = px.imshow(
+        corr_matrix,
+        text_auto=True,
+        color_continuous_scale="RdBu",
+        aspect="auto",
+        title=f"Categorical Feature Correlation Heatmap Based on your Target : '{numerical_col}'",
+    )
+
+    plots.append(fig)
+    return plots

src/AutoVisualizer/numerical_viz.py

@@ -0,0 +1,233 @@
+# Module that will handle plots like histogram, boxplot, density plot, etc.
+import plotly.express as px
+import streamlit as st
+import numpy as np
+import pandas as pd
+import plotly.graph_objs as go
+from scipy.stats import gaussian_kde
+
+# Box Plot Function
+def generate_box_plots(df: pd.DataFrame, x_col: str, y_columns: list, max_label_len: int = 10):
+    """
+    Generates box plots for multiple numerical columns grouped by a categorical column.
+
+    This function creates a series of Plotly box plots to visualize the distribution,
+    spread, and potential outliers of each numerical column across the values of a given 
+    categorical column. Long category labels are truncated for better readability.
+
+    Args:
+        df (pd.DataFrame): The input DataFrame.
+        x_col (str): Categorical column to group the box plots by.
+        y_columns (list): List of numerical columns to plot on the y-axis.
+        max_label_len (int, optional): Maximum character length for category labels on the x-axis (default is 10).
+
+    Returns:
+        list: A list of Plotly figure objects, each representing a box plot for a y_column grouped by x_col.
+    """
+    plots = []
+
+    # Drop rows with missing values in relevant columns
+    df = df[[x_col] + y_columns].dropna()
+    
+    # Truncate long category names
+    df["Truncated_X"] = df[x_col].apply(
+        lambda x: str(x) if len(str(x)) <= max_label_len else str(x)[:max_label_len] + "…"
+    )
+
+    for y_col in y_columns:
+        fig = px.box(
+            df,
+            x="Truncated_X", y=y_col,
+            color="Truncated_X",
+            points="outliers",  # Show outliers
+            title=f"Box Plot of {y_col} by {x_col}",
+            labels={"Truncated_X": x_col, y_col: y_col},
+        )
+
+        fig.update_layout(showlegend=False)
+        plots.append(fig)
+
+    return plots
+
+# HeatMap Functions
+## Heatmap of numerical (continuous) features
+def generate_numeric_correlation_heatmap(df: pd.DataFrame):
+    """
+    Generates a heatmap to visualize Pearson correlation between numerical features.
+
+    This function computes the correlation matrix for all numeric columns in the
+    DataFrame and returns a heatmap figure representing the strength and direction
+    of linear relationships between features.
+
+    Args:
+        df (pd.DataFrame): The input DataFrame.
+
+    Returns:
+        list: A list containing a single Plotly heatmap figure if enough numeric 
+              features exist; otherwise, returns an empty list.
+    """
+    plots = []
+    
+    # Filter numeric columns
+    numeric_df = df.select_dtypes(include=np.number)
+    
+    if numeric_df.shape[1] < 2:
+        return plots  # Not enough numeric features to compute correlation
+
+    corr_matrix = numeric_df.corr(method="pearson")
+
+    fig = px.imshow(
+        corr_matrix,
+        text_auto=True,
+        color_continuous_scale="RdBu",
+        aspect="auto",
+        title="Numerical Feature Correlation Heatmap",
+    )
+
+    plots.append(fig)
+    return plots
+
+# Scatter Plot Function
+def generate_scatter_plots(df: pd.DataFrame, feature_pairs: list, color_by: str = None):
+    """
+    Generates scatter plots for given pairs of numerical features.
+
+    Args:
+        df (pd.DataFrame): The input DataFrame containing the features.
+        feature_pairs (list): List of tuples containing (x, y) column names for each plot.
+        color_by (str, optional): Column name to color points by. Must be in df. Defaults to None.
+
+    Returns:
+        list: A list of Plotly scatter plot figures, one for each feature pair.
+    """
+    plots = []
+
+    for x_col, y_col in feature_pairs:
+        fig = px.scatter(
+            df.dropna(subset=[x_col, y_col]),
+            x=x_col,
+            y=y_col,
+            color=color_by if color_by in df.columns else None,
+            title=f"Scatter Plot: {x_col} vs {y_col}",
+            labels={x_col: x_col, y_col: y_col}
+        )
+        # Update title and legend if coloring is applied
+        if color_by:
+            fig.update_layout(title = f"Scatter Plot: {x_col} vs {y_col} color by {color_by}",showlegend=bool(color_by))
+        
+        fig.update_layout(showlegend=bool(color_by))
+        plots.append(fig)
+
+    return plots
+
+# Histogram Function
+def generate_histograms(df: pd.DataFrame, numeric_columns: list, bins: int = 30):
+    """
+    Generates histogram and KDE plots for each specified numeric column.
+
+    Args:
+        df (pd.DataFrame): The input DataFrame containing numeric features.
+        numeric_columns (list): List of column names to plot histograms for.
+        bins (int, optional): Number of bins to use in the histogram. Defaults to 30.
+
+    Returns:
+        list: A list of Plotly figures, each showing a histogram and KDE curve.
+    """
+    plots = []
+
+    for col in numeric_columns:
+        data = df[col].dropna()
+
+        # Histogram
+        hist = go.Histogram(
+            x=data,
+            nbinsx=bins,
+            name='Histogram',
+            opacity=0.6
+        )
+
+        # KDE Curve
+        kde = gaussian_kde(data)
+        x_range = np.linspace(data.min(), data.max(), 200)
+        kde_curve = go.Scatter(
+            x=x_range,
+            y=kde(x_range) * len(data) * (data.max() - data.min()) / bins,  # scaled to match histogram
+            name='KDE',
+            mode='lines',
+            line=dict(color='red')
+        )
+
+        # Combine into a single figure
+        fig = go.Figure(data=[hist, kde_curve])
+        fig.update_layout(
+            title=f"Histogram + KDE for '{col}'",
+            xaxis_title=col,
+            yaxis_title="Count",
+            barmode='overlay',
+            showlegend=True
+        )
+
+        plots.append(fig)
+
+    return plots
+
+# Line Plots Function
+def generate_line_plots(df: pd.DataFrame, date_component_cols: list, y_columns: list, freq: str = "M"):
+    """
+    Generates line plots for given numerical columns based on reconstructed datetime columns.
+
+    This function identifies datetime-related components in the DataFrame (e.g., 'order_year', 'order_month', 'order_day'),
+    reconstructs them into actual datetime objects, and then plots the specified `y_columns` over time using the chosen frequency.
+
+    Args:
+        df (pd.DataFrame): The input DataFrame containing date components and numerical data.
+        date_component_cols (list): List of column names representing datetime parts (e.g., 'order_date_year', 'order_date_month').
+        y_columns (list): List of numeric columns to be plotted against the date.
+        freq (str, optional): Resampling frequency for datetime aggregation.
+            Options:
+                'D' = daily
+                'W' = weekly
+                'M' = monthly (default)
+                'Y' = yearly
+
+    Returns:
+        list: A list of Plotly line plot figures for each (prefix, y_column) pair.
+    """
+    from collections import defaultdict
+    plots = []
+
+    # Group columns by prefix
+    groups = defaultdict(dict)
+    for col in date_component_cols:
+        for suffix in ['_year', '_month', '_day', '_weekday']:
+            if col.endswith(suffix):
+                prefix = col.replace(suffix, '')
+                groups[prefix][suffix] = col
+
+    # Reconstruct datetime and generate plots
+    for prefix, components in groups.items():
+        if all(k in components for k in ['_year', '_month', '_day']):
+            # Build a datetime column from year, month, day
+            temp_df = df[[components['_year'], components['_month'], components['_day']] + y_columns].dropna()
+            temp_df["__date__"] = pd.to_datetime({
+                'year': temp_df[components['_year']],
+                'month': temp_df[components['_month']],
+                'day': temp_df[components['_day']]
+            }, errors='coerce')
+            temp_df = temp_df.dropna(subset=["__date__"])
+            temp_df.set_index("__date__", inplace=True)
+
+            # Resample and plot
+            resampled_df = temp_df.resample(freq).mean().reset_index()
+
+            for col in y_columns:
+                fig = px.line(
+                    resampled_df,
+                    x="__date__",
+                    y=col,
+                    title=f"Line Plot: {prefix} vs {col}",
+                    labels={"__date__": "Date", col: col},
+                )
+                plots.append(fig)
+    
+    return plots

src/AutoVisualizer/processing.py

@@ -0,0 +1,250 @@
+# Module that will handle processing tasks of the user dataset
+import numpy as np
+import pandas as pd
+import streamlit as st
+
+# A quick cleanliness checker function
+def check_dataset_cleanliness(df):
+    issues_found = False
+
+    # 1. Columns with null values
+    null_cols = df.columns[df.isnull().any()].tolist()
+    if null_cols:
+        issues_found = True
+        st.warning(f"⚠️ These columns contain missing (NaN) values: {null_cols}")
+
+    # 2. Object columns that appear to be numeric (but aren't due to dirty values)
+    misclassified_numeric = []
+    for col in df.select_dtypes(include="object").columns:
+        non_null = df[col].dropna().astype(str)
+        sample_size = min(100, len(non_null))
+        if sample_size == 0:
+            continue  # skip if column has no non-null values
+        sample = non_null.sample(sample_size, random_state=1)
+        numeric_like_ratio = sample.str.replace(",", "").str.replace(".", "", regex=False).str.isdigit().mean()
+        if numeric_like_ratio > 0.6:
+            misclassified_numeric.append(col)
+
+    if misclassified_numeric:
+        issues_found = True
+        st.warning(
+            f"⚠️ These columns are stored as `object` but mostly contain numeric values.\n"
+            f"This may be due to the presence of invalid or non-numeric entries in a few rows: {misclassified_numeric}"
+        )
+
+    # 3. Checking duplicate records
+    num_duplicates = df.duplicated().sum()
+    if num_duplicates > 0:
+        issues_found = True
+        st.warning(f"⚠️ Your dataset contains {num_duplicates} duplicated rows.")
+
+    # 4. Checking Constant Columns (No Variation)
+    constant_cols = [col for col in df.columns if df[col].nunique(dropna=False) <= 1]
+    if constant_cols:
+        issues_found = True
+        st.warning(f"⚠️ These columns contain only a single unique value and may be useless for analysis: {constant_cols}")
+
+    # 5. Suspiciously High Cardinality in Categorical Columns
+    high_card_cols = [col for col in df.select_dtypes(include='object') if df[col].nunique() > 100]
+    if high_card_cols:
+        issues_found = True
+        st.warning(f"⚠️ These object-type columns have unusually high unique values (possibly IDs or noisy data): {high_card_cols}")
+
+
+    # Final message
+    if not issues_found:
+        st.success("✅ No major issues detected. Dataset looks clean!")
+
+
+# Function that will identify the task of the dataset
+def task_type(df: pd.DataFrame, target_col: str) -> str:
+    """
+    Determine the machine learning task type based on the target column.
+
+    Args:
+        df (pd.DataFrame): The input dataset.
+        target_col (str or None): The target column name, or None for unsupervised tasks.
+
+    Returns:
+        str: One of the following task types:
+            - "Classification" if the target is categorical.
+            - "Clustering" if the target is not provided.
+            - "Regression" if the target is numerical.
+            - "Unknown" if the type cannot be recognized.
+    """
+    # Handle unsupervised case (no target)
+    if target_col == "No Target":
+        return "Clustering"
+    
+    target_series = df[target_col]
+    dtype = target_series.dtype
+    n_unique = target_series.nunique()
+    
+    # Check for classification
+    if dtype == 'object' or dtype == 'bool' or (dtype == 'category'):
+        return "Classification"
+    
+    # Check for binary/multi-class classification represented as integers or floats
+    if dtype.kind in ['i', 'u', 'f']:  # Integer types
+        if n_unique <= 10:  # Arbitrary threshold for classification
+            return "Classification"
+        else:
+            return "Regression"
+    
+    # Numeric types default to regression
+    if dtype.kind in ['i', 'u', 'f']:
+        return "Regression"
+    
+    return "Unknown"
+
+# Function that will identify if an object feature is truly categorical or not
+def is_probably_categorical(series: pd.Series, threshold_unique: int = 50, threshold_ratio: float = 0.1) -> bool:
+    """
+    Determines whether a given pandas Series is likely to be a categorical feature.
+
+    Args:
+        series (pd.Series): The input data column to analyze.
+        threshold_unique (int, optional (default=50)) : Maximum number of unique values for an object-type column to be considered categorical.
+        threshold_ratio (float, optional (default=0.1)) : Maximum ratio of unique values to total entries for object-type column to be treated as categorical.
+    
+    Returns:
+        bool: True if the series is likely categorical, False otherwise.
+    """
+
+    # Heuristic for object types (e.g., strings): avoid classifying high-cardinality fields as categorical
+    if series.dtype == 'object':
+        num_unique = series.nunique()
+        unique_ratio = num_unique / len(series)
+        
+        if num_unique <= threshold_unique and unique_ratio <= threshold_ratio:
+            return True   # categorical
+        else:
+            return False  # high-cardinality non-categorical (like names)
+    
+    # Explicit categorical or boolean data types are considered categorical
+    elif pd.api.types.is_categorical_dtype(series):
+        return True
+    elif pd.api.types.is_bool_dtype(series):
+        return True
+    
+    return False
+
+# Function that will identify if an numerical feature is discrete or not
+def is_discrete(series: pd.Series, max_unique: int = 20) -> bool:
+    """
+    Determine whether a numeric series should be considered discrete.
+
+    Args:
+        series (pd.Series): The input numeric data column to analyze.
+        max_unique (int, optional): Maximum number of unique values allowed 
+            to treat a column as discrete. Default is 20.
+
+    Returns:
+        bool: True if the series is likely discrete, False otherwise.
+    """
+    # Check if the series is of integer type
+    if pd.api.types.is_integer_dtype(series):
+        return series.nunique() <= max_unique
+    
+    if pd.api.types.is_float_dtype(series):
+        # If all values are whole numbers AND unique count is low → treat as discrete
+        if series.dropna().apply(float.is_integer).all():
+            return series.nunique() <= max_unique
+        
+    return False
+
+# Function that will identify if an numerical feature is continuous or not
+def is_continuous(series: pd.Series, max_unique: int = 20) -> bool:
+    """
+    Determine whether a numeric series is continuous.
+
+    Args:
+        series (pd.Series): The input numeric data column to analyze.
+        max_unique (int, optional): Threshold for unique values. If a float-type column
+            contains only whole numbers and has fewer than this count, it is not considered continuous.
+            Default is 20.
+
+    Returns:
+        bool: True if the series is likely continuous, False otherwise.
+    """
+    # Only float types are considered potentially continuous
+    if pd.api.types.is_float_dtype(series):
+        # If it's float but looks like discrete, then not continuous
+        all_whole_numbers = series.dropna().apply(float.is_integer).all()
+        if all_whole_numbers and series.nunique() <= max_unique:
+            return False
+        return True
+    return False
+
+# Function that will identify if an feature is date-time format and then extract the time-based components
+def parse_datetime_columns(df: pd.DataFrame) -> tuple[pd.DataFrame, list, list]:
+    """
+    Detects and parses datetime columns in a DataFrame, and extracts useful 
+    date and/or time components into new columns.
+
+    Args:
+        df (pd.DataFrame): Input dataset.
+
+    Returns:
+        tuple:
+            - pd.DataFrame: Updated DataFrame with extracted datetime components.
+            - list: List of original columns identified as datetime.
+            - list: List of newly extracted datetime-related feature names.
+    """
+    datetime_cols = []
+    extracted_datetime = []
+    today = pd.Timestamp.today()  # Just the date, no time
+
+    for col in df.columns:
+        if pd.api.types.is_datetime64_any_dtype(df[col]):
+            datetime_cols.append(col)
+        elif df[col].dtype == "object":
+            try:
+                converted = pd.to_datetime(df[col], errors="raise")
+                df[col] = converted
+                datetime_cols.append(col)
+            except Exception:
+                continue
+
+    for col in datetime_cols:
+        # Flags for what actually exists
+        has_date = True
+        has_time = True
+
+        # Check if all dates are "today" → probably not originally present
+        # if df[col].dt.normalize().nunique() == 1 and df[col].dt.normalize().iloc[0] == today:
+        if (df[col].dt.year == today.year).all() or (df[col].dt.month == today.month).all() or (df[col].dt.day == today.day).all():
+            has_date = False
+
+        # Check if all times are 00:00:00 → probably not originally present
+        if (df[col].dt.hour == 0).all() and (df[col].dt.minute == 0).all() and (df[col].dt.second == 0).all():
+            has_time = False
+
+        if has_date:
+            df[f"{col}_year"] = df[col].dt.year
+            df[f"{col}_month"] = df[col].dt.month
+            df[f"{col}_day"] = df[col].dt.day
+            df[f"{col}_weekday"] = df[col].dt.day_name()
+            extracted_datetime.extend([
+                f"{col}_year", f"{col}_month", f"{col}_day", f"{col}_weekday"
+            ])
+        else:
+            df[f"{col}_year"] = np.nan
+            df[f"{col}_month"] = np.nan
+            df[f"{col}_day"] = np.nan
+            df[f"{col}_weekday"] = np.nan
+
+        if has_time:
+            df[f"{col}_hour"] = df[col].dt.hour
+            df[f"{col}_minute"] = df[col].dt.minute
+            extracted_datetime.extend([
+                f"{col}_hour", f"{col}_minute"
+            ])
+        else:
+            df[f"{col}_hour"] = np.nan
+            df[f"{col}_minute"] = np.nan
+    
+    # Remove any columns that are now entirely NaN
+    df = df.dropna(axis=1, how='all')
+
+    return df, datetime_cols, extracted_datetime

src/app.py

@@ -0,0 +1,222 @@
+import streamlit as st
+import numpy as np
+import pandas as pd
+from AutoVisualizer.processing import check_dataset_cleanliness, task_type,is_probably_categorical, is_discrete, is_continuous, parse_datetime_columns
+from AutoVisualizer.categorical_viz import combine_figures_as_subplots, generate_count_plots, generate_bar_plots, generate_grouped_bar_plots, generate_pie_plots, generate_categorical_correlation_heatmap
+from AutoVisualizer.numerical_viz import generate_box_plots, generate_numeric_correlation_heatmap, generate_scatter_plots, generate_histograms, generate_line_plots
+
+st.set_page_config(page_title= "Auto-Visualizer",page_icon= "📊",layout="wide")
+# col1, col2 = st.columns([0.3, 0.7])
+
+with st.sidebar:
+    # Upload the dataset file (can upload only CSV, XLSX, JSON, XML)
+    uploaded_file = st.file_uploader("Upload your dataset file:", ["csv", "xlsx", "json", "xml"])
+
+if uploaded_file is not None:
+    file_type = uploaded_file.name
+
+    try:
+        # Read the dataset through pandas
+        if file_type.endswith(".csv"):
+            df = pd.read_csv(uploaded_file)
+        elif file_type.endswith(".xlsx"):
+            df = pd.read_excel(uploaded_file)
+        elif file_type.endswith(".json"):
+            df = pd.read_json(uploaded_file)
+        else:
+            df = pd.read_xml(uploaded_file)
+    except Exception as e:
+        st.write("Error:", e)
+    
+    with st.sidebar:
+        # Show a a Disclaimer to user to upload as clean data as possible
+        st.info("""
+            ⚠️ **Heads up!** For the best experience, please upload a clean dataset.
+            
+            This app is designed for *visualizing data*, not cleaning it.
+            
+            📌 *Tip:* Use the quick checker below to spot potential issues.
+            """)
+
+        if st.button("Run Cleanliness Check"):
+            # Use session state to track button click
+            st.session_state.run_clean_check = True
+        st.divider()
+
+    # Display the cleanliness checker result on the main page (not sidebar) if button was clicked
+    if st.session_state.get("run_clean_check", False):
+        with st.expander("➡️ See Cleanliness Checker Result"):
+            check_dataset_cleanliness(df)
+
+    # Display the user DataFrame
+    st.markdown("Your Dataset:")
+    st.dataframe(df, height=210)
+    st.divider()
+
+    # Extract column names from the dataset + add "No Target" element if there's no target in the user dataset
+    feature_list = list(df.columns)
+    target_selector = ["No Target"] + feature_list
+
+    with st.sidebar:
+        # Ask the user to select target column from their dataset
+        target_col = st.selectbox("Specify the target column in your dataset:", target_selector)
+        # Identify the task/type of dataset (i.e. classification/regression/clustering(if no target feature at all))
+        task = task_type(df, target_col)
+        # Display the task to user
+        st.write(f"🔍 Task identified: **{task}**")
+        
+    # Identify the date-time columns (if any) and extract new time-based components from it
+    # date_time_ls       --> List that will store date-time feature names
+    # extracted_datetime --> List that will store extracted date-time feature names
+    df, date_time_ls, extracted_datetime = parse_datetime_columns(df)
+
+    # Remove date-time feature names as we already extracted time based components from it
+    feature_list = [x for x in feature_list if x not in date_time_ls]
+    
+    categorical_ls = []              # List that will store categorical feature names
+    discrete_ls = []                 # List that will store discrete feature names
+    continuous_ls = []               # List that will store continuous feature names
+    for feature in feature_list:
+        if is_probably_categorical(df[feature]):
+            categorical_ls.append(feature)         # Calling Categorical Feature Identifier Function
+        elif is_discrete(df[feature]):
+            discrete_ls.append(feature)            # Calling Discrete Feature Identifier Function
+        elif is_continuous(df[feature]):
+            continuous_ls.append(feature)          # Calling Continuous Feature Identifier Function
+    # Add time based components that appear to be categorical
+    for feature in extracted_datetime:
+        if is_probably_categorical(df[feature]):
+            categorical_ls.append(feature)
+    
+    # Creating Dialog Box to show identified features
+    @st.dialog("Identified/Extracted Features from your Dataset:-")
+    def open_dialog():
+        if categorical_ls:
+            with st.popover("Categorical Features", use_container_width= True):
+                st.code("\n".join([f"• {item}" for item in categorical_ls]))
+        if discrete_ls:
+            with st.popover("Discrete Features", use_container_width= True):
+                st.code("\n".join([f"• {item}" for item in discrete_ls]))
+        if continuous_ls:
+            with st.popover("Continuous Features", use_container_width= True):
+                st.code("\n".join([f"• {item}" for item in continuous_ls]))
+        if date_time_ls:
+            with st.popover("Date-Time Features", use_container_width= True):
+                st.code("\n".join([f"• {item}" for item in date_time_ls]))
+            with st.popover("Extracted features from your Date-Time like features", use_container_width= True):
+                st.code("\n".join([f"• {item}" for item in extracted_datetime]))
+    with st.sidebar:
+        # Calling the dialog box through a button
+        if st.button("See Your Feature Details"):
+            open_dialog()
+
+    # Generate the Plots
+    with st.spinner("Generating Plots.....", show_time= True):
+        if categorical_ls:
+            st.header("📊 Categorical Plots")
+            # 1. Count Plots
+            count_plots = []
+            for x_col in categorical_ls:
+                if df[x_col].nunique() <= 20:
+                    count_plots.extend(generate_count_plots(df, x_col))
+            
+            if count_plots:
+                st.subheader("Count Plots :-")
+                st.plotly_chart(combine_figures_as_subplots(count_plots), use_container_width=True)
+            
+            # 2. Bar Plots
+            bar_plots = []
+            # (Categorical vs Discrete + Continuous)
+            for x_col in categorical_ls:
+                if df[x_col].nunique() <= 20:
+                    bar_plots.extend(generate_bar_plots(df, x_col, discrete_ls + continuous_ls))
+
+            if bar_plots:
+                st.subheader("Bar Plots :-")
+                st.plotly_chart(combine_figures_as_subplots(bar_plots), use_container_width=True)
+            
+            # 3. Grouped Bar Plots
+            grp_bar_plots = []
+            # (Categorical vs Discrete + Continuous)
+            grp_bar_plots.extend(generate_grouped_bar_plots(df, categorical_ls, discrete_ls + continuous_ls))
+
+            if grp_bar_plots:
+                st.subheader("Grouped Bar Plots :-")
+                st.plotly_chart(combine_figures_as_subplots(grp_bar_plots), use_container_width=True)
+            
+            # 4. Pie Charts
+            pie_plots = []
+            for x_col in categorical_ls:
+                if df[x_col].nunique() <= 20:
+                    pie_plots.extend(generate_pie_plots(df, x_col))
+
+            if pie_plots:
+                st.subheader("Pie Charts :-")
+                st.plotly_chart(combine_figures_as_subplots(pie_plots), use_container_width=True)
+
+        if continuous_ls:
+            st.header("📊 Numerical Plots")
+            # 5. Box Plots
+            box_plots = []
+            for x_col in categorical_ls:
+                if df[x_col].nunique() <= 10:
+                    box_plots.extend(generate_box_plots(df, x_col, continuous_ls))
+
+            if box_plots:
+                st.subheader("Box Plots :-")
+                st.plotly_chart(combine_figures_as_subplots(box_plots), use_container_width=True)
+            
+            # 6. Heat Maps
+            heat_maps = []
+            if task == 'Regression':
+                if categorical_ls:
+                    heat_maps.extend(generate_categorical_correlation_heatmap(df, target_col, categorical_ls))
+            heat_maps.extend(generate_numeric_correlation_heatmap(df[continuous_ls]))
+            if heat_maps: 
+                st.subheader("Heat Maps :-")
+                st.plotly_chart(combine_figures_as_subplots(heat_maps), use_container_width=True)
+            
+            # 7. Scatter Plots
+            if len(continuous_ls) >= 2:
+                st.subheader("Scatter Plots")
+            scatter_plots = []
+            # Creation of unique feature pairs (no repetition like (B, A) if (A, B) is already used)
+            feature_pairs = []
+            for i in range(len(continuous_ls)):
+                for j in range(i + 1, len(continuous_ls)):
+                    feature_pairs.append((continuous_ls[i], continuous_ls[j]))
+            selection = st.pills("Highlight using a categorical feature :- ", categorical_ls)
+            scatter_plots.extend(generate_scatter_plots(df, feature_pairs, selection))
+            if scatter_plots:
+                st.plotly_chart(combine_figures_as_subplots(scatter_plots), use_container_width=True)
+            
+            # 8. Histograms
+            histograms = []
+            histograms.extend(generate_histograms(df, continuous_ls))
+
+            if histograms:
+                st.subheader("Histograms")
+                st.plotly_chart(combine_figures_as_subplots(histograms), use_container_width=True)
+            
+            # 9. Line Plots
+            line_plots = []
+            if date_time_ls:
+                # Extract only date-related components
+                date_related_keywords = ['_year', '_month', '_day', '_weekday']
+                date_component_cols = [col for col in extracted_datetime if any(key in col for key in date_related_keywords)]
+                if date_component_cols:
+                    st.subheader("Line Plots :-")
+                    # Mapping of labels to values
+                    time_grouping_options = {
+                        "Daily": "D",
+                        "Weekly": "W",
+                        "Monthly": "ME",
+                        "Yearly": "YE"
+                    }
+                    time_choice  = st.pills("Choose time interval for grouping :- ", list(time_grouping_options.keys()))
+                    # Extract the actual value for resampling
+                    selected_freq = time_grouping_options[time_choice] if time_choice else "ME"  # Use default "ME" if no selection
+                    line_plots.extend(generate_line_plots(df, date_component_cols, continuous_ls, selected_freq))
+            
+            if line_plots:
+                st.plotly_chart(combine_figures_as_subplots(line_plots), use_container_width= True)