csv-stats 0.1.0__py3-none-any.whl

csv-stats/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

csv-stats/anova.py

@@ -0,0 +1,301 @@
+from typing import Union
+from pathlib import Path
+
+import statsmodels.api as sm
+from statsmodels.formula.api import ols
+from statsmodels.stats.anova import AnovaRM
+import pandas as pd
+
+from .utils.summary_stats import calculate_summary_statistics
+from .utils.load_data import load_data_from_path
+from .utils.test_assumptions import test_normality_assumption, test_variance_homogeneity_assumption, test_sphericity_assumption
+from .utils.save_stats import dict_to_pdf
+
+def anova1way(data: Union[Path, str, pd.DataFrame], group_column: str, data_column: str, repeated_measures_column: str = "", filename: Union[str, None] = 'anova1way_results.pdf') -> dict:
+    """
+    Perform one-way ANOVA.
+
+    Parameters:
+    data : file path, str, or pd.DataFrame
+        The input data containing the groups and values.
+    group_column : str
+        The name of the column containing group labels.
+    data_column : str
+        The name of the column containing data values.
+    repeated_measures_column : str, optional
+        The name of the column containing the repeated measures identifiers. Defaults to "".
+    filename : str, optional
+        The filename to save the results to. Defaults to 'anova1way_results.pdf'. If None, results are not saved to a file.
+
+    Returns:
+    result: dict
+        A dictionary containing:        
+        "F" : float
+            The computed F-statistic.
+        "p" : float
+            The associated p-value, rounded to four decimal places.
+    """
+
+    if repeated_measures_column is None:
+        repeated_measures_column = ""
+
+    # Define a boolean flag for repeated measures ANOVA
+    is_repeated_measures = repeated_measures_column == ""
+
+    result = {}
+    result["group_column"] = group_column
+    result["data_column"] = data_column
+    result["repeated_measures_column"] = repeated_measures_column
+
+    # Load the data as a pandas DataFrame
+    data = load_data_from_path(data)    
+    
+    # Perform ANOVA
+    formula = f"{data_column} ~ C({group_column})"
+    anova_result = _perform_anova(data, formula, group_column, data_column, repeated_measures_column, is_repeated_measures)
+    
+    # Extract F-statistic and p-value
+    F = anova_result["anova_table"].loc[f"C({group_column})", "F"]
+    p = anova_result["anova_table"].loc[f"C({group_column})", "PR(>F)"]
+
+    # Calculate degrees of freedom
+    df_between = len(data[group_column].unique()) - 1
+    df_within = len(data) - len(data[group_column].unique())
+        
+    summary_stats = calculate_summary_statistics(data, group_column, data_column)    
+
+    # Store results in the dictionary
+    result["F"] = F
+    result["p"] = round(p, 4)
+    result["df_between"] = df_between
+    result["df_within"] = df_within
+    result["summary_stats"] = summary_stats    
+    result["normality_test"] = anova_result["normality_test"]
+    result["homogeneity_of_variance_test"] = anova_result["homogeneity_of_variance_test"]   
+    result["sphericity_test"] = anova_result["sphericity_test"]
+
+    if filename is not None:
+        dict_to_pdf(result, filename=filename)     
+
+    return result
+
+
+def anova2way(data: Union[Path, str, pd.DataFrame], group_column1: str, group_column2: str, data_column: str, repeated_measures_column: str = "", filename: Union[str, None] = 'anova2way_results.pdf') -> dict:
+    """
+    Perform two-way ANOVA.
+
+    Parameters:
+    data : file path, str, or pd.DataFrame
+        The input data containing the groups and values.
+    group_column1 : str
+        The name of the first column containing group labels.
+    group_column2 : str
+        The name of the second column containing group labels.
+    data_column : str
+        The name of the column containing data values.
+    repeated_measures_column : str, optional
+        The name of the column containing the repeated measures identifiers. Defaults to "".
+    filename : str, optional
+        The filename to save the results to. Defaults to 'anova2way_results.pdf'. If None, results are not saved to a file.
+
+    Returns:
+    result: dict
+        A dictionary containing:
+        "F1" : float
+            The computed F-statistic for the first factor.
+        "p1" : float
+            The associated p-value for the first factor, rounded to four decimal places.
+        "F2" : float
+            The computed F-statistic for the second factor.
+        "p2" : float
+            The associated p-value for the second factor, rounded to four decimal places.
+        "F_interaction" : float
+            The computed F-statistic for the interaction between factors.
+        "p_interaction" : float
+            The associated p-value for the interaction, rounded to four decimal places.
+    """
+
+    if repeated_measures_column is None:
+        repeated_measures_column = ""
+
+    # Define a boolean flag for repeated measures ANOVA
+    is_repeated_measures = repeated_measures_column == ""
+
+    result = {}
+    result["group_column1"] = group_column1
+    result["group_column2"] = group_column2    
+    result["data_column"] = data_column
+    result["repeated_measures_column"] = repeated_measures_column
+
+    # Load the data as a pandas DataFrame
+    data = load_data_from_path(data)
+
+    # Fit the model with interaction
+    formula = f"{data_column} ~ C({group_column1}) + C({group_column2}) + C({group_column1}):C({group_column2})"
+    anova_result = _perform_anova(data, formula, [group_column1, group_column2], data_column, repeated_measures_column, is_repeated_measures)
+
+    summary_stats_group1 = calculate_summary_statistics(data, group_column1, data_column) 
+    summary_stats_group2 = calculate_summary_statistics(data, group_column2, data_column)
+    # Prepare the dataframe to calculate the summary statistics for the interaction effect
+    interaction_column_name = f"{group_column1}_{group_column2}"
+    data[interaction_column_name] = data[group_column1].astype(str) + '_' + data[group_column2].astype(str)
+    summary_stats_interaction = calculate_summary_statistics(data, interaction_column_name, data_column)
+
+    # Store results in the dictionary
+    result["main_effects"] = {}
+    result["main_effects"][group_column1] = {}
+    result["main_effects"][group_column2] = {}
+    result["interaction"] = {}
+
+    anova_table = anova_result["anova_table"]
+    result["main_effects"][group_column1]["F"] = anova_table.loc[f"C({group_column1})", "F"]
+    result["main_effects"][group_column1]["p"] = round(anova_table.loc[f"C({group_column1})", "PR(>F)"], 4)
+    result["main_effects"][group_column2]["F"] = anova_table.loc[f"C({group_column2})", "F"]
+    result["main_effects"][group_column2]["p"] = round(anova_table.loc[f"C({group_column2})", "PR(>F)"], 4)
+    
+    interaction_key = f"C({group_column1}):C({group_column2})"
+    result["interaction"]["F"] = anova_table.loc[interaction_key, "F"]
+    result["interaction"]["p"] = round(anova_table.loc[interaction_key, "PR(>F)"], 4)
+    result[f"summary_stats_{group_column1}"] = summary_stats_group1
+    result[f"summary_stats_{group_column2}"] = summary_stats_group2
+    result["summary_stats_interaction"] = summary_stats_interaction    
+
+    result["normality_test"] = anova_result["normality_test"]
+    result["homogeneity_of_variance_test"] = anova_result["homogeneity_of_variance_test"]
+    result["sphericity_test"] = anova_result["sphericity_test"]
+
+    if filename is not None:
+        dict_to_pdf(result, filename='anova2way_results.pdf')  
+
+    return result
+
+
+def anova3way(data: Union[Path, str, pd.DataFrame], group_column1: str, group_column2: str, group_column3: str, data_column: str, repeated_measures_column: str, filename: Union[str, None] = 'anova3way_results.pdf') -> dict:
+    """
+    Perform three-way ANOVA.
+
+    Parameters:
+    data : file path, str, or pd.DataFrame
+        The input data containing the groups and values.
+    group_column1 : str
+        The name of the first column containing group labels.
+    group_column2 : str
+        The name of the second column containing group labels.
+    group_column3 : str
+        The name of the third column containing group labels.
+    data_column : str
+        The name of the column containing data values.
+
+    Returns:
+    result: dict
+        A dictionary containing:
+        "F1" : float
+            The computed F-statistic for the first factor.
+        "p1" : float
+            The associated p-value for the first factor, rounded to four decimal places.
+        "F2" : float
+            The computed F-statistic for the second factor.
+        "p2" : float
+            The associated p-value for the second factor, rounded to four decimal places.
+        "F3" : float
+            The computed F-statistic for the third factor.
+        "p3" : float
+            The associated p-value for the third factor, rounded to four decimal places.
+        "F_interaction" : float
+            The computed F-statistic for the interaction between factors.
+        "p_interaction" : float
+            The associated p-value for the interaction, rounded to four decimal places.
+    """
+
+    result = {}
+    result["group_column1"] = group_column1
+    result["group_column2"] = group_column2
+    result["group_column3"] = group_column3
+    result["data_column"] = data_column
+
+    # Load the data as a pandas DataFrame
+    data = load_data_from_path(data)
+
+    # Perform ANOVA
+    formula = f"{data_column} ~ C({group_column1}) * C({group_column2}) * C({group_column3})"
+    anova_result = _perform_anova(data, formula, [group_column1, group_column2, group_column3], data_column, repeated_measures_column, False) 
+        
+    summary_stats_group1 = calculate_summary_statistics(data, group_column1, data_column) 
+    summary_stats_group2 = calculate_summary_statistics(data, group_column2, data_column)
+    summary_stats_group3 = calculate_summary_statistics(data, group_column3, data_column)
+    # Prepare the dataframe to calculate the summary statistics for the interaction effect
+    interaction_column_name = f"{group_column1}_{group_column2}+{group_column3}"
+    data[interaction_column_name] = data[group_column1].astype(str) + '_' + data[group_column2].astype(str) + '_' + data[group_column3].astype(str)
+    summary_stats_interaction = calculate_summary_statistics(data, interaction_column_name, data_column)
+
+    # Store results in the dictionary
+    result["main_effects"] = {}
+    result["main_effects"][group_column1] = {}
+    result["main_effects"][group_column2] = {}
+    result["main_effects"][group_column3] = {}
+    result["interaction"] = {}
+
+    anova_table = anova_result["anova_table"]
+    result["main_effects"][group_column1]["F"] = anova_table.loc[f"C({group_column1})", "F"]
+    result["main_effects"][group_column1]["p"] = round(anova_table.loc[f"C({group_column1})", "PR(>F)"], 4)
+    result["main_effects"][group_column2]["F"] = anova_table.loc[f"C({group_column2})", "F"]
+    result["main_effects"][group_column2]["p"] = round(anova_table.loc[f"C({group_column2})", "PR(>F)"], 4)
+    result["main_effects"][group_column3]["F"] = anova_table.loc[f"C({group_column3})", "F"]
+    result["main_effects"][group_column3]["p"] = round(anova_table.loc[f"C({group_column3})", "PR(>F)"], 4)
+    
+    interaction_key = f"C({group_column1}):C({group_column2}):C({group_column3})"
+    result["interaction"]["F"] = anova_table.loc[interaction_key, "F"]
+    result["interaction"]["p"] = round(anova_table.loc[interaction_key, "PR(>F)"], 4)
+    result[f"summary_stats_{group_column1}"] = summary_stats_group1
+    result[f"summary_stats_{group_column2}"] = summary_stats_group2
+    result[f"summary_stats_{group_column3}"] = summary_stats_group3
+    result["summary_stats_interaction"] = summary_stats_interaction    
+
+    result["normality_test"] = anova_result["normality_test"]
+    result["homogeneity_of_variance_test"] = anova_result["homogeneity_of_variance_test"]
+    result["sphericity_test"] = anova_result["sphericity_test"]
+
+    if filename is not None:
+        dict_to_pdf(result, filename=filename)  
+
+    return result
+
+
+def _perform_anova(data: pd.DataFrame, formula: str, group_column: Union[list, str], data_column: str, repeated_measures_column: str, is_repeated_measures: bool) -> dict:
+    """Perform the actual ANOVA computation. Works for all types of ANOVA.
+
+    Args:
+        data (pd.DataFrame): The input data
+        group_column (str): The name of the column containing group labels.
+        data_column (str): The name of the column containing data values.
+        repeated_measures_column (str): The name of the column containing the repeated measures identifiers.
+        is_repeated_measures (bool): The boolean flag indicating if this is a repeated measures ANOVA.
+
+    Returns:
+        dict: The ANOVA results including F-statistic and p-value.
+    """
+    result = {}
+    if not is_repeated_measures:
+        # Fit the one-way ANOVA model using statsmodels        
+        model = ols(formula, data=data).fit()
+        anova_table = sm.stats.anova_lm(model, typ=2)
+        homogeneity_variances_result = test_variance_homogeneity_assumption(data, group_column, data_column)        
+        mauchly_test_result = "Not applicable"
+    else:
+        model = AnovaRM(data, 
+                        depvar=data_column, 
+                        subject=repeated_measures_column, 
+                        within=[group_column]).fit()
+        anova_table = model.anova_table
+        mauchly_test_result = test_sphericity_assumption(data, group_column, repeated_measures_column, data_column)
+        homogeneity_variances_result = "Not applicable"        
+
+    result["model"] = model
+    result["anova_table"] = anova_table
+    result["homogeneity_of_variance_test"] = homogeneity_variances_result
+    result["sphericity_test"] = mauchly_test_result
+
+    normality_result = test_normality_assumption(model)
+    result["normality_test"] = normality_result
+
+    return result

