extract pure api params repository defaulting rules

Author: v1docq

fedot/api/api_utils/api_params_repository.py

@@ -1,13 +1,12 @@
-import datetime
-from dataclasses import asdict
+import datetime
 from typing import Sequence
 
 from golem.core.optimisers.genetic.operators.inheritance import GeneticSchemeTypesEnum
 from golem.core.optimisers.genetic.operators.mutation import MutationTypesEnum
 
+from fedot.api.api_utils.api_params_repository_rules import apply_default_params, build_default_api_params
 from fedot.api.sampling_stage.config import validate_sampling_config
 from fedot.core.composer.gp_composer.specific_operators import parameter_change_mutation, add_resample_mutation
-from fedot.core.constants import AUTO_PRESET_NAME
 from fedot.core.repository.tasks import TaskTypesEnum
 from fedot.core.utils import default_fedot_data_dir
 
@@ -33,68 +32,16 @@ def __init__(self, task_type: TaskTypesEnum):
     @staticmethod
     def default_params_for_task(task_type: TaskTypesEnum) -> dict:
         """ Returns a dict with default parameters"""
-        if task_type in [TaskTypesEnum.classification, TaskTypesEnum.regression]:
-            cv_folds = 5
-
-        elif task_type == TaskTypesEnum.ts_forecasting:
-            cv_folds = 3
-
-        # Dict with allowed keyword attributes for Api and their default values. If None - default value set
-        # in dataclasses ``PipelineComposerRequirements``, ``GPAlgorithmParameters``, ``GraphGenerationParams``
-        # will be used.
-        default_param_values_dict = dict(
-            parallelization_mode='populational',
-            show_progress=True,
-            max_depth=6,
-            max_arity=3,
-            pop_size=20,
-            num_of_generations=None,
-            keep_n_best=1,
-            available_operations=None,
-            metric=None,
-            cv_folds=cv_folds,
-            genetic_scheme=None,
-            early_stopping_iterations=None,
-            early_stopping_timeout=10,
-            optimizer=None,
-            collect_intermediate_metric=False,
-            max_pipeline_fit_time=None,
-            initial_assumption=None,
-            preset=AUTO_PRESET_NAME,
-            use_operations_cache=True,
-            use_preprocessing_cache=True,
-            use_predictions_cache=True,
-            use_stats=False,
-            use_input_preprocessing=True,
-            use_auto_preprocessing=False,
-            use_meta_rules=False,
-            cache_dir=default_fedot_data_dir(),
-            keep_history=True,
-            history_dir=default_fedot_data_dir(),
-            with_tuning=True,
-            seed=None,
-            sampling_config=None,
-        )
-        return default_param_values_dict
+        return build_default_api_params(task_type, default_fedot_data_dir())
 
     def check_and_set_default_params(self, params: dict) -> dict:
         """ Sets default values for parameters which were not set by the user
         and raises KeyError for invalid parameter keys"""
-        allowed_keys = self.default_params.keys()
-        invalid_keys = params.keys() - allowed_keys
-        if invalid_keys:
-            raise KeyError(f"Invalid key parameters {invalid_keys}")
-
-        if 'sampling_config' in params:
-            validated_sampling_config = validate_sampling_config(params['sampling_config'])
-            params['sampling_config'] = asdict(validated_sampling_config) if validated_sampling_config else None
-
-        missing_params = self.default_params.keys() - params.keys()
-        for k in missing_params:
-            if (v := self.default_params[k]) is not None:
-                params[k] = v
-
-        return params
+        return apply_default_params(
+            params=params,
+            default_params=self.default_params,
+            sampling_validator=validate_sampling_config,
+        )
 
     @staticmethod
     def get_params_for_composer_requirements(params: dict) -> dict: