Config

def initiate(
    self, root: Optional[str] = None, **kwargs: Any
) -> Union["NodeConfig", "ResearcherConfig"]:
    """Creates or initiates existing component

    Args:
        root: Root directory of the component
        component_alias: Name of the component, used for outputting the
            component in a user-friendly way.
            Defaults to default component name. (fbm-node or fbm-researcher)
        **kwargs: Additional parameters that can be used for
            component initialization. For example, `node_name` for NodeComponent.
    Returns:
        Config object of the component
    """

    if not root:
        root = os.path.join(os.getcwd(), self._default_component_name)

    reference = self.validate(root)
    config = self.config_cls(root=root, **kwargs)
    # If component is not existing, create it
    if not os.path.isfile(reference):
        create_fedbiomed_setup_folders(root)
        with open(os.path.join(root, ".fedbiomed"), "w", encoding="UTF-8") as file_:
            file_.write(self.config_cls.COMPONENT_TYPE)
        config.generate()
        config.write()
    else:
        config.read()

    return config

def is_component_existing(self, component_dir: str) -> bool:
    """Checks if component existing in the given root directory

    Returns:
        True if any component is instantiated in the given directory
    """
    ref = os.path.join(component_dir, self._reference)
    if os.path.isdir(component_dir):
        if docker_special_case(component_dir):
            return False

        if os.listdir(component_dir) and not os.path.isfile(ref):
            raise ValueError(
                f"Cannot create component. Path {component_dir} "
                "is not empty for Fed-BioMed component initialization. Please "
                f"remove folder {component_dir} or specify another path"
            )

    # Special case for docker container mounted folders
    # empty .fedbiomed is required to keep it
    if os.path.isfile(ref) and not read_file(ref):
        return False

    return os.path.isfile(ref)

def validate(self, root) -> str:
    """Validates given root folder is a component can be instantiated

    Args:
        root: Root directory that Fed-BioMed component will be instantiated.

    Returns:
        Full path to reference file
    """

    iscomp = self.is_component_existing(root)
    ref = os.path.join(root, self._reference)

    if iscomp:
        comp_type = read_file(ref)
        if comp_type != self.config_cls.COMPONENT_TYPE:
            raise ValueError(
                f"Component directory has already been initilazed for component type {comp_type}"
                " can not overwrite or reuse it for component type "
                f"{self.config_cls.COMPONENT_TYPE}"
            )

    return ref

@classmethod
@abstractmethod
def COMPONENT_TYPE(cls):  # pylint: disable=C0103
    """Abstract attribute to oblige defining component type"""

@abstractmethod
def add_parameters(self):
    """ "Component specific argument creation"""

def generate(self, id: Optional[str] = None) -> None:
    """ "Generate configuration file

    Args:
        force: Overwrites existing configuration file
        id: Component ID
    """

    # Check if configuration is already existing
    if not self.is_config_existing():
        # Create default section
        component_id = id if id else f"{self.COMPONENT_TYPE}_{uuid.uuid4()}"

        self._cfg["default"] = {
            "id": component_id,
            "component": self.COMPONENT_TYPE,
            "version": str(self._CONFIG_VERSION),
        }

        db_path = os.path.join(
            self.root, VAR_FOLDER_NAME, f"{DB_PREFIX}{component_id}.json"
        )
        self._cfg["default"]["db"] = os.path.relpath(
            db_path, os.path.join(self.root, CONFIG_FOLDER_NAME)
        )

        # Calls child class add_parameterss
        self.add_parameters()
    else:
        self.read()
        # Provide migration
        self.migrate()

    self._update_vars()

def get(self, section, key, **kwargs) -> str:
    """Returns value for given key and section"""

    return self._get(section, key, **kwargs)

def getbool(self, section, key, **kwargs) -> bool:
    """Gets boolean value from config"""

    return self._get(section, key, **kwargs).lower() in ("true", "1")

def getint(self, section, key, **kwargs) -> int:
    """Gets int value of a given config"""

    return self._cfg.getint(section, key, **kwargs)

def is_config_existing(self) -> bool:
    """Checks if config file exists

    Returns:
        True if config file is already existing
    """

    return os.path.isfile(self.config_path)

def load(
    self,
    root: str,  # pylint: disable=W0622
) -> None:
    """Load configuration from given name and root

    This implementation allows to load configuration after Config class
    is instantiated.

    Args:
        root: Root directory where component files will be saved
            configuration file.
    """

    self.root = root
    self.config_path = os.path.join(self.root, "etc", self._CONFIG_FILE_NAME)
    self.generate()

@abstractmethod
def migrate(self):
    """Migration method to add configuration parameters

    It is used for introducing  new parameters for in minor version or patch
    to not break backward compatibility. This method has to update `self._cfg`
    directly.

    An example;

    ```python
    self._cfg["my-section"].update({"my-new-parameter": "my-new-value"})
    ```
    It should update the section only if the parameter is not existing to avoid
    overwriting user defined values.
    """

def read(self) -> bool:
    """Reads configuration file that is already existing in given path

    Raises version compatibility error
    """
    self._cfg.read(self.config_path)

    # Validate config version
    raise_for_version_compatibility(
        self._cfg["default"]["version"],
        self._CONFIG_VERSION,
        f"Configuration file {self.config_path}: found version %s expected version %s",
    )

    return True

def sections(self) -> list:
    """Returns sections of the config"""

    return self._cfg.sections()

def set(self, section, key, value) -> None:
    """Sets config section values

    Args:
        section: the name of the config file section as defined by the `ini` standard
        key: the name of the attribute to be set
        value: the value of the attribute to be set

    Returns:
        value: the value of the attribute that was just set
    """
    self._cfg.set(section, key, value)

def write(self):
    """Writes config file"""

    try:
        with open(self.config_path, "w", encoding="UTF-8") as f:
            self._cfg.write(f)
    except configparser.Error as exp:
        raise FedbiomedConfigurationError(
            f"{ErrorNumbers.FB600.value}: cannot save config file:  {self.path}"
        ) from exp