csv-stats/ttest.py

@@ -0,0 +1,107 @@
+from typing import Union
+from pathlib import Path
+
+import pandas as pd
+from scipy import stats
+from statsmodels.formula.api import ols
+
+from .anova import anova1way
+from .utils.load_data import load_data_from_path
+from .utils.save_stats import dict_to_pdf
+from .utils.summary_stats import calculate_summary_statistics
+from .utils.test_assumptions import test_normality_assumption, test_variance_homogeneity_assumption
+
+def ttest_ind(data: Union[Path, str, pd.DataFrame], group_column: str, data_column: str, filename: Union[str, None] = 'ttest_ind_results.pdf') -> dict:
+    """Conduct a two-sample t-test (independent or paired) and save results to a PDF.
+
+    Args:
+        data (Union[Path, str, pd.DataFrame]): The input data, which can be a file path, string, or DataFrame.
+        group_column (str): The name of the column containing group labels. If this is a one sample t-test, this should be an empty string.
+        data_column (str): The name of the column containing the data values.
+        repeated_measures_column (str, optional): The name of the. Defaults to "".
+        filename (str, optional): The filename to save the results to. Defaults to 'ttest_ind_results.pdf'. If None, results are not saved to a file.
+    """
+
+    result = {} # Initialize result dictionary
+
+    # Load the data
+    data = load_data_from_path(data)
+
+    # Make sure there is a 'group_column' even for one-sample t-tests    
+    if group_column is None:
+        group_column = ""
+    if group_column == "":
+        group_column = "one_sample"
+        data[group_column] = "all"
+
+    # Store metadata
+    result["group_column"] = group_column
+    result["data_column"] = data_column
+
+    groups = data[group_column].unique()
+    num_groups = len(groups)
+    if num_groups == 2:
+        result = anova1way(data, group_column, data_column, group_column, filename)
+        dict_to_pdf(result, filename=filename)
+        return result
+    
+    if num_groups != 1:
+        raise ValueError("Data must contain exactly one or two groups for a t-test.")
+    
+    t_stat, p_value = stats.ttest_1samp(data[data_column], popmean=0)
+    result["t_statistic"] = round(t_stat, 4)
+    result["p_value"] = round(p_value, 4)
+
+    summary_stats = calculate_summary_statistics(data, group_column, data_column)
+    result["summary_statistics"] = summary_stats
+
+    # Get the model for normality assumption testing
+    formula = f"{data_column} ~ C({group_column})"
+    model = ols(formula, data=data).fit()
+
+    # Test model assumptions
+    normality_test_result = test_normality_assumption(model)
+    homogeneity_variances_result = test_variance_homogeneity_assumption(data, group_column, data_column)
+    result["normality_test"] = normality_test_result
+    result["homogeneity_of_variance_test"] = homogeneity_variances_result
+
+    if filename is not None:
+        dict_to_pdf(result, filename=filename)
+    return result
+
+
+def ttest_dep(data: Union[Path, str, pd.DataFrame], group_column: str, data_column: str, repeated_measures_column: str, filename: Union[str, None] = 'ttest_dep_results.pdf') -> dict:
+    """Conduct a paired t-test and save results to a PDF.
+
+    Args:
+        data (Union[Path, str, pd.DataFrame]): The input data, which can be a file path, string, or DataFrame.
+        group_column (str): The name of the column containing group labels. If this is a one sample t-test, this should be an empty string.
+        data_column (str): The name of the column containing the data values.
+        repeated_measures_column (str, optional): The name of the column containing the repeated measures identifiers. Defaults to "".
+        filename (str, optional): The filename to save the results to. Defaults to 'ttest_dep_results.pdf'. If None, results are not saved to a file.
+    """
+
+    # Load the data
+    data = load_data_from_path(data)
+
+    groups = data[group_column].unique()
+    num_groups = len(groups)
+    if num_groups != 2:
+        raise ValueError("Data must contain exactly two groups for a paired t-test.")
+
+    # Pivot the data to have one column per group
+    pivot_data = data.pivot(index=repeated_measures_column, columns=group_column, values=data_column)
+    delta_column_name = f"{groups[0]}_minus_{groups[1]}"
+    pivot_data[delta_column_name] = pivot_data[groups[0]] - pivot_data[groups[1]]
+
+    # Perform paired t-test on the difference column
+    ttest_ind_result = ttest_ind(pivot_data, "", delta_column_name, filename=None)
+    
+    # Calculate and add summary statistics for the repeated measures
+    # i.e. if there was a pre and post test per subject, this will provide a mean per subject
+    # repeated_measures_summary = calculate_summary_statistics(data, repeated_measures_column, delta_column_name)
+    # ttest_ind_result["repeated_measures_summary_statistics"] = repeated_measures_summary
+
+    if filename is not None:
+        dict_to_pdf(ttest_ind_result, filename=filename)
+    return ttest_ind_result

