simba-uw-tf-dev 4.6.3__py3-none-any.whl → 4.6.6__py3-none-any.whl

simba/sandbox/proboscis_to_tip.py

@@ -0,0 +1,28 @@
+import os
+from simba.mixins.feature_extraction_mixin import FeatureExtractionMixin
+from simba.mixins.config_reader import ConfigReader
+from simba.utils.read_write import read_df, get_fn_ext, read_video_info, write_df
+
+CONFIG_PATH = r"C:\troubleshooting\srami0619\project_folder\project_config.ini"
+BASE = 'prob_base'
+TIP = 'prob_tip'
+
+
+config = ConfigReader(config_path=CONFIG_PATH, read_video_info=True, create_logger=False)
+animal_cnt = config.animal_cnt
+for file_cnt, file_path in enumerate(config.outlier_corrected_paths):
+    file_name = get_fn_ext(file_path)[1]
+    _, px_per_mm, fps = read_video_info(video_name=file_name, video_info_df=config.video_info_df)
+    data_df = read_df(file_path=file_path)
+    save_path = os.path.join(config.features_dir, f'{file_name}.csv')
+    for animal_id in range(1, animal_cnt+1):
+        print(f'Analysing file {file_name}, animal {animal_id} ({file_cnt + 1}/{len(config.outlier_corrected_paths)})')
+        base_cols = [f'{BASE}_{animal_id}_x', f'{BASE}_{animal_id}_y']
+        tip_cols = [f'{TIP}_{animal_id}_x', f'{TIP}_{animal_id}_y']
+        prob_data, tip_data = data_df[base_cols], data_df[tip_cols]
+        data_df[f'animal_{animal_id}_base_tip_distance'] = FeatureExtractionMixin().keypoint_distances(a=prob_data.values, b=tip_data.values, px_per_mm=px_per_mm, in_centimeters=False)
+    write_df(df=data_df, file_type='csv', save_path=save_path, verbose=True)
+
+
+
+

simba/sandbox/test_directionality.py

@@ -0,0 +1,47 @@
+"""Test directionality_to_nonstatic_target function"""
+import sys
+import numpy as np
+
+print(f"Python: {sys.executable}")
+print("="*60)
+
+try:
+    from simba.data_processors.cuda.geometry import directionality_to_nonstatic_target
+    print("✓ Function imported successfully")
+except Exception as e:
+    print(f"✗ Error importing function: {e}")
+    import traceback
+    traceback.print_exc()
+    sys.exit(1)
+
+# Create test data
+print("\nCreating test data...")
+left_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+right_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+nose = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+target = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+
+print(f"left_ear shape: {left_ear.shape}, dtype: {left_ear.dtype}")
+print(f"right_ear shape: {right_ear.shape}, dtype: {right_ear.dtype}")
+print(f"nose shape: {nose.shape}, dtype: {nose.dtype}")
+print(f"target shape: {target.shape}, dtype: {target.dtype}")
+
+# Test the function
+print("\nTesting directionality_to_nonstatic_target...")
+try:
+    result = directionality_to_nonstatic_target(
+        left_ear=left_ear,
+        right_ear=right_ear,
+        nose=nose,
+        target=target
+    )
+    print(f"✓ SUCCESS! Result shape: {result.shape}")
+    print(f"Result: {result}")
+except Exception as e:
+    print(f"✗ Error running function: {e}")
+    import traceback
+    traceback.print_exc()
+    sys.exit(1)
+
+print("\n" + "="*60)
+print("Test passed!")

simba/sandbox/test_nonstatic_directionality.py

