AutoStatLib 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

AutoStatLib/AutoStatLib.py

@@ -16,7 +16,7 @@ class StatisticalAnalysis(StatisticalTests, NormalityTests, TextFormatting, Help
                  paired=False,
                  tails=2,
                  popmean=None,
-                 posthoc=False,
+                 posthoc=True,
                  verbose=True):
         self.results = None
         self.error = False
@@ -92,6 +92,7 @@ class StatisticalAnalysis(StatisticalTests, NormalityTests, TextFormatting, Help
         self.p_value = None
         self.posthoc_matrix_df = None
         self.posthoc_matrix = []
+        self.posthoc_name = None
 
         self.log('\n' + '-'*67)
         self.log('Statistical analysis __init__iated for data in {} groups\n'.format(
@@ -174,7 +175,6 @@ class StatisticalAnalysis(StatisticalTests, NormalityTests, TextFormatting, Help
         else:
             self.run_test_auto()
 
-
         # print the results
         self.results = self.create_results_dict()
         self.print_results()
@@ -186,9 +186,8 @@ class StatisticalAnalysis(StatisticalTests, NormalityTests, TextFormatting, Help
         if self.verbose == True:
             print(self.summary)
 
-
-
     # public methods:
+
     def RunAuto(self):
         self.run_test(test='auto')
 

AutoStatLib/StatPlots.py

@@ -0,0 +1,626 @@
+import random
+# from math import comb
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.colors as mcolors
+import matplotlib.colors as color
+
+
+class Helpers():
+
+    def colors_to_rgba(self, colors, alpha=0.35):
+        rgba_colors = []
+        for col in colors:
+            rgba = list(mcolors.to_rgba(col))
+            rgba[3] = alpha
+            rgba_colors.append(tuple(rgba))
+        return rgba_colors
+
+    def get_colors(self, colormap):
+        # If a colormap is provided, use it;
+        # else generate default one with n_colors colors
+        # (the best color combination is 9 imho)
+        # but we cat change it later
+        if colormap:
+            colors_edge = [c if color.is_color_like(
+                c) else 'k' for c in colormap]
+            colors_fill = self.colors_to_rgba(colors_edge)
+        else:
+            n_colors = 9  # len(self.data_groups)
+            cmap = plt.get_cmap('Set1')
+            colors_edge = [cmap(i / n_colors) for i in range(n_colors)]
+            colors_edge.insert(0, 'k')
+            colors_fill = self.colors_to_rgba(colors_edge)
+        return colors_edge, colors_fill
+
+    def make_p_value_printed(self, p) -> str:
+        if p is not None:
+            if p > 0.99:
+                return 'p>0.99'
+            elif p >= 0.01:
+                return f'p={p:.2g}'
+            elif p >= 0.001:
+                return f'p={p:.2g}'
+            elif p >= 0.0001:
+                return f'p={p:.1g}'
+            elif p < 0.0001:
+                return 'p<0.0001'
+            else:
+                return 'N/A'
+        return 'N/A'
+
+    def make_stars(self, p) -> int:
+        if p is not None:
+            if p < 0.0001:
+                return 4
+            if p < 0.001:
+                return 3
+            elif p < 0.01:
+                return 2
+            elif p < 0.05:
+                return 1
+            else:
+                return 0
+        return 0
+
+    def make_stars_printed(self, n) -> str:
+        return '*' * n if n else 'ns'
+
+    def transpose(self, data):
+        return list(map(list, zip(*data)))
+
+
+class BaseStatPlot(Helpers):
+
+    def __init__(self,
+                 data_groups,
+                 p=None,
+                 testname='',
+                 dependent=False,
+                 plot_title='',
+                 x_label='',
+                 y_label='',
+                 print_x_labels=True,
+                 x_manual_tick_labels=None,
+                 posthoc_matrix=[],
+                 colormap=None,
+                 **kwargs):
+        self.data_groups = data_groups
+        self.n_groups = len(self.data_groups)
+        self.p = p
+        self.testname = testname
+        self.posthoc_matrix = posthoc_matrix
+        self.n_significance_bars = 1
+        self.dependent = dependent
+        self.plot_title = plot_title
+        self.x_label = x_label
+        self.y_label = y_label
+        self.print_x_labels = print_x_labels
+
+        #  sd sem mean and median calculation if they are not provided
+        self.mean = [
+            np.mean(self.data_groups[i]).item() for i in range(self.n_groups)]
+        self.median = [
+            np.median(self.data_groups[i]).item() for i in range(self.n_groups)]
+        self.sd = [
+            np.std(self.data_groups[i]).item() for i in range(self.n_groups)]
+        self.sem = [np.std(self.data_groups[i]).item() / np.sqrt(len(self.data_groups[i])).item()
+                    for i in range(self.n_groups)]
+
+        self.n = [len(i) for i in self.data_groups]
+        self.p_printed = self.make_p_value_printed(self.p)
+        self.stars_printed = self.make_stars_printed(self.make_stars(self.p))
+
+        self.x_manual_tick_labels = x_manual_tick_labels if x_manual_tick_labels is not None else [
+            '']
+
+        if colormap is not None and colormap != ['']:
+            colormap = colormap
+            self.colormap_default = False
+        else:
+            colormap = []
+            self.colormap_default = True
+        self.colors_edge, self.colors_fill = self.get_colors(colormap)
+
+        self.y_max = max([max(data) for data in self.data_groups])
+
+    def setup_figure(self, ):
+        fig, ax = plt.subplots(figsize=(0.5 + 0.9 * self.n_groups, 4))
+        return fig, ax
+
+    def add_scatter(self, ax,
+                    color='k',
+                    alpha=0.5,
+                    marker='o',
+                    linewidth=1,
+                    zorder=1):
+        # Generate x jitter pool.
+        spread_pool = []  # storing x positions of data points
+        for i, data in enumerate(self.data_groups):
+            spread = tuple(random.uniform(-.10, .10) for _ in data)
+            spread_pool.append(tuple(i + s for s in spread))
+
+        for i, data in enumerate(self.transpose(self.data_groups)):
+            # Plot individual data points with x jitter.
+            ax.plot(self.transpose(spread_pool)[i], data,
+                    color=color,
+                    alpha=alpha,
+                    marker=marker,
+                    linewidth=linewidth,
+                    # Connect the data points if desired.
+                    linestyle='-' if self.dependent else '',
+                    zorder=zorder)
+
+    def add_barplot(self, ax, x,
+                    fill=True,
+                    linewidth=2,
+                    zorder=1):
+
+        # Plot bar for mean
+        ax.bar(x, self.mean[x],
+               width=0.75,
+               facecolor=self.colors_fill[x % len(self.colors_fill)],
+               edgecolor=self.colors_edge[x % len(self.colors_edge)],
+               fill=fill,
+               linewidth=linewidth,
+               zorder=zorder)
+
+    def add_violinplot(self, ax, x,
+                       linewidth=2,
+                       widths=0.85,
+                       vert=True,
+                       showmeans=True,
+                       showmedians=True,
+                       showextrema=True,
+                       points=200,
+                       bw_method=0.5):
+
+        vp = ax.violinplot(self.data_groups[x], positions=[x], widths=widths, vert=vert,
+                           showmeans=showmeans, showmedians=showmedians, showextrema=showextrema,
+                           points=points, bw_method=bw_method)
+
+        for pc in vp['bodies']:
+            pc.set_facecolor(self.colors_fill[x % len(self.colors_fill)])
+            pc.set_edgecolor(self.colors_edge[x % len(self.colors_edge)])
+            pc.set_linewidth(linewidth)
+
+    def add_boxplot(self, ax,
+                    # positions of boxes, defaults to range(1,n+1)
+                    positions=None,
+                    widths=0.6,
+                    tickLabels=None,
+                    notch=False,
+                    confidences=None,
+                    fliers=False,
+                    fliersMarker='',
+                    flierFillColor=None,
+                    flierEdgeColor=None,
+                    flierLineWidth=2,
+                    flierLineStyle=None,
+                    vertical=True,
+                    # whiskers when one float is tukeys parameter, when a pair of percentages,
+                    # defines the percentiles where the whiskers should be If a float,
+                    # the lower whisker is at the lowest datum above Q1 - whis*(Q3-Q1),
+                    # and the upper whisker at the highest datum below Q3 + whis*(Q3-Q1),
+                    # where Q1 and Q3 are the first and third quartiles. The default value of whis = 1.5
+                    # corresponds to Tukey's original definition of boxplots.
+                    whiskers=1.5,
+                    bootstrap=None,
+                    whiskersColor=None,
+                    whiskersLineWidth=2,
+                    whiskersLineStyle=None,
+                    showWhiskersCaps=True,
+                    whiskersCapsWidths=None,
+                    whiskersCapsColor=None,
+                    whiskersCapsLineWidth=2,
+                    whiskersCapsLineStyle=None,
+                    boxFill=None,
+                    boxBorderColor=None,
+                    boxBorderWidth=2,
+                    userMedians=None,
+                    medianColor=None,
+                    medianLineStyle=None,
+                    medianLineWidth=2,
+                    showMeans=False,
+                    meanMarker=None,
+                    meanFillColor=None,
+                    meanEdgeColor=None,
+                    meanLine=False,
+                    meanLineColor=None,
+                    meanLineStyle=None,
+                    meanLineWidth=2,
+                    autorange=False
+                    ):
+
+        positions = list(range(self.n_groups))
+        # if (not hasattr(positions, "__len__") or
+        #     len(positions) != self.length or
+        #         any(not isinstance(x, (int, float)) for x in positions)):
+        #     positions = None
+        if fliers == False:
+            fliersMarker = ""
+        else:
+            if fliersMarker == "":
+                fliersMarker = 'b+'
+        # write a function to make a dictionary
+        whiskersCapsStyles = dict()
+        if whiskersCapsColor != None:
+            whiskersCapsStyles["color"] = whiskersCapsColor
+        if whiskersCapsLineWidth != None:
+            whiskersCapsStyles["linewidth"] = whiskersCapsLineWidth
+        if whiskersCapsLineStyle != None:
+            whiskersCapsStyles['linestyle'] = whiskersCapsLineStyle
+
+        boxProps = {"facecolor": (0, 0, 0, 0),
+                    "edgecolor": "black", "linewidth": 1}
+        if boxFill != None:
+            boxProps["facecolor"] = boxFill
+        if boxBorderColor != None:
+            boxProps["edgecolor"] = boxBorderColor
+        if boxBorderWidth != None:
+            boxProps['linewidth'] = boxBorderWidth
+        # if boxBorderStyle != None:
+        #     boxProps['linestyle'] = boxBorderStyle  !!!this feature is not working with patch_artist that is needed for facecolor to work
+
+        whiskersProps = {"color": 'black',
+                         "linestyle": "solid", "linewidth": 1}
+        if whiskersColor != None:
+            whiskersProps["color"] = whiskersColor
+        if whiskersLineStyle != None:
+            whiskersProps["linestyle"] = whiskersLineStyle
+        if whiskersLineWidth != None:
+            whiskersProps['linewidth'] = whiskersLineWidth
+
+        flierProps = {"markerfacecolor": [
+            0, 0, 0, 0], "markeredgecolor": "black", "linestyle": "solid", "markeredgewidth": 1}
+        if flierFillColor != None:
+            flierProps["markerfacecolor"] = flierFillColor
+        if flierEdgeColor != None:
+            flierProps["markeredgecolor"] = flierEdgeColor
+        if flierLineWidth != None:
+            flierProps['markeredgewidth'] = flierLineWidth
+        if flierLineStyle != None:
+            flierProps['linestyle'] = flierLineStyle
+        medianProps = {"linestyle": 'solid', "linewidth": 1, "color": 'red'}
+        if medianColor != None:
+            medianProps["color"] = medianColor
+        if medianLineStyle != None:
+            medianProps["linestyle"] = medianLineStyle
+        if medianLineWidth != None:
+            medianProps['linewidth'] = medianLineWidth
+
+        meanProps = {"color": "black", "marker": 'o', "markerfacecolor": "black",
+                     "markeredgecolor": "black", "linestyle": "solid", "linewidth": 1}
+
+        if meanMarker != None:
+            meanProps['marker'] = meanMarker
+        if meanFillColor != None:
+            meanProps["markerfacecolor"] = meanFillColor
+        if meanEdgeColor != None:
+            meanProps['markeredgecolor'] = meanEdgeColor
+        if meanLineColor != None:
+            meanProps["color"] = meanLineColor
+        if meanLineStyle != None:
+            meanProps['linestyle'] = meanLineStyle
+        if meanLineWidth != None:
+            meanProps['linewidth'] = meanLineWidth
+
+        bplot = ax.boxplot(self.data_groups,
+                           positions=positions,
+                           widths=widths,
+                           # tick_labels=tickLabels,
+                           notch=notch,
+                           conf_intervals=confidences,
+                           sym=fliersMarker,
+                           flierprops=flierProps,
+                           vert=vertical,
+                           whis=whiskers,
+                           whiskerprops=whiskersProps,
+                           showcaps=showWhiskersCaps,
+                           capwidths=whiskersCapsWidths,
+                           capprops=whiskersCapsStyles,
+                           boxprops=boxProps,
+                           usermedians=userMedians,
+                           medianprops=medianProps,
+                           bootstrap=bootstrap,
+                           showmeans=showMeans,
+                           meanline=meanLine,
+                           meanprops=meanProps,
+                           autorange=autorange,
+                           patch_artist=True)
+
+        # apply use r colormap if provided
+        # else left white face with black border
+        if not self.colormap_default:
+            for x, patch in enumerate(bplot['boxes']):
+                patch.set_facecolor(
+                    self.colors_fill[x % len(self.colors_fill)])
+
+    def add_errorbar_sd(self, ax, x,
+                        capsize=8,
+                        ecolor='r',
+                        linewidth=2,
+                        zorder=3):
+        # Add error bars
+        ax.errorbar(x, self.mean[x],
+                    yerr=self.sd[x],
+                    fmt='none',
+                    capsize=capsize,
+                    ecolor=ecolor,
+                    linewidth=linewidth,
+                    zorder=zorder)
+
+    def add_errorbar_sem(self, ax, x,
+                         capsize=8,
+                         ecolor='r',
+                         linewidth=2,
+                         zorder=3):
+        # Add error bars
+        ax.errorbar(x, self.mean[x],
+                    yerr=self.sem[x],
+                    fmt='none',
+                    capsize=capsize,
+                    ecolor=ecolor,
+                    linewidth=linewidth,
+                    zorder=zorder)
+
+    def add_mean_marker(self, ax, x,
+                        marker='_',
+                        markerfacecolor='#00000000',
+                        markeredgecolor='r',
+                        markersize=16,
+                        markeredgewidth=1):
+        # Overlay mean marker
+        ax.plot(x, self.mean[x],
+                marker=marker,
+                markerfacecolor=markerfacecolor,
+                markeredgecolor=markeredgecolor,
+                markersize=markersize,
+                markeredgewidth=markeredgewidth)
+
+    def add_median_marker(self, ax, x,
+                          marker='x',
+                          markerfacecolor='#00000000',
+                          markeredgecolor='r',
+                          markersize=10,
+                          markeredgewidth=1):
+        # Overlay median marker
+        ax.plot(x, self.median[x],
+                marker=marker,
+                markerfacecolor=markerfacecolor,
+                markeredgecolor=markeredgecolor,
+                markersize=markersize,
+                markeredgewidth=markeredgewidth)
+
+    def add_significance_bars(self, ax,
+                              linewidth=2,
+                              capsize=0.01,
+                              col='k',
+                              label=''):
+        '''label can be "p", "s", "both"'''
+
+        # # Estimate how many bars needed
+        # self.n_significance_bars = comb(
+        #     self.n_groups, 2) if self.n_groups > 2 else 1
+
+        posthoc_matrix_printed = [[self.make_p_value_printed(element) for element in row]
+                                  for row in self.posthoc_matrix] if self.posthoc_matrix else []
+        posthoc_matrix_stars = [[self.make_stars_printed(self.make_stars(element)) for element in row]
+                                for row in self.posthoc_matrix] if self.posthoc_matrix else []
+
+        def draw_bar(p, stars, order=0, x1=0, x2=self.n_groups-1, capsize=capsize, linewidth=linewidth, col=col, label=label):
+            if label == 'p':
+                vspace = capsize+0.03
+                label = '{}'.format(p)
+            elif label == 's':
+                vspace = capsize+0.03
+                label = '{}'.format(stars)
+            else:
+                vspace = capsize+0.06
+                label = '{}\n{}'.format(p, stars)
+
+            # Draw significance bar connecting x1 and x2 coords
+            y, h = ((1.05 + (order*vspace)) *
+                    self.y_max), capsize * self.y_max
+            ax.plot([x1, x1, x2, x2], [y, y + h, y + h, y],
+                    lw=linewidth, c=col)
+
+            ax.text((x1 + x2) * 0.5, y + h, label,
+                    ha='center', va='bottom', color=col, fontweight='bold', fontsize=8)
+
+        def draw_bar_from_posthoc_matrix(x1, x2, o):
+            draw_bar(
+                posthoc_matrix_printed[x1][x2], posthoc_matrix_stars[x1][x2], order=o, x1=x1, x2=x2)
+
+        # bars_args= []
+        # vshift=[0 for _ in self.data_groups]
+
+        # for i in range(len(self.posthoc_matrix)):
+        #     for j in range(i+1, len(self.posthoc_matrix[i])):
+        #         bars_args.append((i, j, j*3-i*3))
+        # for i in bars_args:
+        #     draw_bar(i[0], i[1], i[2])
+
+        if (self.p is not None) or (self.posthoc_matrix != []):
+            if not self.posthoc_matrix:
+                draw_bar(
+                    self.p_printed, self.stars_printed)
+            elif len(self.posthoc_matrix) == 3:
+                draw_bar_from_posthoc_matrix(0, 1, 0)
+                draw_bar_from_posthoc_matrix(1, 2, 1)
+                draw_bar_from_posthoc_matrix(0, 2, 3)
+            elif len(self.posthoc_matrix) == 4:
+                draw_bar_from_posthoc_matrix(0, 1, 0)
+                draw_bar_from_posthoc_matrix(2, 3, 0)
+                draw_bar_from_posthoc_matrix(1, 2, 1)
+
+                draw_bar_from_posthoc_matrix(0, 2, 3)
+                draw_bar_from_posthoc_matrix(1, 3, 5)
+
+                draw_bar_from_posthoc_matrix(0, 3, 7)
+
+            elif len(self.posthoc_matrix) == 5:
+
+                draw_bar_from_posthoc_matrix(0, 1, 0)
+                draw_bar_from_posthoc_matrix(2, 3, 0)
+                draw_bar_from_posthoc_matrix(1, 2, 1)
+                draw_bar_from_posthoc_matrix(3, 4, 1)
+
+                draw_bar_from_posthoc_matrix(0, 2, 4)
+                draw_bar_from_posthoc_matrix(2, 4, 5)
+                draw_bar_from_posthoc_matrix(1, 3, 8)
+
+                draw_bar_from_posthoc_matrix(0, 3, 11)
+                draw_bar_from_posthoc_matrix(1, 4, 14)
+
+                draw_bar_from_posthoc_matrix(0, 4, 17)
+
+            else:
+                draw_bar(
+                    self.p_printed, self.stars_printed)
+
+    def axes_formatting(self, ax,
+                        linewidth=2):
+        # Remove all spines except left
+        for spine in ax.spines.values():
+            spine.set_visible(False)
+        ax.spines['left'].set_visible(True)
+        ax.xaxis.set_visible(bool(self.x_label or self.print_x_labels))
+        plt.tight_layout()
+
+        # Set x ticks and labels
+        if self.print_x_labels:
+            plt.subplots_adjust(bottom=0.11)
+            if self.x_manual_tick_labels != ['']:
+                ax.set_xticks(range(self.n_groups))
+                ax.set_xticklabels([self.x_manual_tick_labels[i % len(self.x_manual_tick_labels)]
+                                    for i in range(self.n_groups)])
+            else:
+                ax.set_xticks(range(self.n_groups))
+                ax.set_xticklabels(['Group {}'.format(i + 1)
+                                   for i in range(self.n_groups)], fontweight='regular', fontsize=8)
+        else:
+            plt.subplots_adjust(bottom=0.08)
+            ax.tick_params(axis='x', which='both',
+                           labeltop=False, labelbottom=False)
+
+        # Additional formatting
+        for ytick in ax.get_yticklabels():
+            ytick.set_fontweight('bold')
+        ax.tick_params(width=linewidth)
+        ax.xaxis.set_tick_params(labelsize=10)
+        ax.yaxis.set_tick_params(labelsize=12)
+        ax.spines['left'].set_linewidth(linewidth)
+        ax.tick_params(axis='y', which='both',
+                       length=linewidth * 2, width=linewidth)
+        ax.tick_params(axis='x', which='both', length=0)
+
+    def add_titles_and_labels(self, fig, ax):
+        if self.plot_title:
+            ax.set_title(self.plot_title, fontsize=12, fontweight='bold')
+        if self.x_label:
+            ax.set_xlabel(self.x_label, fontsize=10, fontweight='bold')
+        if self.y_label:
+            ax.set_ylabel(self.y_label, fontsize=10, fontweight='bold')
+        fig.text(0.95, 0.0,
+                 '{}\nn={}'.format(self.testname,
+                                   str(self.n)[1:-1] if not self.dependent else str(self.n[0])),
+                 ha='right', va='bottom', fontsize=8, fontweight='regular')
+
+    def show(self):
+        plt.show()
+
+    def save(self, path):
+        plt.savefig(path)
+
+    def plot(self):
+        # Abstract method—each subclass must implement its own plot method
+        raise NotImplementedError(
+            "Implement the plot() method in the subclass")
+
+
+class BarStatPlot(BaseStatPlot):
+
+    def plot(self):
+        fig, ax = self.setup_figure()
+        linewidth = 2
+
+        for x in range(len(self.data_groups)):
+
+            # Create a bar for given group.
+            self.add_barplot(ax, x)
+
+            # Overlay errbars, and markers.
+            self.add_median_marker(ax, x)
+            self.add_mean_marker(ax, x)
+            self.add_errorbar_sd(ax, x)
+
+        self.add_scatter(ax)
+        self.add_significance_bars(ax, linewidth)
+        self.add_titles_and_labels(fig, ax)
+        self.axes_formatting(ax, linewidth)
+
+
+class ViolinStatPlot(BaseStatPlot):
+    '''
+        Violin plot, for adjusting see
+        https://matplotlib.org/stable/gallery/statistics/customized_violin.html#sphx-glr-gallery-statistics-customized-violin-py
+        https://medium.com/@mohammadaryayi/anything-about-violin-plots-in-matplotlib-ffd58a62bbb5
+
+        Kernel Density Estimation (violin shape prediction approach)
+        https://scikit-learn.org/stable/modules/density.html
+
+        SeaBorn violins:
+        https://seaborn.pydata.org/archive/0.11/generated/seaborn.violinplot.html
+    '''
+
+    def plot(self):
+        fig, ax = self.setup_figure()
+        linewidth = 2
+
+        for x in range(len(self.data_groups)):
+
+            # Create a violin for given group.
+            self.add_violinplot(ax, x)
+
+            # Overlay errbars and markers.
+            self.add_median_marker(ax, x)
+            self.add_mean_marker(ax, x)
+            # self.add_errorbar_sd(ax, x)
+
+        self.add_scatter(ax)
+        self.add_significance_bars(ax, linewidth)
+        self.add_titles_and_labels(fig, ax)
+        self.axes_formatting(ax, linewidth)
+
+
+class BoxStatPlot(BaseStatPlot):
+
+    def plot(self):
+        fig, ax = self.setup_figure()
+        linewidth = 2
+
+        self.add_boxplot(ax)
+        self.add_scatter(ax)
+        self.add_significance_bars(ax, linewidth)
+        self.add_titles_and_labels(fig, ax)
+        self.axes_formatting(ax, linewidth)
+
+
+class ScatterStatPlot(BaseStatPlot):
+
+    def plot(self):
+        fig, ax = self.setup_figure()
+        linewidth = 2
+
+        for x in range(len(self.data_groups)):
+
+            # Overlay errbars, and markers.
+            self.add_median_marker(ax, x)
+            self.add_mean_marker(ax, x)
+            self.add_errorbar_sd(ax, x)
+
+        self.add_scatter(ax)
+        self.add_significance_bars(ax, linewidth)
+        self.add_titles_and_labels(fig, ax)
+        self.axes_formatting(ax, linewidth)

AutoStatLib/__init__.py

@@ -1,2 +1,3 @@
 from AutoStatLib.AutoStatLib import StatisticalAnalysis
+from AutoStatLib.StatPlots import *
 from AutoStatLib._version import __version__

AutoStatLib/__main__.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python
 from AutoStatLib.AutoStatLib import StatisticalAnalysis
+from AutoStatLib.StatPlots import *
 from AutoStatLib._version import __version__
 
 if __name__ == '__main__':

AutoStatLib/_version.py

@@ -1,2 +1,2 @@
 # AutoStatLib package version:
-__version__ = "0.2.5"
+__version__ = "0.2.7"

AutoStatLib/helpers.py

@@ -1,6 +1,7 @@
 import numpy as np
 import pandas as pd
 
+
 class Helpers():
 
     def matrix_to_dataframe(self, matrix):
@@ -61,9 +62,11 @@ class Helpers():
             'Groups_SE': [np.std(self.data[i]).item() / np.sqrt(len(self.data)).item() for i in range(len(self.data))],
             # actually returns list of lists of numpy dtypes of float64, next make it return regular floats:
             'Samples': self.data,
-            'Posthoc_Matrix': self.posthoc_matrix if self.posthoc_matrix else 'N/A',
-            'Posthoc_Matrix_printed': [[self.make_p_value_printed(element) for element in row] for row in self.posthoc_matrix] if self.posthoc_matrix else 'N/A',
-            'Posthoc_Matrix_stars': [[self.make_stars_printed(self.make_stars(element)) for element in row] for row in self.posthoc_matrix] if self.posthoc_matrix else 'N/A',
+            'Posthoc_Tests_Name': self.posthoc_name if self.posthoc_name is not None else '',
+            'Posthoc_Matrix': self.posthoc_matrix if self.posthoc_matrix else [],
+            'Posthoc_Matrix_bool': [[bool(element) for element in row] for row in self.posthoc_matrix] if self.posthoc_matrix else [],
+            'Posthoc_Matrix_printed': [[self.make_p_value_printed(element) for element in row] for row in self.posthoc_matrix] if self.posthoc_matrix else [],
+            'Posthoc_Matrix_stars': [[self.make_stars_printed(self.make_stars(element)) for element in row] for row in self.posthoc_matrix] if self.posthoc_matrix else [],
         }
 
     def log(self, *args, **kwargs):
@@ -74,4 +77,4 @@ class Helpers():
     def AddWarning(self, warning_id):
         message = self.warning_ids_all[warning_id]
         self.log(message)
-        self.warnings.append(message)
+        self.warnings.append(message)

AutoStatLib/normality_tests.py

@@ -20,7 +20,7 @@ class NormalityTests():
 
         # Shapiro-Wilk test
         sw_stat, sw_p_value = shapiro(data)
-        if sw_p_value > 0.05:
+        if sw_p_value and sw_p_value > 0.05:
             sw = True
         else:
             sw = False
@@ -28,7 +28,7 @@ class NormalityTests():
         # Lilliefors test
         lf_stat, lf_p_value = lilliefors(
             data, dist='norm')
-        if lf_p_value > 0.05:
+        if lf_p_value and lf_p_value > 0.05:
             lf = True
         else:
             lf = False
@@ -37,7 +37,7 @@ class NormalityTests():
         if n >= 20:
             ad_stat, ad_p_value = self.anderson_get_p(
                 data, dist='norm')
-            if ad_p_value > 0.05:
+            if ad_p_value and ad_p_value > 0.05:
                 ad = True
             else:
                 ad = False
@@ -46,13 +46,11 @@ class NormalityTests():
         # test result is skewed if n<20
         if n >= 20:
             ap_stat, ap_p_value = normaltest(data)
-            if ap_p_value > 0.05:
+            if ap_p_value and ap_p_value > 0.05:
                 ap = True
             else:
                 ap = False
 
-        # print(ap_p_value, ad_p_value, sw_p_value, lf_p_value)
-
         return (sw, lf, ad, ap)
 
     def anderson_get_p(self, data, dist='norm'):
@@ -82,4 +80,4 @@ class NormalityTests():
         else:
             p = None
 
-        return ad, p
+        return ad, p

AutoStatLib/statistical_tests.py

@@ -1,10 +1,10 @@
 import numpy as np
 import scikit_posthocs as sp
 from statsmodels.stats.anova import AnovaRM
+from statsmodels.stats.multicomp import pairwise_tukeyhsd
 from scipy.stats import ttest_rel, ttest_ind, ttest_1samp, wilcoxon, mannwhitneyu, f_oneway, kruskal, friedmanchisquare
 
 
-
 class StatisticalTests():
     '''
         Statistical tests mixin
@@ -50,7 +50,7 @@ class StatisticalTests():
         test_names_dict = {
             'anova_1w_ordinary': 'Ordinary One-Way ANOVA',
             'anova_1w_rm': 'Repeated Measures One-Way ANOVA',
-            'friedman': 'Friedman test', 
+            'friedman': 'Friedman test',
             'kruskal_wallis': 'Kruskal-Wallis test',
             'mann_whitney': 'Mann-Whitney U test',
             't_test_independent': 't-test for independent samples',
@@ -89,6 +89,15 @@ class StatisticalTests():
         #     p_value /= 2
         # if self.tails == 1:
         #     p_value /= 2
+
+        # if p_value < 0.05 and self.posthoc:
+        #     data_flat = np.concatenate(self.data)
+        #     self.posthoc_name = 'Tukey`s multiple comparisons'
+        #     group_labels = np.concatenate(
+        #         [[f"Group_{i+1}"] * len(group) for i, group in enumerate(self.data)])
+        #     # Tukey's multiple comparisons
+        #     tukey_result = pairwise_tukeyhsd(data_flat, group_labels)
+        #     print(tukey_result)
         return stat, p_value
 
     def anova_1w_rm(self):
@@ -117,7 +126,9 @@ class StatisticalTests():
 
         # Perform Dunn's multiple comparisons if Kruskal-Wallis is significant
         if p_value < 0.05 and self.posthoc:
-            self.posthoc_matrix = sp.posthoc_dunn(self.data, p_adjust='bonferroni').values.tolist()
+            self.posthoc_matrix = sp.posthoc_dunn(
+                self.data, p_adjust='bonferroni').values.tolist()
+            self.posthoc_name = 'Dunn`s multiple comparisons'
         return stat, p_value
 
     def mann_whitney(self):
@@ -161,7 +172,7 @@ class StatisticalTests():
         if self.tails == 1:
             p_value /= 2
         return stat, p_value
-        
+
     def wilcoxon_single_sample(self):
         if self.popmean == None:
             self.popmean = 0
@@ -170,4 +181,4 @@ class StatisticalTests():
         stat, p_value = wilcoxon(data)
         if self.tails == 1:
             p_value /= 2
-        return stat, p_value
+        return stat, p_value

AutoStatLib/text_formatting.py

@@ -51,22 +51,26 @@ class TextFormatting():
                 break
             self.log(self.autospace(row_values, space))
 
-    def make_stars(self, p) -> int:
-        if p is not None:
-            if p < 0.0001:
-                return 4
-            if p < 0.001:
-                return 3
-            elif p < 0.01:
-                return 2
-            elif p < 0.05:
-                return 1
+    def print_results(self):
+        self.log('\n\nResults: \n')
+        for i in self.results:
+            shift = 27 - len(i)
+            if i == 'Warnings':
+                self.log(i, ':', ' ' * shift, len(self.results[i]))
+            elif i == 'Posthoc_Tests_Name':
+                self.log(i, ':', ' ' * shift,
+                         self.results[i]) if self.results[i] != '' else 'N/A'
+            elif i == 'Posthoc_Matrix':
+                self.log(i, ':', ' ' * shift, '{0}x{0} matrix'.format(
+                    len(self.results[i])) if self.results[i] else 'N/A')
+            elif (i == 'Samples'
+                  or i == 'Posthoc_Matrix_bool'
+                  or i == 'Posthoc_Matrix_printed'
+                  or i == 'Posthoc_Matrix_stars'
+                  ):
+                pass
             else:
-                return 0
-        return 0
-
-    def make_stars_printed(self, n) -> str:
-        return '*' * n if n else 'ns'
+                self.log(i, ':', ' ' * shift, self.results[i])
 
     def make_p_value_printed(self, p) -> str:
         if p is not None:
@@ -84,15 +88,19 @@ class TextFormatting():
                 return 'N/A'
         return 'N/A'
 
-    def print_results(self):
-        self.log('\n\nResults: \n')
-        for i in self.results:
-            shift = 27 - len(i)
-            if i == 'Warnings':
-                self.log(i, ':', ' ' * shift, len(self.results[i]))
-            if i == 'Posthoc_Matrix':
-                self.log(i, ':', ' ' * shift, '{0}x{0} matrix'.format(len(self.results[i])))
-            elif i == 'Samples' or i == 'Posthoc_Matrix_printed' or i == 'Posthoc_Matrix_stars':
-                pass
+    def make_stars(self, p) -> int:
+        if p is not None:
+            if p < 0.0001:
+                return 4
+            if p < 0.001:
+                return 3
+            elif p < 0.01:
+                return 2
+            elif p < 0.05:
+                return 1
             else:
-                self.log(i, ':', ' ' * shift, self.results[i])
+                return 0
+        return 0
+
+    def make_stars_printed(self, n) -> str:
+        return '*' * n if n else 'ns'

{AutoStatLib-0.2.5.dist-info → autostatlib-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: AutoStatLib
-Version: 0.2.5
+Version: 0.2.7
 Summary: AutoStatLib - a simple statistical analysis tool
 Author: Stemonitis, SciWare LLC
 Author-email: konung-yaropolk <yaropolk1995@gmail.com>
@@ -509,15 +509,16 @@ License:                   GNU LESSER GENERAL PUBLIC LICENSE
         
         That's all there is to it!
         
-Project-URL: Homepage, https://github.com/konung-yaropolk/NPL
-Project-URL: Issues, https://github.com/konung-yaropolk/NPL/issues
+Project-URL: Homepage, https://github.com/konung-yaropolk/AutoStatLib
+Project-URL: Repository, https://github.com/konung-yaropolk/AutoStatLib.git
+Project-URL: Issues, https://github.com/konung-yaropolk/AutoStatLib/issues
 Keywords: Science,Statistics
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: GNU Lesser General Public License v2 or later (LGPLv2+)
 Classifier: Operating System :: OS Independent
-Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Natural Language :: English
@@ -533,6 +534,7 @@ Requires-Dist: scipy
 Requires-Dist: statsmodels
 Requires-Dist: scikit-posthocs
 Requires-Dist: pandas
+Dynamic: license-file
 
 # AutoStatLib - python library for automated statistical analysis 
 
@@ -620,26 +622,30 @@ results = analysis.GetResult()
 The results dictionary keys with representing value types:
 ```
 {
-    'p-value':                     String
-    'Significance(p<0.05)':        Boolean
-    'Stars_Printed':               String
-    'Test_Name':                   String
-    'Groups_Compared':             Integer
-    'Population_Mean':             Float   (taken from the input)
-    'Data_Normaly_Distributed':    Boolean
-    'Parametric_Test_Applied':     Boolean
-    'Paired_Test_Applied':         Boolean
-    'Tails':                       Integer (taken from the input)
-    'p-value_exact':               Float
-    'Stars':                       Integer
-    'Warnings':                    String
-    'Groups_N':                    List of integers
-    'Groups_Median':               List of floats
-    'Groups_Mean':                 List of floats
-    'Groups_SD':                   List of floats
-    'Groups_SE':                   List of floats
-    'Samples':                     List of input values by groups
+    'p-value' :                    String
+    'Significance(p<0.05)' :       Boolean
+    'Stars_Printed' :              String
+    'Test_Name' :                  String
+    'Groups_Compared' :            Integer
+    'Population_Mean' :            Float   (taken from the input)
+    'Data_Normaly_Distributed' :   Boolean
+    'Parametric_Test_Applied' :    Boolean
+    'Paired_Test_Applied' :        Boolean
+    'Tails' :                      Integer (taken from the input)
+    'p-value_exact' :              Float
+    'Stars' :                      Integer
+    'Warnings' :                   String
+    'Groups_N' :                   List of integers
+    'Groups_Median' :              List of floats
+    'Groups_Mean' :                List of floats
+    'Groups_SD' :                  List of floats
+    'Groups_SE' :                  List of floats
+    'Samples' :                    List of input values by groups
                                            (taken from the input)
+    'Posthoc_Matrix' :             2D List of floats
+    'Posthoc_Matrix_bool' :        2D List of Boolean
+    'Posthoc_Matrix_printed':      2D List of String
+    'Posthoc_Matrix_stars':        2D List of String
 }
 ```
 If errors occured, *GetResult()* returns an empty dictionary

autostatlib-0.2.7.dist-info/RECORD

@@ -0,0 +1,14 @@
+AutoStatLib/AutoStatLib.py,sha256=KJM2x-fChnxVinnCFsAKpoacKeoIJcJw_r8FYqPCljk,9677
+AutoStatLib/StatPlots.py,sha256=KJA-xnuBef0pa6L985XxdWtwEVmb-dcu5DHKLv6Y5Ew,23810
+AutoStatLib/__init__.py,sha256=r7VdcL7F4UCRxEFh8WFBd9y61KavX_qt7fFbKjtjfjo,137
+AutoStatLib/__main__.py,sha256=0OIv5sqFNI-diyHFtYL6HPcYrOWdLiqYYOO_nxrHuTk,283
+AutoStatLib/_version.py,sha256=82BMDplnoVlfpnbkt4ImTQlV7kA099OEgHW37crfaE4,53
+AutoStatLib/helpers.py,sha256=d8P6_q706rjuc6N4WBbdOqNQFuAIjCHfmrhgJABFxqE,3646
+AutoStatLib/normality_tests.py,sha256=TYeKpfpJRzOHvDZucObuZhPktjiZpSZwh381eJ8ENC4,2381
+AutoStatLib/statistical_tests.py,sha256=xfHdTtN5Es_qoVMUwX8VFsl-FLpF3zd56S9ya7dPXVo,6566
+AutoStatLib/text_formatting.py,sha256=rWDsrlZdquook7lUg8t2mb3az8nR12BDprxfy_NwE2o,3576
+autostatlib-0.2.7.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
+autostatlib-0.2.7.dist-info/METADATA,sha256=Xb1tAK4NcJwv8r2D4Y2SUM5sPeiTPFgSBfLfQiuGMbo,36894
+autostatlib-0.2.7.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+autostatlib-0.2.7.dist-info/top_level.txt,sha256=BuHzVyE2andc7RwD_UPmDjLl9CUAyBH6WHZGjaIReUI,12
+autostatlib-0.2.7.dist-info/RECORD,,

{AutoStatLib-0.2.5.dist-info → autostatlib-0.2.7.dist-info}/WHEEL

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

AutoStatLib-0.2.5.dist-info/RECORD

@@ -1,13 +0,0 @@
-AutoStatLib/AutoStatLib.py,sha256=yPNnwCvHSSlEKQvtnoaLFDq6znPlXCz-CrzGInG-1Ys,9647
-AutoStatLib/__init__.py,sha256=0wHYnglzKRPqSHtZlfbMEA2Bj5rDR4LLaXbOrJi-sqM,101
-AutoStatLib/__main__.py,sha256=ROKWensrxDh3Gl-yhexJ-BYFohDSh9y-CuMkaLpmnnQ,247
-AutoStatLib/_version.py,sha256=-QrGYOb9bx4vC_twSInOBJoijtj78lvUzV19y4-tH38,53
-AutoStatLib/helpers.py,sha256=9Fj9pHlXSM3tGHF5L0-i6DilA9VZk6Re93ob_IRxsYg,3424
-AutoStatLib/normality_tests.py,sha256=wvOmo6F7drnhhikoGltyQJC4OBk3PLCszY6ItJk1e0M,2385
-AutoStatLib/statistical_tests.py,sha256=LDcBRkq56hepR23RZtbBnZOs9k9frVjmiB2EKiEkCYs,5990
-AutoStatLib/text_formatting.py,sha256=ShE4BRO69lsC1VT3SsYrmPkuvW7QnyfHVPZEbjNQ_hI,3250
-AutoStatLib-0.2.5.dist-info/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
-AutoStatLib-0.2.5.dist-info/METADATA,sha256=qJxSrqHlL0wsqaH-ah6MAJa15ikH4NCco1dyVxuNlWs,36572
-AutoStatLib-0.2.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-AutoStatLib-0.2.5.dist-info/top_level.txt,sha256=BuHzVyE2andc7RwD_UPmDjLl9CUAyBH6WHZGjaIReUI,12
-AutoStatLib-0.2.5.dist-info/RECORD,,