csv-stats/utils/load_data.py

@@ -0,0 +1,45 @@
+from typing import Union
+from pathlib import Path
+
+import pandas as pd
+
+def load_data_from_path(data: Union[Path, str, pd.DataFrame]) -> pd.DataFrame:
+    """
+    Load data from a file path or return the DataFrame if already provided.
+
+    Parameters:
+    data : Union[Path, str, pd.DataFrame]
+        The file path to load data from or a DataFrame.
+
+    Returns:
+    pd.DataFrame
+        The loaded DataFrame.
+    """
+
+    if isinstance(data, pd.DataFrame):
+        return data
+    
+    # Convert string paths to Path objects
+    if isinstance(data, str):
+        data = Path(data)
+    
+    if isinstance(data, Path):
+        check_file_exists(data)
+        return pd.read_csv(data)
+    else:
+        raise ValueError("Input must be a file path or a pandas DataFrame.")
+
+
+def check_file_exists(path: Union[Path, str]):
+    """
+    Check that the provided file path exists.
+
+    Parameters:
+    path : Union[Path, str]
+        The file path to check.
+    """
+    if isinstance(path, str):
+        path = Path(path)
+    
+    if not path.exists():
+        raise ValueError(f"Unable to find a file at {path}")

csv-stats/utils/save_stats.py