@@ -0,0 +1,27 @@
+"""Test directionality_to_nonstatic_target with int64"""
+import numpy as np
+from simba.data_processors.cuda.geometry import directionality_to_nonstatic_target
+
+print("Testing directionality_to_nonstatic_target with int64...")
+
+left_ear = np.random.randint(0, 500, (100, 2)).astype(np.int64)
+right_ear = np.random.randint(0, 500, (100, 2)).astype(np.int64)
+nose = np.random.randint(0, 500, (100, 2)).astype(np.int64)
+target = np.random.randint(0, 500, (100, 2)).astype(np.int64)
+
+print(f"Arrays shape: {left_ear.shape}, dtype: {left_ear.dtype}")
+
+try:
+    result = directionality_to_nonstatic_target(
+        left_ear=left_ear,
+        right_ear=right_ear,
+        nose=nose,
+        target=target,
+        verbose=True
+    )
+    print(f"✓ SUCCESS! Result shape: {result.shape}, dtype: {result.dtype}")
+    print(f"First 5 results:\n{result[:5]}")
+except Exception as e:
+    print(f"✗ Error: {e}")
+    import traceback
+    traceback.print_exc()

simba/sandbox/test_pycharm_cuda.py

@@ -0,0 +1,51 @@
+"""Test script to verify PyCharm CUDA environment setup"""
+import sys
+print(f"Python version: {sys.version}")
+print(f"Python path: {sys.executable}")
+
+try:
+    from numba import cuda
+    print(f"\nNumba CUDA available: {cuda.is_available()}")
+    if cuda.is_available():
+        print(f"CUDA devices: {len(cuda.gpus)}")
+except Exception as e:
+    print(f"\nError importing numba.cuda: {e}")
+
+try:
+    import cupy as cp
+    print(f"CuPy version: {cp.__version__}")
+    # Test CuPy
+    x = cp.array([1, 2, 3, 4, 5])
+    print(f"CuPy test array: {x.get()}")
+except Exception as e:
+    print(f"Error importing cupy: {e}")
+
+try:
+    import numpy as np
+    print(f"NumPy version: {np.__version__}")
+except Exception as e:
+    print(f"Error importing numpy: {e}")
+
+try:
+    import cv2
+    print(f"OpenCV version: {cv2.__version__}")
+except Exception as e:
+    print(f"Error importing cv2: {e}")
+
+# Test SimBA CUDA imports
+try:
+    from simba.data_processors.cuda.geometry import is_inside_rectangle
+    print("\n✓ Successfully imported simba.data_processors.cuda.geometry")
+    
+    # Quick test
+    test_points = np.array([[150, 150], [300, 300], [50, 50]], dtype=np.int32)
+    test_rect = np.array([[100, 100], [400, 400]], dtype=np.int32)
+    result = is_inside_rectangle(x=test_points, y=test_rect)
+    print(f"✓ is_inside_rectangle test passed: {result}")
+except Exception as e:
+    print(f"\n✗ Error importing SimBA CUDA functions: {e}")
+    import traceback
+    traceback.print_exc()
+
+print("\n" + "="*50)
+print("Environment check complete!")

simba/sandbox/test_simba_install.py

@@ -0,0 +1,41 @@
+"""Test SimBA installation in conda environment"""
+import sys
+print(f"Python: {sys.executable}")
+
+try:
+    import simba
+    print("✓ SimBA imported successfully!")
+except Exception as e:
+    print(f"✗ Error importing SimBA: {e}")
+    import traceback
+    traceback.print_exc()
+    sys.exit(1)
+
+try:
+    from simba.data_processors.cuda.geometry import is_inside_rectangle
+    print("✓ CUDA geometry functions imported!")
+except Exception as e:
+    print(f"✗ Error importing CUDA functions: {e}")
+    import traceback
+    traceback.print_exc()
+    sys.exit(1)
+
+try:
+    import cupy as cp
+    import numpy as np
+    print(f"✓ CuPy {cp.__version__} available")
+    
+    # Quick test
+    test_points = np.array([[150, 150], [300, 300], [50, 50]], dtype=np.int32)
+    test_rect = np.array([[100, 100], [400, 400]], dtype=np.int32)
+    result = is_inside_rectangle(x=test_points, y=test_rect)
+    print(f"✓ CUDA function test passed: {result}")
+except Exception as e:
+    print(f"✗ Error testing CUDA: {e}")
+    import traceback
+    traceback.print_exc()
+    sys.exit(1)
+
+print("\n" + "="*50)
+print("All tests passed! SimBA is ready to use.")
+print("="*50)

