omniopt2 7101__py3-none-any.whl → 7107__py3-none-any.whl

.omniopt.py

@@ -3226,44 +3226,97 @@ def get_return_in_case_of_errors() -> dict:
     return return_in_case_of_error
 
 @beartype
-def write_job_infos_csv(parameters: dict, stdout: Optional[str], program_string_with_params: str, exit_code: Optional[int], _signal: Optional[int], result: Optional[Union[Dict[str, Optional[float]], List[float], int, float]], start_time: Union[int, float], end_time: Union[int, float], run_time: Union[float, int]) -> None:
-    str_parameters_values: List[str] = [str(v) for v in list(parameters.values())]
+def write_job_infos_csv(parameters: dict, stdout: Optional[str], program_string_with_params: str,
+                        exit_code: Optional[int], _signal: Optional[int],
+                        result: Optional[Union[Dict[str, Optional[float]], List[float], int, float]],
+                        start_time: Union[int, float], end_time: Union[int, float],
+                        run_time: Union[float, int]) -> None:
+    _write_job_infos_csv_main(parameters, stdout, program_string_with_params, exit_code, _signal, result, start_time, end_time, run_time)
+
+@beartype
+def _write_job_infos_csv_main(parameters: dict, stdout: Optional[str], program_string_with_params: str,
+                              exit_code: Optional[int], _signal: Optional[int],
+                              result: Optional[Union[Dict[str, Optional[float]], List[float], int, float]],
+                              start_time: Union[int, float], end_time: Union[int, float],
+                              run_time: Union[float, int]) -> None:
+    str_parameters_values = _write_job_infos_csv_parameters_to_str(parameters)
+    extra_vars_names, extra_vars_values = _write_job_infos_csv_extract_extra_vars(stdout)
+    extra_vars_names, extra_vars_values = _write_job_infos_csv_add_slurm_job_id(extra_vars_names, extra_vars_values)
 
-    extra_vars_names, extra_vars_values = extract_info(stdout)
+    parameters_keys = list(parameters.keys())
+
+    headline = _write_job_infos_csv_build_headline(parameters_keys, extra_vars_names)
+    result_values = _write_job_infos_csv_result_to_strlist(result)
+
+    values = _write_job_infos_csv_build_values(start_time, end_time, run_time, program_string_with_params, str_parameters_values, result_values, exit_code, _signal, extra_vars_values)
+
+    headline = _write_job_infos_csv_replace_none_with_str(headline)
+    values = _write_job_infos_csv_replace_none_with_str(values)
+
+    run_folder = get_current_run_folder()
+    if run_folder is not None and os.path.exists(run_folder):
+        try:
+            add_to_csv(f"{run_folder}/job_infos.csv", headline, values)
+        except Exception as e:
+            print_red(f"Error writing job_infos.csv: {e}")
+    else:
+        print_debug(f"evaluate: get_current_run_folder() {run_folder} could not be found")
+
+@beartype
+def _write_job_infos_csv_parameters_to_str(parameters: dict) -> List[str]:
+    return [str(v) for v in list(parameters.values())]
+
+@beartype
+def _write_job_infos_csv_extract_extra_vars(stdout: Optional[str]) -> Tuple[List[str], List[str]]:
+    # extract_info ist hier eine vorhandene Funktion, die extra Variablen aus stdout extrahiert
+    return extract_info(stdout)
 
+@beartype
+def _write_job_infos_csv_add_slurm_job_id(extra_vars_names: List[str], extra_vars_values: List[str]) -> Tuple[List[str], List[str]]:
     _SLURM_JOB_ID = os.getenv('SLURM_JOB_ID')
     if _SLURM_JOB_ID:
         extra_vars_names.append("OO_Info_SLURM_JOB_ID")
         extra_vars_values.append(str(_SLURM_JOB_ID))
+    return extra_vars_names, extra_vars_values
 