@@ -0,0 +1,65 @@
+import json
+from typing import Union, Any
+
+import pandas as pd
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+from reportlab.lib.units import inch
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.ttfonts import TTFont
+
+def dict_to_pdf(data: dict, filename: Union[str, None] = 'output.pdf'):
+    """
+    Convert a dictionary to a formatted JSON string and save as PDF.
+    
+    Args:
+        data: The dictionary to convert
+        filename: Output PDF filename (default: 'output.pdf')
+    """
+    # Convert NumPy types to native Python types for JSON serialization
+    def convert_types(obj: Any) -> Any:
+        if isinstance(obj, dict):
+            return {k: convert_types(v) for k, v in obj.items()}
+        elif isinstance(obj, (list, tuple)):
+            return [convert_types(item) for item in obj]
+        elif hasattr(obj, 'item'):  # NumPy scalar types
+            return obj.item()
+        return obj
+    
+    if filename is None:
+        return
+    
+    filename = str(filename)
+    
+    data = convert_types(data)
+
+    # Convert dictionary to formatted JSON string
+    json_str = json.dumps(data, indent=2)
+    
+    # Create PDF
+    c = canvas.Canvas(filename, pagesize=letter)
+    width, height = letter
+    
+    # Margins and setup
+    margin = 0.5 * inch
+    y_position = height - margin
+    line_height = 0.15 * inch
+    
+    # Use monospace font for better JSON formatting
+    c.setFont("Courier", 9)
+    
+    # Draw each line of the JSON
+    for line in json_str.split('\n'):
+        # Check if we need a new page
+        if y_position < margin:
+            c.showPage()
+            c.setFont("Courier", 9)
+            y_position = height - margin
+        
+        # Draw the line
+        c.drawString(margin, y_position, line)
+        y_position -= line_height
+    
+    # Save the PDF
+    c.save()
+    print(f"PDF saved as {filename}")

