autogaita 1.2.0__tar.gz → 1.3.0__tar.gz

{autogaita-1.2.0 → autogaita-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogaita
-Version: 1.2.0
+Version: 1.3.0
 Summary: Automatic Gait Analysis in Python. A toolbox to streamline and standardise the analysis of kinematics across species after ML-based body posture tracking. Despite being optimised for gait analyses, AutoGaitA has the potential to be used for any kind of kinematic analysis.
 Home-page: https://github.com/mahan-hosseini/AutoGaitA/
 Author: Mahan Hosseini

{autogaita-1.2.0 → autogaita-1.3.0}/autogaita/common2D/common2D_2_sc_extraction.py

@@ -4,6 +4,7 @@ from autogaita.common2D.common2D_utils import (
     check_cycle_out_of_bounds,
     check_cycle_duplicates,
     check_cycle_order,
+    check_differing_angle_joint_coords,
     check_tracking_xy_thresholds,
     check_tracking_SLEAP_nans,
     handle_issues,
@@ -208,14 +209,25 @@ def extract_stepcycles(tracking_software, data, info, folderinfo, cfg):
     # ............................  clean all_cycles  ..................................
     # check if we skipped latencies because they were out of data-bounds
     all_cycles = check_cycle_out_of_bounds(all_cycles)
-    if all_cycles:  # can be None if all SCs were out of bounds
-        # check if there are any duplicates (e.g., SC2's start-lat == SC1's end-lat)
-        all_cycles = check_cycle_duplicates(all_cycles)
-        # check if user input progressively later latencies
-        all_cycles = check_cycle_order(all_cycles, info)
-        # check if tracking broke for any SCs using user-provided x and y thresholds
-        all_cycles = check_tracking_xy_thresholds(data, info, all_cycles, cfg)
-        # for SLEAP - check if there were any NaNs in any joints/angle-joints in SCs
-        if tracking_software == "SLEAP":
-            all_cycles = check_tracking_SLEAP_nans(data, info, all_cycles, cfg)
+    if not all_cycles:  # returns None if no clean cycles found
+        return None
+    # check if there are any duplicates (e.g., SC2's start-lat == SC1's end-lat)
+    all_cycles = check_cycle_duplicates(all_cycles)  # doesnt return None!
+    # check if user input progressively later latencies
+    all_cycles = check_cycle_order(all_cycles, info)
+    if not all_cycles:  # returns empty list if no clean cycles found
+        return None
+    # check that joints used in angle computations have different coords at all tps
+    all_cycles = check_differing_angle_joint_coords(all_cycles, data, info, cfg)
+    if not all_cycles:
+        return None
+    # check if tracking broke for any SCs using user-provided x and y thresholds
+    all_cycles = check_tracking_xy_thresholds(all_cycles, data, info, cfg)
+    if not all_cycles:
+        return None
+    # for SLEAP - check if there were any NaNs in any joints/angle-joints in SCs
+    if tracking_software == "SLEAP":
+        all_cycles = check_tracking_SLEAP_nans(all_cycles, data, info, cfg)
+        if not all_cycles:
+            return None
     return all_cycles

{autogaita-1.2.0 → autogaita-1.3.0}/autogaita/common2D/common2D_3_analysis.py

@@ -1,10 +1,13 @@
 # %% imports
-from autogaita.resources.utils import bin_num_to_percentages
+from autogaita.resources.utils import (
+    bin_num_to_percentages,
+    compute_angle,
+    write_angle_warning,
+)
 import os
 import warnings
 import pandas as pd
 import numpy as np
-import math
 
 # %% constants
 from autogaita.resources.constants import TIME_COL, SC_PERCENTAGE_COL
@@ -50,14 +53,14 @@ def analyse_and_export_stepcycles(data, all_cycles, info, cfg):
         this_step = data_copy.loc[all_cycles[0][0] : all_cycles[0][1]]
         if standardise_x_coordinates:
             all_steps_data, x_standardised_steps_data = (
-                standardise_x_y_and_add_features_to_one_step(this_step, cfg)
+                standardise_x_y_and_add_features_to_one_step(this_step, info, cfg)
             )
             normalised_steps_data = normalise_one_steps_data(
                 x_standardised_steps_data, bin_num
             )
         else:
             all_steps_data = standardise_x_y_and_add_features_to_one_step(
-                this_step, cfg
+                this_step, info, cfg
             )
             normalised_steps_data = normalise_one_steps_data(all_steps_data, bin_num)
     # 2 or more steps - build dataframe
@@ -69,14 +72,14 @@ def analyse_and_export_stepcycles(data, all_cycles, info, cfg):
         first_step = data_copy.loc[all_cycles[0][0] : all_cycles[0][1]]
         if standardise_x_coordinates:
             all_steps_data, x_standardised_steps_data = (
-                standardise_x_y_and_add_features_to_one_step(first_step, cfg)
+                standardise_x_y_and_add_features_to_one_step(first_step, info, cfg)
             )
             normalised_steps_data = normalise_one_steps_data(
                 x_standardised_steps_data, bin_num
             )
         else:
             all_steps_data = standardise_x_y_and_add_features_to_one_step(
-                first_step, cfg
+                first_step, info, cfg
             )
             normalised_steps_data = normalise_one_steps_data(all_steps_data, bin_num)
         # some prep for addition of further steps
@@ -98,13 +101,15 @@ def analyse_and_export_stepcycles(data, all_cycles, info, cfg):
             this_step = data_copy.loc[all_cycles[s][0] : all_cycles[s][1]]
             if standardise_x_coordinates:
                 this_step, this_x_standardised_step = (
-                    standardise_x_y_and_add_features_to_one_step(this_step, cfg)
+                    standardise_x_y_and_add_features_to_one_step(this_step, info, cfg)
                 )
                 this_normalised_step = normalise_one_steps_data(
                     this_x_standardised_step, bin_num
                 )
             else:
-                this_step = standardise_x_y_and_add_features_to_one_step(this_step, cfg)
+                this_step = standardise_x_y_and_add_features_to_one_step(
+                    this_step, info, cfg
+                )
                 this_normalised_step = normalise_one_steps_data(this_step, bin_num)
             # step separators & step-to-rest-concatenation
             # => note that normalised_step is already based on x-stand if required
@@ -170,7 +175,7 @@ def analyse_and_export_stepcycles(data, all_cycles, info, cfg):
 # ......................................................................................
 
 
-def standardise_x_y_and_add_features_to_one_step(step, cfg):
+def standardise_x_y_and_add_features_to_one_step(step, info, cfg):
     """For a single step cycle's data, standardise x & y if wanted and add features"""
     # if user wanted this, standardise y (height) at step-cycle level
     step_copy = step.copy()
@@ -184,11 +189,11 @@ def standardise_x_y_and_add_features_to_one_step(step, cfg):
         step_copy[y_cols] -= this_y_min
     # if no x-standardisation, just add features & return non-(x-)normalised step
     if cfg["standardise_x_coordinates"] is False:
-        non_stand_step = add_features(step_copy, cfg)
+        non_stand_step = add_features(step_copy, info, cfg)
         return non_stand_step
         # else standardise x (horizontal dimension) at step-cycle level too
     else:
-        non_stand_step = add_features(step_copy, cfg)
+        non_stand_step = add_features(step_copy, info, cfg)
         x_stand_step = step_copy.copy()
         x_cols = [col for col in x_stand_step.columns if col.endswith("x")]
         # note the [0] here is important because it's still a list of len=1!!
@@ -196,11 +201,11 @@ def standardise_x_y_and_add_features_to_one_step(step, cfg):
             cfg["x_standardisation_joint"][0] + "x"
         ].min()
         x_stand_step[x_cols] -= min_x_standardisation_joint
-        x_stand_step = add_features(x_stand_step, cfg)
+        x_stand_step = add_features(x_stand_step, info, cfg)
         return non_stand_step, x_stand_step
 
 
-def add_features(step, cfg):
+def add_features(step, info, cfg):
     """Add Features, i.e. Angles & Velocities"""
     # unpack
     hind_joints = cfg["hind_joints"]
@@ -208,12 +213,12 @@ def add_features(step, cfg):
     if hind_joints:
         step = add_x_velocities(step, cfg)
     if angles["name"]:  # if there is at least 1 string in the list
-        step = add_angles(step, cfg)
+        step = add_angles(step, info, cfg)
         step = add_angular_velocities(step, cfg)
     return step
 
 
-def add_angles(step, cfg):
+def add_angles(step, info, cfg):
     """Feature #1: Joint Angles"""
     # unpack
     angles = cfg["angles"]
@@ -234,26 +239,20 @@ def add_angles(step, cfg):
         joint3[:, 1] = step[upper_joint + "y"]
         # initialise the angle vector and assign looping over timepoints
         this_angle = np.zeros(len(joint_angle))
+        broken_angle_idxs = []  # initialise broken idxs-list for each angle anew
         for t in range(len(joint_angle)):
-            this_angle[t] = compute_angle(joint_angle[t, :], joint2[t, :], joint3[t, :])
+            this_angle[t], broken = compute_angle(
+                joint_angle[t, :], joint2[t, :], joint3[t, :]
+            )
+            if broken:
+                broken_angle_idxs.append(t)
+        if broken_angle_idxs:
+            write_angle_warning(step, a, angles, broken_angle_idxs, info)
         this_colname = angle + "Angle"
         step[this_colname] = this_angle
     return step
 
 
-def compute_angle(joint_angle, joint2, joint3):
-    """Compute a given angle at a joint & a given timepoint"""
-    # Get vectors between the joints
-    v1 = (joint_angle[0] - joint2[0], joint_angle[1] - joint2[1])
-    v2 = (joint_angle[0] - joint3[0], joint_angle[1] - joint3[1])
-    # dot product, magnitude of vectors, angle in radians & convert 2 degrees
-    dot_product = v1[0] * v2[0] + v1[1] * v2[1]
-    mag_v1 = math.sqrt(v1[0] ** 2 + v1[1] ** 2)
-    mag_v2 = math.sqrt(v2[0] ** 2 + v2[1] ** 2)
-    angle = math.acos(dot_product / (mag_v1 * mag_v2))
-    return math.degrees(angle)
-
-
 def add_x_velocities(step, cfg):
     """Feature #2: Joint x Velocities & Accelerations"""
     # unpack

{autogaita-1.2.0 → autogaita-1.3.0}/autogaita/common2D/common2D_utils.py

@@ -6,6 +6,9 @@ import copy
 import numpy as np
 import tkinter as tk
 
+# %% constants
+from autogaita.resources.constants import TIME_COL
+
 
 def run_singlerun_in_multirun(tracking_software, idx, info, folderinfo, cfg):
     """When performing a multirun, either via Batch Analysis in GUI or batchrun scripts, run the analysis for a given dataset"""
@@ -210,7 +213,81 @@ def check_cycle_order(all_cycles, info):
     return clean_cycles
 
 
-def check_tracking_xy_thresholds(data, info, all_cycles, cfg):
+def check_differing_angle_joint_coords(all_cycles, data, info, cfg):
+    """Check if none of the joints used for angle computations later have equal values (since this would lead to math.domain errors due to floating point precision)"""
+
+    # Note
+    # ----
+    # In theory, I could fix this programatically in the add_angle function, but I feel
+    # like joint-coords should not often be exactly equal like this in a meaningful way
+    # We can still change it in the future.
+
+    # unpack
+    angles = cfg["angles"]
+
+    clean_cycles = None
+    for c, cycle in enumerate(all_cycles):  # for each SC
+        cycle = check_a_single_cycle_for_joint_coords(cycle, angles, data, c, info)
+        if cycle:  # if cycle was not valid (equal-joint-coords) this returns None
+            if clean_cycles == None:
+                clean_cycles = [cycle]  # also makes a 2xscs list of lists
+            else:
+                clean_cycles.append(cycle)
+    return clean_cycles
+
+
+def check_a_single_cycle_for_joint_coords(cycle, angles, data, c, info):
+    for a in range(len(angles["name"])):  # for each angle configuration
+        # prepare a dict that has only the data of this angle config's joints
+        this_angle_data = {"name": [], "lower_joint": [], "upper_joint": []}
+        for key in this_angle_data.keys():
+            this_joint = angles[key][a]
+            this_angle_data[key] = np.array(
+                [data[this_joint + "x"], data[this_joint + "y"]]
+            )
+        # now check if any of the joints have the same coord at any idx
+        for idx in range(cycle[0], cycle[1]):
+            if (
+                np.array_equal(
+                    this_angle_data["name"][:, idx],
+                    this_angle_data["lower_joint"][:, idx],
+                )
+                or np.array_equal(
+                    this_angle_data["name"][:, idx],
+                    this_angle_data["upper_joint"][:, idx],
+                )
+                or np.array_equal(
+                    this_angle_data["lower_joint"][:, idx],
+                    this_angle_data["upper_joint"][:, idx],
+                )
+            ):
+                this_message = (
+                    "\n***********\n! WARNING !\n***********\n"
+                    + f"SC #{c + 1} has equal joint coordinates at "
+                    + f"{round(data[TIME_COL][idx],4)}s:"
+                    + "\n\nAngle - [x y]:\n"
+                    + angles["name"][a]
+                    + " - "
+                    + str(this_angle_data["name"][:, idx])
+                    + "\nLower joint: "
+                    + angles["lower_joint"][a]
+                    + " - "
+                    + str(this_angle_data["lower_joint"][:, idx])
+                    + "\nUpper joint: "
+                    + angles["upper_joint"][a]
+                    + " - "
+                    + str(this_angle_data["upper_joint"][:, idx])
+                    + "\nRemoving the SC from "
+                    + f"{round(data[TIME_COL][cycle[0]], 4)}-"
+                    + f"{round(data[TIME_COL][cycle[1]], 4)}s"
+                )
+                print(this_message)
+                write_issues_to_textfile(this_message, info)
+                return None  # removes this SC
+    return cycle  # if we never returned None, this SC is valid
+
+
+def check_tracking_xy_thresholds(all_cycles, data, info, cfg):
     """Check if any x/y column of any joint has broken datapoints"""
     # unpack
     convert_to_mm = cfg["convert_to_mm"]
@@ -255,7 +332,7 @@ def check_tracking_xy_thresholds(data, info, all_cycles, cfg):
     return clean_cycles
 
 
-def check_tracking_SLEAP_nans(data, info, all_cycles, cfg):
+def check_tracking_SLEAP_nans(all_cycles, data, info, cfg):
     """In SLEAP if tracking fails it generates NaNs - make sure we don't have those in any SC in any joint or angle-joint"""
     # unpack
     hind_joints = cfg["hind_joints"]

{autogaita-1.2.0 → autogaita-1.3.0}/autogaita/group/group_1_preparation.py

@@ -23,6 +23,28 @@ from autogaita.group.group_constants import (
 def some_prep(folderinfo, cfg):
     """Add some folderinfo & cfg variables to the dictionaries for further processes"""
 
+    # AN IMPORTANT NOTE ABOUT LOAD_DIR
+    # --------------------------------
+    # Alright so the group pipeline's cfg (and thus, of course, config.json) is a bit
+    # special because it includes:
+    # 1) first-level config-keys, such as "joints" or "angles", that reflect what has
+    #    been analysed at the first level. These are also checked for equivalence
+    #    across groups when running this without load_dir (see the for g_idx loop
+    #    below) to ensure we are not comparing different sampling rates or so with a
+    #    group analysis
+    # 2) group-level config-keys, such as "do_permtest" or "PCA_variables" that define
+    #    how group analysis should be done
+    # Now:
+    # When loading previously generated group dfs (i.e., using load_dir), the vars in
+    # (2) should naturally be changing so the user can change "PCA_variables" or
+    # "do_anova". The config.json is coded to reflect the group-keys of the most
+    # recent analysis. The "first-level" config keys are, however, just checked for
+    # equivalence once and then never changed by group gaita. So if users should
+    # repeatedly run analyses in the same results_dir, the config.json file includes
+    # the first-level keys of the first run and the group-level keys of the most recent
+    # run. This is not an issue per se but very likely something that I might forget in
+    # a year thus here is a note.
+
     # unpack
     group_names = folderinfo["group_names"]
     group_dirs = folderinfo["group_dirs"]
@@ -49,23 +71,16 @@ def some_prep(folderinfo, cfg):
         if os.path.exists(info_file_path):
             os.remove(info_file_path)
 
-    # *********** IMPORTANT ***********
-    # if load_dir, we have already saved a group config.json (see below before return)
-    # => use this and just return the cfg
-    # => make sure to write folderinfo["contrast"] manually above as is and then return
-    #    that folderinfo plus the cfg you load from the file
+    # load a couple necessary first-level cfg vars from previous run's group config.json
     if len(folderinfo["load_dir"]) > 0:
-        with open(
-            os.path.join(folderinfo["load_dir"], CONFIG_JSON_FILENAME), "r"
-        ) as config_json_file:
-            cfg = json.load(config_json_file)
-            cfg["loaded"] = True  # used in a unit test in test_group_unit.py
+        cfg = load_previous_runs_first_level_cfg_vars(folderinfo, cfg)
 
-    else:  # if not, do the below things based on group dirs' configs
-        # 1. extracted_cfg_vars: save_to_xls, PCA stuff & dont show plots
-        cfg = extract_cfg_vars(folderinfo, cfg)
+    # define save_to_xls and test PCA
+    cfg = extract_save_to_xls_and_test_PCA_config(folderinfo, cfg)
 
-        # 2. ennsure each key's across-group-equivalence and then add to cfg dict
+    # if not loading previous results, ensure cfg-keys are equivalent across groups
+    # then add them to cfg dict
+    if len(folderinfo["load_dir"]) == 0:
         for g_idx, group_dir in enumerate(group_dirs):
             with open(
                 os.path.join(group_dir, CONFIG_JSON_FILENAME), "r"
@@ -84,24 +99,31 @@ def some_prep(folderinfo, cfg):
                                 "config.json variables differ between groups!"
                                 + "\nPlease make sure that all cfg variables between "
                                 + "groups match & try again!"
+                                + f"\nMismatch at {key} in group {group_names[g_idx]}"
                             )
                             raise ValueError(error_message)
                         else:
                             cfg[key] = config_vars_from_json[key]
 
-        # 3. rename hind_joints is to joints if DLC or SLEAP
-        if "hind_joints" in cfg.keys():
-            cfg["joints"] = cfg["hind_joints"]
+    # rename hind_joints to joints (if DLC or SLEAP)
+    if "hind_joints" in cfg.keys():
+        cfg["joints"] = cfg["hind_joints"]
 
-    # ******** IMPORTANT *******
-    # => Do the following two things regardless of load_dir:
-    # 1. save cfg to json file in results_dir for load_dir capability
+    # update cfg keys in json file in results_dir
+    # => i.e. if there's already a config.json @ results_dir (happens if load_dir was
+    #    True) the if-condition below updates (only) the group-config keys according to
+    #    this run's cfg dict
+    # => this also means that first-level cfg keys are never changed (which is intended)
     config_json_path = os.path.join(results_dir, CONFIG_JSON_FILENAME)
-    if os.path.exists(config_json_path):  # overwrite if exists
-        os.remove(config_json_path)
+    if os.path.exists(config_json_path):
+        with open(config_json_path, "r") as config_json_file:
+            existing_cfg = json.load(config_json_file)
+        existing_cfg.update({key: cfg[key] for key in cfg if key in existing_cfg})
+        cfg = existing_cfg  # update cfg with existing keys
     with open(config_json_path, "w") as config_json_file:
         json.dump(cfg, config_json_file)
-    # 2. create this plot stuff manually (cycler objects cannot be written to json)
+
+    # create this plot stuff manually (cycler objects cannot be written to json)
     cfg["group_color_cycler"] = plt.cycler(
         "color", sns.color_palette(cfg["color_palette"], len(group_names))
     )
@@ -115,76 +137,40 @@ def some_prep(folderinfo, cfg):
         "color", sns.color_palette(cfg["color_palette"], len(cfg["angles"]["name"]))
     )
 
+    # have this key for a unit test - make sure it's never written to json
+    if len(folderinfo["load_dir"]) > 0:
+        cfg["loaded"] = True
+
     return folderinfo, cfg
 
 
-def extract_cfg_vars(folderinfo, cfg):
+def load_previous_runs_first_level_cfg_vars(folderinfo, cfg):
+    """There are only a few "first-level" cfg vars (like "joints") we require for group gaita's workflow - load them here"""
+    with open(
+        os.path.join(folderinfo["load_dir"], CONFIG_JSON_FILENAME), "r"
+    ) as config_json_file:
+        old_cfg = json.load(config_json_file)
+        cfg["save_to_xls"] = old_cfg["save_to_xls"]
+        cfg["joints"] = old_cfg["joints"]
+        cfg["angles"] = old_cfg["angles"]
+    return cfg
+
+
+def extract_save_to_xls_and_test_PCA_config(folderinfo, cfg):
     """Extract save_to_xls from example Normalised dfs and sanity check
-    that they match between groups. Also some stuff for PCA!
+    that they match between groups. Also some tests for users' PCA config!
     """
 
-    group_names = folderinfo["group_names"]
-    group_dirs = folderinfo["group_dirs"]
+    # NOTE
+    # ----
+    # save_to_xls is a list of bools that is infered from file type of group's sheet
+    # files - only when not using load_dir. if we use load_dir, save_to_xls is loaded
+    # by load_previous_runs_first_level_cfg_vars
 
     # ................................  save_to_xls  ...................................
-    save_to_xls = [None] * len(group_dirs)
-    for g, group_dir in enumerate(group_dirs):
-        all_results_folders = os.listdir(
-            group_dir
-        )  # remove no-results valid_results_folders
-        valid_results_folders = []
-        # => Note if there's ambiguity / mixed filetypes, we set save_to_xls to True!
-        sheet_type_mismatch_message = (
-            "\n***********\n! WARNING !\n***********\n"
-            + "Mismatch in sheet file types for group "
-            + group_names[g]
-            + "!\nSaving all output sheets to"
-            + ".xlsx!\nRe-run first level & only save .csvs if "
-            + "you want .csv files of group results!"
-        )
-        for folder in all_results_folders:
-            # create save_to_xls here, there are two cases we have to deal with:
-            # case 1: we found a csv file
-            if os.path.exists(
-                os.path.join(
-                    group_dir,
-                    folder,
-                    folder + " - " + ORIG_SHEET_NAME + ".csv",
-                )
-            ):
-                valid_results_folders.append(folder)
-                if save_to_xls[g] is None:
-                    save_to_xls[g] = False
-                if save_to_xls[g] is True:
-                    print(sheet_type_mismatch_message)
-                    write_issues_to_textfile(sheet_type_mismatch_message, folderinfo)
-            # case 2: we found a xlsx file
-            elif os.path.exists(
-                os.path.join(
-                    group_dir,
-                    folder,
-                    folder + " - " + ORIG_SHEET_NAME + ".xlsx",
-                )
-            ):
-                valid_results_folders.append(folder)
-                if save_to_xls[g] is None:
-                    save_to_xls[g] = True
-                if save_to_xls[g] is False:
-                    save_to_xls[g] = True
-                    print(sheet_type_mismatch_message)
-                    write_issues_to_textfile(sheet_type_mismatch_message, folderinfo)
-        # test that at least 1 folder has valid results for all groups
-        if not valid_results_folders:
-            no_valid_results_error = (
-                "\n*********\n! ERROR !\n*********\n"
-                + "No valid results folder found for "
-                + group_names[g]
-                + "\nFix & re-run!"
-            )
-            print(no_valid_results_error)
-            write_issues_to_textfile(no_valid_results_error, folderinfo)
-    # assign to our cfg dict after group loop
-    cfg["save_to_xls"] = save_to_xls
+    if len(folderinfo["load_dir"]) == 0:
+        # infer save_to_xls from sheet files
+        cfg["save_to_xls"] = infer_save_to_xls_from_group_dirs_sheetfiles(folderinfo)
 
     # .........................  test if PCA config is valid  ..........................
     # only test if user wants PCA (ie. selected any features) and is not using the
@@ -272,3 +258,69 @@ def extract_cfg_vars(folderinfo, cfg):
             cfg["PCA_bins"] = cfg["PCA_bins"][:-1]
 
     return cfg
+
+
+def infer_save_to_xls_from_group_dirs_sheetfiles(folderinfo):
+    """Generate a list of save_to_xls bools that is automatically inferred from sheet file in group dir"""
+
+    # unpack
+    group_names = folderinfo["group_names"]
+    group_dirs = folderinfo["group_dirs"]
+
+    save_to_xls = [None] * len(group_dirs)
+    for g, group_dir in enumerate(group_dirs):
+        all_results_folders = os.listdir(
+            group_dir
+        )  # remove no-results valid_results_folders
+        valid_results_folders = []
+        # => Note if there are mixed filetypes, we set save_to_xls to True!
+        sheet_type_mismatch_message = (
+            "\n***********\n! WARNING !\n***********\n"
+            + "Mismatch in sheet file types for group "
+            + group_names[g]
+            + "!\nSaving all output sheets to"
+            + ".xlsx!\nRe-run first level & only save .csvs if "
+            + "you want .csv files of group results!"
+        )
+        for folder in all_results_folders:
+            # create save_to_xls here, there are two cases we have to deal with:
+            # case 1: we found a csv file
+            if os.path.exists(
+                os.path.join(
+                    group_dir,
+                    folder,
+                    folder + " - " + ORIG_SHEET_NAME + ".csv",
+                )
+            ):
+                valid_results_folders.append(folder)
+                if save_to_xls[g] is None:
+                    save_to_xls[g] = False
+                if save_to_xls[g] is True:
+                    print(sheet_type_mismatch_message)
+                    write_issues_to_textfile(sheet_type_mismatch_message, folderinfo)
+            # case 2: we found a xlsx file
+            elif os.path.exists(
+                os.path.join(
+                    group_dir,
+                    folder,
+                    folder + " - " + ORIG_SHEET_NAME + ".xlsx",
+                )
+            ):
+                valid_results_folders.append(folder)
+                if save_to_xls[g] is None:
+                    save_to_xls[g] = True
+                if save_to_xls[g] is False:
+                    save_to_xls[g] = True
+                    print(sheet_type_mismatch_message)
+                    write_issues_to_textfile(sheet_type_mismatch_message, folderinfo)
+        # test that at least 1 folder has valid results for all groups
+        if not valid_results_folders:
+            no_valid_results_error = (
+                "\n*********\n! ERROR !\n*********\n"
+                + "No valid results folder found for "
+                + group_names[g]
+                + "\nFix & re-run!"
+            )
+            print(no_valid_results_error)
+            write_issues_to_textfile(no_valid_results_error, folderinfo)
+    return save_to_xls

{autogaita-1.2.0 → autogaita-1.3.0}/autogaita/group/group_main.py

@@ -58,6 +58,7 @@ def group(folderinfo, cfg):
     # ................................  preparation  ...................................
     # => either creates and sanity-checks folderinfo & cfg or loads it from a previous
     #    run's config.json file (if load_dir)
+    # => there is an IMPORTANT NOTE about this in some_prep!
     folderinfo, cfg = some_prep(folderinfo, cfg)
 
     # ..............................  print start  ....................................
@@ -68,8 +69,8 @@ def group(folderinfo, cfg):
 
     # approach a - import & transform (i.e. no previous results to load from)
     if not folderinfo["load_dir"]:
-        # in dlc/sleap, dfs is x-standardised automatically if 1st-level standardised x
-        # => As a result all average & std dfs are x-standardised as well
+        # "dfs" are x-/Y-standardised automatically if 1st-level standardised x/Y
+        # => if this is the case, it translates to all average & std dfs as well
         dfs, raw_dfs, cfg = import_data(folderinfo, cfg)
         avg_dfs, std_dfs = avg_and_std(dfs, folderinfo, cfg)
         g_avg_dfs, g_std_dfs = grand_avg_and_std(avg_dfs, folderinfo, cfg)