-    parameters_keys = list(parameters.keys())
-
-    headline: List[str] = [
+@beartype
+def _write_job_infos_csv_build_headline(parameters_keys: List[str], extra_vars_names: List[str]) -> List[str]:
+    return [
         "start_time",
         "end_time",
         "run_time",
         "program_string",
         *parameters_keys,
-        *arg_result_names,
+        *arg_result_names,  # arg_result_names muss global definiert sein
         "exit_code",
         "signal",
         "hostname",
         *extra_vars_names
     ]
 
-    result_values = []
+@beartype
+def _write_job_infos_csv_result_to_strlist(result: Optional[Union[Dict[str, Optional[float]], List[float], int, float]]) -> List[str]:
+    result_values: List[str] = []
 
     if isinstance(result, list):
         for rkey in result:
             result_values.append(str(rkey))
     elif isinstance(result, dict):
-        result_keys: list = list(result.keys())
+        result_keys = list(result.keys())
         for rkey in result_keys:
             rval = str(result[str(rkey)])
-
             result_values.append(rval)
+    elif result is not None:  # int or float
+        result_values.append(str(result))
 
-    values: List[str] = [
+    return result_values
+
+@beartype
+def _write_job_infos_csv_build_values(start_time: Union[int, float], end_time: Union[int, float], run_time: Union[float, int],
+                                      program_string_with_params: str, str_parameters_values: List[str],
+                                      result_values: List[str], exit_code: Optional[int], _signal: Optional[int],
+                                      extra_vars_values: List[str]) -> List[str]:
+    return [
         str(start_time),
         str(end_time),
         str(run_time),
@@ -3276,16 +3329,9 @@ def write_job_infos_csv(parameters: dict, stdout: Optional[str], program_string_
         *extra_vars_values
     ]
 
-    headline = ['None' if element is None else element for element in headline]
-    values = ['None' if element is None else element for element in values]
-
-    if get_current_run_folder() is not None and os.path.exists(get_current_run_folder()):
-        try:
-            add_to_csv(f"{get_current_run_folder()}/job_infos.csv", headline, values)
-        except Exception as e:
-            print_red(f"Error writing job_infos.csv: {e}")
-    else:
-        print_debug(f"evaluate: get_current_run_folder() {get_current_run_folder()} could not be found")
+@beartype
+def _write_job_infos_csv_replace_none_with_str(elements: List[Optional[str]]) -> List[str]:
+    return ['None' if element is None else element for element in elements]
 
 @beartype
 def print_evaluate_times() -> None:
@@ -3456,28 +3502,59 @@ def die_for_debug_reasons() -> None:
         except ValueError:
             print_red(f"Invalid value for DIE_AFTER_THIS_NR_OF_DONE_JOBS: '{max_done_str}', cannot be converted to int")
 
+@beartype
+def _evaluate_preprocess_parameters(parameters: dict) -> dict:
+    return {
+        k: (int(float(v)) if isinstance(v, (int, float, str)) and re.fullmatch(r'^\d+(\.0+)?$', str(v)) else v)
+        for k, v in parameters.items()
+    }
+
+@beartype
+def _evaluate_create_signal_map() -> Dict[str, type[BaseException]]:
+    return {
+        "USR1-signal": SignalUSR,
+        "CONT-signal": SignalCONT,
+        "INT-signal": SignalINT
+    }
+
+@beartype
+def _evaluate_handle_result(
+    stdout: str,
+    result: Union[int, float, dict, list],
+    parameters: dict
+) -> Dict[str, Optional[Union[float, Tuple]]]:
+    final_result: Dict[str, Optional[Union[float, Tuple]]] = {}
+
+    if isinstance(result, (int, float)):
+        for name in arg_result_names:
+            final_result[name] = attach_sem_to_result(stdout, name, float(result))
+
+    elif isinstance(result, list):
+        float_values = [float(r) for r in result]
+        for name in arg_result_names:
+            final_result[name] = attach_sem_to_result(stdout, name, float_values)
+
+    elif isinstance(result, dict):
+        for name in arg_result_names:
+            final_result[name] = attach_sem_to_result(stdout, name, result.get(name))
+
+    else:
+        write_failed_logs(parameters, "No Result")
+
+    return final_result
+
 @beartype
 def evaluate(parameters: dict) -> Optional[Union[int, float, Dict[str, Optional[Union[int, float, Tuple]]], List[float]]]:
     start_nvidia_smi_thread()
-
     return_in_case_of_error: dict = get_return_in_case_of_errors()
 
     _test_gpu = test_gpu_before_evaluate(return_in_case_of_error)
-    final_result = return_in_case_of_error
+    final_result: Optional[Union[int, float, Dict[str, Optional[Union[int, float, Tuple]]], List[float]]] = return_in_case_of_error
 
     if _test_gpu is None:
-        parameters = {
-            k: (int(float(v)) if isinstance(v, (int, float, str)) and re.fullmatch(r'^\d+(\.0+)?$', str(v)) else v)
-            for k, v in parameters.items()
-        }
-
+        parameters = _evaluate_preprocess_parameters(parameters)
         ignore_signals()
-
-        signal_messages = {
-            "USR1-signal": SignalUSR,
-            "CONT-signal": SignalCONT,
-            "INT-signal": SignalINT
-        }
+        signal_messages = _evaluate_create_signal_map()
 
         try:
             if args.raise_in_eval:
@@ -3498,23 +3575,7 @@ def evaluate(parameters: dict) -> Optional[Union[int, float, Dict[str, Optional[
 
             result = get_results_with_occ(stdout)
 
-            final_result = {}
-
-            if isinstance(result, (int, float)):
-                for name in arg_result_names:
-                    final_result[name] = attach_sem_to_result(stdout, name, float(result))
-
-            elif isinstance(result, list):
-                float_values = [float(r) for r in result]
-                for name in arg_result_names:
-                    final_result[name] = attach_sem_to_result(stdout, name, float_values)
-
-            elif isinstance(result, dict):
-                for name in arg_result_names:
-                    final_result[name] = attach_sem_to_result(stdout, name, result.get(name))
-
-            else:
-                write_failed_logs(parameters, "No Result")
+            final_result = _evaluate_handle_result(stdout, result, parameters)
 
             _evaluate_print_stuff(
                 parameters,
@@ -5562,7 +5623,6 @@ def parse_csv(csv_path: str) -> Tuple[List, List]:
 
     return arm_params_list, results_list
 
-
 @beartype
 def get_generation_node_for_index(
     this_csv_file_path: str,
@@ -5585,7 +5645,6 @@ def get_generation_node_for_index(
         print(f"Error while get_generation_node_for_index: {e}")
         return "MANUAL"
 
-
 @beartype
 def _get_generation_node_for_index_index_valid(
     index: int,
@@ -5594,7 +5653,6 @@ def _get_generation_node_for_index_index_valid(
 ) -> bool:
     return 0 <= index < len(arm_params_list) and index < len(results_list)
 
-
 @beartype
 def _get_generation_node_for_index_combine_dicts(
     dict1: Dict[str, Any],
@@ -5605,7 +5663,6 @@ def _get_generation_node_for_index_combine_dicts(
     combined.update(dict2)
     return combined
 
-
 @beartype
 def _get_generation_node_for_index_find_generation_node(
     csv_file_path: str,
@@ -5622,7 +5679,6 @@ def _get_generation_node_for_index_find_generation_node(
 
     return "MANUAL"
 
-
 @beartype
 def _get_generation_node_for_index_row_matches(
     row: Dict[str, str],
@@ -5642,7 +5698,6 @@ def _get_generation_node_for_index_row_matches(
 
     return True
 
-
 @beartype
 def _get_generation_node_for_index_floats_match(
     val: float,
@@ -6352,7 +6407,6 @@ def check_orchestrator(stdout_path: str, trial_index: int) -> Optional[List[str]
 
     return _check_orchestrator_find_behaviors(stdout, orchestrator["errors"])
 
-
 @beartype
 def _check_orchestrator_read_stdout_with_fallback(stdout_path: str, trial_index: int) -> Optional[str]:
     try:
@@ -6369,7 +6423,6 @@ def _check_orchestrator_read_stdout_with_fallback(stdout_path: str, trial_index:
         _check_orchestrator_register_missing_file(stdout_path, trial_index)
         return None
 
-
 @beartype
 def _check_orchestrator_register_missing_file(stdout_path: str, trial_index: int) -> None:
     if stdout_path not in ORCHESTRATE_TODO:
@@ -6378,7 +6431,6 @@ def _check_orchestrator_register_missing_file(stdout_path: str, trial_index: int
     else:
         print_red(f"File not found: {stdout_path}, not trying again")
 
-
 @beartype
 def _check_orchestrator_find_behaviors(stdout: str, errors: List[Dict[str, Any]]) -> List[str]:
     behaviors: List[str] = []
@@ -7163,64 +7215,82 @@ def generate_time_table_rich() -> None:
     save_table_as_text(table, filepath)
 
 @beartype
-def generate_job_submit_table_rich() -> None:
-    if not isinstance(job_submit_durations, list) or not isinstance(job_submit_nrs, list):
-        print_debug("generate_job_submit_table_rich: Error: job_submit_durations or job_submit_nrs is not a list.")
-        return
+def validate_job_submit_data(durations: List[float], job_counts: List[int]) -> bool:
+    if not durations or not job_counts:
+        print_debug("No durations or job counts to display.")
+        return False
 
-    if len(job_submit_durations) == 0 or len(job_submit_nrs) == 0:
-        print_debug("generate_job_submit_table_rich: No durations or job counts to display.")
-        return
+    if len(durations) != len(job_counts):
+        print_debug("Length mismatch between durations and job counts.")
+        return False
 
-    if len(job_submit_durations) != len(job_submit_nrs):
-        print_debug("generate_job_submit_table_rich: Length mismatch between durations and job counts.")
-        return
+    return True
 
-    for i, val in enumerate(job_submit_durations):
-        try:
-            float(val)
-        except (ValueError, TypeError):
-            print_debug(f"generate_job_submit_table_rich: Error: Element at index {i} in durations is not a valid float.")
-            return
-    for i, val in enumerate(job_submit_nrs):
-        if not isinstance(val, int):
-            print_debug(f"generate_job_submit_table_rich: Error: Element at index {i} in job counts is not an int.")
-            return
+@beartype
+def convert_durations_to_float(raw_durations: List) -> List[float] | None:
+    try:
+        return [float(val) for val in raw_durations]
+    except (ValueError, TypeError) as e:
+        print_debug(f"Invalid float in durations: {e}")
+        return None
+
+@beartype
+def convert_job_counts_to_int(raw_counts: List) -> List[int] | None:
+    try:
+        return [int(val) for val in raw_counts]
+    except (ValueError, TypeError) as e:
+        print_debug(f"Invalid int in job counts: {e}")
+        return None
 
+@beartype
+def build_job_submission_table(durations: List[float], job_counts: List[int]) -> Table:
     table = Table(show_header=True, header_style="bold", title="Job submission durations")
     table.add_column("Batch", justify="right")
     table.add_column("Seconds", justify="right")
     table.add_column("Jobs", justify="right")
     table.add_column("Time per job", justify="right")
 
-    for idx, (time_val, jobs) in enumerate(zip(job_submit_durations, job_submit_nrs), start=1):
-        time_val_float = float(time_val)
-        time_per_job = time_val_float / jobs if jobs > 0 else 0
-        table.add_row(str(idx), f"{time_val_float:.3f}", str(jobs), f"{time_per_job:.3f}")
-
-    times_float = [float(t) for t in job_submit_durations]
-    avg_time = mean(times_float)
-    median_time = median(times_float)
-    total_time = sum(times_float)
-    max_time = max(times_float)
-    min_time = min(times_float)
+    for idx, (duration, jobs) in enumerate(zip(durations, job_counts), start=1):
+        time_per_job = duration / jobs if jobs > 0 else 0
+        table.add_row(str(idx), f"{duration:.3f}", str(jobs), f"{time_per_job:.3f}")
 
     table.add_section()
+    table.add_row("Average", f"{mean(durations):.3f}", "", "")
+    table.add_row("Median", f"{median(durations):.3f}", "", "")
+    table.add_row("Total", f"{sum(durations):.3f}", "", "")
+    table.add_row("Max", f"{max(durations):.3f}", "", "")
+    table.add_row("Min", f"{min(durations):.3f}", "", "")
 
-    table.add_row("Average", f"{avg_time:.3f}", "", "")
-    table.add_row("Median", f"{median_time:.3f}", "", "")
-    table.add_row("Total", f"{total_time:.3f}", "", "")
-    table.add_row("Max", f"{max_time:.3f}", "", "")
-    table.add_row("Min", f"{min_time:.3f}", "", "")
-
-    if args.show_generate_time_table:
-        console.print(table)
+    return table
 
+@beartype
+def export_table_to_file(table: Table, filename: str) -> None:
     folder = get_current_run_folder()
-    filename = "job_submit_durations.txt"
     filepath = os.path.join(folder, filename)
     save_table_as_text(table, filepath)
 
+@beartype
+def generate_job_submit_table_rich() -> None:
+    if not isinstance(job_submit_durations, list) or not isinstance(job_submit_nrs, list):
+        print_debug("job_submit_durations or job_submit_nrs is not a list.")
+        return
+
+    durations = convert_durations_to_float(job_submit_durations)
+    job_counts = convert_job_counts_to_int(job_submit_nrs)
+
+    if durations is None or job_counts is None:
+        return
+
+    if not validate_job_submit_data(durations, job_counts):
+        return
+
+    table = build_job_submission_table(durations, job_counts)
+
+    if args.show_generate_time_table:
+        console.print(table)
+
+    export_table_to_file(table, "job_submit_durations.txt")
+
 @beartype
 def plot_times_for_creation_and_submission() -> None:
     if not args.show_generation_and_submission_sixel:
@@ -7851,49 +7921,71 @@ def create_and_execute_next_runs(next_nr_steps: int, phase: Optional[str], _max_
         print_debug(f"Warning: create_and_execute_next_runs(next_nr_steps: {next_nr_steps}, phase: {phase}, _max_eval: {_max_eval}, progress_bar)")
         return 0
 
-    trial_index_to_param = None
-    done_optimizing = False
+    trial_index_to_param: Optional[Dict] = None
+    done_optimizing: bool = False
+    results: List = []
 
     try:
-        nr_of_jobs_to_get = _calculate_nr_of_jobs_to_get(get_nr_of_imported_jobs(), len(global_vars["jobs"]))
-        results = []
+        done_optimizing, trial_index_to_param, results = _create_and_execute_next_runs_run_loop(next_nr_steps, _max_eval, phase, _progress_bar)
+        _create_and_execute_next_runs_finish(done_optimizing)
+    except Exception as e:
+        stacktrace = traceback.format_exc()
+        print_debug(f"Warning: create_and_execute_next_runs encountered an exception: {e}\n{stacktrace}")
+        return handle_exceptions_create_and_execute_next_runs(e)
 
-        new_nr_of_jobs_to_get = min(max_eval - (submitted_jobs() - failed_jobs()), nr_of_jobs_to_get)
+    return _create_and_execute_next_runs_return_value(trial_index_to_param)
 
-        range_nr = new_nr_of_jobs_to_get
-        get_next_trials_nr = 1
+@beartype
+def _create_and_execute_next_runs_run_loop(next_nr_steps: int, _max_eval: Optional[int], phase: Optional[str], _progress_bar: Any
+                                          ) -> Tuple[bool, Optional[Dict], List]:
+    done_optimizing = False
+    trial_index_to_param: Optional[Dict] = None
+    results: List = []
 
-        if args.generate_all_jobs_at_once:
-            range_nr = 1
-            get_next_trials_nr = new_nr_of_jobs_to_get
+    nr_of_jobs_to_get = _calculate_nr_of_jobs_to_get(get_nr_of_imported_jobs(), len(global_vars["jobs"]))
 
-        for _ in range(range_nr):
-            trial_index_to_param, optimization_complete = _get_next_trials(get_next_trials_nr)
-            done_optimizing = handle_optimization_completion(optimization_complete)
-            if done_optimizing:
-                continue
-            if trial_index_to_param:
-                nr_jobs_before_removing_abandoned = len(list(trial_index_to_param.keys()))
+    # Sicherstellen, dass _max_eval nicht None ist
+    __max_eval = _max_eval if _max_eval is not None else 0
+    new_nr_of_jobs_to_get = min(__max_eval - (submitted_jobs() - failed_jobs()), nr_of_jobs_to_get)
+
+    range_nr = new_nr_of_jobs_to_get
+    get_next_trials_nr = 1
 
-                trial_index_to_param = {k: v for k, v in trial_index_to_param.items() if k not in abandoned_trial_indices}
+    if getattr(args, "generate_all_jobs_at_once", False):
+        range_nr = 1
+        get_next_trials_nr = new_nr_of_jobs_to_get
 
-                if len(list(trial_index_to_param.keys())):
-                    results.extend(execute_trials(trial_index_to_param, next_nr_steps, phase, _max_eval, _progress_bar))
+    for _ in range(range_nr):
+        trial_index_to_param, optimization_complete = _get_next_trials(get_next_trials_nr)
+        done_optimizing = handle_optimization_completion(optimization_complete)
+        if done_optimizing:
+            continue
+
+        if trial_index_to_param:
+            nr_jobs_before_removing_abandoned = len(list(trial_index_to_param.keys()))
+
+            filtered_trial_index_to_param = {k: v for k, v in trial_index_to_param.items() if k not in abandoned_trial_indices}
+
+            if len(filtered_trial_index_to_param):
+                results.extend(execute_trials(filtered_trial_index_to_param, next_nr_steps, phase, _max_eval, _progress_bar))
+            else:
+                if nr_jobs_before_removing_abandoned > 0:
+                    print_debug(f"Could not get jobs. They've been deleted by abandoned_trial_indices: {abandoned_trial_indices}")
                 else:
-                    if nr_jobs_before_removing_abandoned > 0:
-                        print_debug(f"Could not get jobs. They've been deleted by abandoned_trial_indices: {abandoned_trial_indices}")
-                    else:
-                        print_debug("Could not generate any jobs")
+                    print_debug("Could not generate any jobs")
 
-        finish_previous_jobs(["finishing jobs"])
+            trial_index_to_param = filtered_trial_index_to_param
 
-        if done_optimizing:
-            end_program(False, 0)
-    except Exception as e:
-        stacktrace = traceback.format_exc()
-        print_debug(f"Warning: create_and_execute_next_runs encountered an exception: {e}\n{stacktrace}")
-        return handle_exceptions_create_and_execute_next_runs(e)
+    return done_optimizing, trial_index_to_param, results
+
+@beartype
+def _create_and_execute_next_runs_finish(done_optimizing: bool) -> None:
+    finish_previous_jobs(["finishing jobs"])
+    if done_optimizing:
+        end_program(False, 0)
 
+@beartype
+def _create_and_execute_next_runs_return_value(trial_index_to_param: Optional[Dict]) -> int:
     try:
         if trial_index_to_param:
             res = len(trial_index_to_param.keys())
@@ -8386,6 +8478,41 @@ def plot_pareto_frontier_sixel(data: Any, x_metric: str, y_metric: str) -> None:
 
     plt.close(fig)
 
+@beartype
+def _pareto_front_general_validate_shapes(x: np.ndarray, y: np.ndarray) -> None:
+    if x.shape != y.shape:
+        raise ValueError("Input arrays x and y must have the same shape.")
+
+@beartype
+def _pareto_front_general_compare(
+    xi: float, yi: float, xj: float, yj: float,
+    x_minimize: bool, y_minimize: bool
+) -> bool:
+    x_better_eq = xj <= xi if x_minimize else xj >= xi
+    y_better_eq = yj <= yi if y_minimize else yj >= yi
+    x_strictly_better = xj < xi if x_minimize else xj > xi
+    y_strictly_better = yj < yi if y_minimize else yj > yi
+
+    return x_better_eq and y_better_eq and (x_strictly_better or y_strictly_better)
+
+@beartype
+def _pareto_front_general_find_dominated(
+    x: np.ndarray, y: np.ndarray, x_minimize: bool, y_minimize: bool
+) -> np.ndarray:
+    num_points = len(x)
+    is_dominated = np.zeros(num_points, dtype=bool)
+
+    for i in range(num_points):
+        for j in range(num_points):
+            if i == j:
+                continue
+
+            if _pareto_front_general_compare(x[i], y[i], x[j], y[j], x_minimize, y_minimize):
+                is_dominated[i] = True
+                break
+
+    return is_dominated
+
 @beartype
 def pareto_front_general(
     x: np.ndarray,
@@ -8394,28 +8521,9 @@ def pareto_front_general(
     y_minimize: bool = True
 ) -> np.ndarray:
     try:
-        if x.shape != y.shape:
-            raise ValueError("Input arrays x and y must have the same shape.")
-
-        num_points = len(x)
-        is_dominated = np.zeros(num_points, dtype=bool)
-
-        for i in range(num_points):
-            for j in range(num_points):
-                if i == j:
-                    continue
-
-                x_better_or_equal = x[j] <= x[i] if x_minimize else x[j] >= x[i]
-                y_better_or_equal = y[j] <= y[i] if y_minimize else y[j] >= y[i]
-                x_strictly_better = x[j] < x[i] if x_minimize else x[j] > x[i]
-                y_strictly_better = y[j] < y[i] if y_minimize else y[j] > y[i]
-
-                if x_better_or_equal and y_better_or_equal and (x_strictly_better or y_strictly_better):
-                    is_dominated[i] = True
-                    break
-
+        _pareto_front_general_validate_shapes(x, y)
+        is_dominated = _pareto_front_general_find_dominated(x, y, x_minimize, y_minimize)
         return np.where(~is_dominated)[0]
-
     except Exception as e:
         print("Error in pareto_front_general:", str(e))
         return np.array([], dtype=int)