csv-stats/utils/summary_stats.py

@@ -0,0 +1,62 @@
+
+import numpy as np
+import pandas as pd
+
+def calculate_summary_statistics(data: pd.DataFrame, group_column: str, data_column: str) -> dict:
+    """
+    Calculate summary statistics for each group in the data. If there is only one group, grouped statistics will still be calculated.
+
+    Parameters:
+    data : pd.DataFrame
+        The input data containing the groups and values.
+    group_column : str
+        The name of the column containing group labels.
+    data_column : str
+        The name of the column containing data values.
+
+    Returns:
+    summary_stats: dict
+        A dictionary where keys are group names and values are dictionaries of summary statistics:
+        "count", "mean", "std", "min", "25%", "50%", "75%", "max"
+    """
+    summary_stats = {}
+    grouped = data.groupby(group_column)[data_column]
+
+    # Calculate summary statistics for each group
+    means = {name: group.mean() for name, group in grouped}    
+    std_devs = {name: group.std() for name, group in grouped}
+    counts = {name: len(group) for name, group in grouped}
+    variances = {name: group.var() for name, group in grouped}
+    n_missing = {name: group.isnull().sum() for name, group in grouped}   
+    mins = {name: group.min() for name, group in grouped}
+    maxs = {name: group.max() for name, group in grouped}
+            
+    # Calculate quartiles
+    quartiles = {name: group.quantile([0.25, 0.5, 0.75]).to_dict() for name, group in grouped}
+
+    # Store group-wise statistics
+    summary_stats_grouped = {}    
+    summary_stats_grouped["mean"] = means
+    summary_stats_grouped["std_dev"] = std_devs
+    summary_stats_grouped["count"] = counts
+    summary_stats_grouped["variance"] = variances
+    summary_stats_grouped["n_missing"] = n_missing
+    summary_stats_grouped["quartiles"] = quartiles
+    summary_stats_grouped["min"] = mins
+    summary_stats_grouped["max"] = maxs
+
+    # Store overall statistics
+    summary_stats_overall = {}
+    summary_stats_overall["mean"] = data[data_column].mean()
+    summary_stats_overall["std_dev"] = data[data_column].std()
+    summary_stats_overall["count"] = len(data)
+    summary_stats_overall["n_missing"] = data[data_column].isnull().sum()
+    summary_stats_overall["variance"] = data[data_column].var()
+    summary_stats_overall["quartiles"] = data[data_column].quantile([0.25,0.5, 0.75]).to_dict()
+    summary_stats_overall["min"] = data[data_column].min()
+    summary_stats_overall["max"] = data[data_column].max()
+
+    summary_stats["grouped"] = summary_stats_grouped
+    summary_stats["overall"] = summary_stats_overall
+
+    return summary_stats