simba/sandbox/test_static_directionality.py

@@ -0,0 +1,26 @@
+"""Test directionality_to_static_targets function"""
+import numpy as np
+from simba.data_processors.cuda.geometry import directionality_to_static_targets
+
+print("Testing directionality_to_static_targets...")
+
+left_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+right_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+nose = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+target = np.array([250, 250], dtype=np.int32)
+
+print(f"target shape: {target.shape}, dtype: {target.dtype}")
+
+try:
+    result = directionality_to_static_targets(
+        left_ear=left_ear,
+        right_ear=right_ear,
+        nose=nose,
+        target=target
+    )
+    print(f"✓ SUCCESS! Result shape: {result.shape}")
+    print(f"Result:\n{result}")
+except Exception as e:
+    print(f"✗ Error: {e}")
+    import traceback
+    traceback.print_exc()

simba/sandbox/test_static_directionality_2d.py

@@ -0,0 +1,26 @@
+"""Test directionality_to_static_targets with correct 1D target"""
+import numpy as np
+from simba.data_processors.cuda.geometry import directionality_to_static_targets
+
+print("Testing directionality_to_static_targets with 1D target (correct)...")
+
+left_ear = np.random.randint(0, 500, (100, 2)).astype(np.int32)
+right_ear = np.random.randint(0, 500, (100, 2)).astype(np.int32)
+nose = np.random.randint(0, 500, (100, 2)).astype(np.int32)
+target = np.array([250, 250], dtype=np.int32)  # 1D array for static target
+
+print(f"target shape: {target.shape}, dtype: {target.dtype}")
+
+try:
+    result = directionality_to_static_targets(
+        left_ear=left_ear,
+        right_ear=right_ear,
+        nose=nose,
+        target=target
+    )
+    print(f"✓ SUCCESS! Result shape: {result.shape}")
+    print(f"First 5 results:\n{result[:5]}")
+except Exception as e:
+    print(f"✗ Error: {e}")
+    import traceback
+    traceback.print_exc()

simba/sandbox/verify_env.py

@@ -0,0 +1,42 @@
+"""Verify CUDA environment is properly configured"""
+from numba import cuda
+import cupy as cp
+import numba
+
+print("="*60)
+print("CUDA Environment Verification")
+print("="*60)
+print(f"Numba version: {numba.__version__}")
+print(f"CuPy version: {cp.__version__}")
+print(f"CUDA available: {cuda.is_available()}")
+if cuda.is_available():
+    print(f"CUDA devices: {len(cuda.gpus)}")
+    for i, gpu in enumerate(cuda.gpus):
+        print(f"  GPU {i}: {gpu}")
+
+# Test the function
+print("\n" + "="*60)
+print("Testing directionality_to_nonstatic_target...")
+try:
+    from simba.data_processors.cuda.geometry import directionality_to_nonstatic_target
+    import numpy as np
+    
+    left_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+    right_ear = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+    nose = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+    target = np.random.randint(0, 500, (10, 2)).astype(np.int32)
+    
+    result = directionality_to_nonstatic_target(
+        left_ear=left_ear,
+        right_ear=right_ear,
+        nose=nose,
+        target=target
+    )
+    print(f"✓ Function works! Result shape: {result.shape}")
+except Exception as e:
+    print(f"✗ Error: {e}")
+    import traceback
+    traceback.print_exc()
+
+print("\n" + "="*60)
+print("Environment is ready!")

simba/ui/pop_ups/fsttc_pop_up.py

@@ -7,25 +7,29 @@ from typing import Union
 from simba.data_processors.fsttc_calculator import FSTTCCalculator
 from simba.mixins.config_reader import ConfigReader
 from simba.mixins.pop_up_mixin import PopUpMixin
-from simba.ui.tkinter_functions import CreateLabelFrameWithIcon, Entry_Box
+from simba.ui.tkinter_functions import (CreateLabelFrameWithIcon, Entry_Box,
+                                        SimbaCheckbox)
 from simba.utils.checks import check_int
