dragon-ml-toolbox 8.1.0__py3-none-any.whl → 9.0.0__py3-none-any.whl

ml_tools/data_exploration.py

@@ -83,7 +83,8 @@ def drop_constant_columns(df: pd.DataFrame, verbose: bool = True) -> pd.DataFram
             A new DataFrame with the constant columns removed.
     """
     if not isinstance(df, pd.DataFrame):
-        raise TypeError("Input must be a pandas DataFrame.")
+        _LOGGER.error("Input must be a pandas DataFrame.")
+        raise TypeError()
 
     original_columns = set(df.columns)
     cols_to_keep = []
@@ -136,7 +137,7 @@ def drop_rows_with_missing_data(df: pd.DataFrame, targets: Optional[list[str]],
             _LOGGER.info(f"🧹 Dropping {target_na.sum()} rows with all target columns missing.")
             df_clean = df_clean[~target_na]
         else:
-            _LOGGER.info("✅ No rows with all targets missing.")
+            _LOGGER.info("No rows found where all targets are missing.")
     else:
         valid_targets = []
 
@@ -149,9 +150,9 @@ def drop_rows_with_missing_data(df: pd.DataFrame, targets: Optional[list[str]],
             _LOGGER.info(f"🧹 Dropping {len(rows_to_drop)} rows with more than {threshold*100:.0f}% missing feature data.")
             df_clean = df_clean.drop(index=rows_to_drop)
         else:
-            _LOGGER.info(f"✅ No rows exceed the {threshold*100:.0f}% missing feature data threshold.")
+            _LOGGER.info(f"No rows exceed the {threshold*100:.0f}% missing feature data threshold.")
     else:
-        _LOGGER.warning("⚠️ No feature columns available to evaluate.")
+        _LOGGER.warning("No feature columns available to evaluate.")
 
     return df_clean
 
@@ -211,7 +212,7 @@ def drop_columns_with_missing_data(df: pd.DataFrame, threshold: float = 0.7, sho
     cols_to_drop = missing_fraction[missing_fraction > threshold].index
 
     if len(cols_to_drop) > 0:
-        _LOGGER.info(f"Dropping columns with more than {threshold*100:.0f}% missing data:")
+        _LOGGER.info(f"🧹 Dropping columns with more than {threshold*100:.0f}% missing data:")
         print(list(cols_to_drop))
         
         result_df = df.drop(columns=cols_to_drop)
@@ -339,7 +340,8 @@ def split_continuous_binary(df: pd.DataFrame) -> Tuple[pd.DataFrame, pd.DataFram
         TypeError: If any column is not numeric.
     """
     if not all(np.issubdtype(dtype, np.number) for dtype in df.dtypes):
-        raise TypeError("All columns must be numeric (int or float).")
+        _LOGGER.error("All columns must be numeric (int or float).")
+        raise TypeError()
 
     binary_cols = []
     continuous_cols = []
@@ -390,7 +392,7 @@ def plot_correlation_heatmap(df: pd.DataFrame,
     """
     numeric_df = df.select_dtypes(include='number')
     if numeric_df.empty:
-        _LOGGER.warning("⚠️ No numeric columns found. Heatmap not generated.")
+        _LOGGER.warning("No numeric columns found. Heatmap not generated.")
         return
     
     corr = numeric_df.corr(method=method)
@@ -558,11 +560,11 @@ def clip_outliers_single(
         None: if a problem with the dataframe column occurred.
     """
     if column not in df.columns:
-        _LOGGER.warning(f"⚠️ Column '{column}' not found in DataFrame.")
+        _LOGGER.warning(f"Column '{column}' not found in DataFrame.")
         return None
 
     if not pd.api.types.is_numeric_dtype(df[column]):
-        _LOGGER.warning(f"⚠️ Column '{column}' must be numeric.")
+        _LOGGER.warning(f"Column '{column}' must be numeric.")
         return None
 
     new_df = df.copy(deep=True)
@@ -600,13 +602,16 @@ def clip_outliers_multi(
     for col, bounds in clip_dict.items():
         try:
             if col not in df.columns:
-                raise ValueError(f"Column '{col}' not found in DataFrame.")
+                _LOGGER.error(f"Column '{col}' not found in DataFrame.")
+                raise ValueError()
 
             if not pd.api.types.is_numeric_dtype(df[col]):
-                raise TypeError(f"Column '{col}' is not numeric.")
+                _LOGGER.error(f"Column '{col}' is not numeric.")
+                raise TypeError()
 
             if not (isinstance(bounds, tuple) and len(bounds) == 2):
-                raise ValueError(f"Bounds for '{col}' must be a tuple of (min, max).")
+                _LOGGER.error(f"Bounds for '{col}' must be a tuple of (min, max).")
+                raise ValueError()
 
             min_val, max_val = bounds
             new_df[col] = new_df[col].clip(lower=min_val, upper=max_val)
@@ -621,7 +626,7 @@ def clip_outliers_multi(
     _LOGGER.info(f"Clipped {clipped_columns} columns.")
 
     if skipped_columns:
-        _LOGGER.warning("⚠️ Skipped columns:")
+        _LOGGER.warning("Skipped columns:")
         for col, msg in skipped_columns:
             print(f" - {col}: {msg}")
 
@@ -707,11 +712,11 @@ def standardize_percentages(
     for col in columns:
         # --- Robustness Checks ---
         if col not in df_copy.columns:
-            _LOGGER.warning(f"⚠️ Column '{col}' not found. Skipping.")
+            _LOGGER.warning(f"Column '{col}' not found. Skipping.")
             continue
 
         if not is_numeric_dtype(df_copy[col]):
-            _LOGGER.warning(f"⚠️ Column '{col}' is not numeric. Skipping.")
+            _LOGGER.warning(f"Column '{col}' is not numeric. Skipping.")
             continue
 
         # --- Applying the Logic ---

ml_tools/ensemble_evaluation.py

@@ -119,8 +119,8 @@ def evaluate_model_classification(
         heatmap_path = save_path / f"Classification_Report_{sanitized_target_name}.svg"
         plt.savefig(heatmap_path, format="svg", bbox_inches="tight")
         plt.close()
-    except Exception as e:
-        _LOGGER.error(f"❌ Could not generate classification report heatmap for {target_name}: {e}")
+    except Exception:
+        _LOGGER.exception(f"Could not generate classification report heatmap for {target_name}:")
 
     # Create confusion matrix
     fig, ax = plt.subplots(figsize=figsize)
@@ -198,7 +198,8 @@ def plot_roc_curve(
             
     elif hasattr(probabilities_or_model, "predict_proba"):
         if input_features is None:
-            raise ValueError("input_features must be provided when using a classifier.")
+            _LOGGER.error("input_features must be provided when using a classifier.")
+            raise ValueError()
 
         try:
             classes = probabilities_or_model.classes_ # type: ignore
@@ -209,7 +210,8 @@ def plot_roc_curve(
         y_score = probabilities_or_model.predict_proba(input_features)[:, positive_class_index] # type: ignore
 
     else:
-        raise TypeError("Unsupported type for 'probabilities_or_model'. Must be a NumPy array or a model with support for '.predict_proba()'.")
+        _LOGGER.error("Unsupported type for 'probabilities_or_model'. Must be a NumPy array or a model with support for '.predict_proba()'.")
+        raise TypeError()
 
     # ROC and AUC
     fpr, tpr, _ = roc_curve(true_labels, y_score)
@@ -276,7 +278,8 @@ def plot_precision_recall_curve(
             
     elif hasattr(probabilities_or_model, "predict_proba"):
         if input_features is None:
-            raise ValueError("input_features must be provided when using a classifier.")
+            _LOGGER.error("input_features must be provided when using a classifier.")
+            raise ValueError()
         try:
             classes = probabilities_or_model.classes_ # type: ignore
             positive_class_index = list(classes).index(1)
@@ -284,7 +287,8 @@ def plot_precision_recall_curve(
             positive_class_index = 1
         y_score = probabilities_or_model.predict_proba(input_features)[:, positive_class_index] # type: ignore
     else:
-        raise TypeError("Unsupported type for 'probabilities_or_model'. Must be a NumPy array or a model with support for '.predict_proba()'.")
+        _LOGGER.error("Unsupported type for 'probabilities_or_model'. Must be a NumPy array or a model with support for '.predict_proba()'.")
+        raise TypeError()
 
     # Calculate PR curve and AP score
     precision, recall, _ = precision_recall_curve(true_labels, y_score)

ml_tools/ensemble_inference.py

@@ -59,15 +59,15 @@ class InferenceHandler:
                     self._feature_names = feature_names_list
                 elif self._feature_names != feature_names_list:
                     # Add a warning if subsequent models have different feature names.
-                    _LOGGER.warning(f"⚠️ Mismatched feature names in {fname}. Using feature order from the first model loaded.")
+                    _LOGGER.warning(f"Mismatched feature names in {fname}. Using feature order from the first model loaded.")
                 
                 self.models[target_name] = model
                 if self.verbose:
-                    _LOGGER.info(f"✅ Loaded model for target: {target_name}")
+                    _LOGGER.info(f"Loaded model for target: {target_name}")
+
+            except Exception:
+                _LOGGER.error(f"Failed to load or parse {fname}.")
 
-            except Exception as e:
-                _LOGGER.warning(f"⚠️ Failed to load or parse {fname}: {e}")
-                
     @property
     def feature_names(self) -> List[str]:
         """
@@ -92,7 +92,8 @@ class InferenceHandler:
             features = features.reshape(1, -1)
         
         if features.shape[0] != 1:
-            raise ValueError("The predict() method is for a single sample. Use predict_batch() for multiple samples.")
+            _LOGGER.error("The 'predict()' method is for a single sample. Use 'predict_batch()' for multiple samples.")
+            raise ValueError()
 
         results: Dict[str, Any] = dict()
         for target_name, model in self.models.items():
@@ -106,7 +107,7 @@ class InferenceHandler:
                                         EnsembleKeys.CLASSIFICATION_PROBABILITIES: probabilities}
         
         if self.verbose:
-            _LOGGER.info("✅ Inference process complete.")
+            _LOGGER.info("Inference process complete.")
         return results
 
     def predict_batch(self, features: np.ndarray) -> Dict[str, Any]:
@@ -122,7 +123,8 @@ class InferenceHandler:
                 - For classification: The value is another dictionary {'labels': ..., 'probabilities': ...}.
         """
         if features.ndim != 2:
-            raise ValueError("Input for batch prediction must be a 2D array.")
+            _LOGGER.error("Input for batch prediction must be a 2D array.")
+            raise ValueError()
 
         results: Dict[str, Any] = dict()
         for target_name, model in self.models.items():
@@ -134,7 +136,7 @@ class InferenceHandler:
                 results[target_name] = {"labels": labels, "probabilities": probabilities}
                 
         if self.verbose:
-            _LOGGER.info("✅ Inference process complete.")
+            _LOGGER.info("Inference process complete.")
 
         return results
 
@@ -174,11 +176,11 @@ def model_report(
         target = full_object[EnsembleKeys.TARGET]
         features = full_object[EnsembleKeys.FEATURES]
     except FileNotFoundError:
-        _LOGGER.error(f"❌ Model file not found at '{model_p}'")
+        _LOGGER.error(f"Model file not found at '{model_p}'")
         raise
     except (KeyError, TypeError) as e:
         _LOGGER.error(
-            f"❌ The serialized object is missing required keys '{EnsembleKeys.MODEL}', '{EnsembleKeys.TARGET}', '{EnsembleKeys.FEATURES}'"
+            f"The serialized object is missing required keys '{EnsembleKeys.MODEL}', '{EnsembleKeys.TARGET}', '{EnsembleKeys.FEATURES}'"
         )
         raise e
 
@@ -209,9 +211,9 @@ def model_report(
         with open(json_filepath, 'w') as f:
             json.dump(report_data, f, indent=4)
         if verbose:
-            _LOGGER.info(f"✅ JSON report saved to: '{json_filepath}'")
+            _LOGGER.info(f"JSON report saved to: '{json_filepath}'")
     except PermissionError:
-        _LOGGER.error(f"❌ Permission denied to write JSON report at '{json_filepath}'")
+        _LOGGER.exception(f"Permission denied to write JSON report at '{json_filepath}'.")
 
     # --- 5. Return the extracted data ---
     return report_data
@@ -233,15 +235,13 @@ def _deserialize_object(filepath: Union[str,Path], verbose: bool=True, raise_on_
     try:
         obj = joblib.load(true_filepath)
     except (IOError, OSError, EOFError, TypeError, ValueError) as e:
-        message = f"❌ Failed to deserialize object from '{true_filepath}': {e}"
+        _LOGGER.error(f"Failed to deserialize object from '{true_filepath}'.")
         if raise_on_error:
-            raise Exception(message)
-        else:
-            print(message)
+            raise e
         return None
     else:
         if verbose:
-            print(f"\n✅ Loaded object of type '{type(obj)}'")
+            _LOGGER.info(f"Loaded object of type '{type(obj)}'")
         return obj
 
 

ml_tools/ensemble_learning.py

@@ -339,7 +339,8 @@ def _resample(X_train: np.ndarray, y_train: pd.Series,
     elif strategy == 'ADASYN':
         resample_algorithm = ADASYN(random_state=random_state, n_neighbors=3)
     else:
-        raise ValueError(f"Invalid resampling strategy: {strategy}")
+        _LOGGER.error(f"Invalid resampling strategy: {strategy}")
+        raise ValueError()
     
     X_res, y_res, *_ = resample_algorithm.fit_resample(X_train, y_train)
     return X_res, y_res
@@ -459,7 +460,8 @@ def train_test_pipeline(model, model_name: str, dataset_id: str, task: Literal["
         y_pred = evaluate_model_regression(model=trained_model, model_name=model_name, save_dir=local_save_directory, 
                              x_test_scaled=test_features, single_y_test=test_target, target_name=target_name)
     else:
-        raise ValueError(f"Unrecognized task '{task}' for model training,")
+        _LOGGER.error(f"Unrecognized task '{task}' for model training,")
+        raise ValueError()
     if debug:
         _LOGGER.info(f"Predicted vector: {type(y_pred)} with shape: {y_pred.shape}")
     
@@ -487,13 +489,14 @@ def run_ensemble_pipeline(datasets_dir: Union[str,Path], save_dir: Union[str,Pat
     elif isinstance(model_object, ClassificationTreeModels):
         task = "classification"
         if handle_classification_imbalance is None:
-            _LOGGER.warning("⚠️ No method to handle classification class imbalance has been selected. Datasets are assumed to be balanced.")
+            _LOGGER.warning("No method to handle classification class imbalance has been selected. Datasets are assumed to be balanced.")
         elif handle_classification_imbalance == "by_model":
             model_object.use_model_balance = True
         else:
             model_object.use_model_balance = False
     else:
-        raise TypeError(f"Unrecognized model {type(model_object)}")
+        _LOGGER.error(f"Unrecognized model {type(model_object)}")
+        raise TypeError()
     
     #Check paths
     datasets_path = make_fullpath(datasets_dir)
@@ -519,7 +522,7 @@ def run_ensemble_pipeline(datasets_dir: Union[str,Path], save_dir: Union[str,Pat
                                     debug=debug, save_dir=save_path, save_model=save_model,
                                     generate_learning_curves=generate_learning_curves)
 
-    _LOGGER.info("✅ Training and evaluation complete.")
+    _LOGGER.info("Training and evaluation complete.")
 
 
 def info():

ml_tools/handle_excel.py

@@ -37,7 +37,8 @@ def find_excel_files(
     input_path = make_fullpath(directory)
 
     if not input_path.is_dir():
-        raise NotADirectoryError(f"❌ Directory not found: {input_path}")
+        _LOGGER.error(f"Directory not found: {input_path}")
+        raise NotADirectoryError()
 
     excel_files = [
         f for f in input_path.iterdir()
@@ -47,7 +48,8 @@ def find_excel_files(
     ]
     
     if not excel_files:
-        raise FileNotFoundError(f"❌ No valid Excel files found in directory: {input_path}")
+        _LOGGER.error(f"No valid Excel files found in directory: {input_path}")
+        raise FileNotFoundError()
 
     return excel_files
 
@@ -99,7 +101,7 @@ def unmerge_and_split_excel(filepath: Union[str,Path]) -> None:
 
         total_output_files += 1
 
-    _LOGGER.info(f"✅ Processed file: {file_path} into {total_output_files} output file(s).")
+    _LOGGER.info(f"Processed file: {file_path} into {total_output_files} output file(s).")
     return None
 
 
@@ -155,7 +157,7 @@ def unmerge_and_split_from_directory(input_dir: Union[str,Path], output_dir: Uni
 
             total_output_files += 1
 
-    _LOGGER.info(f"✅ Processed {len(excel_files)} input Excel file(s) with a total of {total_output_files} output Excel file(s).")
+    _LOGGER.info(f"Processed {len(excel_files)} input Excel file(s) with a total of {total_output_files} output Excel file(s).")
     return None
 
 
@@ -199,13 +201,13 @@ def validate_excel_schema(
                     invalid_files.append(file)
 
         except Exception as e:
-            _LOGGER.error(f"❌ Error processing '{file}': {e}")
+            _LOGGER.error(f"Error processing '{file}': {e}")
             invalid_files.append(file)
     
     valid_excel_number = len(excel_paths) - len(invalid_files)
     _LOGGER.info(f"{valid_excel_number} out of {len(excel_paths)} excel files conform to the schema.")
     if invalid_files:
-        _LOGGER.warning(f"⚠️ {len(invalid_files)} excel files are invalid:")
+        _LOGGER.warning(f"{len(invalid_files)} excel files are invalid:")
         for in_file in invalid_files:
             print(f"  - {in_file.name}")
 
@@ -252,7 +254,8 @@ def vertical_merge_transform_excel(
         if target_columns is not None:
             missing = [col for col in target_columns if col not in df.columns]
             if missing:
-                raise ValueError(f"❌ Invalid columns in {file.name}: {missing}")
+                _LOGGER.error(f"Invalid columns in {file.name}: {missing}")
+                raise ValueError()
             df = df[target_columns]
 
         dataframes.append(df)
@@ -262,11 +265,12 @@ def vertical_merge_transform_excel(
     if rename_columns is not None:
         expected_len = len(target_columns if target_columns is not None else merged_df.columns)
         if len(rename_columns) != expected_len:
-            raise ValueError("❌ Length of 'rename_columns' must match the selected columns")
+            _LOGGER.error("Length of 'rename_columns' must match the selected columns")
+            raise ValueError()
         merged_df.columns = rename_columns
 
     merged_df.to_csv(csv_path, index=False, encoding='utf-8')
-    _LOGGER.info(f"✅ Merged {len(dataframes)} excel files into '{csv_filename}'.")
+    _LOGGER.info(f"Merged {len(dataframes)} excel files into '{csv_filename}'.")
 
 
 def horizontal_merge_transform_excel(
@@ -327,7 +331,7 @@ def horizontal_merge_transform_excel(
     duplicate_columns = merged_df.columns[merged_df.columns.duplicated()].tolist()
     
     if duplicate_columns:
-        _LOGGER.warning(f"⚠️ Duplicate columns: {duplicate_columns}")
+        _LOGGER.warning(f"Duplicate columns: {duplicate_columns}")
 
     if skip_duplicates:
         merged_df = merged_df.loc[:, ~merged_df.columns.duplicated()]
@@ -347,7 +351,7 @@ def horizontal_merge_transform_excel(
 
     merged_df.to_csv(csv_path, index=False, encoding='utf-8')
 
-    _LOGGER.info(f"✅ Merged {len(excel_files)} Excel files into '{csv_filename}'.")
+    _LOGGER.info(f"Merged {len(excel_files)} Excel files into '{csv_filename}'.")
     
 
 def info():

ml_tools/optimization_tools.py

@@ -61,7 +61,7 @@ def plot_optimal_feature_distributions(results_dir: Union[str, Path]):
     
     long_df = pd.concat(data_to_plot, ignore_index=True)
     features = long_df['feature'].unique()
-    _LOGGER.info(f"📂 Found data for {len(features)} features across {len(long_df['target'].unique())} targets. Generating plots...")
+    _LOGGER.info(f"Found data for {len(features)} features across {len(long_df['target'].unique())} targets. Generating plots...")
 
     # --- Plotting Loop ---
     for feature_name in features:
@@ -105,7 +105,7 @@ def plot_optimal_feature_distributions(results_dir: Union[str, Path]):
         plt.savefig(plot_filename, bbox_inches='tight')
         plt.close()
 
-    _LOGGER.info(f"✅ All plots saved successfully to: '{output_path}'")
+    _LOGGER.info(f"All plots saved successfully to: '{output_path}'")
     
 
 def _save_result(
@@ -129,8 +129,7 @@ def _save_result(
         if db_manager and db_table_name:
             db_manager.insert_row(db_table_name, result_dict)
         else:
-            _LOGGER.warning("⚠️ SQLite saving requested but db_manager or table_name not provided.")
-
+            _LOGGER.warning("SQLite saving requested but db_manager or table_name not provided.")
 
 
 def info():

ml_tools/path_manager.py

@@ -88,7 +88,7 @@ class PathManager:
         try:
             return self._paths[key]
         except KeyError:
-            _LOGGER.error(f"❌ Path key '{key}' not found.")
+            _LOGGER.error(f"Path key '{key}' not found.")
             raise
 
     def update(self, new_paths: Dict[str, Union[str, Path]], overwrite: bool = False) -> None:
@@ -106,9 +106,8 @@ class PathManager:
         if not overwrite:
             for key in new_paths:
                 if key in self._paths:
-                    raise KeyError(
-                        f"❌ Path key '{key}' already exists in the manager. To replace it, call update() with overwrite=True."
-                    )
+                    _LOGGER.error(f"Path key '{key}' already exists in the manager. To replace it, call update() with overwrite=True.")
+                    raise KeyError
 
         # Resolve any string paths to Path objects before storing
         resolved_new_paths = {k: Path(v) for k, v in new_paths.items()}
@@ -136,7 +135,7 @@ class PathManager:
                 if key in self._paths:
                     path_items.append((key, self._paths[key]))
                 elif verbose:
-                    _LOGGER.warning(f"⚠️ Key '{key}' not found in PathManager, skipping.")
+                    _LOGGER.warning(f"Key '{key}' not found in PathManager, skipping.")
         else:
             path_items = self._paths.items()
 
@@ -153,7 +152,7 @@ class PathManager:
 
             if self._is_bundled and is_internal_path:
                 if verbose:
-                    _LOGGER.warning(f"⚠️ Skipping internal directory '{key}' in bundled app (read-only).")
+                    _LOGGER.warning(f"Skipping internal directory '{key}' in bundled app (read-only).")
                 continue
             # -------------------------
 
@@ -261,7 +260,8 @@ def make_fullpath(
         resolved = path.resolve(strict=True)
     except FileNotFoundError:
         if not make:
-            raise ValueError(f"❌ Path does not exist: '{path}'")
+            _LOGGER.error(f"Path does not exist: '{path}'.")
+            raise FileNotFoundError()
 
         try:
             if is_file:
@@ -271,14 +271,17 @@ def make_fullpath(
             else:
                 path.mkdir(parents=True, exist_ok=True)
             resolved = path.resolve(strict=True)
-        except Exception as e:
-            raise ValueError(f"❌ Failed to create {'file' if is_file else 'directory'} '{path}': {e}")
+        except Exception:
+            _LOGGER.exception(f"Failed to create {'file' if is_file else 'directory'} '{path}'.")
+            raise IOError()
     
     if enforce == "file" and not resolved.is_file():
-        raise TypeError(f"❌ Path was enforced as a file, but it is not: '{resolved}'")
+        _LOGGER.error(f"Path was enforced as a file, but it is not: '{resolved}'")
+        raise TypeError()
     
     if enforce == "directory" and not resolved.is_dir():
-        raise TypeError(f"❌ Path was enforced as a directory, but it is not: '{resolved}'")
+        _LOGGER.error(f"Path was enforced as a directory, but it is not: '{resolved}'")
+        raise TypeError()
 
     if verbose:
         if resolved.is_file():
@@ -315,7 +318,8 @@ def sanitize_filename(filename: str) -> str:
     
     # Check for empty string after sanitization
     if not sanitized:
-        raise ValueError("The sanitized filename is empty. The original input may have contained only invalid characters.")
+        _LOGGER.error("The sanitized filename is empty. The original input may have contained only invalid characters.")
+        raise ValueError()
 
     return sanitized
 
@@ -334,7 +338,8 @@ def list_csv_paths(directory: Union[str,Path], verbose: bool=True) -> dict[str,
 
     csv_paths = list(dir_path.glob("*.csv"))
     if not csv_paths:
-        raise IOError(f"❌ No CSV files found in directory: {dir_path.name}")
+        _LOGGER.error(f"No CSV files found in directory: {dir_path.name}")
+        raise IOError()
     
     # make a dictionary of paths and names
     name_path_dict = {p.stem: p for p in csv_paths}
@@ -367,12 +372,13 @@ def list_files_by_extension(directory: Union[str,Path], extension: str, verbose:
     
     matched_paths = list(dir_path.glob(pattern))
     if not matched_paths:
-        raise IOError(f"❌ No '.{normalized_ext}' files found in directory: {dir_path}")
+        _LOGGER.error(f"No '.{normalized_ext}' files found in directory: {dir_path}.")
+        raise IOError()
 
     name_path_dict = {p.stem: p for p in matched_paths}
     
     if verbose:
-        _LOGGER.info(f"\n📂 '{normalized_ext.upper()}' files found:")
+        _LOGGER.info(f"📂 '{normalized_ext.upper()}' files found:")
         for name in name_path_dict:
             print(f"\t{name}")