spacr 0.4.0__py3-none-any.whl → 0.4.11__py3-none-any.whl

spacr/__init__.py

@@ -27,7 +27,7 @@ from . import openai
 from . import ml
 from . import toxo
 from . import cellpose
-from . import stats
+from . import sp_stats
 from . import logger
 
 __all__ = [
@@ -58,7 +58,7 @@ __all__ = [
     "ml",
     "toxo",
     "cellpose",
-    "stats",
+    "sp_stats",
     "logger"
 ]
 

spacr/deep_spacr.py

@@ -938,67 +938,8 @@ def deep_spacr(settings={}):
         if os.path.exists(settings['model_path']):
             apply_model_to_tar(settings)
             
-def model_knowledge_transfer(
-    teacher_paths,
-    student_save_path,
-    data_loader,                 # A DataLoader with (images, labels)
-    device='cpu',
-    student_model_name='maxvit_t',
-    pretrained=True,
-    dropout_rate=None,
-    use_checkpoint=False,
-    alpha=0.5,
-    temperature=2.0,
-    lr=1e-4,
-    epochs=10
-):
-    """
-    Performs multi-teacher knowledge distillation on a new labeled dataset,
-    producing a single student TorchModel that combines (distills) the 
-    teachers' knowledge plus the labeled data.
-
-    Usage:
-        student = model_knowledge_transfer(
-            teacher_paths=[
-                'teacherA.pth', 
-                'teacherB.pth', 
-                ...
-            ],
-            student_save_path='distilled_student.pth',
-            data_loader=my_data_loader, 
-            device='cuda', 
-            student_model_name='maxvit_t',
-            alpha=0.5,
-            temperature=2.0,
-            lr=1e-4,
-            epochs=10
-        )
-
-    Then load it via:
-        fused_student = torch.load('distilled_student.pth')
-        # fused_student is a TorchModel instance, ready for inference.
-
-    Args:
-        teacher_paths (list[str]): List of paths to teacher models (TorchModel 
-            or dict with 'model' in it). They must have the same architecture 
-            or at least produce the same dimension of output.
-        student_save_path (str): Destination path to save the final student 
-            TorchModel. 
-        data_loader (DataLoader): Yields (images, labels) from the new dataset.
-        device (str): 'cpu' or 'cuda'.
-        student_model_name (str): Architecture name for the student TorchModel.
-        pretrained (bool): If the student should be initialized as pretrained.
-        dropout_rate (float): If needed by your TorchModel init.
-        use_checkpoint (bool): If needed by your TorchModel init.
-        alpha (float): Weight balancing real-label CE vs. distillation loss 
-            (0..1). 
-        temperature (float): Distillation temperature (>1 typically).
-        lr (float): Learning rate for the student.
-        epochs (int): Number of training epochs.
+def model_knowledge_transfer(teacher_paths, student_save_path, data_loader, device='cpu', student_model_name='maxvit_t', pretrained=True, dropout_rate=None, use_checkpoint=False, alpha=0.5, temperature=2.0, lr=1e-4, epochs=10):
 
-    Returns:
-        TorchModel: The final, trained student model.
-    """
     from spacr.utils import TorchModel  # Adapt if needed
 
     # Adjust filename to reflect knowledge-distillation if desired
@@ -1101,42 +1042,8 @@ def model_knowledge_transfer(
 
     return student_model
             
-def model_fusion(model_paths,
-                 save_path,
-                 device='cpu',
-                 model_name='maxvit_t',
-                 pretrained=True,
-                 dropout_rate=None,
-                 use_checkpoint=False,
-                 aggregator='mean'):
-    """
-    Fuses an arbitrary number of TorchModel instances by combining their weights 
-    (using mean, geomean, median, sum, max, or min) and saves the entire fused 
-    model object. 
-
-    You can later load the fused model with:
-        model = torch.load('fused_model.pth')
-
-    which returns a ready-to-use TorchModel instance.
-
-    Parameters:
-        model_paths (list of str): Paths to the model checkpoints to fuse.
-                                   Each checkpoint can be:
-                                     - A dict with keys ['model', 'model_name', ...]
-                                     - A TorchModel instance
-        save_path (str): Destination path to save the fused model.
-        device (str): 'cpu' or 'cuda' for loading weights and final model device.
-        model_name (str): Default model name (used if not in checkpoint).
-        pretrained (bool): Default if not in checkpoint.
-        dropout_rate (float): Default if not in checkpoint.
-        use_checkpoint (bool): Default if not in checkpoint.
-        aggregator (str): How to combine weights across models:
-                            'mean', 'geomean', 'median', 'sum', 'max', or 'min'.
+def model_fusion(model_paths,save_path,device='cpu',model_name='maxvit_t',pretrained=True,dropout_rate=None,use_checkpoint=False,aggregator='mean'):
 
-    Returns:
-        fused_model (TorchModel): The final fused TorchModel instance 
-                                  with combined weights.
-    """
     from spacr.utils import TorchModel
     
     if save_path.endswith('.pth'):

spacr/plot.py

@@ -2705,7 +2705,7 @@ class spacrGraph:
     def perform_posthoc_tests(self, is_normal, unique_groups):
         """Perform post-hoc tests for multiple groups based on all_to_all flag."""
 
-        from .stats import choose_p_adjust_method
+        from .sp_stats import choose_p_adjust_method
 
         posthoc_results = []
         if is_normal and len(unique_groups) > 2 and self.all_to_all:
@@ -3815,7 +3815,7 @@ def plot_proportion_stacked_bars(settings, df, group_column, bin_column, prc_col
     - pairwise_results (list): Pairwise test results from `chi_pairwise`.
     """
     
-    from .stats import chi_pairwise
+    from .sp_stats import chi_pairwise
     
     # Calculate contingency table for overall chi-squared test
     raw_counts = df.groupby([group_column, bin_column]).size().unstack(fill_value=0)

spacr/settings.py

@@ -89,7 +89,7 @@ def set_default_settings_preprocess_generate_masks(settings={}):
     settings.setdefault('timelapse_frame_limits', None)
     settings.setdefault('timelapse_remove_transient', False)
     settings.setdefault('timelapse_mode', 'trackpy')
-    settings.setdefault('timelapse_objects', 'cells')
+    settings.setdefault('timelapse_objects', None)
 
     # Misc settings
     settings.setdefault('all_to_mip', False)

spacr/sp_stats.py

@@ -0,0 +1,221 @@
+from scipy.stats import shapiro, normaltest, levene, ttest_ind, mannwhitneyu, kruskal, f_oneway
+from statsmodels.stats.multicomp import pairwise_tukeyhsd
+import scikit_posthocs as sp
+import numpy as np
+import pandas as pd
+from scipy.stats import chi2_contingency, fisher_exact
+import itertools
+from statsmodels.stats.multitest import multipletests
+
+
+def choose_p_adjust_method(num_groups, num_data_points):
+    """
+    Selects the most appropriate p-value adjustment method based on data characteristics.
+    
+    Parameters:
+    - num_groups: Number of unique groups being compared
+    - num_data_points: Number of data points per group (assuming balanced groups)
+    
+    Returns:
+    - A string representing the recommended p-adjustment method
+    """
+    num_comparisons = (num_groups * (num_groups - 1)) // 2  # Number of pairwise comparisons
+
+    # Decision logic for choosing the adjustment method
+    if num_comparisons <= 10 and num_data_points > 5:
+        return 'holm'  # Balanced between power and Type I error control
+    elif num_comparisons > 10 and num_data_points <= 5:
+        return 'fdr_bh'  # FDR control for large number of comparisons and small sample size
+    elif num_comparisons <= 10:
+        return 'sidak'  # Less conservative than Bonferroni, good for independent comparisons
+    else:
+        return 'bonferroni'  # Very conservative, use for strict control of Type I errors
+
+def perform_normality_tests(df, grouping_column, data_columns):
+    """Perform normality tests for each group and data column."""
+    unique_groups = df[grouping_column].unique()
+    normality_results = []
+
+    for column in data_columns:
+        for group in unique_groups:
+            data = df.loc[df[grouping_column] == group, column].dropna()
+            n_samples = len(data)
+
+            if n_samples < 3:
+                # Skip test if there aren't enough data points
+                print(f"Skipping normality test for group '{group}' on column '{column}' - Not enough data.")
+                normality_results.append({
+                    'Comparison': f'Normality test for {group} on {column}',
+                    'Test Statistic': None,
+                    'p-value': None,
+                    'Test Name': 'Skipped',
+                    'Column': column,
+                    'n': n_samples
+                })
+                continue
+
+            # Choose the appropriate normality test based on the sample size
+            if n_samples >= 8:
+                stat, p_value = normaltest(data)
+                test_name = "D'Agostino-Pearson test"
+            else:
+                stat, p_value = shapiro(data)
+                test_name = "Shapiro-Wilk test"
+
+            normality_results.append({
+                'Comparison': f'Normality test for {group} on {column}',
+                'Test Statistic': stat,
+                'p-value': p_value,
+                'Test Name': test_name,
+                'Column': column,
+                'n': n_samples
+            })
+
+        # Check if all groups are normally distributed (p > 0.05)
+        normal_p_values = [result['p-value'] for result in normality_results if result['Column'] == column and result['p-value'] is not None]
+        is_normal = all(p > 0.05 for p in normal_p_values)
+
+    return is_normal, normality_results
+
+
+def perform_levene_test(df, grouping_column, data_column):
+    """Perform Levene's test for equal variance."""
+    unique_groups = df[grouping_column].unique()
+    grouped_data = [df.loc[df[grouping_column] == group, data_column].dropna() for group in unique_groups]
+    stat, p_value = levene(*grouped_data)
+    return stat, p_value
+
+def perform_statistical_tests(df, grouping_column, data_columns, paired=False):
+    """Perform statistical tests for each data column."""
+    unique_groups = df[grouping_column].unique()
+    test_results = []
+
+    for column in data_columns:
+        grouped_data = [df.loc[df[grouping_column] == group, column].dropna() for group in unique_groups]
+        if len(unique_groups) == 2:  # For two groups
+            if paired:
+                print("Performing paired tests (not implemented in this template).")
+                continue  # Extend as needed
+            else:
+                # Check normality for two groups
+                is_normal, _ = perform_normality_tests(df, grouping_column, [column])
+                if is_normal:
+                    stat, p = ttest_ind(grouped_data[0], grouped_data[1])
+                    test_name = 'T-test'
+                else:
+                    stat, p = mannwhitneyu(grouped_data[0], grouped_data[1])
+                    test_name = 'Mann-Whitney U test'
+        else:
+            # Check normality for multiple groups
+            is_normal, _ = perform_normality_tests(df, grouping_column, [column])
+            if is_normal:
+                stat, p = f_oneway(*grouped_data)
+                test_name = 'One-way ANOVA'
+            else:
+                stat, p = kruskal(*grouped_data)
+                test_name = 'Kruskal-Wallis test'
+
+        test_results.append({
+            'Column': column,
+            'Test Name': test_name,
+            'Test Statistic': stat,
+            'p-value': p,
+            'Groups': len(unique_groups)
+        })
+
+    return test_results
+
+
+def perform_posthoc_tests(df, grouping_column, data_column, is_normal):
+    """Perform post-hoc tests for multiple groups with both original and adjusted p-values."""
+    unique_groups = df[grouping_column].unique()
+    posthoc_results = []
+
+    if len(unique_groups) > 2:
+        num_groups = len(unique_groups)
+        num_data_points = len(df[data_column].dropna()) // num_groups  # Assuming roughly equal data points per group
+        p_adjust_method = choose_p_adjust_method(num_groups, num_data_points)
+
+        if is_normal:
+            # Tukey's HSD automatically adjusts p-values
+            tukey_result = pairwise_tukeyhsd(df[data_column], df[grouping_column], alpha=0.05)
+            for comparison, p_value in zip(tukey_result._results_table.data[1:], tukey_result.pvalues):
+                posthoc_results.append({
+                    'Comparison': f"{comparison[0]} vs {comparison[1]}",
+                    'Original p-value': None,  # Tukey HSD does not provide raw p-values
+                    'Adjusted p-value': p_value,
+                    'Adjusted Method': 'Tukey HSD',
+                    'Test Name': 'Tukey HSD'
+                })
+        else:
+            # Dunn's test with p-value adjustment
+            raw_dunn_result = sp.posthoc_dunn(df, val_col=data_column, group_col=grouping_column, p_adjust=None)
+            adjusted_dunn_result = sp.posthoc_dunn(df, val_col=data_column, group_col=grouping_column, p_adjust=p_adjust_method)
+            for i, group_a in enumerate(adjusted_dunn_result.index):
+                for j, group_b in enumerate(adjusted_dunn_result.columns):
+                    if i < j:  # Only consider unique pairs
+                        posthoc_results.append({
+                            'Comparison': f"{group_a} vs {group_b}",
+                            'Original p-value': raw_dunn_result.iloc[i, j],
+                            'Adjusted p-value': adjusted_dunn_result.iloc[i, j],
+                            'Adjusted Method': p_adjust_method,
+                            'Test Name': "Dunn's Post-hoc"
+                        })
+
+    return posthoc_results
+
+def chi_pairwise(raw_counts, verbose=False):
+    """
+    Perform pairwise chi-square or Fisher's exact tests between all unique group pairs
+    and apply p-value correction.
+
+    Parameters:
+    - raw_counts (DataFrame): Contingency table with group-wise counts.
+    - verbose (bool): Whether to print results for each pair.
+
+    Returns:
+    - pairwise_df (DataFrame): DataFrame with pairwise test results, including corrected p-values.
+    """
+    pairwise_results = []
+    groups = raw_counts.index.unique()  # Use index from raw_counts for group pairs
+    raw_p_values = []  # Store raw p-values for correction later
+    
+    # Calculate the number of groups and average number of data points per group
+    num_groups = len(groups)
+    num_data_points = raw_counts.sum(axis=1).mean()  # Average total data points per group
+    p_adjust_method = choose_p_adjust_method(num_groups, num_data_points)
+
+    for group1, group2 in itertools.combinations(groups, 2):
+        contingency_table = raw_counts.loc[[group1, group2]].values
+        if contingency_table.shape[1] == 2:  # Fisher's Exact Test for 2x2 tables
+            oddsratio, p_value = fisher_exact(contingency_table)
+            test_name = "Fisher's Exact Test"
+        else:  # Chi-Square Test for larger tables
+            chi2_stat, p_value, _, _ = chi2_contingency(contingency_table)
+            test_name = 'Pairwise Chi-Square Test'
+        
+        pairwise_results.append({
+            'Group 1': group1,
+            'Group 2': group2,
+            'Test Name': test_name,
+            'p-value': p_value
+        })
+        raw_p_values.append(p_value)
+
+    # Apply p-value correction
+    corrected_p_values = multipletests(raw_p_values, method=p_adjust_method)[1]
+
+    # Add corrected p-values to results
+    for i, result in enumerate(pairwise_results):
+        result['p-value_adj'] = corrected_p_values[i]
+
+    pairwise_df = pd.DataFrame(pairwise_results)
+    
+    pairwise_df['adj'] = p_adjust_method
+
+    if verbose:
+        # Print pairwise results
+        print("\nPairwise Frequency Analysis Results:")
+        print(pairwise_df.to_string(index=False))
+
+    return pairwise_df

spacr/submodules.py

@@ -1041,7 +1041,7 @@ def analyze_class_proportion(settings):
     from .io import _read_and_merge_data
     from .settings import set_analyze_class_proportion_defaults
     from .plot import plot_plates, plot_proportion_stacked_bars
-    from .stats import perform_normality_tests, perform_levene_test, perform_statistical_tests, perform_posthoc_tests
+    from .sp_stats import perform_normality_tests, perform_levene_test, perform_statistical_tests, perform_posthoc_tests
     
     settings = set_analyze_class_proportion_defaults(settings)
     save_settings(settings, name='analyze_class_proportion', show=True)

spacr/utils.py

@@ -5011,22 +5011,22 @@ def generate_cytoplasm_mask(nucleus_mask, cell_mask):
     return cytoplasm_mask
 
 def add_column_to_database(settings):
-    #"""
-    #Adds a new column to the database table by matching on a common column from the DataFrame.
-    #If the column already exists in the database, it adds the column with a suffix.
-    #NaN values will remain as NULL in the database.
-
-    #Parameters:
-    #    settings (dict): A dictionary containing the following keys:
-    #    csv_path (str): Path to the CSV file with the data to be added.
-    #    db_path (str): Path to the SQLite database (or connection string for other databases).
-    #    table_name (str): The name of the table in the database.
-    #    update_column (str): The name of the new column in the DataFrame to add to the database.
-    #    match_column (str): The common column used to match rows.
-
-    #Returns:
-    #    None
-    #"""
+    """
+    Adds a new column to the database table by matching on a common column from the DataFrame.
+    If the column already exists in the database, it adds the column with a suffix.
+    NaN values will remain as NULL in the database.
+
+    Parameters:
+        settings (dict): A dictionary containing the following keys:
+            csv_path (str): Path to the CSV file with the data to be added.
+            db_path (str): Path to the SQLite database (or connection string for other databases).
+            table_name (str): The name of the table in the database.
+            update_column (str): The name of the new column in the DataFrame to add to the database.
+            match_column (str): The common column used to match rows.
+
+    Returns:
+        None
+    """
 
     # Read the DataFrame from the provided CSV path
     df = pd.read_csv(settings['csv_path'])

{spacr-0.4.0.dist-info → spacr-0.4.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.4.0
+Version: 0.4.11
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson

{spacr-0.4.0.dist-info → spacr-0.4.11.dist-info}/RECORD

@@ -1,4 +1,4 @@
-spacr/__init__.py,sha256=KgkkUyqbm4kh8bwxWeFpp4rilNE0y0RkeylPvS-cTLY,1395
+spacr/__init__.py,sha256=iPlE-WRc1CjSNGPMbVvEKlJsTQlKjq29VjzvNUCpcOM,1401
 spacr/__main__.py,sha256=bkAJJD2kjIqOP-u1kLvct9jQQCeUXzlEjdgitwi1Lm8,75
 spacr/app_annotate.py,sha256=W9eLPa_LZIvXsXx_-0iDFEU938LBDvRy6prXo0qF4KQ,2533
 spacr/app_classify.py,sha256=urTP_wlZ58hSyM5a19slYlBxN0PdC-9-ga0hvq8CGWc,165
@@ -10,7 +10,7 @@ spacr/app_umap.py,sha256=ZWAmf_OsIKbYvolYuWPMYhdlVe-n2CADoJulAizMiEo,153
 spacr/cellpose.py,sha256=RBHMs2vwXcfkj0xqAULpALyzJYXddSRycgZSzmwI7v0,14755
 spacr/chat_bot.py,sha256=n3Fhqg3qofVXHmh3H9sUcmfYy9MmgRnr48663MVdY9E,1244
 spacr/core.py,sha256=lKeqmsVrGQ8cPU_WkoNGNBWrk-gtR1RkRkwDdnJ0u64,48829
-spacr/deep_spacr.py,sha256=AsAbehxPChAq65YVPuFqCt5JabdeO8AwVWZmcmyLeFw,58020
+spacr/deep_spacr.py,sha256=WN64EaQqF87JZg3Uan46t5Y28xsAGD2KMjr2ht6CyDs,54563
 spacr/gui.py,sha256=ARyn9Q_g8HoP-cXh1nzMLVFCKqthY4v2u9yORyaQqQE,8230
 spacr/gui_core.py,sha256=U0A7waKgWq_Es9fMwcZbXUZYGzCqt2bgfY3HbxiFXnw,47466
 spacr/gui_elements.py,sha256=HmITDncklKwtdFhxLhtYXOwndsRfgwWIPVi83VlXHB4,146419
@@ -21,15 +21,16 @@ spacr/measure.py,sha256=jmOnLBudq3TuY723Cfo1EJBn67P6rlEvL6I-2FSkUgI,55315
 spacr/mediar.py,sha256=FwLvbLQW5LQzPgvJZG8Lw7GniA2vbZx6Jv6vIKu7I5c,14743
 spacr/ml.py,sha256=MrIAtUUxMOibWVL1SjCUnYlizawCp3l3SeY4Y9yEsPw,97251
 spacr/openai.py,sha256=5vBZ3Jl2llYcW3oaTEXgdyCB2aJujMUIO5K038z7w_A,1246
-spacr/plot.py,sha256=p4AY5EWmVNPMqFD0I4NARJkvJA5gTErbDDYqDMU18pc,169479
+spacr/plot.py,sha256=Q5TbsR2NUWhA7z4HyF_2_FAEBFSNMU-G3UNDbRzW6mM,169485
 spacr/sequencing.py,sha256=ClUfwPPK6rNUbUuiEkzcwakzVyDKKUMv9ricrxT8qQY,25227
-spacr/settings.py,sha256=e6QWZ5o6Im02_t-3GQh3H4kksMTQmIZ1Rbh3BeQmmsw,84000
+spacr/settings.py,sha256=fEk-9LSSvV1wGsn6xTaJWY7wF7_u8Fc-S1DaDHqZU3I,83997
 spacr/sim.py,sha256=1xKhXimNU3ukzIw-3l9cF3Znc_brW8h20yv8fSTzvss,71173
+spacr/sp_stats.py,sha256=mbhwsyIqt5upsSD346qGjdCw7CFBa0tIS7zHU9e0jNI,9536
 spacr/stats.py,sha256=mbhwsyIqt5upsSD346qGjdCw7CFBa0tIS7zHU9e0jNI,9536
-spacr/submodules.py,sha256=e_JNMGBHakEra_2pstHFmgI1NhF9TybfvTNDAegVsl0,67626
+spacr/submodules.py,sha256=mb2g0igUTws7y6xW1zIJw1E7eQyxsjEj5mk2Z-Qd8uw,67629
 spacr/timelapse.py,sha256=KGfG4L4-QnFfgbF7L6C5wL_3gd_rqr05Foje6RsoTBg,39603
 spacr/toxo.py,sha256=TmuhejSIPLBvsgeblsUgSvBFCR1gOkApyTKidooJ5Us,26044
-spacr/utils.py,sha256=m4MZiNbmQpZD78eu5DNmxk4cU_tk2VeVLCe_R_7YShY,226287
+spacr/utils.py,sha256=of2t5Tq_RKdJ1QRDo4nJ3oEVev_6s2Oko3-lBxl4ScU,226293
 spacr/version.py,sha256=axH5tnGwtgSnJHb5IDhiu4Zjk5GhLyAEDRe-rnaoFOA,409
 spacr/resources/MEDIAR/.gitignore,sha256=Ff1q9Nme14JUd-4Q3jZ65aeQ5X4uttptssVDgBVHYo8,152
 spacr/resources/MEDIAR/LICENSE,sha256=yEj_TRDLUfDpHDNM0StALXIt6mLqSgaV2hcCwa6_TcY,1065
@@ -152,9 +153,9 @@ spacr/resources/icons/umap.png,sha256=dOLF3DeLYy9k0nkUybiZMe1wzHQwLJFRmgccppw-8b
 spacr/resources/images/plate1_E01_T0001F001L01A01Z01C02.tif,sha256=Tl0ZUfZ_AYAbu0up_nO0tPRtF1BxXhWQ3T3pURBCCRo,7958528
 spacr/resources/images/plate1_E01_T0001F001L01A02Z01C01.tif,sha256=m8N-V71rA1TT4dFlENNg8s0Q0YEXXs8slIn7yObmZJQ,7958528
 spacr/resources/images/plate1_E01_T0001F001L01A03Z01C03.tif,sha256=Pbhk7xn-KUP6RSIhJsxQcrHFImBm3GEpLkzx7WOc-5M,7958528
-spacr-0.4.0.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
-spacr-0.4.0.dist-info/METADATA,sha256=uloYFy8DrWtHZvy5W47jBRNUEF_SeX4nLZ0OL2wMizc,6072
-spacr-0.4.0.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-spacr-0.4.0.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
-spacr-0.4.0.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
-spacr-0.4.0.dist-info/RECORD,,
+spacr-0.4.11.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
+spacr-0.4.11.dist-info/METADATA,sha256=xQABPDmILj46nsesjIjNZ7SoVliz-PzHg0AHprY85-4,6073
+spacr-0.4.11.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
+spacr-0.4.11.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
+spacr-0.4.11.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
+spacr-0.4.11.dist-info/RECORD,,