-from simba.utils.enums import Defaults, Formats, Keys, Links
+from simba.utils.enums import Formats, Keys, Links
 from simba.utils.errors import CountError
 
 
 class FSTTCPopUp(PopUpMixin, ConfigReader):
-    def __init__(self, config_path: Union[str, os.PathLike]):
+    def __init__(self,
+                 config_path: Union[str, os.PathLike]):
 
-        PopUpMixin.__init__(self, title="FORWARD SPIKE TIME TILING COEFFICIENTS", icon='dependency')
         ConfigReader.__init__(self, config_path=config_path, read_video_info=False)
+        if len(self.clf_names) < 2:
+            raise CountError(msg=f'Cannot compute FSTTC: Needs project with at least 2 classified behaviors, got {len(self.clf_names)}', source=self.__class__.__name__)
+
+        PopUpMixin.__init__(self, title="FORWARD SPIKE TIME TILING COEFFICIENTS", icon='dependency')
         settings_frm = CreateLabelFrameWithIcon( parent=self.main_frm, header="SETTINGS", icon_name=Keys.DOCUMENTATION.value, icon_link=Links.FSTTC.value,)
-        self.time_delta_eb = Entry_Box(settings_frm, "TIME-DELTA", "10", validation="numeric")
-        self.graph_cb_var = BooleanVar(value=False)
-        graph_cb = Checkbutton(settings_frm, font=Formats.FONT_REGULAR.value, text="CREATE GRAPH", variable=self.graph_cb_var)
-        self.join_bouts_within_delta_var = BooleanVar(value=False)
-        join_bouts_within_delta_cb = Checkbutton(settings_frm, text="JOIN BOUTS WITHIN TIME-DELTA", font=Formats.FONT_REGULAR.value, variable=self.join_bouts_within_delta_var,)
-        self.time_delta_at_onset_var = BooleanVar(value=False)
-        time_delta_at_onset_cb = Checkbutton( settings_frm, text="TIME-DELTA AT BOUT START", font=Formats.FONT_REGULAR.value, variable=self.time_delta_at_onset_var)
+        self.time_delta_eb = Entry_Box(parent=settings_frm, fileDescription="TIME-DELTA", labelwidth=25, validation="numeric", entry_box_width=20, img='timer_2')
+
+        graph_cb, self.graph_cb_var = SimbaCheckbox(parent=settings_frm, font=Formats.FONT_REGULAR.value, val=False, txt_img='line_chart_blue', txt="CREATE GRAPH")
+        join_bouts_within_delta_cb, self.join_bouts_within_delta_var = SimbaCheckbox(parent=settings_frm, font=Formats.FONT_REGULAR.value, val=False, txt_img='join_purple', txt="JOIN BOUTS WITHIN TIME-DELTA")
+        time_delta_at_onset_cb, self.time_delta_at_onset_var = SimbaCheckbox(parent=settings_frm, font=Formats.FONT_REGULAR.value, val=False, txt_img='play', txt="TIME-DELTA AT BOUT START")
+
         settings_frm.grid(row=0, column=0, sticky=NW)
         self.time_delta_eb.grid(row=0, column=0, sticky="NW")
         join_bouts_within_delta_cb.grid(row=1, column=0, sticky="NW")
@@ -43,22 +47,20 @@ class FSTTCPopUp(PopUpMixin, ConfigReader):
                 targets.append(behaviour)
 
         if len(targets) < 2:
-            raise CountError(
-                msg="FORWARD SPIKE TIME TILING COEFFICIENTS REQUIRE 2 OR MORE BEHAVIORS.",
-                source=self.__class__.__name__,
-            )
-
-        fsttc_calculator = FSTTCCalculator(
-            config_path=self.config_path,
-            time_window=self.time_delta_eb.entry_get,
-            join_bouts_within_delta=self.join_bouts_within_delta_var.get(),
-            time_delta_at_onset=self.time_delta_at_onset_var.get(),
-            behavior_lst=targets,
-            create_graphs=self.graph_cb_var.get(),
-        )
+            raise CountError(msg="FORWARD SPIKE TIME TILING COEFFICIENTS REQUIRE 2 OR MORE BEHAVIORS.", source=self.__class__.__name__,)
+
+        fsttc_calculator = FSTTCCalculator(config_path=self.config_path,
+                                           time_window=self.time_delta_eb.entry_get,
+                                           join_bouts_within_delta=self.join_bouts_within_delta_var.get(),
+                                           time_delta_at_onset=self.time_delta_at_onset_var.get(),
+                                           behavior_lst=targets,
+                                           create_graphs=self.graph_cb_var.get())
         fsttc_calculator.run()
 
 
