simba-uw-tf-dev 4.6.2__py3-none-any.whl → 4.6.4__py3-none-any.whl

simba/plotting/spontaneous_alternation_plotter.py

@@ -14,7 +14,7 @@ from simba.data_processors.spontaneous_alternation_calculator import \
 from simba.mixins.config_reader import ConfigReader
 from simba.utils.checks import (check_file_exist_and_readable, check_float,
                                 check_int, check_str, check_valid_lst)
-from simba.utils.data import detect_bouts
+from simba.utils.data import detect_bouts, terminate_cpu_pool
 from simba.utils.enums import Formats, Paths, TextOptions
 from simba.utils.errors import AnimalNumberError, InvalidInputError
 from simba.utils.printing import stdout_success
@@ -296,8 +296,7 @@ class SpontaneousAlternationsPlotter(ConfigReader):
                 pool.imap(constants, frm_index, chunksize=self.multiprocess_chunksize)
             ):
                 print(f"Section {cnt} complete...")
-        pool.terminate()
-        pool.join()
+        terminate_cpu_pool(pool=pool, force=False)
         print(f"Joining {sa_computer.video_name} multiprocessed video...")
         concatenate_videos_in_folder(in_folder=self.temp_folder, save_path=save_path)
         self.timer.stop_timer()

simba/plotting/yolo_pose_track_visualizer.py

@@ -13,9 +13,11 @@ from simba.mixins.plotting_mixin import PlottingMixin
 from simba.utils.checks import (check_file_exist_and_readable, check_float,
                                 check_if_dir_exists, check_int,
                                 check_valid_boolean, check_valid_dataframe)
+from simba.utils.data import get_cpu_pool, terminate_cpu_pool
 from simba.utils.enums import Defaults, Formats
 from simba.utils.errors import InvalidFilepathError, NoFilesFoundError