csv-stats/utils/test_assumptions.py

@@ -0,0 +1,87 @@
+from typing import Union
+
+from scipy import stats
+import pandas as pd
+import pingouin as pg
+
+def test_normality_assumption(model) -> dict:
+    """Test the normality assumption of residuals using the Shapiro-Wilk test.
+
+    Args:
+        model (_type_): The fitted statistical model from statsmodels.
+
+    Returns:
+        dict: The result of the Shapiro-Wilk test containing the test statistic and p-value.
+    """
+
+    # Test for normality
+    residuals = model.resid
+    normality_test_statistic, p_value_normality = stats.shapiro(residuals)
+
+    normality_result = {}
+    normality_result["shapiro_wilk"] = {"test_statistic": normality_test_statistic, "p_value": p_value_normality}
+
+    if p_value_normality < 0.05:
+        print(f"Warning: The Shapiro-Wilk test for normality returned a p-value of {p_value_normality:.4f}. A p-value less than 0.05 suggests that the residuals may not be normally distributed. Consider using a non-parametric test if normality is violated.")
+    
+    return normality_result
+
+
+def test_variance_homogeneity_assumption(data: pd.DataFrame, group_columns: Union[str, list], data_column: str) -> dict:
+    """Test the homogeneity of variances using Levene's test. For 2 or more factors, uses the interaction of all factors.
+
+    Args:
+        data (pd.DataFrame): The input data containing the groups and values.
+        group_columns (Union[str, list]): The name(s) of the column(s) containing group labels.
+        data_column (str): The name of the column containing data values.
+
+    Returns:
+        dict: The result of Levene's test containing the test statistic and p-value.
+    """
+
+    if isinstance(group_columns, str):
+        group_columns = [group_columns]    
+    
+    # Test for homogeneity of variances
+    data['combined_group'] = data[group_columns].astype(str).agg('_'.join, axis=1)
+    grouped_data = [group[data_column].values for name, group in data.groupby('combined_group')]
+    levene_statistic, p_value_levene = stats.levene(*grouped_data)
+
+    homogeneity_variances_result = {}
+    homogeneity_variances_result["levene"] = {"test_statistic": levene_statistic, "p_value": p_value_levene}
+    
+    if p_value_levene < 0.05:
+        print(f"Warning: The Levene's test for homogeneity of variances returned a p-value of {p_value_levene:.4f}. A p-value less than 0.05 suggests that the variances across groups may not be equal. Consider using a non-parametric test if homogeneity of variances is violated.")
+
+    return homogeneity_variances_result
+
+
+def test_sphericity_assumption(data: pd.DataFrame, group_columns: Union[str, list], subject_column: str, data_column: str) -> dict:
+    """Test the sphericity assumption using Mauchly's test.
+
+    Args:
+        data (pd.DataFrame): The input data containing the groups, subjects, and values.
+        group_column (str): The name of the column containing group labels.
+        subject_column (str): The name of the column containing subject identifiers.
+        data_column (str): The name of the column containing data values.
+
+    Returns:
+        dict: The result of Mauchly's test containing the test statistic and p-value.
+    """
+
+    if isinstance(group_columns, str):
+        group_columns = [group_columns]
+
+    # Perform Mauchly's test for sphericity using pingouin
+    mauchly_result = pg.sphericity(data, dv=data_column, subject=subject_column, within=group_columns)
+    
+    sphericity_result = {}
+    sphericity_result["mauchly"] = {
+        "W": mauchly_result['W'].values[0],
+        "p_value": mauchly_result['pval'].values[0]
+    }
+
+    if mauchly_result['pval'].values[0] < 0.05:
+        print(f"Warning: Mauchly's test for sphericity returned a p-value of {mauchly_result['pval'].values[0]:.4f}. A p-value less than 0.05 suggests that the sphericity assumption may be violated. Consider applying a correction (e.g., Greenhouse-Geisser or Huynh-Feldt) to the ANOVA results.")
+    
+    return sphericity_result