-#ExtractAnnotationFramesPopUp(config_path=)
+
 
 #_ = FSTTCPopUp(config_path=r"C:\troubleshooting\multi_animal_dlc_two_c57\project_folder\project_config.ini")
+
+#_ = FSTTCPopUp(config_path=r"C:\troubleshooting\mitra\project_folder\project_config.ini")
+

simba/ui/pop_ups/kleinberg_pop_up.py

@@ -8,12 +8,13 @@ from simba.data_processors.kleinberg_calculator import KleinbergCalculator
 from simba.mixins.config_reader import ConfigReader
 from simba.mixins.pop_up_mixin import PopUpMixin
 from simba.ui.tkinter_functions import (CreateLabelFrameWithIcon, Entry_Box,
-                                        SimbaButton, SimBADropDown)
+                                        SimbaButton, SimBADropDown, SimBALabel)
 from simba.utils.checks import check_float, check_int
 from simba.utils.enums import Formats, Keys, Links
 from simba.utils.errors import NoChoosenClassifierError, NoDataError
-from simba.utils.read_write import str_2_bool
+from simba.utils.read_write import get_current_time, str_2_bool
 
+INSTRUCTIONS_TXT = 'Results in the project_folder/csv/machine_results folder are overwritten.\n If saving the originals, the original un-smoothened data is saved in a subdirectory of \nthe project_folder/csv/machine_results folder'
 
 class KleinbergPopUp(PopUpMixin, ConfigReader):
     def __init__(self,
@@ -24,61 +25,59 @@ class KleinbergPopUp(PopUpMixin, ConfigReader):
             raise NoDataError(msg=f'Cannot perform Kleinberg smoothing: No data files found in {self.machine_results_dir} directory', source=self.__class__.__name__)
         PopUpMixin.__init__(self, title="APPLY KLEINBERG BEHAVIOR CLASSIFICATION SMOOTHING", icon='smooth')
         kleinberg_settings_frm = CreateLabelFrameWithIcon(parent=self.main_frm, header="KLEINBERG SETTINGS", icon_name=Keys.DOCUMENTATION.value, icon_link=Links.KLEINBERG.value)
-        self.k_sigma = Entry_Box(kleinberg_settings_frm, fileDescription="SIGMA", img='sigma', value='2', justify='center', labelwidth=35, entry_box_width=35)
-        self.k_gamma = Entry_Box(kleinberg_settings_frm, fileDescription="GAMMA", img='gamma', value='0.3', justify='center', labelwidth=35, entry_box_width=35)
-        self.k_hierarchy = Entry_Box(kleinberg_settings_frm, fileDescription="HIERARCHY", value=1, img='hierarchy_2', justify='center', labelwidth=35, entry_box_width=35)
-        self.h_search_dropdown = SimBADropDown(parent=kleinberg_settings_frm, dropdown_options=['TRUE', 'FALSE'], label="HIERACHICAL SEARCH", value='FALSE', img='hierarchy', label_width=35, dropdown_width=35)
+        self.k_sigma = Entry_Box(kleinberg_settings_frm, fileDescription="SIGMA", img='sigma', value='2', justify='center', labelwidth=35, entry_box_width=35, tooltip_key='KLEINBERG_SIGMA')
+        self.k_gamma = Entry_Box(kleinberg_settings_frm, fileDescription="GAMMA", img='gamma', value='0.3', justify='center', labelwidth=35, entry_box_width=35, tooltip_key='KLEINBERG_GAMMA')
+        self.k_hierarchy = Entry_Box(kleinberg_settings_frm, fileDescription="HIERARCHY", value=1, img='hierarchy_2', justify='center', labelwidth=35, entry_box_width=35, validation='numeric', tooltip_key='KLEINBERG_HIERARCHY')
+        self.h_search_dropdown = SimBADropDown(parent=kleinberg_settings_frm, dropdown_options=['TRUE', 'FALSE'], label="HIERARCHICAL SEARCH", value='FALSE', img='hierarchy', label_width=35, dropdown_width=35, tooltip_key='KLEINBERG_HIERARCHY_SEARCH')
+        self.save_originals_dropdown = SimBADropDown(parent=kleinberg_settings_frm, dropdown_options=['TRUE', 'FALSE'], label="SAVE ORIGINAL DATA:", value='TRUE', img='save', label_width=35, dropdown_width=35, tooltip_key='KLEINBERG_SAVE_ORIGINALS')
+        self.instructions_lbl = SimBALabel(parent=kleinberg_settings_frm, txt=INSTRUCTIONS_TXT, justify='center', txt_clr='blue', font=Formats.FONT_REGULAR_ITALICS.value)
 
 
-        kleinberg_table_frame = LabelFrame(self.main_frm, text="CHOOSE CLASSIFIER(S) FOR KLEINBERG SMOOTHING", font=Formats.FONT_HEADER.value)
+        kleinberg_table_frame = CreateLabelFrameWithIcon(parent=self.main_frm, header="CHOOSE CLASSIFIER(S) FOR KLEINBERG SMOOTHING", icon_name=Keys.DOCUMENTATION.value, icon_link=Links.KLEINBERG.value)
         clf_var_dict, clf_cb_dict = {}, {}
         for clf_cnt, clf in enumerate(self.clf_names):
             clf_var_dict[clf] = BooleanVar()
             clf_cb_dict[clf] = Checkbutton(kleinberg_table_frame, text=clf, font=Formats.FONT_REGULAR.value, variable=clf_var_dict[clf])
-            clf_cb_dict[clf].grid(row=clf_cnt, sticky=NW)
+            clf_cb_dict[clf].grid(row=clf_cnt, column=0, sticky=NW)
 
         run_kleinberg_btn = SimbaButton(parent=self.main_frm, txt="APPLY KLEINBERG SMOOTHER", img='rocket', txt_clr="blue", font=Formats.FONT_REGULAR.value, cmd=self.run_kleinberg, cmd_kwargs={'behaviors_dict': lambda: clf_var_dict, 'hierarchical_search': lambda: str_2_bool(self.h_search_dropdown.get_value())})
-        kleinberg_settings_frm.grid(row=0, sticky=W, padx=10)
-        self.k_sigma.grid(row=0, sticky=W)
-        self.k_gamma.grid(row=1, sticky=W)
-        self.k_hierarchy.grid(row=2, sticky=W)
-        self.h_search_dropdown.grid(row=3, column=0, sticky=W)
-        kleinberg_table_frame.grid(row=1, pady=10, padx=10)
-        run_kleinberg_btn.grid(row=2)
+        kleinberg_settings_frm.grid(row=0, sticky=W, pady=(15, 0))
+        self.instructions_lbl.grid(row=0, sticky=W)
+        self.k_sigma.grid(row=1, sticky=W)
+        self.k_gamma.grid(row=2, sticky=W)
+        self.k_hierarchy.grid(row=3, sticky=W)
+        self.h_search_dropdown.grid(row=4, column=0, sticky=W)
+        self.save_originals_dropdown.grid(row=5, column=0, sticky=W)
+        kleinberg_table_frame.grid(row=1, column=0, sticky=NW, pady=(15, 0))
+        run_kleinberg_btn.grid(row=2, column=0, sticky=NW, pady=(15, 0))
         self.main_frm.mainloop()
 
     def run_kleinberg(self, behaviors_dict: dict, hierarchical_search: bool):
         targets = []
         for behaviour, behavior_val in behaviors_dict.items():
-            if behavior_val.get():
-                targets.append(behaviour)
+            if behavior_val.get(): targets.append(behaviour)
 
         if len(targets) == 0:
             raise NoChoosenClassifierError(source=self.__class__.__name__)
 
-        check_int(name="Hierarchy", value=self.k_hierarchy.entry_get)
-        check_float(name="Sigma", value=self.k_sigma.entry_get)
-        check_float(name="Gamma", value=self.k_gamma.entry_get)
-
-        try:
-            print(
-                "Applying kleinberg hyperparameter Setting: Sigma: {}, Gamma: {}, Hierarchy: {}".format(
-                    str(self.k_sigma.entry_get),
-                    str(self.k_gamma.entry_get),
-                    str(self.k_hierarchy.entry_get),
-                )
-            )
-        except:
-            print("Please insert accurate values for all hyperparameters.")
-
-        kleinberg_analyzer = KleinbergCalculator(
-            config_path=self.config_path,
-            classifier_names=targets,
-            sigma=self.k_sigma.entry_get,
-            gamma=self.k_gamma.entry_get,
-            hierarchy=self.k_hierarchy.entry_get,
-            hierarchical_search=hierarchical_search,
-        )
+        k_hierarchy = self.k_hierarchy.entry_get
+        k_sigma = self.k_sigma.entry_get
+        k_gamma = self.k_gamma.entry_get
+        save_originals = str_2_bool(self.save_originals_dropdown.get_value())
+
+        check_int(name="Hierarchy", value=k_hierarchy, min_value=1, allow_negative=False, allow_zero=False, raise_error=True)
+        check_float(name="Sigma", value=k_sigma, allow_negative=False, allow_zero=False, raise_error=True)
+        check_float(name="Gamma", value=k_gamma, allow_negative=False, allow_zero=False, raise_error=True)
+
+        print(f"[{get_current_time()}] Applying kleinberg hyperparameter Setting: Sigma: {k_sigma}, Gamma: {k_gamma}, Hierarchy: {k_hierarchy}")
+
+        kleinberg_analyzer = KleinbergCalculator(config_path=self.config_path,
+                                                 classifier_names=targets,
+                                                 sigma=float(k_sigma),
+                                                 gamma=float(k_gamma),
+                                                 hierarchy=int(k_hierarchy),
+                                                 hierarchical_search=hierarchical_search,
+                                                 save_originals=save_originals)
         kleinberg_analyzer.run()
 
 

simba/ui/tkinter_functions.py

@@ -229,6 +229,7 @@ class Entry_Box(Frame):
                  value: Optional[Any] = None,
                  label_font: tuple = Formats.FONT_REGULAR.value,
                  entry_font: tuple = Formats.FONT_REGULAR.value,
+                 tooltip_key: Optional[str] = None,
                  justify: Literal["left", "center", "right"] = 'left',
                  cmd: Optional[Callable] = None,
                  **kw):
@@ -249,6 +250,8 @@ class Entry_Box(Frame):
         self.filePath = StringVar()
         self.lblName = Label(self, text=fileDescription, width=labelwidth, anchor=W, font=label_font, bg=label_bg_clr)
         self.lblName.grid(row=0, column=1)
+        if tooltip_key in TOOLTIPS.keys():
+            CreateToolTip(widget=self.lblName, text=TOOLTIPS[tooltip_key])
         if not entry_box_width:
             self.entPath = Entry(self, textvariable=self.filePath, state=self.status,  validate="key", validatecommand=self.validation_methods.get(validation, None), font=entry_font, justify=justify, bg=entry_box_clr)
         else:

simba/utils/data.py

@@ -48,7 +48,6 @@ from simba.utils.errors import (BodypartColumnNotFoundError, CountError,
                                 InvalidFileTypeError, InvalidInputError,
                                 NoFilesFoundError, NoROIDataError,
                                 SimBAModuleNotFoundError)
-from simba.utils.lookups import get_current_time
 from simba.utils.printing import stdout_success, stdout_warning
 from simba.utils.read_write import (find_core_cnt, find_video_of_file,
                                     get_current_time, get_fn_ext,