-from simba.utils.lookups import get_random_color_palette, intermittent_palette
+from simba.utils.lookups import (get_current_time, get_random_color_palette,
+                                 intermittent_palette)
 from simba.utils.printing import SimbaTimer, stdout_success
 from simba.utils.read_write import (concatenate_videos_in_folder,
                                     create_directory,
@@ -53,13 +55,12 @@ def _yolo_keypoint_track_visualizer(frm_ids: np.ndarray,
     video_save_path = os.path.join(save_dir, f'{batch_id}.mp4')
     video_writer = cv2.VideoWriter(video_save_path, fourcc, video_meta_data["fps"], (video_meta_data["width"], video_meta_data["height"]))
     while current_frm <= end_frm:
-        print(f'Processing frame {current_frm}/{video_meta_data["frame_count"]} (batch: {batch_id})...')
+        print(f'[{get_current_time()}] Processing frame {current_frm}/{video_meta_data["frame_count"]} (batch: {batch_id}, video name: {video_meta_data["video_name"]})...')
         img = read_frm_of_video(video_path=video_path, frame_index=current_frm, raise_error=False)
         if img is not None:
             frm_data = data.loc[data[FRAME] == current_frm]
             frm_data = frm_data[frm_data[CONFIDENCE] > threshold]
             for cnt, (row, row_data) in enumerate(frm_data.iterrows()):
-
                 clrs = np.array(palettes[int(row_data[TRACK])]).astype(np.int32)
                 bbox_cords = row_data[BOX_CORD_FIELDS].values.astype(np.int32).reshape(-1, 2)
                 kp_coords = row_data.drop(EXPECTED_COLS).values.astype(np.int32).reshape(-1, 3)[:, :-1]
@@ -159,6 +160,8 @@ class YOLOPoseTrackVisualizer():
         self.threshold, self.circle_size, self.thickness, self.show_bbox, self.overwrite = threshold, circle_size, thickness, bbox, overwrite
 
     def run(self):
+        self.pool = get_cpu_pool(core_cnt=self.core_cnt, maxtasksperchild=Defaults.MAXIMUM_MAX_TASK_PER_CHILD.value, source=self.__class__.__name__)
+        self.timer = SimbaTimer(start=True)
         for video_cnt, (video_name, data_path) in enumerate(self.data_paths.items()):
             print(f'Visualizing YOLO pose tracks in video {video_name} ({video_cnt+1}/{len(self.data_paths.keys())}) ...')
             video_timer = SimbaTimer(start=True)
@@ -189,23 +192,25 @@ class YOLOPoseTrackVisualizer():
 
             frm_batches = np.array_split(np.array(list(range(0, df_frm_cnt))), self.core_cnt)
             frm_batches = [(i, j) for i, j in enumerate(frm_batches)]
-            with multiprocessing.Pool(self.core_cnt, maxtasksperchild=Defaults.MAXIMUM_MAX_TASK_PER_CHILD.value) as pool:
-                constants = functools.partial(_yolo_keypoint_track_visualizer,
-                                              data=self.data_df,
-                                              threshold=self.threshold,
-                                              video_path=self.video_paths[video_name],
-                                              save_dir=video_temp_dir,
-                                              circle_size=video_circle_size,
-                                              thickness=video_thickness,
-                                              palettes=video_palettes,
-                                              show_bbox=self.show_bbox)
-                for cnt, result in enumerate(pool.imap(constants, frm_batches, chunksize=1)):
-                    print(f'Video batch {result+1}/{self.core_cnt} complete...')
-            pool.terminate()
-            pool.join()
+            constants = functools.partial(_yolo_keypoint_track_visualizer,
+                                          data=self.data_df,
+                                          threshold=self.threshold,
+                                          video_path=self.video_paths[video_name],
+                                          save_dir=video_temp_dir,
+                                          circle_size=video_circle_size,
+                                          thickness=video_thickness,
+                                          palettes=video_palettes,
+                                          show_bbox=self.show_bbox)
+            for cnt, result in enumerate(self.pool.imap(constants, frm_batches, chunksize=1)):
+                print(f'[{get_current_time()}] Video batch {result+1}/{self.core_cnt} complete...')
             video_timer.stop_timer()
             concatenate_videos_in_folder(in_folder=video_temp_dir, save_path=save_path, gpu=True)
             stdout_success(msg=f'YOLO track pose video saved at {save_path}', source=self.__class__.__name__, elapsed_time=video_timer.elapsed_time_str)
+        terminate_cpu_pool(pool=self.pool, force=False, source=self.__class__.__name__)
+        self.timer.stop_timer()
+        stdout_success(msg=f'YOLO track pose video data for {len(self.data_paths.keys())} videos saved in {self.save_dir}', source=self.__class__.__name__,  elapsed_time=self.timer.elapsed_time_str)
+
+
 #
 # if __name__ == "__main__" and not hasattr(sys, 'ps1'):
 #     parser = argparse.ArgumentParser(description="Visualize YOLO pose tracking CSV outputs on their source videos.")
@@ -247,13 +252,13 @@ class YOLOPoseTrackVisualizer():
 # #kp_vis.run()
 
 
-if __name__ == "__main__":
-    VIDEO_PATH = r"E:\netholabs_videos\primeintellect_100_videos"
-    DATA_PATH = r"E:\netholabs_videos\primeintellect_100_largest"
-    SAVE_DIR = r"E:\netholabs_videos\primeintellect_100_videos\out"
-    kp_vis = YOLOPoseTrackVisualizer(data_path=DATA_PATH,
-                                     video_path=VIDEO_PATH,
-                                     save_dir=SAVE_DIR,
-                                     core_cnt=8,
-                                     bbox=True)
-    kp_vis.run()
+# if __name__ == "__main__":
+#     VIDEO_PATH = r"E:\netholabs_videos\primeintellect_100_videos"
+#     DATA_PATH = r"E:\netholabs_videos\primeintellect_100_largest"
+#     SAVE_DIR = r"E:\netholabs_videos\primeintellect_100_videos\out"
+#     kp_vis = YOLOPoseTrackVisualizer(data_path=DATA_PATH,
+#                                      video_path=VIDEO_PATH,
+#                                      save_dir=SAVE_DIR,
+#                                      core_cnt=8,
+#                                      bbox=True)
+#     kp_vis.run()

simba/plotting/yolo_pose_visualizer.py

@@ -14,7 +14,8 @@ from simba.utils.checks import (check_file_exist_and_readable, check_float,
                                 check_if_dir_exists, check_int,
                                 check_valid_boolean, check_valid_dataframe,
                                 check_valid_lst, check_valid_tuple)
-from simba.utils.data import create_color_palette
+from simba.utils.data import (create_color_palette, get_cpu_pool,
+                              terminate_cpu_pool)
 from simba.utils.enums import Defaults, Options
 from simba.utils.errors import (CountError, DataHeaderError, FrameRangeError,
                                 InvalidInputError, NoDataError)
@@ -22,10 +23,9 @@ from simba.utils.printing import SimbaTimer, stdout_success
 from simba.utils.read_write import (concatenate_videos_in_folder,
                                     create_directory, find_core_cnt,
                                     find_files_of_filetypes_in_directory,
-                                    get_fn_ext, get_video_meta_data,
-                                    read_frm_of_video, recursive_file_search,
-                                    remove_a_folder)
-from simba.utils.warnings import InvalidValueWarning
+                                    get_current_time, get_fn_ext,
+                                    get_video_meta_data, read_frm_of_video,
+                                    recursive_file_search, remove_a_folder)
 
 FRAME = 'FRAME'
 CLASS_ID = 'CLASS_ID'
@@ -58,7 +58,7 @@ def _yolo_keypoint_visualizer(frm_ids: np.ndarray,
     if TRACK in data.columns:
         data = data.drop([TRACK], axis=1)
     while current_frm <= end_frm:
-        print(f'Processing frame {current_frm}/{video_meta_data["frame_count"]} (batch: {batch_id}, video: {video_meta_data["video_name"]})...')
+        print(f'[{get_current_time()}] Processing frame {current_frm}/{video_meta_data["frame_count"]} (batch: {batch_id}, video: {video_meta_data["video_name"]})...')
         img = read_frm_of_video(video_path=video_path, frame_index=current_frm)
         frm_data = data.loc[data[FRAME] == current_frm]
         frm_data = frm_data[frm_data[CONFIDENCE] > threshold]
@@ -206,6 +206,7 @@ class YOLOPoseVisualizer():
         self.timer = SimbaTimer(start=True)
 
     def run(self):
+        self.pool = get_cpu_pool(core_cnt=self.core_cnt, maxtasksperchild=Defaults.MAXIMUM_MAX_TASK_PER_CHILD.value, verbose=True, source=self.__class__.__name__)
         for video_cnt, (video_name, data_path) in enumerate(self.data_paths.items()):
             video_timer = SimbaTimer(start=True)
             self.video_temp_dir = os.path.join(self.save_dir, video_name, "temp")
@@ -248,26 +249,24 @@ class YOLOPoseVisualizer():
                 thickness = deepcopy(self.thickness)
             frm_batches = np.array_split(np.array(list(range(0, self.df_frm_cnt))), self.core_cnt)
             frm_batches = [(i, j) for i, j in enumerate(frm_batches)]
-            if self.verbose: print(f'Visualizing video {self.video_meta_data["video_name"]} (frame count: {self.video_meta_data["frame_count"]})...')
-            with multiprocessing.Pool(self.core_cnt, maxtasksperchild=Defaults.MAXIMUM_MAX_TASK_PER_CHILD.value) as pool:
-                constants = functools.partial(_yolo_keypoint_visualizer,
-                                          data=self.data_df,
-                                          threshold=self.threshold,
-                                          video_path=self.video_paths[video_name],
-                                          save_dir=self.video_temp_dir,
-                                          circle_size=circle_size,
-                                          thickness=thickness,
-                                          palettes=self.clrs,
-                                          bbox=self.bbox,
-                                          skeleton=self.skeleton)
-                for cnt, result in enumerate(pool.imap(constants, frm_batches, chunksize=1)):
-                    print(f'Video batch {result+1}/{self.core_cnt} complete...')
-            pool.terminate()
-            pool.join()
+            if self.verbose: print(f'[{get_current_time()}] Visualizing video {self.video_meta_data["video_name"]} (frame count: {self.video_meta_data["frame_count"]})...')
+            constants = functools.partial(_yolo_keypoint_visualizer,
+                                      data=self.data_df,
+                                      threshold=self.threshold,
+                                      video_path=self.video_paths[video_name],
+                                      save_dir=self.video_temp_dir,
+                                      circle_size=circle_size,
+                                      thickness=thickness,
+                                      palettes=self.clrs,
+                                      bbox=self.bbox,
+                                      skeleton=self.skeleton)
+            for cnt, result in enumerate(self.pool.imap(constants, frm_batches, chunksize=1)):
+                print(f'[{get_current_time()}] Video batch {result+1}/{self.core_cnt} complete...')
             video_timer.stop_timer()
             concatenate_videos_in_folder(in_folder=self.video_temp_dir, save_path=self.save_path, gpu=True)
             stdout_success(msg=f'YOLO pose video saved at {self.save_path} (Video {video_cnt+1}/{len(list(self.data_paths.keys()))})', source=self.__class__.__name__, elapsed_time=video_timer.elapsed_time_str)
 
+        terminate_cpu_pool(pool=self.pool, force=False, source=self.__class__.__name__)
         self.timer.stop_timer()
         stdout_success(msg=f'{len(list(self.data_paths.keys()))} YOLO pose video saved in directory {self.save_dir}', source=self.__class__.__name__, elapsed_time=self.timer.elapsed_time_str)
 
@@ -413,18 +412,18 @@ class YOLOPoseVisualizer():
 #     kp_vis.run()
 
 
-# if __name__ == "__main__":
-#     video_path = r"E:\netholabs_videos\primeintellect_100_videos\cage_1_date_2025_08_28_hour_20_minute_21.avi"
-#     data_path = r"E:\netholabs_videos\primeintellect_100_largest\cage_1_date_2025_08_28_hour_20_minute_21.csv"
-#     save_dir = r'E:\netholabs_videos\test_order'
-#     kp_vis = YOLOPoseVisualizer(data_path=data_path,
-#                                 video_path=video_path,
-#                                 save_dir=save_dir,
-#                                 core_cnt=14,
-#                                 palettes=('tab20',),
-#                                 recursive=True,
-#                                 sample_n=None)
-#
-#
-#     kp_vis.run()
+if __name__ == "__main__":
+    video_path = r"E:\netholabs_videos\primeintellect_100_videos\cage_1_date_2025_08_28_hour_20_minute_21.avi"
+    data_path = r"E:\netholabs_videos\primeintellect_100_largest\cage_1_date_2025_08_28_hour_20_minute_21.csv"
+    save_dir = r'E:\netholabs_videos\test_order'
+    kp_vis = YOLOPoseVisualizer(data_path=data_path,
+                                video_path=video_path,
+                                save_dir=save_dir,
+                                core_cnt=14,
+                                palettes=('tab20',),
+                                recursive=True,
+                                sample_n=None)
+
+
+    kp_vis.run()
 

simba/plotting/yolo_seg_visualizer.py

@@ -12,7 +12,7 @@ from simba.utils.checks import (check_file_exist_and_readable, check_float,
                                 check_int, check_valid_boolean,
                                 check_valid_dataframe, check_valid_lst,
                                 check_valid_tuple)
-from simba.utils.data import create_color_palette
+from simba.utils.data import create_color_palette, terminate_cpu_pool
 from simba.utils.enums import Defaults, Options
 from simba.utils.errors import CountError, DataHeaderError, FrameRangeError
 from simba.utils.printing import SimbaTimer, stdout_success
@@ -140,8 +140,7 @@ class YOLOSegmentationVisualizer():
                                           shape_opacity=self.shape_opacity)
             for cnt, result in enumerate(pool.imap(constants, frm_batches, chunksize=1)):
                 print(f'Video batch {result+1}/{self.core_cnt} complete...')
-        pool.terminate()
-        pool.join()
+        terminate_cpu_pool(pool=pool, force=False)
         video_timer.stop_timer()
         concatenate_videos_in_folder(in_folder=self.video_temp_dir, save_path=self.save_path, gpu=True)
         stdout_success(msg=f'YOLO pose video saved at {self.save_path}', source=self.__class__.__name__, elapsed_time=video_timer.elapsed_time_str)

simba/roi_tools/roi_aggregate_stats_mp.py

@@ -17,7 +17,8 @@ from simba.utils.checks import (
     check_all_file_names_are_represented_in_video_log,
     check_file_exist_and_readable, check_float, check_if_dir_exists, check_int,
     check_that_column_exist, check_valid_boolean, check_valid_lst)
-from simba.utils.data import detect_bouts, slice_roi_dict_for_video
+from simba.utils.data import (detect_bouts, slice_roi_dict_for_video,
+                              terminate_cpu_pool)
 from simba.utils.enums import ROI_SETTINGS, Formats, Keys
 from simba.utils.errors import CountError, ROICoordinatesNotFoundError
 from simba.utils.printing import SimbaTimer, stdout_success
@@ -297,8 +298,8 @@ class ROIAggregateStatisticsAnalyzerMultiprocess(ConfigReader, FeatureExtraction
                 self.results.append(result); self.detailed_dfs.append(detailed_dfs)
                 print(f"Data batch core {batch_id} / {self.core_cnt} complete...")
         self.results = pd.concat(self.results, axis=0).reset_index(drop=True)
-        pool.join()
-        pool.terminate()
+        terminate_cpu_pool(pool=pool, force=False)
+
 
     def save(self):
         self.__clean_results()

simba/roi_tools/roi_clf_calculator_mp.py

@@ -16,7 +16,8 @@ from simba.utils.checks import (
     check_all_file_names_are_represented_in_video_log,
     check_file_exist_and_readable, check_if_dir_exists, check_int,
     check_valid_boolean, check_valid_dataframe, check_valid_lst)
-from simba.utils.data import detect_bouts, slice_roi_dict_for_video
+from simba.utils.data import (detect_bouts, slice_roi_dict_for_video,
+                              terminate_cpu_pool)
 from simba.utils.enums import ROI_SETTINGS, Keys
 from simba.utils.errors import InvalidInputError, NoROIDataError
 from simba.utils.lookups import get_current_time
@@ -237,8 +238,7 @@ class ROIClfCalculatorMultiprocess(ConfigReader):
                 self.bouts_results.append(batch_bout_results)
                 print(f"Data batch core {batch_id + 1} / {self.core_cnt} complete...")
         self.bouts_results = pd.concat(self.bouts_results, axis=0).reset_index(drop=True) if len(self.bouts_results) > 0 else None
-        pool.join()
-        pool.terminate()
+        terminate_cpu_pool(pool=pool, force=False)
 
     def save(self):
         self.timer.stop_timer()

simba/sandbox/get_cpu_pool.py

@@ -0,0 +1,5 @@
+from simba.utils.data import get_cpu_pool, terminate_cpu_pool
+
+
+pool = get_cpu_pool()
+terminate_cpu_pool(pool=pool)

simba/ui/pop_ups/kleinberg_pop_up.py

@@ -7,13 +7,13 @@ from typing import Union
 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)
+from simba.ui.tkinter_functions import (CreateLabelFrameWithIcon, Entry_Box, 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 str_2_bool, get_current_time
 
+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 +24,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

@@ -5,6 +5,7 @@ import configparser
 import gc
 import io
 import os
+import platform
 import subprocess
 from copy import deepcopy
 from datetime import datetime
@@ -38,15 +39,19 @@ from simba.utils.checks import (check_file_exist_and_readable, check_float,
                                 check_if_valid_rgb_tuple, check_instance,
                                 check_int, check_str, check_that_column_exist,
                                 check_that_hhmmss_start_is_before_end,
-                                check_valid_array, check_valid_cpu_pool,
-                                check_valid_dataframe, check_valid_lst)
-from simba.utils.enums import ConfigKey, Dtypes, Formats, Keys, Options
+                                check_valid_array, check_valid_boolean,
+                                check_valid_cpu_pool, check_valid_dataframe,
+                                check_valid_lst)
+from simba.utils.enums import (OS, ConfigKey, Defaults, Dtypes, Formats, Keys,
+                               Options)
 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_video_of_file, get_fn_ext,
+from simba.utils.read_write import (find_core_cnt, find_video_of_file,
+                                    get_current_time, get_fn_ext,
                                     get_video_meta_data, read_config_entry,
                                     read_config_file, read_df,
                                     read_project_path_and_file_type,
@@ -1813,33 +1818,105 @@ def fft_lowpass_filter(data: np.ndarray, cut_off: float = 0.1) -> np.ndarray:
     return results.astype(data.dtype)
 
 
-def terminate_cpu_pool(pool: Optional[multiprocessing.pool.Pool],
-                       force: bool = False) -> None:
+def terminate_cpu_pool(pool: multiprocessing.pool.Pool,
+                       force: bool = False,
+                       verbose: bool = True,
+                       source: Optional[str] = None) -> None:
     """
-    Safely terminates a multiprocessing.Pool instance.
+    Safely terminates a multiprocessing.Pool instance with optional graceful shutdown.
 
-    :param Optional[multiprocessing.pool.Pool] pool: The pool to terminate. If None, function returns without action.
-    :param bool force: If True, skips join() and immediately terminates. Default: False.
-    :raises InvalidInputError: If pool is not a valid Pool instance.
+    .. note::
+       If pool is None or invalid, function returns without action. Exceptions during termination are silently caught.
+
+    :param multiprocessing.pool.Pool pool: The multiprocessing pool to terminate. If None, function returns without action.
+    :param bool force: If True, skips graceful shutdown (close/join) and immediately terminates. Default: False.
+    :param bool verbose: If True, prints termination message with timestamp. Default: True.
+    :param Optional[str] source: Optional identifier string for logging purposes (e.g., 'VideoProcessor'). Default: None.
 
     :example:
     >>> import multiprocessing
     >>> pool = multiprocessing.Pool(4)
-    >>> terminate_cpu_pool(pool)
+    >>> terminate_cpu_pool(pool=pool, force=False, verbose=True, source='FeatureExtractor')
     """
     if pool is None:
         return
-    check_valid_cpu_pool(value=pool, source=terminate_cpu_pool.__name__, raise_error=True)
+    if not check_valid_cpu_pool(value=pool, source=terminate_cpu_pool.__name__, raise_error=False):
+        return
     try:
+        core_cnt = pool._processes if hasattr(pool, '_processes') else None
         if not force:
             pool.close()
             pool.join()
         pool.terminate()
+        if verbose: print(f'[{get_current_time()}] {"" if source is None else f"{core_cnt} core"} SimBA CPU pool {"" if source is None else source} terminated.')
     except (ValueError, AssertionError, AttributeError):
         pass
     gc.collect()
 
 
+
+def get_cpu_pool(core_cnt: int = -1,
+                 maxtasksperchild: int = Defaults.MAXIMUM_MAX_TASK_PER_CHILD.value,
+                 context: Literal['fork', 'spawn', 'forkserver'] = None,
+                 verbose: bool = True,
+                 source: Optional[str] = None) -> multiprocessing.Pool:
+    """
+    Creates and returns a multiprocessing.Pool instance with platform-appropriate defaults and validation.
+
+    :param int core_cnt: Number of worker processes. -1 uses all available cores. Default: -1.
+    :param int maxtasksperchild: Maximum number of tasks a worker process can complete before being replaced. Default: From Defaults.MAXIMUM_MAX_TASK_PER_CHILD.
+    :param Optional[Literal['fork', 'spawn', 'forkserver']] context: Multiprocessing start method. None uses platform default. Default: None.
+    :param bool verbose: If True, prints pool creation message with timestamp. Default: True.
+    :param Optional[str] source: Optional identifier string for logging purposes (e.g., 'VideoProcessor'). Default: None.
+    :return: Configured multiprocessing.Pool instance.
+    :rtype: multiprocessing.Pool
+
+    :example:
+    >>> pool = get_cpu_pool(core_cnt=4, source='FeatureExtractor')
+    >>> pool = get_cpu_pool(core_cnt=-1, context='spawn', verbose=True)
+    >>> pool = get_cpu_pool(core_cnt=8, maxtasksperchild=100, source='VideoProcessor')
+    """
+
+    check_int(name=f'{get_cpu_pool.__name__} core_cnt', min_value=-1, unaccepted_vals=[0], value=core_cnt, raise_error=True)
+    check_int(name=f'{get_cpu_pool.__name__} maxtasksperchild', min_value=1, value=maxtasksperchild, raise_error=True)
+    check_valid_boolean(value=verbose, source=f'{get_cpu_pool.__name__} verbose', raise_error=True)
+    if source is not None: check_str(name=f'{get_cpu_pool.__name__} source', value=source, raise_error=True, allow_blank=True)
+    current_process = multiprocessing.current_process()
+    if current_process.name != 'MainProcess': core_cnt = 1
+    core_cnt = find_core_cnt()[0] if core_cnt == -1 or core_cnt > find_core_cnt()[0] else core_cnt
+    if verbose: print(f'[{get_current_time()}] {core_cnt} core SimBA CPU pool {"" if source is None else source} started.')
+    if context is not None:
+        check_str(name=f'{get_cpu_pool.__name__} context', value=context, options=('fork', 'spawn', 'forkserver'), raise_error=True)
+    else:
+        existing_method = multiprocessing.get_start_method(allow_none=True)
+        if existing_method is not None:
+            context = existing_method
+        else:
+            system = platform.system()
+            if system == OS.WINDOWS.value: context = OS.SPAWN.value
+            elif system == OS.MAC.value: context = OS.SPAWN.value
+            else: context = OS.FORK.value
+
+    if context is not None:
+        try:
+            ctx = multiprocessing.get_context(context)
+        except ValueError:
+            system = platform.system()
+            if system == OS.WINDOWS.value: fallback_context = OS.SPAWN.value
+            elif system == OS.MAC.value: fallback_context = OS.SPAWN.value
+            else: fallback_context = OS.FORK.value
+            try:
+                ctx = multiprocessing.get_context(fallback_context)
+            except ValueError:
+                pool = multiprocessing.Pool(processes=core_cnt, maxtasksperchild=maxtasksperchild)
+                return pool
+        pool = ctx.Pool(processes=core_cnt, maxtasksperchild=maxtasksperchild)
+    else:
+        pool = multiprocessing.Pool(processes=core_cnt, maxtasksperchild=maxtasksperchild)
+    return pool
+
+
+#get_cpu_pool()
 # run_user_defined_feature_extraction_class(config_path='/Users/simon/Desktop/envs/troubleshooting/circular_features_zebrafish/project_folder/project_config.ini', file_path='/Users/simon/Desktop/fish_feature_extractor_2023_version_5.py')
 
 

simba/utils/enums.py

@@ -127,6 +127,7 @@ class OS(Enum):
     LINUX = "Linux"
     MAC = "Darwin"
     SPAWN = 'spawn'
+    FORK = 'fork'
     PYTHON_VER = str(f"{sys.version_info.major}.{sys.version_info.minor}")
     try:
         SIMBA_VERSION = pkg_resources.get_distribution("simba-uw-tf-dev").version