csv_stats-0.1.0.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: csv-stats
+Version: 0.1.0
+Summary: A Python package for the life sciences to conduct hypothesis testing from CSV files.
+Author-email: Mitchell Tillman <mtillman14@gmail.com>
+Maintainer-email: Mitchell Tillman <mtillman14@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/mtillman14/csv-stats
+Project-URL: Documentation, https://github.com/mtillman14/csv-stats
+Project-URL: Repository, https://github.com/mtillman14/csv-stats
+Project-URL: Issues, https://github.com/mtillman14/csv-stats/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Development Status :: 3 - Alpha
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: pingouin>=0.5.5
+Requires-Dist: scipy>=1.16.2
+Requires-Dist: statsmodels>=0.14.5
+
+# csv-stats
+Python package for rapid hypothesis testing on CSV files with data in long table format, which are common in the life sciences.

csv_stats-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+csv-stats/__init__.py,sha256=Pru0BlFBASFCFo7McHdohtKkUtgMPDwbGfyUZlE2_Vw,21
+csv-stats/anova.py,sha256=TGK1AE0fWGGz3NNn5N81ByuPyfNY-s7CRUjCtONAvh4,13822
+csv-stats/ttest.py,sha256=BPk0PKMFngZ7eAw4kjC_CA3JYtqMZ_tG36RnK8BGdDg,4929
+csv-stats/utils/load_data.py,sha256=S2jj1N8lsli6tJoz8GVIP1ya3AvwNBEVs8E8jzoqY8U,1106
+csv-stats/utils/save_stats.py,sha256=miIKM6Skq5qPwRLwzF0q7ovzBcucm4XEKjTG1WGA_5A,1902
+csv-stats/utils/summary_stats.py,sha256=Hz4lmj8Ar_evGENTODZ6PZDJcGkGhh6lyX2UJcBuuV4,2602
+csv-stats/utils/test_assumptions.py,sha256=T9xeiuT5-_QjrI26zeoYPrXC6NnR_MzqcajSHtcHy5k,3932
+csv_stats-0.1.0.dist-info/METADATA,sha256=k87MgZOEj-AjVpCgneniodLpd-5gzLCoPA5HVO3u7DI,1104
+csv_stats-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+csv_stats-0.1.0.dist-info/top_level.txt,sha256=ddAwVrUJVKxXCfDSFFl62yHBrVf8uFpyuLpp_UlK_k8,10
+csv_stats-0.1.0.dist-info/RECORD,,

csv_stats-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

csv_stats-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+csv-stats