Delete src

src/AutoVisualizer/categorical_viz.py

@@ -1,283 +0,0 @@
-# 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

@@ -1,233 +0,0 @@
-# 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

@@ -1,250 +0,0 @@
-# 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

@@ -1,221 +0,0 @@
-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")
-
-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)